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
27 depends on (MODULE_SIG || !MODULES)
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.
54 config CRYPTO_BLKCIPHER
56 select CRYPTO_BLKCIPHER2
59 config CRYPTO_BLKCIPHER2
63 select CRYPTO_WORKQUEUE
83 config CRYPTO_RNG_DEFAULT
85 select CRYPTO_DRBG_MENU
87 config CRYPTO_AKCIPHER2
91 config CRYPTO_AKCIPHER
93 select CRYPTO_AKCIPHER2
107 select CRYPTO_ALGAPI2
115 tristate "RSA algorithm"
116 select CRYPTO_AKCIPHER
117 select CRYPTO_MANAGER
121 Generic implementation of the RSA public key algorithm.
124 tristate "Diffie-Hellman algorithm"
128 Generic implementation of the Diffie-Hellman algorithm.
131 tristate "ECDH algorithm"
134 Generic implementation of the ECDH algorithm
136 config CRYPTO_MANAGER
137 tristate "Cryptographic algorithm manager"
138 select CRYPTO_MANAGER2
140 Create default cryptographic template instantiations such as
143 config CRYPTO_MANAGER2
144 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
147 select CRYPTO_BLKCIPHER2
148 select CRYPTO_AKCIPHER2
153 tristate "Userspace cryptographic algorithm configuration"
155 select CRYPTO_MANAGER
157 Userspace configuration for cryptographic instantiations such as
160 config CRYPTO_MANAGER_DISABLE_TESTS
161 bool "Disable run-time self tests"
163 depends on CRYPTO_MANAGER2
165 Disable run-time self tests that normally take place at
166 algorithm registration.
168 config CRYPTO_GF128MUL
169 tristate "GF(2^128) multiplication functions"
171 Efficient table driven implementation of multiplications in the
172 field GF(2^128). This is needed by some cypher modes. This
173 option will be selected automatically if you select such a
174 cipher mode. Only select this option by hand if you expect to load
175 an external module that requires these functions.
178 tristate "Null algorithms"
181 These are 'Null' algorithms, used by IPsec, which do nothing.
185 select CRYPTO_ALGAPI2
186 select CRYPTO_BLKCIPHER2
190 tristate "Parallel crypto engine"
193 select CRYPTO_MANAGER
196 This converts an arbitrary crypto algorithm into a parallel
197 algorithm that executes in kernel threads.
199 config CRYPTO_WORKQUEUE
203 tristate "Software async crypto daemon"
204 select CRYPTO_BLKCIPHER
206 select CRYPTO_MANAGER
207 select CRYPTO_WORKQUEUE
209 This is a generic software asynchronous crypto daemon that
210 converts an arbitrary synchronous software crypto algorithm
211 into an asynchronous algorithm that executes in a kernel thread.
213 config CRYPTO_MCRYPTD
214 tristate "Software async multi-buffer crypto daemon"
215 select CRYPTO_BLKCIPHER
217 select CRYPTO_MANAGER
218 select CRYPTO_WORKQUEUE
220 This is a generic software asynchronous crypto daemon that
221 provides the kernel thread to assist multi-buffer crypto
222 algorithms for submitting jobs and flushing jobs in multi-buffer
223 crypto algorithms. Multi-buffer crypto algorithms are executed
224 in the context of this kernel thread and drivers can post
225 their crypto request asynchronously to be processed by this daemon.
227 config CRYPTO_AUTHENC
228 tristate "Authenc support"
230 select CRYPTO_BLKCIPHER
231 select CRYPTO_MANAGER
235 Authenc: Combined mode wrapper for IPsec.
236 This is required for IPSec.
239 tristate "Testing module"
241 select CRYPTO_MANAGER
243 Quick & dirty crypto test module.
245 config CRYPTO_ABLK_HELPER
253 config CRYPTO_GLUE_HELPER_X86
256 select CRYPTO_BLKCIPHER
261 comment "Authenticated Encryption with Associated Data"
264 tristate "CCM support"
268 Support for Counter with CBC MAC. Required for IPsec.
271 tristate "GCM/GMAC support"
277 Support for Galois/Counter Mode (GCM) and Galois Message
278 Authentication Code (GMAC). Required for IPSec.
280 config CRYPTO_CHACHA20POLY1305
281 tristate "ChaCha20-Poly1305 AEAD support"
282 select CRYPTO_CHACHA20
283 select CRYPTO_POLY1305
286 ChaCha20-Poly1305 AEAD support, RFC7539.
288 Support for the AEAD wrapper using the ChaCha20 stream cipher combined
289 with the Poly1305 authenticator. It is defined in RFC7539 for use in
293 tristate "Sequence Number IV Generator"
295 select CRYPTO_BLKCIPHER
297 select CRYPTO_RNG_DEFAULT
299 This IV generator generates an IV based on a sequence number by
300 xoring it with a salt. This algorithm is mainly useful for CTR
302 config CRYPTO_ECHAINIV
303 tristate "Encrypted Chain IV Generator"
306 select CRYPTO_RNG_DEFAULT
309 This IV generator generates an IV based on the encryption of
310 a sequence number xored with a salt. This is the default
313 comment "Block modes"
316 tristate "CBC support"
317 select CRYPTO_BLKCIPHER
318 select CRYPTO_MANAGER
320 CBC: Cipher Block Chaining mode
321 This block cipher algorithm is required for IPSec.
324 tristate "CTR support"
325 select CRYPTO_BLKCIPHER
327 select CRYPTO_MANAGER
330 This block cipher algorithm is required for IPSec.
333 tristate "CTS support"
334 select CRYPTO_BLKCIPHER
336 CTS: Cipher Text Stealing
337 This is the Cipher Text Stealing mode as described by
338 Section 8 of rfc2040 and referenced by rfc3962.
339 (rfc3962 includes errata information in its Appendix A)
340 This mode is required for Kerberos gss mechanism support
344 tristate "ECB support"
345 select CRYPTO_BLKCIPHER
346 select CRYPTO_MANAGER
348 ECB: Electronic CodeBook mode
349 This is the simplest block cipher algorithm. It simply encrypts
350 the input block by block.
353 tristate "LRW support"
354 select CRYPTO_BLKCIPHER
355 select CRYPTO_MANAGER
356 select CRYPTO_GF128MUL
358 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
359 narrow block cipher mode for dm-crypt. Use it with cipher
360 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
361 The first 128, 192 or 256 bits in the key are used for AES and the
362 rest is used to tie each cipher block to its logical position.
365 tristate "PCBC support"
366 select CRYPTO_BLKCIPHER
367 select CRYPTO_MANAGER
369 PCBC: Propagating Cipher Block Chaining mode
370 This block cipher algorithm is required for RxRPC.
373 tristate "XTS support"
374 select CRYPTO_BLKCIPHER
375 select CRYPTO_MANAGER
376 select CRYPTO_GF128MUL
379 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
380 key size 256, 384 or 512 bits. This implementation currently
381 can't handle a sectorsize which is not a multiple of 16 bytes.
383 config CRYPTO_KEYWRAP
384 tristate "Key wrapping support"
385 select CRYPTO_BLKCIPHER
387 Support for key wrapping (NIST SP800-38F / RFC3394) without
393 tristate "CMAC support"
395 select CRYPTO_MANAGER
397 Cipher-based Message Authentication Code (CMAC) specified by
398 The National Institute of Standards and Technology (NIST).
400 https://tools.ietf.org/html/rfc4493
401 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
404 tristate "HMAC support"
406 select CRYPTO_MANAGER
408 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
409 This is required for IPSec.
412 tristate "XCBC support"
414 select CRYPTO_MANAGER
416 XCBC: Keyed-Hashing with encryption algorithm
417 http://www.ietf.org/rfc/rfc3566.txt
418 http://csrc.nist.gov/encryption/modes/proposedmodes/
419 xcbc-mac/xcbc-mac-spec.pdf
422 tristate "VMAC support"
424 select CRYPTO_MANAGER
426 VMAC is a message authentication algorithm designed for
427 very high speed on 64-bit architectures.
430 <http://fastcrypto.org/vmac>
435 tristate "CRC32c CRC algorithm"
439 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
440 by iSCSI for header and data digests and by others.
441 See Castagnoli93. Module will be crc32c.
443 config CRYPTO_CRC32C_INTEL
444 tristate "CRC32c INTEL hardware acceleration"
448 In Intel processor with SSE4.2 supported, the processor will
449 support CRC32C implementation using hardware accelerated CRC32
450 instruction. This option will create 'crc32c-intel' module,
451 which will enable any routine to use the CRC32 instruction to
452 gain performance compared with software implementation.
453 Module will be crc32c-intel.
455 config CRYPTO_CRC32C_VPMSUM
456 tristate "CRC32c CRC algorithm (powerpc64)"
457 depends on PPC64 && ALTIVEC
461 CRC32c algorithm implemented using vector polynomial multiply-sum
462 (vpmsum) instructions, introduced in POWER8. Enable on POWER8
463 and newer processors for improved performance.
466 config CRYPTO_CRC32C_SPARC64
467 tristate "CRC32c CRC algorithm (SPARC64)"
472 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
476 tristate "CRC32 CRC algorithm"
480 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
481 Shash crypto api wrappers to crc32_le function.
483 config CRYPTO_CRC32_PCLMUL
484 tristate "CRC32 PCLMULQDQ hardware acceleration"
489 From Intel Westmere and AMD Bulldozer processor with SSE4.2
490 and PCLMULQDQ supported, the processor will support
491 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
492 instruction. This option will create 'crc32-plcmul' module,
493 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
494 and gain better performance as compared with the table implementation.
496 config CRYPTO_CRCT10DIF
497 tristate "CRCT10DIF algorithm"
500 CRC T10 Data Integrity Field computation is being cast as
501 a crypto transform. This allows for faster crc t10 diff
502 transforms to be used if they are available.
504 config CRYPTO_CRCT10DIF_PCLMUL
505 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
506 depends on X86 && 64BIT && CRC_T10DIF
509 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
510 CRC T10 DIF PCLMULQDQ computation can be hardware
511 accelerated PCLMULQDQ instruction. This option will create
512 'crct10dif-plcmul' module, which is faster when computing the
513 crct10dif checksum as compared with the generic table implementation.
516 tristate "GHASH digest algorithm"
517 select CRYPTO_GF128MUL
520 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
522 config CRYPTO_POLY1305
523 tristate "Poly1305 authenticator algorithm"
526 Poly1305 authenticator algorithm, RFC7539.
528 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
529 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
530 in IETF protocols. This is the portable C implementation of Poly1305.
532 config CRYPTO_POLY1305_X86_64
533 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
534 depends on X86 && 64BIT
535 select CRYPTO_POLY1305
537 Poly1305 authenticator algorithm, RFC7539.
539 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
540 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
541 in IETF protocols. This is the x86_64 assembler implementation using SIMD
545 tristate "MD4 digest algorithm"
548 MD4 message digest algorithm (RFC1320).
551 tristate "MD5 digest algorithm"
554 MD5 message digest algorithm (RFC1321).
556 config CRYPTO_MD5_OCTEON
557 tristate "MD5 digest algorithm (OCTEON)"
558 depends on CPU_CAVIUM_OCTEON
562 MD5 message digest algorithm (RFC1321) implemented
563 using OCTEON crypto instructions, when available.
565 config CRYPTO_MD5_PPC
566 tristate "MD5 digest algorithm (PPC)"
570 MD5 message digest algorithm (RFC1321) implemented
573 config CRYPTO_MD5_SPARC64
574 tristate "MD5 digest algorithm (SPARC64)"
579 MD5 message digest algorithm (RFC1321) implemented
580 using sparc64 crypto instructions, when available.
582 config CRYPTO_MICHAEL_MIC
583 tristate "Michael MIC keyed digest algorithm"
586 Michael MIC is used for message integrity protection in TKIP
587 (IEEE 802.11i). This algorithm is required for TKIP, but it
588 should not be used for other purposes because of the weakness
592 tristate "RIPEMD-128 digest algorithm"
595 RIPEMD-128 (ISO/IEC 10118-3:2004).
597 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
598 be used as a secure replacement for RIPEMD. For other use cases,
599 RIPEMD-160 should be used.
601 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
602 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
605 tristate "RIPEMD-160 digest algorithm"
608 RIPEMD-160 (ISO/IEC 10118-3:2004).
610 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
611 to be used as a secure replacement for the 128-bit hash functions
612 MD4, MD5 and it's predecessor RIPEMD
613 (not to be confused with RIPEMD-128).
615 It's speed is comparable to SHA1 and there are no known attacks
618 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
619 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
622 tristate "RIPEMD-256 digest algorithm"
625 RIPEMD-256 is an optional extension of RIPEMD-128 with a
626 256 bit hash. It is intended for applications that require
627 longer hash-results, without needing a larger security level
630 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
631 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
634 tristate "RIPEMD-320 digest algorithm"
637 RIPEMD-320 is an optional extension of RIPEMD-160 with a
638 320 bit hash. It is intended for applications that require
639 longer hash-results, without needing a larger security level
642 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
643 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
646 tristate "SHA1 digest algorithm"
649 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
651 config CRYPTO_SHA1_SSSE3
652 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
653 depends on X86 && 64BIT
657 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
658 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
659 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
662 config CRYPTO_SHA256_SSSE3
663 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
664 depends on X86 && 64BIT
668 SHA-256 secure hash standard (DFIPS 180-2) implemented
669 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
670 Extensions version 1 (AVX1), or Advanced Vector Extensions
671 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
672 Instructions) when available.
674 config CRYPTO_SHA512_SSSE3
675 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
676 depends on X86 && 64BIT
680 SHA-512 secure hash standard (DFIPS 180-2) implemented
681 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
682 Extensions version 1 (AVX1), or Advanced Vector Extensions
683 version 2 (AVX2) instructions, when available.
685 config CRYPTO_SHA1_OCTEON
686 tristate "SHA1 digest algorithm (OCTEON)"
687 depends on CPU_CAVIUM_OCTEON
691 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
692 using OCTEON crypto instructions, when available.
694 config CRYPTO_SHA1_SPARC64
695 tristate "SHA1 digest algorithm (SPARC64)"
700 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
701 using sparc64 crypto instructions, when available.
703 config CRYPTO_SHA1_PPC
704 tristate "SHA1 digest algorithm (powerpc)"
707 This is the powerpc hardware accelerated implementation of the
708 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
710 config CRYPTO_SHA1_PPC_SPE
711 tristate "SHA1 digest algorithm (PPC SPE)"
712 depends on PPC && SPE
714 SHA-1 secure hash standard (DFIPS 180-4) implemented
715 using powerpc SPE SIMD instruction set.
717 config CRYPTO_SHA1_MB
718 tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
719 depends on X86 && 64BIT
722 select CRYPTO_MCRYPTD
724 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
725 using multi-buffer technique. This algorithm computes on
726 multiple data lanes concurrently with SIMD instructions for
727 better throughput. It should not be enabled by default but
728 used when there is significant amount of work to keep the keep
729 the data lanes filled to get performance benefit. If the data
730 lanes remain unfilled, a flush operation will be initiated to
731 process the crypto jobs, adding a slight latency.
733 config CRYPTO_SHA256_MB
734 tristate "SHA256 digest algorithm (x86_64 Multi-Buffer, Experimental)"
735 depends on X86 && 64BIT
738 select CRYPTO_MCRYPTD
740 SHA-256 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
741 using multi-buffer technique. This algorithm computes on
742 multiple data lanes concurrently with SIMD instructions for
743 better throughput. It should not be enabled by default but
744 used when there is significant amount of work to keep the keep
745 the data lanes filled to get performance benefit. If the data
746 lanes remain unfilled, a flush operation will be initiated to
747 process the crypto jobs, adding a slight latency.
749 config CRYPTO_SHA512_MB
750 tristate "SHA512 digest algorithm (x86_64 Multi-Buffer, Experimental)"
751 depends on X86 && 64BIT
754 select CRYPTO_MCRYPTD
756 SHA-512 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
757 using multi-buffer technique. This algorithm computes on
758 multiple data lanes concurrently with SIMD instructions for
759 better throughput. It should not be enabled by default but
760 used when there is significant amount of work to keep the keep
761 the data lanes filled to get performance benefit. If the data
762 lanes remain unfilled, a flush operation will be initiated to
763 process the crypto jobs, adding a slight latency.
766 tristate "SHA224 and SHA256 digest algorithm"
769 SHA256 secure hash standard (DFIPS 180-2).
771 This version of SHA implements a 256 bit hash with 128 bits of
772 security against collision attacks.
774 This code also includes SHA-224, a 224 bit hash with 112 bits
775 of security against collision attacks.
777 config CRYPTO_SHA256_PPC_SPE
778 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
779 depends on PPC && SPE
783 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
784 implemented using powerpc SPE SIMD instruction set.
786 config CRYPTO_SHA256_OCTEON
787 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
788 depends on CPU_CAVIUM_OCTEON
792 SHA-256 secure hash standard (DFIPS 180-2) implemented
793 using OCTEON crypto instructions, when available.
795 config CRYPTO_SHA256_SPARC64
796 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
801 SHA-256 secure hash standard (DFIPS 180-2) implemented
802 using sparc64 crypto instructions, when available.
805 tristate "SHA384 and SHA512 digest algorithms"
808 SHA512 secure hash standard (DFIPS 180-2).
810 This version of SHA implements a 512 bit hash with 256 bits of
811 security against collision attacks.
813 This code also includes SHA-384, a 384 bit hash with 192 bits
814 of security against collision attacks.
816 config CRYPTO_SHA512_OCTEON
817 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
818 depends on CPU_CAVIUM_OCTEON
822 SHA-512 secure hash standard (DFIPS 180-2) implemented
823 using OCTEON crypto instructions, when available.
825 config CRYPTO_SHA512_SPARC64
826 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
831 SHA-512 secure hash standard (DFIPS 180-2) implemented
832 using sparc64 crypto instructions, when available.
835 tristate "SHA3 digest algorithm"
838 SHA-3 secure hash standard (DFIPS 202). It's based on
839 cryptographic sponge function family called Keccak.
842 http://keccak.noekeon.org/
845 tristate "Tiger digest algorithms"
848 Tiger hash algorithm 192, 160 and 128-bit hashes
850 Tiger is a hash function optimized for 64-bit processors while
851 still having decent performance on 32-bit processors.
852 Tiger was developed by Ross Anderson and Eli Biham.
855 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
858 tristate "Whirlpool digest algorithms"
861 Whirlpool hash algorithm 512, 384 and 256-bit hashes
863 Whirlpool-512 is part of the NESSIE cryptographic primitives.
864 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
867 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
869 config CRYPTO_GHASH_CLMUL_NI_INTEL
870 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
871 depends on X86 && 64BIT
874 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
875 The implementation is accelerated by CLMUL-NI of Intel.
880 tristate "AES cipher algorithms"
883 AES cipher algorithms (FIPS-197). AES uses the Rijndael
886 Rijndael appears to be consistently a very good performer in
887 both hardware and software across a wide range of computing
888 environments regardless of its use in feedback or non-feedback
889 modes. Its key setup time is excellent, and its key agility is
890 good. Rijndael's very low memory requirements make it very well
891 suited for restricted-space environments, in which it also
892 demonstrates excellent performance. Rijndael's operations are
893 among the easiest to defend against power and timing attacks.
895 The AES specifies three key sizes: 128, 192 and 256 bits
897 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
899 config CRYPTO_AES_586
900 tristate "AES cipher algorithms (i586)"
901 depends on (X86 || UML_X86) && !64BIT
905 AES cipher algorithms (FIPS-197). AES uses the Rijndael
908 Rijndael appears to be consistently a very good performer in
909 both hardware and software across a wide range of computing
910 environments regardless of its use in feedback or non-feedback
911 modes. Its key setup time is excellent, and its key agility is
912 good. Rijndael's very low memory requirements make it very well
913 suited for restricted-space environments, in which it also
914 demonstrates excellent performance. Rijndael's operations are
915 among the easiest to defend against power and timing attacks.
917 The AES specifies three key sizes: 128, 192 and 256 bits
919 See <http://csrc.nist.gov/encryption/aes/> for more information.
921 config CRYPTO_AES_X86_64
922 tristate "AES cipher algorithms (x86_64)"
923 depends on (X86 || UML_X86) && 64BIT
927 AES cipher algorithms (FIPS-197). AES uses the Rijndael
930 Rijndael appears to be consistently a very good performer in
931 both hardware and software across a wide range of computing
932 environments regardless of its use in feedback or non-feedback
933 modes. Its key setup time is excellent, and its key agility is
934 good. Rijndael's very low memory requirements make it very well
935 suited for restricted-space environments, in which it also
936 demonstrates excellent performance. Rijndael's operations are
937 among the easiest to defend against power and timing attacks.
939 The AES specifies three key sizes: 128, 192 and 256 bits
941 See <http://csrc.nist.gov/encryption/aes/> for more information.
943 config CRYPTO_AES_NI_INTEL
944 tristate "AES cipher algorithms (AES-NI)"
947 select CRYPTO_AES_X86_64 if 64BIT
948 select CRYPTO_AES_586 if !64BIT
950 select CRYPTO_BLKCIPHER
951 select CRYPTO_GLUE_HELPER_X86 if 64BIT
954 Use Intel AES-NI instructions for AES algorithm.
956 AES cipher algorithms (FIPS-197). AES uses the Rijndael
959 Rijndael appears to be consistently a very good performer in
960 both hardware and software across a wide range of computing
961 environments regardless of its use in feedback or non-feedback
962 modes. Its key setup time is excellent, and its key agility is
963 good. Rijndael's very low memory requirements make it very well
964 suited for restricted-space environments, in which it also
965 demonstrates excellent performance. Rijndael's operations are
966 among the easiest to defend against power and timing attacks.
968 The AES specifies three key sizes: 128, 192 and 256 bits
970 See <http://csrc.nist.gov/encryption/aes/> for more information.
972 In addition to AES cipher algorithm support, the acceleration
973 for some popular block cipher mode is supported too, including
974 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
975 acceleration for CTR.
977 config CRYPTO_AES_SPARC64
978 tristate "AES cipher algorithms (SPARC64)"
983 Use SPARC64 crypto opcodes for AES algorithm.
985 AES cipher algorithms (FIPS-197). AES uses the Rijndael
988 Rijndael appears to be consistently a very good performer in
989 both hardware and software across a wide range of computing
990 environments regardless of its use in feedback or non-feedback
991 modes. Its key setup time is excellent, and its key agility is
992 good. Rijndael's very low memory requirements make it very well
993 suited for restricted-space environments, in which it also
994 demonstrates excellent performance. Rijndael's operations are
995 among the easiest to defend against power and timing attacks.
997 The AES specifies three key sizes: 128, 192 and 256 bits
999 See <http://csrc.nist.gov/encryption/aes/> for more information.
1001 In addition to AES cipher algorithm support, the acceleration
1002 for some popular block cipher mode is supported too, including
1005 config CRYPTO_AES_PPC_SPE
1006 tristate "AES cipher algorithms (PPC SPE)"
1007 depends on PPC && SPE
1009 AES cipher algorithms (FIPS-197). Additionally the acceleration
1010 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
1011 This module should only be used for low power (router) devices
1012 without hardware AES acceleration (e.g. caam crypto). It reduces the
1013 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
1014 timining attacks. Nevertheless it might be not as secure as other
1015 architecture specific assembler implementations that work on 1KB
1016 tables or 256 bytes S-boxes.
1018 config CRYPTO_ANUBIS
1019 tristate "Anubis cipher algorithm"
1020 select CRYPTO_ALGAPI
1022 Anubis cipher algorithm.
1024 Anubis is a variable key length cipher which can use keys from
1025 128 bits to 320 bits in length. It was evaluated as a entrant
1026 in the NESSIE competition.
1029 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1030 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1033 tristate "ARC4 cipher algorithm"
1034 select CRYPTO_BLKCIPHER
1036 ARC4 cipher algorithm.
1038 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1039 bits in length. This algorithm is required for driver-based
1040 WEP, but it should not be for other purposes because of the
1041 weakness of the algorithm.
1043 config CRYPTO_BLOWFISH
1044 tristate "Blowfish cipher algorithm"
1045 select CRYPTO_ALGAPI
1046 select CRYPTO_BLOWFISH_COMMON
1048 Blowfish cipher algorithm, by Bruce Schneier.
1050 This is a variable key length cipher which can use keys from 32
1051 bits to 448 bits in length. It's fast, simple and specifically
1052 designed for use on "large microprocessors".
1055 <http://www.schneier.com/blowfish.html>
1057 config CRYPTO_BLOWFISH_COMMON
1060 Common parts of the Blowfish cipher algorithm shared by the
1061 generic c and the assembler implementations.
1064 <http://www.schneier.com/blowfish.html>
1066 config CRYPTO_BLOWFISH_X86_64
1067 tristate "Blowfish cipher algorithm (x86_64)"
1068 depends on X86 && 64BIT
1069 select CRYPTO_ALGAPI
1070 select CRYPTO_BLOWFISH_COMMON
1072 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1074 This is a variable key length cipher which can use keys from 32
1075 bits to 448 bits in length. It's fast, simple and specifically
1076 designed for use on "large microprocessors".
1079 <http://www.schneier.com/blowfish.html>
1081 config CRYPTO_CAMELLIA
1082 tristate "Camellia cipher algorithms"
1084 select CRYPTO_ALGAPI
1086 Camellia cipher algorithms module.
1088 Camellia is a symmetric key block cipher developed jointly
1089 at NTT and Mitsubishi Electric Corporation.
1091 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1094 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1096 config CRYPTO_CAMELLIA_X86_64
1097 tristate "Camellia cipher algorithm (x86_64)"
1098 depends on X86 && 64BIT
1100 select CRYPTO_ALGAPI
1101 select CRYPTO_GLUE_HELPER_X86
1105 Camellia cipher algorithm module (x86_64).
1107 Camellia is a symmetric key block cipher developed jointly
1108 at NTT and Mitsubishi Electric Corporation.
1110 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1113 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1115 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1116 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1117 depends on X86 && 64BIT
1119 select CRYPTO_ALGAPI
1120 select CRYPTO_CRYPTD
1121 select CRYPTO_ABLK_HELPER
1122 select CRYPTO_GLUE_HELPER_X86
1123 select CRYPTO_CAMELLIA_X86_64
1127 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1129 Camellia is a symmetric key block cipher developed jointly
1130 at NTT and Mitsubishi Electric Corporation.
1132 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1135 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1137 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1138 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1139 depends on X86 && 64BIT
1141 select CRYPTO_ALGAPI
1142 select CRYPTO_CRYPTD
1143 select CRYPTO_ABLK_HELPER
1144 select CRYPTO_GLUE_HELPER_X86
1145 select CRYPTO_CAMELLIA_X86_64
1146 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1150 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1152 Camellia is a symmetric key block cipher developed jointly
1153 at NTT and Mitsubishi Electric Corporation.
1155 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1158 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1160 config CRYPTO_CAMELLIA_SPARC64
1161 tristate "Camellia cipher algorithm (SPARC64)"
1164 select CRYPTO_ALGAPI
1166 Camellia cipher algorithm module (SPARC64).
1168 Camellia is a symmetric key block cipher developed jointly
1169 at NTT and Mitsubishi Electric Corporation.
1171 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1174 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1176 config CRYPTO_CAST_COMMON
1179 Common parts of the CAST cipher algorithms shared by the
1180 generic c and the assembler implementations.
1183 tristate "CAST5 (CAST-128) cipher algorithm"
1184 select CRYPTO_ALGAPI
1185 select CRYPTO_CAST_COMMON
1187 The CAST5 encryption algorithm (synonymous with CAST-128) is
1188 described in RFC2144.
1190 config CRYPTO_CAST5_AVX_X86_64
1191 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1192 depends on X86 && 64BIT
1193 select CRYPTO_ALGAPI
1194 select CRYPTO_CRYPTD
1195 select CRYPTO_ABLK_HELPER
1196 select CRYPTO_CAST_COMMON
1199 The CAST5 encryption algorithm (synonymous with CAST-128) is
1200 described in RFC2144.
1202 This module provides the Cast5 cipher algorithm that processes
1203 sixteen blocks parallel using the AVX instruction set.
1206 tristate "CAST6 (CAST-256) cipher algorithm"
1207 select CRYPTO_ALGAPI
1208 select CRYPTO_CAST_COMMON
1210 The CAST6 encryption algorithm (synonymous with CAST-256) is
1211 described in RFC2612.
1213 config CRYPTO_CAST6_AVX_X86_64
1214 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1215 depends on X86 && 64BIT
1216 select CRYPTO_ALGAPI
1217 select CRYPTO_CRYPTD
1218 select CRYPTO_ABLK_HELPER
1219 select CRYPTO_GLUE_HELPER_X86
1220 select CRYPTO_CAST_COMMON
1225 The CAST6 encryption algorithm (synonymous with CAST-256) is
1226 described in RFC2612.
1228 This module provides the Cast6 cipher algorithm that processes
1229 eight blocks parallel using the AVX instruction set.
1232 tristate "DES and Triple DES EDE cipher algorithms"
1233 select CRYPTO_ALGAPI
1235 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1237 config CRYPTO_DES_SPARC64
1238 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1240 select CRYPTO_ALGAPI
1243 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1244 optimized using SPARC64 crypto opcodes.
1246 config CRYPTO_DES3_EDE_X86_64
1247 tristate "Triple DES EDE cipher algorithm (x86-64)"
1248 depends on X86 && 64BIT
1249 select CRYPTO_ALGAPI
1252 Triple DES EDE (FIPS 46-3) algorithm.
1254 This module provides implementation of the Triple DES EDE cipher
1255 algorithm that is optimized for x86-64 processors. Two versions of
1256 algorithm are provided; regular processing one input block and
1257 one that processes three blocks parallel.
1259 config CRYPTO_FCRYPT
1260 tristate "FCrypt cipher algorithm"
1261 select CRYPTO_ALGAPI
1262 select CRYPTO_BLKCIPHER
1264 FCrypt algorithm used by RxRPC.
1266 config CRYPTO_KHAZAD
1267 tristate "Khazad cipher algorithm"
1268 select CRYPTO_ALGAPI
1270 Khazad cipher algorithm.
1272 Khazad was a finalist in the initial NESSIE competition. It is
1273 an algorithm optimized for 64-bit processors with good performance
1274 on 32-bit processors. Khazad uses an 128 bit key size.
1277 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1279 config CRYPTO_SALSA20
1280 tristate "Salsa20 stream cipher algorithm"
1281 select CRYPTO_BLKCIPHER
1283 Salsa20 stream cipher algorithm.
1285 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1286 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1288 The Salsa20 stream cipher algorithm is designed by Daniel J.
1289 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1291 config CRYPTO_SALSA20_586
1292 tristate "Salsa20 stream cipher algorithm (i586)"
1293 depends on (X86 || UML_X86) && !64BIT
1294 select CRYPTO_BLKCIPHER
1296 Salsa20 stream cipher algorithm.
1298 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1299 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1301 The Salsa20 stream cipher algorithm is designed by Daniel J.
1302 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1304 config CRYPTO_SALSA20_X86_64
1305 tristate "Salsa20 stream cipher algorithm (x86_64)"
1306 depends on (X86 || UML_X86) && 64BIT
1307 select CRYPTO_BLKCIPHER
1309 Salsa20 stream cipher algorithm.
1311 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1312 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1314 The Salsa20 stream cipher algorithm is designed by Daniel J.
1315 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1317 config CRYPTO_CHACHA20
1318 tristate "ChaCha20 cipher algorithm"
1319 select CRYPTO_BLKCIPHER
1321 ChaCha20 cipher algorithm, RFC7539.
1323 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1324 Bernstein and further specified in RFC7539 for use in IETF protocols.
1325 This is the portable C implementation of ChaCha20.
1328 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1330 config CRYPTO_CHACHA20_X86_64
1331 tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1332 depends on X86 && 64BIT
1333 select CRYPTO_BLKCIPHER
1334 select CRYPTO_CHACHA20
1336 ChaCha20 cipher algorithm, RFC7539.
1338 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1339 Bernstein and further specified in RFC7539 for use in IETF protocols.
1340 This is the x86_64 assembler implementation using SIMD instructions.
1343 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1346 tristate "SEED cipher algorithm"
1347 select CRYPTO_ALGAPI
1349 SEED cipher algorithm (RFC4269).
1351 SEED is a 128-bit symmetric key block cipher that has been
1352 developed by KISA (Korea Information Security Agency) as a
1353 national standard encryption algorithm of the Republic of Korea.
1354 It is a 16 round block cipher with the key size of 128 bit.
1357 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1359 config CRYPTO_SERPENT
1360 tristate "Serpent cipher algorithm"
1361 select CRYPTO_ALGAPI
1363 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1365 Keys are allowed to be from 0 to 256 bits in length, in steps
1366 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1367 variant of Serpent for compatibility with old kerneli.org code.
1370 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1372 config CRYPTO_SERPENT_SSE2_X86_64
1373 tristate "Serpent cipher algorithm (x86_64/SSE2)"
1374 depends on X86 && 64BIT
1375 select CRYPTO_ALGAPI
1376 select CRYPTO_CRYPTD
1377 select CRYPTO_ABLK_HELPER
1378 select CRYPTO_GLUE_HELPER_X86
1379 select CRYPTO_SERPENT
1383 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1385 Keys are allowed to be from 0 to 256 bits in length, in steps
1388 This module provides Serpent cipher algorithm that processes eight
1389 blocks parallel using SSE2 instruction set.
1392 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1394 config CRYPTO_SERPENT_SSE2_586
1395 tristate "Serpent cipher algorithm (i586/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 four
1411 blocks parallel using SSE2 instruction set.
1414 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1416 config CRYPTO_SERPENT_AVX_X86_64
1417 tristate "Serpent cipher algorithm (x86_64/AVX)"
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 the Serpent cipher algorithm that processes
1433 eight blocks parallel using the AVX instruction set.
1436 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1438 config CRYPTO_SERPENT_AVX2_X86_64
1439 tristate "Serpent cipher algorithm (x86_64/AVX2)"
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
1446 select CRYPTO_SERPENT_AVX_X86_64
1450 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1452 Keys are allowed to be from 0 to 256 bits in length, in steps
1455 This module provides Serpent cipher algorithm that processes 16
1456 blocks parallel using AVX2 instruction set.
1459 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1462 tristate "TEA, XTEA and XETA cipher algorithms"
1463 select CRYPTO_ALGAPI
1465 TEA cipher algorithm.
1467 Tiny Encryption Algorithm is a simple cipher that uses
1468 many rounds for security. It is very fast and uses
1471 Xtendend Tiny Encryption Algorithm is a modification to
1472 the TEA algorithm to address a potential key weakness
1473 in the TEA algorithm.
1475 Xtendend Encryption Tiny Algorithm is a mis-implementation
1476 of the XTEA algorithm for compatibility purposes.
1478 config CRYPTO_TWOFISH
1479 tristate "Twofish cipher algorithm"
1480 select CRYPTO_ALGAPI
1481 select CRYPTO_TWOFISH_COMMON
1483 Twofish cipher algorithm.
1485 Twofish was submitted as an AES (Advanced Encryption Standard)
1486 candidate cipher by researchers at CounterPane Systems. It is a
1487 16 round block cipher supporting key sizes of 128, 192, and 256
1491 <http://www.schneier.com/twofish.html>
1493 config CRYPTO_TWOFISH_COMMON
1496 Common parts of the Twofish cipher algorithm shared by the
1497 generic c and the assembler implementations.
1499 config CRYPTO_TWOFISH_586
1500 tristate "Twofish cipher algorithms (i586)"
1501 depends on (X86 || UML_X86) && !64BIT
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_X86_64
1516 tristate "Twofish cipher algorithm (x86_64)"
1517 depends on (X86 || UML_X86) && 64BIT
1518 select CRYPTO_ALGAPI
1519 select CRYPTO_TWOFISH_COMMON
1521 Twofish cipher algorithm (x86_64).
1523 Twofish was submitted as an AES (Advanced Encryption Standard)
1524 candidate cipher by researchers at CounterPane Systems. It is a
1525 16 round block cipher supporting key sizes of 128, 192, and 256
1529 <http://www.schneier.com/twofish.html>
1531 config CRYPTO_TWOFISH_X86_64_3WAY
1532 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1533 depends on X86 && 64BIT
1534 select CRYPTO_ALGAPI
1535 select CRYPTO_TWOFISH_COMMON
1536 select CRYPTO_TWOFISH_X86_64
1537 select CRYPTO_GLUE_HELPER_X86
1541 Twofish cipher algorithm (x86_64, 3-way parallel).
1543 Twofish was submitted as an AES (Advanced Encryption Standard)
1544 candidate cipher by researchers at CounterPane Systems. It is a
1545 16 round block cipher supporting key sizes of 128, 192, and 256
1548 This module provides Twofish cipher algorithm that processes three
1549 blocks parallel, utilizing resources of out-of-order CPUs better.
1552 <http://www.schneier.com/twofish.html>
1554 config CRYPTO_TWOFISH_AVX_X86_64
1555 tristate "Twofish cipher algorithm (x86_64/AVX)"
1556 depends on X86 && 64BIT
1557 select CRYPTO_ALGAPI
1558 select CRYPTO_CRYPTD
1559 select CRYPTO_ABLK_HELPER
1560 select CRYPTO_GLUE_HELPER_X86
1561 select CRYPTO_TWOFISH_COMMON
1562 select CRYPTO_TWOFISH_X86_64
1563 select CRYPTO_TWOFISH_X86_64_3WAY
1567 Twofish cipher algorithm (x86_64/AVX).
1569 Twofish was submitted as an AES (Advanced Encryption Standard)
1570 candidate cipher by researchers at CounterPane Systems. It is a
1571 16 round block cipher supporting key sizes of 128, 192, and 256
1574 This module provides the Twofish cipher algorithm that processes
1575 eight blocks parallel using the AVX Instruction Set.
1578 <http://www.schneier.com/twofish.html>
1580 comment "Compression"
1582 config CRYPTO_DEFLATE
1583 tristate "Deflate compression algorithm"
1584 select CRYPTO_ALGAPI
1585 select CRYPTO_ACOMP2
1589 This is the Deflate algorithm (RFC1951), specified for use in
1590 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1592 You will most probably want this if using IPSec.
1595 tristate "LZO compression algorithm"
1596 select CRYPTO_ALGAPI
1597 select CRYPTO_ACOMP2
1599 select LZO_DECOMPRESS
1601 This is the LZO algorithm.
1604 tristate "842 compression algorithm"
1605 select CRYPTO_ALGAPI
1606 select CRYPTO_ACOMP2
1608 select 842_DECOMPRESS
1610 This is the 842 algorithm.
1613 tristate "LZ4 compression algorithm"
1614 select CRYPTO_ALGAPI
1615 select CRYPTO_ACOMP2
1617 select LZ4_DECOMPRESS
1619 This is the LZ4 algorithm.
1622 tristate "LZ4HC compression algorithm"
1623 select CRYPTO_ALGAPI
1624 select CRYPTO_ACOMP2
1625 select LZ4HC_COMPRESS
1626 select LZ4_DECOMPRESS
1628 This is the LZ4 high compression mode algorithm.
1630 comment "Random Number Generation"
1632 config CRYPTO_ANSI_CPRNG
1633 tristate "Pseudo Random Number Generation for Cryptographic modules"
1637 This option enables the generic pseudo random number generator
1638 for cryptographic modules. Uses the Algorithm specified in
1639 ANSI X9.31 A.2.4. Note that this option must be enabled if
1640 CRYPTO_FIPS is selected
1642 menuconfig CRYPTO_DRBG_MENU
1643 tristate "NIST SP800-90A DRBG"
1645 NIST SP800-90A compliant DRBG. In the following submenu, one or
1646 more of the DRBG types must be selected.
1650 config CRYPTO_DRBG_HMAC
1654 select CRYPTO_SHA256
1656 config CRYPTO_DRBG_HASH
1657 bool "Enable Hash DRBG"
1658 select CRYPTO_SHA256
1660 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1662 config CRYPTO_DRBG_CTR
1663 bool "Enable CTR DRBG"
1665 depends on CRYPTO_CTR
1667 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1671 default CRYPTO_DRBG_MENU
1673 select CRYPTO_JITTERENTROPY
1675 endif # if CRYPTO_DRBG_MENU
1677 config CRYPTO_JITTERENTROPY
1678 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1681 The Jitterentropy RNG is a noise that is intended
1682 to provide seed to another RNG. The RNG does not
1683 perform any cryptographic whitening of the generated
1684 random numbers. This Jitterentropy RNG registers with
1685 the kernel crypto API and can be used by any caller.
1687 config CRYPTO_USER_API
1690 config CRYPTO_USER_API_HASH
1691 tristate "User-space interface for hash algorithms"
1694 select CRYPTO_USER_API
1696 This option enables the user-spaces interface for hash
1699 config CRYPTO_USER_API_SKCIPHER
1700 tristate "User-space interface for symmetric key cipher algorithms"
1702 select CRYPTO_BLKCIPHER
1703 select CRYPTO_USER_API
1705 This option enables the user-spaces interface for symmetric
1706 key cipher algorithms.
1708 config CRYPTO_USER_API_RNG
1709 tristate "User-space interface for random number generator algorithms"
1712 select CRYPTO_USER_API
1714 This option enables the user-spaces interface for random
1715 number generator algorithms.
1717 config CRYPTO_USER_API_AEAD
1718 tristate "User-space interface for AEAD cipher algorithms"
1721 select CRYPTO_USER_API
1723 This option enables the user-spaces interface for AEAD
1726 config CRYPTO_HASH_INFO
1729 source "drivers/crypto/Kconfig"
1730 source crypto/asymmetric_keys/Kconfig
1731 source certs/Kconfig