2 # Generic algorithms support
8 # async_tx api: hardware offloaded memory transfer/transform support
10 source "crypto/async_tx/Kconfig"
13 # Cryptographic API Configuration
16 tristate "Cryptographic API"
18 This option provides the core Cryptographic API.
22 comment "Crypto core or helper"
25 bool "FIPS 200 compliance"
26 depends on (CRYPTO_ANSI_CPRNG || CRYPTO_DRBG) && !CRYPTO_MANAGER_DISABLE_TESTS
29 This options enables the fips boot option which is
30 required if you want to system to operate in a FIPS 200
31 certification. You should say no unless you know what
38 This option provides the API for cryptographic algorithms.
52 config CRYPTO_BLKCIPHER
54 select CRYPTO_BLKCIPHER2
57 config CRYPTO_BLKCIPHER2
61 select CRYPTO_WORKQUEUE
91 tristate "Cryptographic algorithm manager"
92 select CRYPTO_MANAGER2
94 Create default cryptographic template instantiations such as
97 config CRYPTO_MANAGER2
98 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
101 select CRYPTO_BLKCIPHER2
105 tristate "Userspace cryptographic algorithm configuration"
107 select CRYPTO_MANAGER
109 Userspace configuration for cryptographic instantiations such as
112 config CRYPTO_MANAGER_DISABLE_TESTS
113 bool "Disable run-time self tests"
115 depends on CRYPTO_MANAGER2
117 Disable run-time self tests that normally take place at
118 algorithm registration.
120 config CRYPTO_GF128MUL
121 tristate "GF(2^128) multiplication functions"
123 Efficient table driven implementation of multiplications in the
124 field GF(2^128). This is needed by some cypher modes. This
125 option will be selected automatically if you select such a
126 cipher mode. Only select this option by hand if you expect to load
127 an external module that requires these functions.
130 tristate "Null algorithms"
132 select CRYPTO_BLKCIPHER
135 These are 'Null' algorithms, used by IPsec, which do nothing.
138 tristate "Parallel crypto engine"
141 select CRYPTO_MANAGER
144 This converts an arbitrary crypto algorithm into a parallel
145 algorithm that executes in kernel threads.
147 config CRYPTO_WORKQUEUE
151 tristate "Software async crypto daemon"
152 select CRYPTO_BLKCIPHER
154 select CRYPTO_MANAGER
155 select CRYPTO_WORKQUEUE
157 This is a generic software asynchronous crypto daemon that
158 converts an arbitrary synchronous software crypto algorithm
159 into an asynchronous algorithm that executes in a kernel thread.
161 config CRYPTO_MCRYPTD
162 tristate "Software async multi-buffer crypto daemon"
163 select CRYPTO_BLKCIPHER
165 select CRYPTO_MANAGER
166 select CRYPTO_WORKQUEUE
168 This is a generic software asynchronous crypto daemon that
169 provides the kernel thread to assist multi-buffer crypto
170 algorithms for submitting jobs and flushing jobs in multi-buffer
171 crypto algorithms. Multi-buffer crypto algorithms are executed
172 in the context of this kernel thread and drivers can post
173 their crypto request asynchronously to be processed by this daemon.
175 config CRYPTO_AUTHENC
176 tristate "Authenc support"
178 select CRYPTO_BLKCIPHER
179 select CRYPTO_MANAGER
182 Authenc: Combined mode wrapper for IPsec.
183 This is required for IPSec.
186 tristate "Testing module"
188 select CRYPTO_MANAGER
190 Quick & dirty crypto test module.
192 config CRYPTO_ABLK_HELPER
196 config CRYPTO_GLUE_HELPER_X86
201 comment "Authenticated Encryption with Associated Data"
204 tristate "CCM support"
208 Support for Counter with CBC MAC. Required for IPsec.
211 tristate "GCM/GMAC support"
217 Support for Galois/Counter Mode (GCM) and Galois Message
218 Authentication Code (GMAC). Required for IPSec.
221 tristate "Sequence Number IV Generator"
223 select CRYPTO_BLKCIPHER
227 This IV generator generates an IV based on a sequence number by
228 xoring it with a salt. This algorithm is mainly useful for CTR
230 config CRYPTO_ECHAINIV
231 tristate "Encrypted Chain IV Generator"
236 This IV generator generates an IV based on the encryption of
237 a sequence number xored with a salt. This is the default
240 comment "Block modes"
243 tristate "CBC support"
244 select CRYPTO_BLKCIPHER
245 select CRYPTO_MANAGER
247 CBC: Cipher Block Chaining mode
248 This block cipher algorithm is required for IPSec.
251 tristate "CTR support"
252 select CRYPTO_BLKCIPHER
254 select CRYPTO_MANAGER
257 This block cipher algorithm is required for IPSec.
260 tristate "CTS support"
261 select CRYPTO_BLKCIPHER
263 CTS: Cipher Text Stealing
264 This is the Cipher Text Stealing mode as described by
265 Section 8 of rfc2040 and referenced by rfc3962.
266 (rfc3962 includes errata information in its Appendix A)
267 This mode is required for Kerberos gss mechanism support
271 tristate "ECB support"
272 select CRYPTO_BLKCIPHER
273 select CRYPTO_MANAGER
275 ECB: Electronic CodeBook mode
276 This is the simplest block cipher algorithm. It simply encrypts
277 the input block by block.
280 tristate "LRW support"
281 select CRYPTO_BLKCIPHER
282 select CRYPTO_MANAGER
283 select CRYPTO_GF128MUL
285 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
286 narrow block cipher mode for dm-crypt. Use it with cipher
287 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
288 The first 128, 192 or 256 bits in the key are used for AES and the
289 rest is used to tie each cipher block to its logical position.
292 tristate "PCBC support"
293 select CRYPTO_BLKCIPHER
294 select CRYPTO_MANAGER
296 PCBC: Propagating Cipher Block Chaining mode
297 This block cipher algorithm is required for RxRPC.
300 tristate "XTS support"
301 select CRYPTO_BLKCIPHER
302 select CRYPTO_MANAGER
303 select CRYPTO_GF128MUL
305 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
306 key size 256, 384 or 512 bits. This implementation currently
307 can't handle a sectorsize which is not a multiple of 16 bytes.
312 tristate "CMAC support"
314 select CRYPTO_MANAGER
316 Cipher-based Message Authentication Code (CMAC) specified by
317 The National Institute of Standards and Technology (NIST).
319 https://tools.ietf.org/html/rfc4493
320 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
323 tristate "HMAC support"
325 select CRYPTO_MANAGER
327 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
328 This is required for IPSec.
331 tristate "XCBC support"
333 select CRYPTO_MANAGER
335 XCBC: Keyed-Hashing with encryption algorithm
336 http://www.ietf.org/rfc/rfc3566.txt
337 http://csrc.nist.gov/encryption/modes/proposedmodes/
338 xcbc-mac/xcbc-mac-spec.pdf
341 tristate "VMAC support"
343 select CRYPTO_MANAGER
345 VMAC is a message authentication algorithm designed for
346 very high speed on 64-bit architectures.
349 <http://fastcrypto.org/vmac>
354 tristate "CRC32c CRC algorithm"
358 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
359 by iSCSI for header and data digests and by others.
360 See Castagnoli93. Module will be crc32c.
362 config CRYPTO_CRC32C_INTEL
363 tristate "CRC32c INTEL hardware acceleration"
367 In Intel processor with SSE4.2 supported, the processor will
368 support CRC32C implementation using hardware accelerated CRC32
369 instruction. This option will create 'crc32c-intel' module,
370 which will enable any routine to use the CRC32 instruction to
371 gain performance compared with software implementation.
372 Module will be crc32c-intel.
374 config CRYPTO_CRC32C_SPARC64
375 tristate "CRC32c CRC algorithm (SPARC64)"
380 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
384 tristate "CRC32 CRC algorithm"
388 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
389 Shash crypto api wrappers to crc32_le function.
391 config CRYPTO_CRC32_PCLMUL
392 tristate "CRC32 PCLMULQDQ hardware acceleration"
397 From Intel Westmere and AMD Bulldozer processor with SSE4.2
398 and PCLMULQDQ supported, the processor will support
399 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
400 instruction. This option will create 'crc32-plcmul' module,
401 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
402 and gain better performance as compared with the table implementation.
404 config CRYPTO_CRCT10DIF
405 tristate "CRCT10DIF algorithm"
408 CRC T10 Data Integrity Field computation is being cast as
409 a crypto transform. This allows for faster crc t10 diff
410 transforms to be used if they are available.
412 config CRYPTO_CRCT10DIF_PCLMUL
413 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
414 depends on X86 && 64BIT && CRC_T10DIF
417 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
418 CRC T10 DIF PCLMULQDQ computation can be hardware
419 accelerated PCLMULQDQ instruction. This option will create
420 'crct10dif-plcmul' module, which is faster when computing the
421 crct10dif checksum as compared with the generic table implementation.
424 tristate "GHASH digest algorithm"
425 select CRYPTO_GF128MUL
427 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
430 tristate "MD4 digest algorithm"
433 MD4 message digest algorithm (RFC1320).
436 tristate "MD5 digest algorithm"
439 MD5 message digest algorithm (RFC1321).
441 config CRYPTO_MD5_OCTEON
442 tristate "MD5 digest algorithm (OCTEON)"
443 depends on CPU_CAVIUM_OCTEON
447 MD5 message digest algorithm (RFC1321) implemented
448 using OCTEON crypto instructions, when available.
450 config CRYPTO_MD5_PPC
451 tristate "MD5 digest algorithm (PPC)"
455 MD5 message digest algorithm (RFC1321) implemented
458 config CRYPTO_MD5_SPARC64
459 tristate "MD5 digest algorithm (SPARC64)"
464 MD5 message digest algorithm (RFC1321) implemented
465 using sparc64 crypto instructions, when available.
467 config CRYPTO_MICHAEL_MIC
468 tristate "Michael MIC keyed digest algorithm"
471 Michael MIC is used for message integrity protection in TKIP
472 (IEEE 802.11i). This algorithm is required for TKIP, but it
473 should not be used for other purposes because of the weakness
477 tristate "RIPEMD-128 digest algorithm"
480 RIPEMD-128 (ISO/IEC 10118-3:2004).
482 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
483 be used as a secure replacement for RIPEMD. For other use cases,
484 RIPEMD-160 should be used.
486 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
487 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
490 tristate "RIPEMD-160 digest algorithm"
493 RIPEMD-160 (ISO/IEC 10118-3:2004).
495 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
496 to be used as a secure replacement for the 128-bit hash functions
497 MD4, MD5 and it's predecessor RIPEMD
498 (not to be confused with RIPEMD-128).
500 It's speed is comparable to SHA1 and there are no known attacks
503 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
504 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
507 tristate "RIPEMD-256 digest algorithm"
510 RIPEMD-256 is an optional extension of RIPEMD-128 with a
511 256 bit hash. It is intended for applications that require
512 longer hash-results, without needing a larger security level
515 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
516 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
519 tristate "RIPEMD-320 digest algorithm"
522 RIPEMD-320 is an optional extension of RIPEMD-160 with a
523 320 bit hash. It is intended for applications that require
524 longer hash-results, without needing a larger security level
527 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
528 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
531 tristate "SHA1 digest algorithm"
534 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
536 config CRYPTO_SHA1_SSSE3
537 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2)"
538 depends on X86 && 64BIT
542 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
543 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
544 Extensions (AVX/AVX2), when available.
546 config CRYPTO_SHA256_SSSE3
547 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2)"
548 depends on X86 && 64BIT
552 SHA-256 secure hash standard (DFIPS 180-2) implemented
553 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
554 Extensions version 1 (AVX1), or Advanced Vector Extensions
555 version 2 (AVX2) instructions, when available.
557 config CRYPTO_SHA512_SSSE3
558 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
559 depends on X86 && 64BIT
563 SHA-512 secure hash standard (DFIPS 180-2) implemented
564 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
565 Extensions version 1 (AVX1), or Advanced Vector Extensions
566 version 2 (AVX2) instructions, when available.
568 config CRYPTO_SHA1_OCTEON
569 tristate "SHA1 digest algorithm (OCTEON)"
570 depends on CPU_CAVIUM_OCTEON
574 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
575 using OCTEON crypto instructions, when available.
577 config CRYPTO_SHA1_SPARC64
578 tristate "SHA1 digest algorithm (SPARC64)"
583 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
584 using sparc64 crypto instructions, when available.
586 config CRYPTO_SHA1_PPC
587 tristate "SHA1 digest algorithm (powerpc)"
590 This is the powerpc hardware accelerated implementation of the
591 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
593 config CRYPTO_SHA1_PPC_SPE
594 tristate "SHA1 digest algorithm (PPC SPE)"
595 depends on PPC && SPE
597 SHA-1 secure hash standard (DFIPS 180-4) implemented
598 using powerpc SPE SIMD instruction set.
600 config CRYPTO_SHA1_MB
601 tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
602 depends on X86 && 64BIT
605 select CRYPTO_MCRYPTD
607 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
608 using multi-buffer technique. This algorithm computes on
609 multiple data lanes concurrently with SIMD instructions for
610 better throughput. It should not be enabled by default but
611 used when there is significant amount of work to keep the keep
612 the data lanes filled to get performance benefit. If the data
613 lanes remain unfilled, a flush operation will be initiated to
614 process the crypto jobs, adding a slight latency.
617 tristate "SHA224 and SHA256 digest algorithm"
620 SHA256 secure hash standard (DFIPS 180-2).
622 This version of SHA implements a 256 bit hash with 128 bits of
623 security against collision attacks.
625 This code also includes SHA-224, a 224 bit hash with 112 bits
626 of security against collision attacks.
628 config CRYPTO_SHA256_PPC_SPE
629 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
630 depends on PPC && SPE
634 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
635 implemented using powerpc SPE SIMD instruction set.
637 config CRYPTO_SHA256_OCTEON
638 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
639 depends on CPU_CAVIUM_OCTEON
643 SHA-256 secure hash standard (DFIPS 180-2) implemented
644 using OCTEON crypto instructions, when available.
646 config CRYPTO_SHA256_SPARC64
647 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
652 SHA-256 secure hash standard (DFIPS 180-2) implemented
653 using sparc64 crypto instructions, when available.
656 tristate "SHA384 and SHA512 digest algorithms"
659 SHA512 secure hash standard (DFIPS 180-2).
661 This version of SHA implements a 512 bit hash with 256 bits of
662 security against collision attacks.
664 This code also includes SHA-384, a 384 bit hash with 192 bits
665 of security against collision attacks.
667 config CRYPTO_SHA512_OCTEON
668 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
669 depends on CPU_CAVIUM_OCTEON
673 SHA-512 secure hash standard (DFIPS 180-2) implemented
674 using OCTEON crypto instructions, when available.
676 config CRYPTO_SHA512_SPARC64
677 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
682 SHA-512 secure hash standard (DFIPS 180-2) implemented
683 using sparc64 crypto instructions, when available.
686 tristate "Tiger digest algorithms"
689 Tiger hash algorithm 192, 160 and 128-bit hashes
691 Tiger is a hash function optimized for 64-bit processors while
692 still having decent performance on 32-bit processors.
693 Tiger was developed by Ross Anderson and Eli Biham.
696 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
699 tristate "Whirlpool digest algorithms"
702 Whirlpool hash algorithm 512, 384 and 256-bit hashes
704 Whirlpool-512 is part of the NESSIE cryptographic primitives.
705 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
708 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
710 config CRYPTO_GHASH_CLMUL_NI_INTEL
711 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
712 depends on X86 && 64BIT
715 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
716 The implementation is accelerated by CLMUL-NI of Intel.
721 tristate "AES cipher algorithms"
724 AES cipher algorithms (FIPS-197). AES uses the Rijndael
727 Rijndael appears to be consistently a very good performer in
728 both hardware and software across a wide range of computing
729 environments regardless of its use in feedback or non-feedback
730 modes. Its key setup time is excellent, and its key agility is
731 good. Rijndael's very low memory requirements make it very well
732 suited for restricted-space environments, in which it also
733 demonstrates excellent performance. Rijndael's operations are
734 among the easiest to defend against power and timing attacks.
736 The AES specifies three key sizes: 128, 192 and 256 bits
738 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
740 config CRYPTO_AES_586
741 tristate "AES cipher algorithms (i586)"
742 depends on (X86 || UML_X86) && !64BIT
746 AES cipher algorithms (FIPS-197). AES uses the Rijndael
749 Rijndael appears to be consistently a very good performer in
750 both hardware and software across a wide range of computing
751 environments regardless of its use in feedback or non-feedback
752 modes. Its key setup time is excellent, and its key agility is
753 good. Rijndael's very low memory requirements make it very well
754 suited for restricted-space environments, in which it also
755 demonstrates excellent performance. Rijndael's operations are
756 among the easiest to defend against power and timing attacks.
758 The AES specifies three key sizes: 128, 192 and 256 bits
760 See <http://csrc.nist.gov/encryption/aes/> for more information.
762 config CRYPTO_AES_X86_64
763 tristate "AES cipher algorithms (x86_64)"
764 depends on (X86 || UML_X86) && 64BIT
768 AES cipher algorithms (FIPS-197). AES uses the Rijndael
771 Rijndael appears to be consistently a very good performer in
772 both hardware and software across a wide range of computing
773 environments regardless of its use in feedback or non-feedback
774 modes. Its key setup time is excellent, and its key agility is
775 good. Rijndael's very low memory requirements make it very well
776 suited for restricted-space environments, in which it also
777 demonstrates excellent performance. Rijndael's operations are
778 among the easiest to defend against power and timing attacks.
780 The AES specifies three key sizes: 128, 192 and 256 bits
782 See <http://csrc.nist.gov/encryption/aes/> for more information.
784 config CRYPTO_AES_NI_INTEL
785 tristate "AES cipher algorithms (AES-NI)"
787 select CRYPTO_AES_X86_64 if 64BIT
788 select CRYPTO_AES_586 if !64BIT
790 select CRYPTO_ABLK_HELPER
792 select CRYPTO_GLUE_HELPER_X86 if 64BIT
796 Use Intel AES-NI instructions for AES algorithm.
798 AES cipher algorithms (FIPS-197). AES uses the Rijndael
801 Rijndael appears to be consistently a very good performer in
802 both hardware and software across a wide range of computing
803 environments regardless of its use in feedback or non-feedback
804 modes. Its key setup time is excellent, and its key agility is
805 good. Rijndael's very low memory requirements make it very well
806 suited for restricted-space environments, in which it also
807 demonstrates excellent performance. Rijndael's operations are
808 among the easiest to defend against power and timing attacks.
810 The AES specifies three key sizes: 128, 192 and 256 bits
812 See <http://csrc.nist.gov/encryption/aes/> for more information.
814 In addition to AES cipher algorithm support, the acceleration
815 for some popular block cipher mode is supported too, including
816 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
817 acceleration for CTR.
819 config CRYPTO_AES_SPARC64
820 tristate "AES cipher algorithms (SPARC64)"
825 Use SPARC64 crypto opcodes for AES algorithm.
827 AES cipher algorithms (FIPS-197). AES uses the Rijndael
830 Rijndael appears to be consistently a very good performer in
831 both hardware and software across a wide range of computing
832 environments regardless of its use in feedback or non-feedback
833 modes. Its key setup time is excellent, and its key agility is
834 good. Rijndael's very low memory requirements make it very well
835 suited for restricted-space environments, in which it also
836 demonstrates excellent performance. Rijndael's operations are
837 among the easiest to defend against power and timing attacks.
839 The AES specifies three key sizes: 128, 192 and 256 bits
841 See <http://csrc.nist.gov/encryption/aes/> for more information.
843 In addition to AES cipher algorithm support, the acceleration
844 for some popular block cipher mode is supported too, including
847 config CRYPTO_AES_PPC_SPE
848 tristate "AES cipher algorithms (PPC SPE)"
849 depends on PPC && SPE
851 AES cipher algorithms (FIPS-197). Additionally the acceleration
852 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
853 This module should only be used for low power (router) devices
854 without hardware AES acceleration (e.g. caam crypto). It reduces the
855 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
856 timining attacks. Nevertheless it might be not as secure as other
857 architecture specific assembler implementations that work on 1KB
858 tables or 256 bytes S-boxes.
861 tristate "Anubis cipher algorithm"
864 Anubis cipher algorithm.
866 Anubis is a variable key length cipher which can use keys from
867 128 bits to 320 bits in length. It was evaluated as a entrant
868 in the NESSIE competition.
871 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
872 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
875 tristate "ARC4 cipher algorithm"
876 select CRYPTO_BLKCIPHER
878 ARC4 cipher algorithm.
880 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
881 bits in length. This algorithm is required for driver-based
882 WEP, but it should not be for other purposes because of the
883 weakness of the algorithm.
885 config CRYPTO_BLOWFISH
886 tristate "Blowfish cipher algorithm"
888 select CRYPTO_BLOWFISH_COMMON
890 Blowfish cipher algorithm, by Bruce Schneier.
892 This is a variable key length cipher which can use keys from 32
893 bits to 448 bits in length. It's fast, simple and specifically
894 designed for use on "large microprocessors".
897 <http://www.schneier.com/blowfish.html>
899 config CRYPTO_BLOWFISH_COMMON
902 Common parts of the Blowfish cipher algorithm shared by the
903 generic c and the assembler implementations.
906 <http://www.schneier.com/blowfish.html>
908 config CRYPTO_BLOWFISH_X86_64
909 tristate "Blowfish cipher algorithm (x86_64)"
910 depends on X86 && 64BIT
912 select CRYPTO_BLOWFISH_COMMON
914 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
916 This is a variable key length cipher which can use keys from 32
917 bits to 448 bits in length. It's fast, simple and specifically
918 designed for use on "large microprocessors".
921 <http://www.schneier.com/blowfish.html>
923 config CRYPTO_CAMELLIA
924 tristate "Camellia cipher algorithms"
928 Camellia cipher algorithms module.
930 Camellia is a symmetric key block cipher developed jointly
931 at NTT and Mitsubishi Electric Corporation.
933 The Camellia specifies three key sizes: 128, 192 and 256 bits.
936 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
938 config CRYPTO_CAMELLIA_X86_64
939 tristate "Camellia cipher algorithm (x86_64)"
940 depends on X86 && 64BIT
943 select CRYPTO_GLUE_HELPER_X86
947 Camellia cipher algorithm module (x86_64).
949 Camellia is a symmetric key block cipher developed jointly
950 at NTT and Mitsubishi Electric Corporation.
952 The Camellia specifies three key sizes: 128, 192 and 256 bits.
955 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
957 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
958 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
959 depends on X86 && 64BIT
963 select CRYPTO_ABLK_HELPER
964 select CRYPTO_GLUE_HELPER_X86
965 select CRYPTO_CAMELLIA_X86_64
969 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
971 Camellia is a symmetric key block cipher developed jointly
972 at NTT and Mitsubishi Electric Corporation.
974 The Camellia specifies three key sizes: 128, 192 and 256 bits.
977 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
979 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
980 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
981 depends on X86 && 64BIT
985 select CRYPTO_ABLK_HELPER
986 select CRYPTO_GLUE_HELPER_X86
987 select CRYPTO_CAMELLIA_X86_64
988 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
992 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
994 Camellia is a symmetric key block cipher developed jointly
995 at NTT and Mitsubishi Electric Corporation.
997 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1000 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1002 config CRYPTO_CAMELLIA_SPARC64
1003 tristate "Camellia cipher algorithm (SPARC64)"
1006 select CRYPTO_ALGAPI
1008 Camellia cipher algorithm module (SPARC64).
1010 Camellia is a symmetric key block cipher developed jointly
1011 at NTT and Mitsubishi Electric Corporation.
1013 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1016 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1018 config CRYPTO_CAST_COMMON
1021 Common parts of the CAST cipher algorithms shared by the
1022 generic c and the assembler implementations.
1025 tristate "CAST5 (CAST-128) cipher algorithm"
1026 select CRYPTO_ALGAPI
1027 select CRYPTO_CAST_COMMON
1029 The CAST5 encryption algorithm (synonymous with CAST-128) is
1030 described in RFC2144.
1032 config CRYPTO_CAST5_AVX_X86_64
1033 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1034 depends on X86 && 64BIT
1035 select CRYPTO_ALGAPI
1036 select CRYPTO_CRYPTD
1037 select CRYPTO_ABLK_HELPER
1038 select CRYPTO_CAST_COMMON
1041 The CAST5 encryption algorithm (synonymous with CAST-128) is
1042 described in RFC2144.
1044 This module provides the Cast5 cipher algorithm that processes
1045 sixteen blocks parallel using the AVX instruction set.
1048 tristate "CAST6 (CAST-256) cipher algorithm"
1049 select CRYPTO_ALGAPI
1050 select CRYPTO_CAST_COMMON
1052 The CAST6 encryption algorithm (synonymous with CAST-256) is
1053 described in RFC2612.
1055 config CRYPTO_CAST6_AVX_X86_64
1056 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1057 depends on X86 && 64BIT
1058 select CRYPTO_ALGAPI
1059 select CRYPTO_CRYPTD
1060 select CRYPTO_ABLK_HELPER
1061 select CRYPTO_GLUE_HELPER_X86
1062 select CRYPTO_CAST_COMMON
1067 The CAST6 encryption algorithm (synonymous with CAST-256) is
1068 described in RFC2612.
1070 This module provides the Cast6 cipher algorithm that processes
1071 eight blocks parallel using the AVX instruction set.
1074 tristate "DES and Triple DES EDE cipher algorithms"
1075 select CRYPTO_ALGAPI
1077 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1079 config CRYPTO_DES_SPARC64
1080 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1082 select CRYPTO_ALGAPI
1085 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1086 optimized using SPARC64 crypto opcodes.
1088 config CRYPTO_DES3_EDE_X86_64
1089 tristate "Triple DES EDE cipher algorithm (x86-64)"
1090 depends on X86 && 64BIT
1091 select CRYPTO_ALGAPI
1094 Triple DES EDE (FIPS 46-3) algorithm.
1096 This module provides implementation of the Triple DES EDE cipher
1097 algorithm that is optimized for x86-64 processors. Two versions of
1098 algorithm are provided; regular processing one input block and
1099 one that processes three blocks parallel.
1101 config CRYPTO_FCRYPT
1102 tristate "FCrypt cipher algorithm"
1103 select CRYPTO_ALGAPI
1104 select CRYPTO_BLKCIPHER
1106 FCrypt algorithm used by RxRPC.
1108 config CRYPTO_KHAZAD
1109 tristate "Khazad cipher algorithm"
1110 select CRYPTO_ALGAPI
1112 Khazad cipher algorithm.
1114 Khazad was a finalist in the initial NESSIE competition. It is
1115 an algorithm optimized for 64-bit processors with good performance
1116 on 32-bit processors. Khazad uses an 128 bit key size.
1119 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1121 config CRYPTO_SALSA20
1122 tristate "Salsa20 stream cipher algorithm"
1123 select CRYPTO_BLKCIPHER
1125 Salsa20 stream cipher algorithm.
1127 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1128 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1130 The Salsa20 stream cipher algorithm is designed by Daniel J.
1131 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1133 config CRYPTO_SALSA20_586
1134 tristate "Salsa20 stream cipher algorithm (i586)"
1135 depends on (X86 || UML_X86) && !64BIT
1136 select CRYPTO_BLKCIPHER
1138 Salsa20 stream cipher algorithm.
1140 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1141 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1143 The Salsa20 stream cipher algorithm is designed by Daniel J.
1144 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1146 config CRYPTO_SALSA20_X86_64
1147 tristate "Salsa20 stream cipher algorithm (x86_64)"
1148 depends on (X86 || UML_X86) && 64BIT
1149 select CRYPTO_BLKCIPHER
1151 Salsa20 stream cipher algorithm.
1153 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1154 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1156 The Salsa20 stream cipher algorithm is designed by Daniel J.
1157 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1159 config CRYPTO_CHACHA20
1160 tristate "ChaCha20 cipher algorithm"
1161 select CRYPTO_BLKCIPHER
1163 ChaCha20 cipher algorithm, RFC7539.
1165 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1166 Bernstein and further specified in RFC7539 for use in IETF protocols.
1167 This is the portable C implementation of ChaCha20.
1170 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1173 tristate "SEED cipher algorithm"
1174 select CRYPTO_ALGAPI
1176 SEED cipher algorithm (RFC4269).
1178 SEED is a 128-bit symmetric key block cipher that has been
1179 developed by KISA (Korea Information Security Agency) as a
1180 national standard encryption algorithm of the Republic of Korea.
1181 It is a 16 round block cipher with the key size of 128 bit.
1184 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1186 config CRYPTO_SERPENT
1187 tristate "Serpent cipher algorithm"
1188 select CRYPTO_ALGAPI
1190 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1192 Keys are allowed to be from 0 to 256 bits in length, in steps
1193 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1194 variant of Serpent for compatibility with old kerneli.org code.
1197 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1199 config CRYPTO_SERPENT_SSE2_X86_64
1200 tristate "Serpent cipher algorithm (x86_64/SSE2)"
1201 depends on X86 && 64BIT
1202 select CRYPTO_ALGAPI
1203 select CRYPTO_CRYPTD
1204 select CRYPTO_ABLK_HELPER
1205 select CRYPTO_GLUE_HELPER_X86
1206 select CRYPTO_SERPENT
1210 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1212 Keys are allowed to be from 0 to 256 bits in length, in steps
1215 This module provides Serpent cipher algorithm that processes eight
1216 blocks parallel using SSE2 instruction set.
1219 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1221 config CRYPTO_SERPENT_SSE2_586
1222 tristate "Serpent cipher algorithm (i586/SSE2)"
1223 depends on X86 && !64BIT
1224 select CRYPTO_ALGAPI
1225 select CRYPTO_CRYPTD
1226 select CRYPTO_ABLK_HELPER
1227 select CRYPTO_GLUE_HELPER_X86
1228 select CRYPTO_SERPENT
1232 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1234 Keys are allowed to be from 0 to 256 bits in length, in steps
1237 This module provides Serpent cipher algorithm that processes four
1238 blocks parallel using SSE2 instruction set.
1241 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1243 config CRYPTO_SERPENT_AVX_X86_64
1244 tristate "Serpent cipher algorithm (x86_64/AVX)"
1245 depends on X86 && 64BIT
1246 select CRYPTO_ALGAPI
1247 select CRYPTO_CRYPTD
1248 select CRYPTO_ABLK_HELPER
1249 select CRYPTO_GLUE_HELPER_X86
1250 select CRYPTO_SERPENT
1254 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1256 Keys are allowed to be from 0 to 256 bits in length, in steps
1259 This module provides the Serpent cipher algorithm that processes
1260 eight blocks parallel using the AVX instruction set.
1263 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1265 config CRYPTO_SERPENT_AVX2_X86_64
1266 tristate "Serpent cipher algorithm (x86_64/AVX2)"
1267 depends on X86 && 64BIT
1268 select CRYPTO_ALGAPI
1269 select CRYPTO_CRYPTD
1270 select CRYPTO_ABLK_HELPER
1271 select CRYPTO_GLUE_HELPER_X86
1272 select CRYPTO_SERPENT
1273 select CRYPTO_SERPENT_AVX_X86_64
1277 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1279 Keys are allowed to be from 0 to 256 bits in length, in steps
1282 This module provides Serpent cipher algorithm that processes 16
1283 blocks parallel using AVX2 instruction set.
1286 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1289 tristate "TEA, XTEA and XETA cipher algorithms"
1290 select CRYPTO_ALGAPI
1292 TEA cipher algorithm.
1294 Tiny Encryption Algorithm is a simple cipher that uses
1295 many rounds for security. It is very fast and uses
1298 Xtendend Tiny Encryption Algorithm is a modification to
1299 the TEA algorithm to address a potential key weakness
1300 in the TEA algorithm.
1302 Xtendend Encryption Tiny Algorithm is a mis-implementation
1303 of the XTEA algorithm for compatibility purposes.
1305 config CRYPTO_TWOFISH
1306 tristate "Twofish cipher algorithm"
1307 select CRYPTO_ALGAPI
1308 select CRYPTO_TWOFISH_COMMON
1310 Twofish cipher algorithm.
1312 Twofish was submitted as an AES (Advanced Encryption Standard)
1313 candidate cipher by researchers at CounterPane Systems. It is a
1314 16 round block cipher supporting key sizes of 128, 192, and 256
1318 <http://www.schneier.com/twofish.html>
1320 config CRYPTO_TWOFISH_COMMON
1323 Common parts of the Twofish cipher algorithm shared by the
1324 generic c and the assembler implementations.
1326 config CRYPTO_TWOFISH_586
1327 tristate "Twofish cipher algorithms (i586)"
1328 depends on (X86 || UML_X86) && !64BIT
1329 select CRYPTO_ALGAPI
1330 select CRYPTO_TWOFISH_COMMON
1332 Twofish cipher algorithm.
1334 Twofish was submitted as an AES (Advanced Encryption Standard)
1335 candidate cipher by researchers at CounterPane Systems. It is a
1336 16 round block cipher supporting key sizes of 128, 192, and 256
1340 <http://www.schneier.com/twofish.html>
1342 config CRYPTO_TWOFISH_X86_64
1343 tristate "Twofish cipher algorithm (x86_64)"
1344 depends on (X86 || UML_X86) && 64BIT
1345 select CRYPTO_ALGAPI
1346 select CRYPTO_TWOFISH_COMMON
1348 Twofish cipher algorithm (x86_64).
1350 Twofish was submitted as an AES (Advanced Encryption Standard)
1351 candidate cipher by researchers at CounterPane Systems. It is a
1352 16 round block cipher supporting key sizes of 128, 192, and 256
1356 <http://www.schneier.com/twofish.html>
1358 config CRYPTO_TWOFISH_X86_64_3WAY
1359 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1360 depends on X86 && 64BIT
1361 select CRYPTO_ALGAPI
1362 select CRYPTO_TWOFISH_COMMON
1363 select CRYPTO_TWOFISH_X86_64
1364 select CRYPTO_GLUE_HELPER_X86
1368 Twofish cipher algorithm (x86_64, 3-way parallel).
1370 Twofish was submitted as an AES (Advanced Encryption Standard)
1371 candidate cipher by researchers at CounterPane Systems. It is a
1372 16 round block cipher supporting key sizes of 128, 192, and 256
1375 This module provides Twofish cipher algorithm that processes three
1376 blocks parallel, utilizing resources of out-of-order CPUs better.
1379 <http://www.schneier.com/twofish.html>
1381 config CRYPTO_TWOFISH_AVX_X86_64
1382 tristate "Twofish cipher algorithm (x86_64/AVX)"
1383 depends on X86 && 64BIT
1384 select CRYPTO_ALGAPI
1385 select CRYPTO_CRYPTD
1386 select CRYPTO_ABLK_HELPER
1387 select CRYPTO_GLUE_HELPER_X86
1388 select CRYPTO_TWOFISH_COMMON
1389 select CRYPTO_TWOFISH_X86_64
1390 select CRYPTO_TWOFISH_X86_64_3WAY
1394 Twofish cipher algorithm (x86_64/AVX).
1396 Twofish was submitted as an AES (Advanced Encryption Standard)
1397 candidate cipher by researchers at CounterPane Systems. It is a
1398 16 round block cipher supporting key sizes of 128, 192, and 256
1401 This module provides the Twofish cipher algorithm that processes
1402 eight blocks parallel using the AVX Instruction Set.
1405 <http://www.schneier.com/twofish.html>
1407 comment "Compression"
1409 config CRYPTO_DEFLATE
1410 tristate "Deflate compression algorithm"
1411 select CRYPTO_ALGAPI
1415 This is the Deflate algorithm (RFC1951), specified for use in
1416 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1418 You will most probably want this if using IPSec.
1421 tristate "Zlib compression algorithm"
1427 This is the zlib algorithm.
1430 tristate "LZO compression algorithm"
1431 select CRYPTO_ALGAPI
1433 select LZO_DECOMPRESS
1435 This is the LZO algorithm.
1438 tristate "842 compression algorithm"
1439 select CRYPTO_ALGAPI
1441 select 842_DECOMPRESS
1443 This is the 842 algorithm.
1446 tristate "LZ4 compression algorithm"
1447 select CRYPTO_ALGAPI
1449 select LZ4_DECOMPRESS
1451 This is the LZ4 algorithm.
1454 tristate "LZ4HC compression algorithm"
1455 select CRYPTO_ALGAPI
1456 select LZ4HC_COMPRESS
1457 select LZ4_DECOMPRESS
1459 This is the LZ4 high compression mode algorithm.
1461 comment "Random Number Generation"
1463 config CRYPTO_ANSI_CPRNG
1464 tristate "Pseudo Random Number Generation for Cryptographic modules"
1469 This option enables the generic pseudo random number generator
1470 for cryptographic modules. Uses the Algorithm specified in
1471 ANSI X9.31 A.2.4. Note that this option must be enabled if
1472 CRYPTO_FIPS is selected
1474 menuconfig CRYPTO_DRBG_MENU
1475 tristate "NIST SP800-90A DRBG"
1477 NIST SP800-90A compliant DRBG. In the following submenu, one or
1478 more of the DRBG types must be selected.
1482 config CRYPTO_DRBG_HMAC
1483 bool "Enable HMAC DRBG"
1487 Enable the HMAC DRBG variant as defined in NIST SP800-90A.
1489 config CRYPTO_DRBG_HASH
1490 bool "Enable Hash DRBG"
1493 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1495 config CRYPTO_DRBG_CTR
1496 bool "Enable CTR DRBG"
1499 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1503 default CRYPTO_DRBG_MENU if (CRYPTO_DRBG_HMAC || CRYPTO_DRBG_HASH || CRYPTO_DRBG_CTR)
1505 select CRYPTO_JITTERENTROPY
1507 endif # if CRYPTO_DRBG_MENU
1509 config CRYPTO_JITTERENTROPY
1510 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1512 The Jitterentropy RNG is a noise that is intended
1513 to provide seed to another RNG. The RNG does not
1514 perform any cryptographic whitening of the generated
1515 random numbers. This Jitterentropy RNG registers with
1516 the kernel crypto API and can be used by any caller.
1518 config CRYPTO_USER_API
1521 config CRYPTO_USER_API_HASH
1522 tristate "User-space interface for hash algorithms"
1525 select CRYPTO_USER_API
1527 This option enables the user-spaces interface for hash
1530 config CRYPTO_USER_API_SKCIPHER
1531 tristate "User-space interface for symmetric key cipher algorithms"
1533 select CRYPTO_BLKCIPHER
1534 select CRYPTO_USER_API
1536 This option enables the user-spaces interface for symmetric
1537 key cipher algorithms.
1539 config CRYPTO_USER_API_RNG
1540 tristate "User-space interface for random number generator algorithms"
1543 select CRYPTO_USER_API
1545 This option enables the user-spaces interface for random
1546 number generator algorithms.
1548 config CRYPTO_USER_API_AEAD
1549 tristate "User-space interface for AEAD cipher algorithms"
1552 select CRYPTO_USER_API
1554 This option enables the user-spaces interface for AEAD
1557 config CRYPTO_HASH_INFO
1560 source "drivers/crypto/Kconfig"
1561 source crypto/asymmetric_keys/Kconfig