1 # SPDX-License-Identifier: GPL-2.0
3 # Generic algorithms support
9 # async_tx api: hardware offloaded memory transfer/transform support
11 source "crypto/async_tx/Kconfig"
14 # Cryptographic API Configuration
17 tristate "Cryptographic API"
19 This option provides the core Cryptographic API.
23 comment "Crypto core or helper"
26 bool "FIPS 200 compliance"
27 depends on (CRYPTO_ANSI_CPRNG || CRYPTO_DRBG) && !CRYPTO_MANAGER_DISABLE_TESTS
28 depends on (MODULE_SIG || !MODULES)
30 This options enables the fips boot option which is
31 required if you want to system to operate in a FIPS 200
32 certification. You should say no unless you know what
39 This option provides the API for cryptographic algorithms.
55 config CRYPTO_BLKCIPHER
57 select CRYPTO_BLKCIPHER2
60 config CRYPTO_BLKCIPHER2
64 select CRYPTO_WORKQUEUE
84 config CRYPTO_RNG_DEFAULT
86 select CRYPTO_DRBG_MENU
88 config CRYPTO_AKCIPHER2
92 config CRYPTO_AKCIPHER
94 select CRYPTO_AKCIPHER2
108 select CRYPTO_ALGAPI2
116 tristate "RSA algorithm"
117 select CRYPTO_AKCIPHER
118 select CRYPTO_MANAGER
122 Generic implementation of the RSA public key algorithm.
125 tristate "Diffie-Hellman algorithm"
129 Generic implementation of the Diffie-Hellman algorithm.
132 tristate "ECDH algorithm"
134 select CRYPTO_RNG_DEFAULT
136 Generic implementation of the ECDH algorithm
138 config CRYPTO_MANAGER
139 tristate "Cryptographic algorithm manager"
140 select CRYPTO_MANAGER2
142 Create default cryptographic template instantiations such as
145 config CRYPTO_MANAGER2
146 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
149 select CRYPTO_BLKCIPHER2
150 select CRYPTO_AKCIPHER2
155 tristate "Userspace cryptographic algorithm configuration"
157 select CRYPTO_MANAGER
159 Userspace configuration for cryptographic instantiations such as
162 config CRYPTO_MANAGER_DISABLE_TESTS
163 bool "Disable run-time self tests"
165 depends on CRYPTO_MANAGER2
167 Disable run-time self tests that normally take place at
168 algorithm registration.
170 config CRYPTO_GF128MUL
171 tristate "GF(2^128) multiplication functions"
173 Efficient table driven implementation of multiplications in the
174 field GF(2^128). This is needed by some cypher modes. This
175 option will be selected automatically if you select such a
176 cipher mode. Only select this option by hand if you expect to load
177 an external module that requires these functions.
180 tristate "Null algorithms"
183 These are 'Null' algorithms, used by IPsec, which do nothing.
187 select CRYPTO_ALGAPI2
188 select CRYPTO_BLKCIPHER2
192 tristate "Parallel crypto engine"
195 select CRYPTO_MANAGER
198 This converts an arbitrary crypto algorithm into a parallel
199 algorithm that executes in kernel threads.
201 config CRYPTO_WORKQUEUE
205 tristate "Software async crypto daemon"
206 select CRYPTO_BLKCIPHER
208 select CRYPTO_MANAGER
209 select CRYPTO_WORKQUEUE
211 This is a generic software asynchronous crypto daemon that
212 converts an arbitrary synchronous software crypto algorithm
213 into an asynchronous algorithm that executes in a kernel thread.
215 config CRYPTO_MCRYPTD
216 tristate "Software async multi-buffer crypto daemon"
217 select CRYPTO_BLKCIPHER
219 select CRYPTO_MANAGER
220 select CRYPTO_WORKQUEUE
222 This is a generic software asynchronous crypto daemon that
223 provides the kernel thread to assist multi-buffer crypto
224 algorithms for submitting jobs and flushing jobs in multi-buffer
225 crypto algorithms. Multi-buffer crypto algorithms are executed
226 in the context of this kernel thread and drivers can post
227 their crypto request asynchronously to be processed by this daemon.
229 config CRYPTO_AUTHENC
230 tristate "Authenc support"
232 select CRYPTO_BLKCIPHER
233 select CRYPTO_MANAGER
237 Authenc: Combined mode wrapper for IPsec.
238 This is required for IPSec.
241 tristate "Testing module"
243 select CRYPTO_MANAGER
245 Quick & dirty crypto test module.
247 config CRYPTO_ABLK_HELPER
255 config CRYPTO_GLUE_HELPER_X86
258 select CRYPTO_BLKCIPHER
263 comment "Authenticated Encryption with Associated Data"
266 tristate "CCM support"
271 Support for Counter with CBC MAC. Required for IPsec.
274 tristate "GCM/GMAC support"
280 Support for Galois/Counter Mode (GCM) and Galois Message
281 Authentication Code (GMAC). Required for IPSec.
283 config CRYPTO_CHACHA20POLY1305
284 tristate "ChaCha20-Poly1305 AEAD support"
285 select CRYPTO_CHACHA20
286 select CRYPTO_POLY1305
289 ChaCha20-Poly1305 AEAD support, RFC7539.
291 Support for the AEAD wrapper using the ChaCha20 stream cipher combined
292 with the Poly1305 authenticator. It is defined in RFC7539 for use in
296 tristate "Sequence Number IV Generator"
298 select CRYPTO_BLKCIPHER
300 select CRYPTO_RNG_DEFAULT
302 This IV generator generates an IV based on a sequence number by
303 xoring it with a salt. This algorithm is mainly useful for CTR
305 config CRYPTO_ECHAINIV
306 tristate "Encrypted Chain IV Generator"
309 select CRYPTO_RNG_DEFAULT
312 This IV generator generates an IV based on the encryption of
313 a sequence number xored with a salt. This is the default
316 comment "Block modes"
319 tristate "CBC support"
320 select CRYPTO_BLKCIPHER
321 select CRYPTO_MANAGER
323 CBC: Cipher Block Chaining mode
324 This block cipher algorithm is required for IPSec.
327 tristate "CTR support"
328 select CRYPTO_BLKCIPHER
330 select CRYPTO_MANAGER
333 This block cipher algorithm is required for IPSec.
336 tristate "CTS support"
337 select CRYPTO_BLKCIPHER
339 CTS: Cipher Text Stealing
340 This is the Cipher Text Stealing mode as described by
341 Section 8 of rfc2040 and referenced by rfc3962.
342 (rfc3962 includes errata information in its Appendix A)
343 This mode is required for Kerberos gss mechanism support
347 tristate "ECB support"
348 select CRYPTO_BLKCIPHER
349 select CRYPTO_MANAGER
351 ECB: Electronic CodeBook mode
352 This is the simplest block cipher algorithm. It simply encrypts
353 the input block by block.
356 tristate "LRW support"
357 select CRYPTO_BLKCIPHER
358 select CRYPTO_MANAGER
359 select CRYPTO_GF128MUL
361 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
362 narrow block cipher mode for dm-crypt. Use it with cipher
363 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
364 The first 128, 192 or 256 bits in the key are used for AES and the
365 rest is used to tie each cipher block to its logical position.
368 tristate "PCBC support"
369 select CRYPTO_BLKCIPHER
370 select CRYPTO_MANAGER
372 PCBC: Propagating Cipher Block Chaining mode
373 This block cipher algorithm is required for RxRPC.
376 tristate "XTS support"
377 select CRYPTO_BLKCIPHER
378 select CRYPTO_MANAGER
381 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
382 key size 256, 384 or 512 bits. This implementation currently
383 can't handle a sectorsize which is not a multiple of 16 bytes.
385 config CRYPTO_KEYWRAP
386 tristate "Key wrapping support"
387 select CRYPTO_BLKCIPHER
389 Support for key wrapping (NIST SP800-38F / RFC3394) without
395 tristate "CMAC support"
397 select CRYPTO_MANAGER
399 Cipher-based Message Authentication Code (CMAC) specified by
400 The National Institute of Standards and Technology (NIST).
402 https://tools.ietf.org/html/rfc4493
403 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
406 tristate "HMAC support"
408 select CRYPTO_MANAGER
410 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
411 This is required for IPSec.
414 tristate "XCBC support"
416 select CRYPTO_MANAGER
418 XCBC: Keyed-Hashing with encryption algorithm
419 http://www.ietf.org/rfc/rfc3566.txt
420 http://csrc.nist.gov/encryption/modes/proposedmodes/
421 xcbc-mac/xcbc-mac-spec.pdf
424 tristate "VMAC support"
426 select CRYPTO_MANAGER
428 VMAC is a message authentication algorithm designed for
429 very high speed on 64-bit architectures.
432 <http://fastcrypto.org/vmac>
437 tristate "CRC32c CRC algorithm"
441 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
442 by iSCSI for header and data digests and by others.
443 See Castagnoli93. Module will be crc32c.
445 config CRYPTO_CRC32C_INTEL
446 tristate "CRC32c INTEL hardware acceleration"
450 In Intel processor with SSE4.2 supported, the processor will
451 support CRC32C implementation using hardware accelerated CRC32
452 instruction. This option will create 'crc32c-intel' module,
453 which will enable any routine to use the CRC32 instruction to
454 gain performance compared with software implementation.
455 Module will be crc32c-intel.
457 config CRYPTO_CRC32C_VPMSUM
458 tristate "CRC32c CRC algorithm (powerpc64)"
459 depends on PPC64 && ALTIVEC
463 CRC32c algorithm implemented using vector polynomial multiply-sum
464 (vpmsum) instructions, introduced in POWER8. Enable on POWER8
465 and newer processors for improved performance.
468 config CRYPTO_CRC32C_SPARC64
469 tristate "CRC32c CRC algorithm (SPARC64)"
474 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
478 tristate "CRC32 CRC algorithm"
482 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
483 Shash crypto api wrappers to crc32_le function.
485 config CRYPTO_CRC32_PCLMUL
486 tristate "CRC32 PCLMULQDQ hardware acceleration"
491 From Intel Westmere and AMD Bulldozer processor with SSE4.2
492 and PCLMULQDQ supported, the processor will support
493 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
494 instruction. This option will create 'crc32-plcmul' module,
495 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
496 and gain better performance as compared with the table implementation.
498 config CRYPTO_CRCT10DIF
499 tristate "CRCT10DIF algorithm"
502 CRC T10 Data Integrity Field computation is being cast as
503 a crypto transform. This allows for faster crc t10 diff
504 transforms to be used if they are available.
506 config CRYPTO_CRCT10DIF_PCLMUL
507 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
508 depends on X86 && 64BIT && CRC_T10DIF
511 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
512 CRC T10 DIF PCLMULQDQ computation can be hardware
513 accelerated PCLMULQDQ instruction. This option will create
514 'crct10dif-plcmul' module, which is faster when computing the
515 crct10dif checksum as compared with the generic table implementation.
517 config CRYPTO_CRCT10DIF_VPMSUM
518 tristate "CRC32T10DIF powerpc64 hardware acceleration"
519 depends on PPC64 && ALTIVEC && CRC_T10DIF
522 CRC10T10DIF algorithm implemented using vector polynomial
523 multiply-sum (vpmsum) instructions, introduced in POWER8. Enable on
524 POWER8 and newer processors for improved performance.
526 config CRYPTO_VPMSUM_TESTER
527 tristate "Powerpc64 vpmsum hardware acceleration tester"
528 depends on CRYPTO_CRCT10DIF_VPMSUM && CRYPTO_CRC32C_VPMSUM
530 Stress test for CRC32c and CRC-T10DIF algorithms implemented with
531 POWER8 vpmsum instructions.
532 Unless you are testing these algorithms, you don't need this.
535 tristate "GHASH digest algorithm"
536 select CRYPTO_GF128MUL
539 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
541 config CRYPTO_POLY1305
542 tristate "Poly1305 authenticator algorithm"
545 Poly1305 authenticator algorithm, RFC7539.
547 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
548 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
549 in IETF protocols. This is the portable C implementation of Poly1305.
551 config CRYPTO_POLY1305_X86_64
552 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
553 depends on X86 && 64BIT
554 select CRYPTO_POLY1305
556 Poly1305 authenticator algorithm, RFC7539.
558 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
559 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
560 in IETF protocols. This is the x86_64 assembler implementation using SIMD
564 tristate "MD4 digest algorithm"
567 MD4 message digest algorithm (RFC1320).
570 tristate "MD5 digest algorithm"
573 MD5 message digest algorithm (RFC1321).
575 config CRYPTO_MD5_OCTEON
576 tristate "MD5 digest algorithm (OCTEON)"
577 depends on CPU_CAVIUM_OCTEON
581 MD5 message digest algorithm (RFC1321) implemented
582 using OCTEON crypto instructions, when available.
584 config CRYPTO_MD5_PPC
585 tristate "MD5 digest algorithm (PPC)"
589 MD5 message digest algorithm (RFC1321) implemented
592 config CRYPTO_MD5_SPARC64
593 tristate "MD5 digest algorithm (SPARC64)"
598 MD5 message digest algorithm (RFC1321) implemented
599 using sparc64 crypto instructions, when available.
601 config CRYPTO_MICHAEL_MIC
602 tristate "Michael MIC keyed digest algorithm"
605 Michael MIC is used for message integrity protection in TKIP
606 (IEEE 802.11i). This algorithm is required for TKIP, but it
607 should not be used for other purposes because of the weakness
611 tristate "RIPEMD-128 digest algorithm"
614 RIPEMD-128 (ISO/IEC 10118-3:2004).
616 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
617 be used as a secure replacement for RIPEMD. For other use cases,
618 RIPEMD-160 should be used.
620 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
621 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
624 tristate "RIPEMD-160 digest algorithm"
627 RIPEMD-160 (ISO/IEC 10118-3:2004).
629 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
630 to be used as a secure replacement for the 128-bit hash functions
631 MD4, MD5 and it's predecessor RIPEMD
632 (not to be confused with RIPEMD-128).
634 It's speed is comparable to SHA1 and there are no known attacks
637 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
638 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
641 tristate "RIPEMD-256 digest algorithm"
644 RIPEMD-256 is an optional extension of RIPEMD-128 with a
645 256 bit hash. It is intended for applications that require
646 longer hash-results, without needing a larger security level
649 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
650 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
653 tristate "RIPEMD-320 digest algorithm"
656 RIPEMD-320 is an optional extension of RIPEMD-160 with a
657 320 bit hash. It is intended for applications that require
658 longer hash-results, without needing a larger security level
661 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
662 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
665 tristate "SHA1 digest algorithm"
668 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
670 config CRYPTO_SHA1_SSSE3
671 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
672 depends on X86 && 64BIT
676 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
677 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
678 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
681 config CRYPTO_SHA256_SSSE3
682 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
683 depends on X86 && 64BIT
687 SHA-256 secure hash standard (DFIPS 180-2) implemented
688 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
689 Extensions version 1 (AVX1), or Advanced Vector Extensions
690 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
691 Instructions) when available.
693 config CRYPTO_SHA512_SSSE3
694 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
695 depends on X86 && 64BIT
699 SHA-512 secure hash standard (DFIPS 180-2) implemented
700 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
701 Extensions version 1 (AVX1), or Advanced Vector Extensions
702 version 2 (AVX2) instructions, when available.
704 config CRYPTO_SHA1_OCTEON
705 tristate "SHA1 digest algorithm (OCTEON)"
706 depends on CPU_CAVIUM_OCTEON
710 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
711 using OCTEON crypto instructions, when available.
713 config CRYPTO_SHA1_SPARC64
714 tristate "SHA1 digest algorithm (SPARC64)"
719 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
720 using sparc64 crypto instructions, when available.
722 config CRYPTO_SHA1_PPC
723 tristate "SHA1 digest algorithm (powerpc)"
726 This is the powerpc hardware accelerated implementation of the
727 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
729 config CRYPTO_SHA1_PPC_SPE
730 tristate "SHA1 digest algorithm (PPC SPE)"
731 depends on PPC && SPE
733 SHA-1 secure hash standard (DFIPS 180-4) implemented
734 using powerpc SPE SIMD instruction set.
736 config CRYPTO_SHA1_MB
737 tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
738 depends on X86 && 64BIT
741 select CRYPTO_MCRYPTD
743 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
744 using multi-buffer technique. This algorithm computes on
745 multiple data lanes concurrently with SIMD instructions for
746 better throughput. It should not be enabled by default but
747 used when there is significant amount of work to keep the keep
748 the data lanes filled to get performance benefit. If the data
749 lanes remain unfilled, a flush operation will be initiated to
750 process the crypto jobs, adding a slight latency.
752 config CRYPTO_SHA256_MB
753 tristate "SHA256 digest algorithm (x86_64 Multi-Buffer, Experimental)"
754 depends on X86 && 64BIT
757 select CRYPTO_MCRYPTD
759 SHA-256 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
760 using multi-buffer technique. This algorithm computes on
761 multiple data lanes concurrently with SIMD instructions for
762 better throughput. It should not be enabled by default but
763 used when there is significant amount of work to keep the keep
764 the data lanes filled to get performance benefit. If the data
765 lanes remain unfilled, a flush operation will be initiated to
766 process the crypto jobs, adding a slight latency.
768 config CRYPTO_SHA512_MB
769 tristate "SHA512 digest algorithm (x86_64 Multi-Buffer, Experimental)"
770 depends on X86 && 64BIT
773 select CRYPTO_MCRYPTD
775 SHA-512 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
776 using multi-buffer technique. This algorithm computes on
777 multiple data lanes concurrently with SIMD instructions for
778 better throughput. It should not be enabled by default but
779 used when there is significant amount of work to keep the keep
780 the data lanes filled to get performance benefit. If the data
781 lanes remain unfilled, a flush operation will be initiated to
782 process the crypto jobs, adding a slight latency.
785 tristate "SHA224 and SHA256 digest algorithm"
788 SHA256 secure hash standard (DFIPS 180-2).
790 This version of SHA implements a 256 bit hash with 128 bits of
791 security against collision attacks.
793 This code also includes SHA-224, a 224 bit hash with 112 bits
794 of security against collision attacks.
796 config CRYPTO_SHA256_PPC_SPE
797 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
798 depends on PPC && SPE
802 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
803 implemented using powerpc SPE SIMD instruction set.
805 config CRYPTO_SHA256_OCTEON
806 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
807 depends on CPU_CAVIUM_OCTEON
811 SHA-256 secure hash standard (DFIPS 180-2) implemented
812 using OCTEON crypto instructions, when available.
814 config CRYPTO_SHA256_SPARC64
815 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
820 SHA-256 secure hash standard (DFIPS 180-2) implemented
821 using sparc64 crypto instructions, when available.
824 tristate "SHA384 and SHA512 digest algorithms"
827 SHA512 secure hash standard (DFIPS 180-2).
829 This version of SHA implements a 512 bit hash with 256 bits of
830 security against collision attacks.
832 This code also includes SHA-384, a 384 bit hash with 192 bits
833 of security against collision attacks.
835 config CRYPTO_SHA512_OCTEON
836 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
837 depends on CPU_CAVIUM_OCTEON
841 SHA-512 secure hash standard (DFIPS 180-2) implemented
842 using OCTEON crypto instructions, when available.
844 config CRYPTO_SHA512_SPARC64
845 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
850 SHA-512 secure hash standard (DFIPS 180-2) implemented
851 using sparc64 crypto instructions, when available.
854 tristate "SHA3 digest algorithm"
857 SHA-3 secure hash standard (DFIPS 202). It's based on
858 cryptographic sponge function family called Keccak.
861 http://keccak.noekeon.org/
864 tristate "SM3 digest algorithm"
867 SM3 secure hash function as defined by OSCCA GM/T 0004-2012 SM3).
868 It is part of the Chinese Commercial Cryptography suite.
871 http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
872 https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
875 tristate "Tiger digest algorithms"
878 Tiger hash algorithm 192, 160 and 128-bit hashes
880 Tiger is a hash function optimized for 64-bit processors while
881 still having decent performance on 32-bit processors.
882 Tiger was developed by Ross Anderson and Eli Biham.
885 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
888 tristate "Whirlpool digest algorithms"
891 Whirlpool hash algorithm 512, 384 and 256-bit hashes
893 Whirlpool-512 is part of the NESSIE cryptographic primitives.
894 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
897 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
899 config CRYPTO_GHASH_CLMUL_NI_INTEL
900 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
901 depends on X86 && 64BIT
904 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
905 The implementation is accelerated by CLMUL-NI of Intel.
910 tristate "AES cipher algorithms"
913 AES cipher algorithms (FIPS-197). AES uses the Rijndael
916 Rijndael appears to be consistently a very good performer in
917 both hardware and software across a wide range of computing
918 environments regardless of its use in feedback or non-feedback
919 modes. Its key setup time is excellent, and its key agility is
920 good. Rijndael's very low memory requirements make it very well
921 suited for restricted-space environments, in which it also
922 demonstrates excellent performance. Rijndael's operations are
923 among the easiest to defend against power and timing attacks.
925 The AES specifies three key sizes: 128, 192 and 256 bits
927 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
930 tristate "Fixed time AES cipher"
933 This is a generic implementation of AES that attempts to eliminate
934 data dependent latencies as much as possible without affecting
935 performance too much. It is intended for use by the generic CCM
936 and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
937 solely on encryption (although decryption is supported as well, but
938 with a more dramatic performance hit)
940 Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
941 8 for decryption), this implementation only uses just two S-boxes of
942 256 bytes each, and attempts to eliminate data dependent latencies by
943 prefetching the entire table into the cache at the start of each
944 block. Interrupts are also disabled to avoid races where cachelines
945 are evicted when the CPU is interrupted to do something else.
947 config CRYPTO_AES_586
948 tristate "AES cipher algorithms (i586)"
949 depends on (X86 || UML_X86) && !64BIT
953 AES cipher algorithms (FIPS-197). AES uses the Rijndael
956 Rijndael appears to be consistently a very good performer in
957 both hardware and software across a wide range of computing
958 environments regardless of its use in feedback or non-feedback
959 modes. Its key setup time is excellent, and its key agility is
960 good. Rijndael's very low memory requirements make it very well
961 suited for restricted-space environments, in which it also
962 demonstrates excellent performance. Rijndael's operations are
963 among the easiest to defend against power and timing attacks.
965 The AES specifies three key sizes: 128, 192 and 256 bits
967 See <http://csrc.nist.gov/encryption/aes/> for more information.
969 config CRYPTO_AES_X86_64
970 tristate "AES cipher algorithms (x86_64)"
971 depends on (X86 || UML_X86) && 64BIT
975 AES cipher algorithms (FIPS-197). AES uses the Rijndael
978 Rijndael appears to be consistently a very good performer in
979 both hardware and software across a wide range of computing
980 environments regardless of its use in feedback or non-feedback
981 modes. Its key setup time is excellent, and its key agility is
982 good. Rijndael's very low memory requirements make it very well
983 suited for restricted-space environments, in which it also
984 demonstrates excellent performance. Rijndael's operations are
985 among the easiest to defend against power and timing attacks.
987 The AES specifies three key sizes: 128, 192 and 256 bits
989 See <http://csrc.nist.gov/encryption/aes/> for more information.
991 config CRYPTO_AES_NI_INTEL
992 tristate "AES cipher algorithms (AES-NI)"
995 select CRYPTO_AES_X86_64 if 64BIT
996 select CRYPTO_AES_586 if !64BIT
998 select CRYPTO_BLKCIPHER
999 select CRYPTO_GLUE_HELPER_X86 if 64BIT
1002 Use Intel AES-NI instructions for AES algorithm.
1004 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1007 Rijndael appears to be consistently a very good performer in
1008 both hardware and software across a wide range of computing
1009 environments regardless of its use in feedback or non-feedback
1010 modes. Its key setup time is excellent, and its key agility is
1011 good. Rijndael's very low memory requirements make it very well
1012 suited for restricted-space environments, in which it also
1013 demonstrates excellent performance. Rijndael's operations are
1014 among the easiest to defend against power and timing attacks.
1016 The AES specifies three key sizes: 128, 192 and 256 bits
1018 See <http://csrc.nist.gov/encryption/aes/> for more information.
1020 In addition to AES cipher algorithm support, the acceleration
1021 for some popular block cipher mode is supported too, including
1022 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
1023 acceleration for CTR.
1025 config CRYPTO_AES_SPARC64
1026 tristate "AES cipher algorithms (SPARC64)"
1028 select CRYPTO_CRYPTD
1029 select CRYPTO_ALGAPI
1031 Use SPARC64 crypto opcodes for AES algorithm.
1033 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1036 Rijndael appears to be consistently a very good performer in
1037 both hardware and software across a wide range of computing
1038 environments regardless of its use in feedback or non-feedback
1039 modes. Its key setup time is excellent, and its key agility is
1040 good. Rijndael's very low memory requirements make it very well
1041 suited for restricted-space environments, in which it also
1042 demonstrates excellent performance. Rijndael's operations are
1043 among the easiest to defend against power and timing attacks.
1045 The AES specifies three key sizes: 128, 192 and 256 bits
1047 See <http://csrc.nist.gov/encryption/aes/> for more information.
1049 In addition to AES cipher algorithm support, the acceleration
1050 for some popular block cipher mode is supported too, including
1053 config CRYPTO_AES_PPC_SPE
1054 tristate "AES cipher algorithms (PPC SPE)"
1055 depends on PPC && SPE
1057 AES cipher algorithms (FIPS-197). Additionally the acceleration
1058 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
1059 This module should only be used for low power (router) devices
1060 without hardware AES acceleration (e.g. caam crypto). It reduces the
1061 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
1062 timining attacks. Nevertheless it might be not as secure as other
1063 architecture specific assembler implementations that work on 1KB
1064 tables or 256 bytes S-boxes.
1066 config CRYPTO_ANUBIS
1067 tristate "Anubis cipher algorithm"
1068 select CRYPTO_ALGAPI
1070 Anubis cipher algorithm.
1072 Anubis is a variable key length cipher which can use keys from
1073 128 bits to 320 bits in length. It was evaluated as a entrant
1074 in the NESSIE competition.
1077 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1078 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1081 tristate "ARC4 cipher algorithm"
1082 select CRYPTO_BLKCIPHER
1084 ARC4 cipher algorithm.
1086 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1087 bits in length. This algorithm is required for driver-based
1088 WEP, but it should not be for other purposes because of the
1089 weakness of the algorithm.
1091 config CRYPTO_BLOWFISH
1092 tristate "Blowfish cipher algorithm"
1093 select CRYPTO_ALGAPI
1094 select CRYPTO_BLOWFISH_COMMON
1096 Blowfish cipher algorithm, by Bruce Schneier.
1098 This is a variable key length cipher which can use keys from 32
1099 bits to 448 bits in length. It's fast, simple and specifically
1100 designed for use on "large microprocessors".
1103 <http://www.schneier.com/blowfish.html>
1105 config CRYPTO_BLOWFISH_COMMON
1108 Common parts of the Blowfish cipher algorithm shared by the
1109 generic c and the assembler implementations.
1112 <http://www.schneier.com/blowfish.html>
1114 config CRYPTO_BLOWFISH_X86_64
1115 tristate "Blowfish cipher algorithm (x86_64)"
1116 depends on X86 && 64BIT
1117 select CRYPTO_ALGAPI
1118 select CRYPTO_BLOWFISH_COMMON
1120 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1122 This is a variable key length cipher which can use keys from 32
1123 bits to 448 bits in length. It's fast, simple and specifically
1124 designed for use on "large microprocessors".
1127 <http://www.schneier.com/blowfish.html>
1129 config CRYPTO_CAMELLIA
1130 tristate "Camellia cipher algorithms"
1132 select CRYPTO_ALGAPI
1134 Camellia cipher algorithms module.
1136 Camellia is a symmetric key block cipher developed jointly
1137 at NTT and Mitsubishi Electric Corporation.
1139 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1142 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1144 config CRYPTO_CAMELLIA_X86_64
1145 tristate "Camellia cipher algorithm (x86_64)"
1146 depends on X86 && 64BIT
1148 select CRYPTO_ALGAPI
1149 select CRYPTO_GLUE_HELPER_X86
1153 Camellia cipher algorithm module (x86_64).
1155 Camellia is a symmetric key block cipher developed jointly
1156 at NTT and Mitsubishi Electric Corporation.
1158 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1161 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1163 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1164 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1165 depends on X86 && 64BIT
1167 select CRYPTO_ALGAPI
1168 select CRYPTO_CRYPTD
1169 select CRYPTO_ABLK_HELPER
1170 select CRYPTO_GLUE_HELPER_X86
1171 select CRYPTO_CAMELLIA_X86_64
1175 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1177 Camellia is a symmetric key block cipher developed jointly
1178 at NTT and Mitsubishi Electric Corporation.
1180 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1183 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1185 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1186 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1187 depends on X86 && 64BIT
1189 select CRYPTO_ALGAPI
1190 select CRYPTO_CRYPTD
1191 select CRYPTO_ABLK_HELPER
1192 select CRYPTO_GLUE_HELPER_X86
1193 select CRYPTO_CAMELLIA_X86_64
1194 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1198 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1200 Camellia is a symmetric key block cipher developed jointly
1201 at NTT and Mitsubishi Electric Corporation.
1203 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1206 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1208 config CRYPTO_CAMELLIA_SPARC64
1209 tristate "Camellia cipher algorithm (SPARC64)"
1212 select CRYPTO_ALGAPI
1214 Camellia cipher algorithm module (SPARC64).
1216 Camellia is a symmetric key block cipher developed jointly
1217 at NTT and Mitsubishi Electric Corporation.
1219 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1222 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1224 config CRYPTO_CAST_COMMON
1227 Common parts of the CAST cipher algorithms shared by the
1228 generic c and the assembler implementations.
1231 tristate "CAST5 (CAST-128) cipher algorithm"
1232 select CRYPTO_ALGAPI
1233 select CRYPTO_CAST_COMMON
1235 The CAST5 encryption algorithm (synonymous with CAST-128) is
1236 described in RFC2144.
1238 config CRYPTO_CAST5_AVX_X86_64
1239 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1240 depends on X86 && 64BIT
1241 select CRYPTO_ALGAPI
1242 select CRYPTO_CRYPTD
1243 select CRYPTO_ABLK_HELPER
1244 select CRYPTO_CAST_COMMON
1247 The CAST5 encryption algorithm (synonymous with CAST-128) is
1248 described in RFC2144.
1250 This module provides the Cast5 cipher algorithm that processes
1251 sixteen blocks parallel using the AVX instruction set.
1254 tristate "CAST6 (CAST-256) cipher algorithm"
1255 select CRYPTO_ALGAPI
1256 select CRYPTO_CAST_COMMON
1258 The CAST6 encryption algorithm (synonymous with CAST-256) is
1259 described in RFC2612.
1261 config CRYPTO_CAST6_AVX_X86_64
1262 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1263 depends on X86 && 64BIT
1264 select CRYPTO_ALGAPI
1265 select CRYPTO_CRYPTD
1266 select CRYPTO_ABLK_HELPER
1267 select CRYPTO_GLUE_HELPER_X86
1268 select CRYPTO_CAST_COMMON
1273 The CAST6 encryption algorithm (synonymous with CAST-256) is
1274 described in RFC2612.
1276 This module provides the Cast6 cipher algorithm that processes
1277 eight blocks parallel using the AVX instruction set.
1280 tristate "DES and Triple DES EDE cipher algorithms"
1281 select CRYPTO_ALGAPI
1283 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1285 config CRYPTO_DES_SPARC64
1286 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1288 select CRYPTO_ALGAPI
1291 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1292 optimized using SPARC64 crypto opcodes.
1294 config CRYPTO_DES3_EDE_X86_64
1295 tristate "Triple DES EDE cipher algorithm (x86-64)"
1296 depends on X86 && 64BIT
1297 select CRYPTO_ALGAPI
1300 Triple DES EDE (FIPS 46-3) algorithm.
1302 This module provides implementation of the Triple DES EDE cipher
1303 algorithm that is optimized for x86-64 processors. Two versions of
1304 algorithm are provided; regular processing one input block and
1305 one that processes three blocks parallel.
1307 config CRYPTO_FCRYPT
1308 tristate "FCrypt cipher algorithm"
1309 select CRYPTO_ALGAPI
1310 select CRYPTO_BLKCIPHER
1312 FCrypt algorithm used by RxRPC.
1314 config CRYPTO_KHAZAD
1315 tristate "Khazad cipher algorithm"
1316 select CRYPTO_ALGAPI
1318 Khazad cipher algorithm.
1320 Khazad was a finalist in the initial NESSIE competition. It is
1321 an algorithm optimized for 64-bit processors with good performance
1322 on 32-bit processors. Khazad uses an 128 bit key size.
1325 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1327 config CRYPTO_SALSA20
1328 tristate "Salsa20 stream cipher algorithm"
1329 select CRYPTO_BLKCIPHER
1331 Salsa20 stream cipher algorithm.
1333 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1334 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1336 The Salsa20 stream cipher algorithm is designed by Daniel J.
1337 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1339 config CRYPTO_CHACHA20
1340 tristate "ChaCha20 cipher algorithm"
1341 select CRYPTO_BLKCIPHER
1343 ChaCha20 cipher algorithm, RFC7539.
1345 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1346 Bernstein and further specified in RFC7539 for use in IETF protocols.
1347 This is the portable C implementation of ChaCha20.
1350 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1352 config CRYPTO_CHACHA20_X86_64
1353 tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1354 depends on X86 && 64BIT
1355 select CRYPTO_BLKCIPHER
1356 select CRYPTO_CHACHA20
1358 ChaCha20 cipher algorithm, RFC7539.
1360 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1361 Bernstein and further specified in RFC7539 for use in IETF protocols.
1362 This is the x86_64 assembler implementation using SIMD instructions.
1365 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1368 tristate "SEED cipher algorithm"
1369 select CRYPTO_ALGAPI
1371 SEED cipher algorithm (RFC4269).
1373 SEED is a 128-bit symmetric key block cipher that has been
1374 developed by KISA (Korea Information Security Agency) as a
1375 national standard encryption algorithm of the Republic of Korea.
1376 It is a 16 round block cipher with the key size of 128 bit.
1379 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1381 config CRYPTO_SERPENT
1382 tristate "Serpent cipher algorithm"
1383 select CRYPTO_ALGAPI
1385 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1387 Keys are allowed to be from 0 to 256 bits in length, in steps
1388 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1389 variant of Serpent for compatibility with old kerneli.org code.
1392 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1394 config CRYPTO_SERPENT_SSE2_X86_64
1395 tristate "Serpent cipher algorithm (x86_64/SSE2)"
1396 depends on X86 && 64BIT
1397 select CRYPTO_ALGAPI
1398 select CRYPTO_CRYPTD
1399 select CRYPTO_ABLK_HELPER
1400 select CRYPTO_GLUE_HELPER_X86
1401 select CRYPTO_SERPENT
1405 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1407 Keys are allowed to be from 0 to 256 bits in length, in steps
1410 This module provides Serpent cipher algorithm that processes eight
1411 blocks parallel using SSE2 instruction set.
1414 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1416 config CRYPTO_SERPENT_SSE2_586
1417 tristate "Serpent cipher algorithm (i586/SSE2)"
1418 depends on X86 && !64BIT
1419 select CRYPTO_ALGAPI
1420 select CRYPTO_CRYPTD
1421 select CRYPTO_ABLK_HELPER
1422 select CRYPTO_GLUE_HELPER_X86
1423 select CRYPTO_SERPENT
1427 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1429 Keys are allowed to be from 0 to 256 bits in length, in steps
1432 This module provides Serpent cipher algorithm that processes four
1433 blocks parallel using SSE2 instruction set.
1436 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1438 config CRYPTO_SERPENT_AVX_X86_64
1439 tristate "Serpent cipher algorithm (x86_64/AVX)"
1440 depends on X86 && 64BIT
1441 select CRYPTO_ALGAPI
1442 select CRYPTO_CRYPTD
1443 select CRYPTO_ABLK_HELPER
1444 select CRYPTO_GLUE_HELPER_X86
1445 select CRYPTO_SERPENT
1449 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1451 Keys are allowed to be from 0 to 256 bits in length, in steps
1454 This module provides the Serpent cipher algorithm that processes
1455 eight blocks parallel using the AVX instruction set.
1458 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1460 config CRYPTO_SERPENT_AVX2_X86_64
1461 tristate "Serpent cipher algorithm (x86_64/AVX2)"
1462 depends on X86 && 64BIT
1463 select CRYPTO_ALGAPI
1464 select CRYPTO_CRYPTD
1465 select CRYPTO_ABLK_HELPER
1466 select CRYPTO_GLUE_HELPER_X86
1467 select CRYPTO_SERPENT
1468 select CRYPTO_SERPENT_AVX_X86_64
1472 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1474 Keys are allowed to be from 0 to 256 bits in length, in steps
1477 This module provides Serpent cipher algorithm that processes 16
1478 blocks parallel using AVX2 instruction set.
1481 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1484 tristate "TEA, XTEA and XETA cipher algorithms"
1485 select CRYPTO_ALGAPI
1487 TEA cipher algorithm.
1489 Tiny Encryption Algorithm is a simple cipher that uses
1490 many rounds for security. It is very fast and uses
1493 Xtendend Tiny Encryption Algorithm is a modification to
1494 the TEA algorithm to address a potential key weakness
1495 in the TEA algorithm.
1497 Xtendend Encryption Tiny Algorithm is a mis-implementation
1498 of the XTEA algorithm for compatibility purposes.
1500 config CRYPTO_TWOFISH
1501 tristate "Twofish cipher algorithm"
1502 select CRYPTO_ALGAPI
1503 select CRYPTO_TWOFISH_COMMON
1505 Twofish cipher algorithm.
1507 Twofish was submitted as an AES (Advanced Encryption Standard)
1508 candidate cipher by researchers at CounterPane Systems. It is a
1509 16 round block cipher supporting key sizes of 128, 192, and 256
1513 <http://www.schneier.com/twofish.html>
1515 config CRYPTO_TWOFISH_COMMON
1518 Common parts of the Twofish cipher algorithm shared by the
1519 generic c and the assembler implementations.
1521 config CRYPTO_TWOFISH_586
1522 tristate "Twofish cipher algorithms (i586)"
1523 depends on (X86 || UML_X86) && !64BIT
1524 select CRYPTO_ALGAPI
1525 select CRYPTO_TWOFISH_COMMON
1527 Twofish cipher algorithm.
1529 Twofish was submitted as an AES (Advanced Encryption Standard)
1530 candidate cipher by researchers at CounterPane Systems. It is a
1531 16 round block cipher supporting key sizes of 128, 192, and 256
1535 <http://www.schneier.com/twofish.html>
1537 config CRYPTO_TWOFISH_X86_64
1538 tristate "Twofish cipher algorithm (x86_64)"
1539 depends on (X86 || UML_X86) && 64BIT
1540 select CRYPTO_ALGAPI
1541 select CRYPTO_TWOFISH_COMMON
1543 Twofish cipher algorithm (x86_64).
1545 Twofish was submitted as an AES (Advanced Encryption Standard)
1546 candidate cipher by researchers at CounterPane Systems. It is a
1547 16 round block cipher supporting key sizes of 128, 192, and 256
1551 <http://www.schneier.com/twofish.html>
1553 config CRYPTO_TWOFISH_X86_64_3WAY
1554 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1555 depends on X86 && 64BIT
1556 select CRYPTO_ALGAPI
1557 select CRYPTO_TWOFISH_COMMON
1558 select CRYPTO_TWOFISH_X86_64
1559 select CRYPTO_GLUE_HELPER_X86
1563 Twofish cipher algorithm (x86_64, 3-way parallel).
1565 Twofish was submitted as an AES (Advanced Encryption Standard)
1566 candidate cipher by researchers at CounterPane Systems. It is a
1567 16 round block cipher supporting key sizes of 128, 192, and 256
1570 This module provides Twofish cipher algorithm that processes three
1571 blocks parallel, utilizing resources of out-of-order CPUs better.
1574 <http://www.schneier.com/twofish.html>
1576 config CRYPTO_TWOFISH_AVX_X86_64
1577 tristate "Twofish cipher algorithm (x86_64/AVX)"
1578 depends on X86 && 64BIT
1579 select CRYPTO_ALGAPI
1580 select CRYPTO_CRYPTD
1581 select CRYPTO_ABLK_HELPER
1582 select CRYPTO_GLUE_HELPER_X86
1583 select CRYPTO_TWOFISH_COMMON
1584 select CRYPTO_TWOFISH_X86_64
1585 select CRYPTO_TWOFISH_X86_64_3WAY
1589 Twofish cipher algorithm (x86_64/AVX).
1591 Twofish was submitted as an AES (Advanced Encryption Standard)
1592 candidate cipher by researchers at CounterPane Systems. It is a
1593 16 round block cipher supporting key sizes of 128, 192, and 256
1596 This module provides the Twofish cipher algorithm that processes
1597 eight blocks parallel using the AVX Instruction Set.
1600 <http://www.schneier.com/twofish.html>
1602 comment "Compression"
1604 config CRYPTO_DEFLATE
1605 tristate "Deflate compression algorithm"
1606 select CRYPTO_ALGAPI
1607 select CRYPTO_ACOMP2
1611 This is the Deflate algorithm (RFC1951), specified for use in
1612 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1614 You will most probably want this if using IPSec.
1617 tristate "LZO compression algorithm"
1618 select CRYPTO_ALGAPI
1619 select CRYPTO_ACOMP2
1621 select LZO_DECOMPRESS
1623 This is the LZO algorithm.
1626 tristate "842 compression algorithm"
1627 select CRYPTO_ALGAPI
1628 select CRYPTO_ACOMP2
1630 select 842_DECOMPRESS
1632 This is the 842 algorithm.
1635 tristate "LZ4 compression algorithm"
1636 select CRYPTO_ALGAPI
1637 select CRYPTO_ACOMP2
1639 select LZ4_DECOMPRESS
1641 This is the LZ4 algorithm.
1644 tristate "LZ4HC compression algorithm"
1645 select CRYPTO_ALGAPI
1646 select CRYPTO_ACOMP2
1647 select LZ4HC_COMPRESS
1648 select LZ4_DECOMPRESS
1650 This is the LZ4 high compression mode algorithm.
1652 comment "Random Number Generation"
1654 config CRYPTO_ANSI_CPRNG
1655 tristate "Pseudo Random Number Generation for Cryptographic modules"
1659 This option enables the generic pseudo random number generator
1660 for cryptographic modules. Uses the Algorithm specified in
1661 ANSI X9.31 A.2.4. Note that this option must be enabled if
1662 CRYPTO_FIPS is selected
1664 menuconfig CRYPTO_DRBG_MENU
1665 tristate "NIST SP800-90A DRBG"
1667 NIST SP800-90A compliant DRBG. In the following submenu, one or
1668 more of the DRBG types must be selected.
1672 config CRYPTO_DRBG_HMAC
1676 select CRYPTO_SHA256
1678 config CRYPTO_DRBG_HASH
1679 bool "Enable Hash DRBG"
1680 select CRYPTO_SHA256
1682 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1684 config CRYPTO_DRBG_CTR
1685 bool "Enable CTR DRBG"
1687 depends on CRYPTO_CTR
1689 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1693 default CRYPTO_DRBG_MENU
1695 select CRYPTO_JITTERENTROPY
1697 endif # if CRYPTO_DRBG_MENU
1699 config CRYPTO_JITTERENTROPY
1700 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1703 The Jitterentropy RNG is a noise that is intended
1704 to provide seed to another RNG. The RNG does not
1705 perform any cryptographic whitening of the generated
1706 random numbers. This Jitterentropy RNG registers with
1707 the kernel crypto API and can be used by any caller.
1709 config CRYPTO_USER_API
1712 config CRYPTO_USER_API_HASH
1713 tristate "User-space interface for hash algorithms"
1716 select CRYPTO_USER_API
1718 This option enables the user-spaces interface for hash
1721 config CRYPTO_USER_API_SKCIPHER
1722 tristate "User-space interface for symmetric key cipher algorithms"
1724 select CRYPTO_BLKCIPHER
1725 select CRYPTO_USER_API
1727 This option enables the user-spaces interface for symmetric
1728 key cipher algorithms.
1730 config CRYPTO_USER_API_RNG
1731 tristate "User-space interface for random number generator algorithms"
1734 select CRYPTO_USER_API
1736 This option enables the user-spaces interface for random
1737 number generator algorithms.
1739 config CRYPTO_USER_API_AEAD
1740 tristate "User-space interface for AEAD cipher algorithms"
1743 select CRYPTO_BLKCIPHER
1745 select CRYPTO_USER_API
1747 This option enables the user-spaces interface for AEAD
1750 config CRYPTO_HASH_INFO
1753 source "drivers/crypto/Kconfig"
1754 source crypto/asymmetric_keys/Kconfig
1755 source certs/Kconfig