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.
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
106 tristate "RSA algorithm"
107 select CRYPTO_AKCIPHER
108 select CRYPTO_MANAGER
112 Generic implementation of the RSA public key algorithm.
115 tristate "Diffie-Hellman algorithm"
119 Generic implementation of the Diffie-Hellman algorithm.
122 tristate "ECDH algorithm"
125 Generic implementation of the ECDH algorithm
127 config CRYPTO_MANAGER
128 tristate "Cryptographic algorithm manager"
129 select CRYPTO_MANAGER2
131 Create default cryptographic template instantiations such as
134 config CRYPTO_MANAGER2
135 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
138 select CRYPTO_BLKCIPHER2
139 select CRYPTO_AKCIPHER2
143 tristate "Userspace cryptographic algorithm configuration"
145 select CRYPTO_MANAGER
147 Userspace configuration for cryptographic instantiations such as
150 config CRYPTO_MANAGER_DISABLE_TESTS
151 bool "Disable run-time self tests"
153 depends on CRYPTO_MANAGER2
155 Disable run-time self tests that normally take place at
156 algorithm registration.
158 config CRYPTO_GF128MUL
159 tristate "GF(2^128) multiplication functions"
161 Efficient table driven implementation of multiplications in the
162 field GF(2^128). This is needed by some cypher modes. This
163 option will be selected automatically if you select such a
164 cipher mode. Only select this option by hand if you expect to load
165 an external module that requires these functions.
168 tristate "Null algorithms"
171 These are 'Null' algorithms, used by IPsec, which do nothing.
175 select CRYPTO_ALGAPI2
176 select CRYPTO_BLKCIPHER2
180 tristate "Parallel crypto engine"
183 select CRYPTO_MANAGER
186 This converts an arbitrary crypto algorithm into a parallel
187 algorithm that executes in kernel threads.
189 config CRYPTO_WORKQUEUE
193 tristate "Software async crypto daemon"
194 select CRYPTO_BLKCIPHER
196 select CRYPTO_MANAGER
197 select CRYPTO_WORKQUEUE
199 This is a generic software asynchronous crypto daemon that
200 converts an arbitrary synchronous software crypto algorithm
201 into an asynchronous algorithm that executes in a kernel thread.
203 config CRYPTO_MCRYPTD
204 tristate "Software async multi-buffer crypto daemon"
205 select CRYPTO_BLKCIPHER
207 select CRYPTO_MANAGER
208 select CRYPTO_WORKQUEUE
210 This is a generic software asynchronous crypto daemon that
211 provides the kernel thread to assist multi-buffer crypto
212 algorithms for submitting jobs and flushing jobs in multi-buffer
213 crypto algorithms. Multi-buffer crypto algorithms are executed
214 in the context of this kernel thread and drivers can post
215 their crypto request asynchronously to be processed by this daemon.
217 config CRYPTO_AUTHENC
218 tristate "Authenc support"
220 select CRYPTO_BLKCIPHER
221 select CRYPTO_MANAGER
225 Authenc: Combined mode wrapper for IPsec.
226 This is required for IPSec.
229 tristate "Testing module"
231 select CRYPTO_MANAGER
233 Quick & dirty crypto test module.
235 config CRYPTO_ABLK_HELPER
239 config CRYPTO_GLUE_HELPER_X86
247 comment "Authenticated Encryption with Associated Data"
250 tristate "CCM support"
254 Support for Counter with CBC MAC. Required for IPsec.
257 tristate "GCM/GMAC support"
263 Support for Galois/Counter Mode (GCM) and Galois Message
264 Authentication Code (GMAC). Required for IPSec.
266 config CRYPTO_CHACHA20POLY1305
267 tristate "ChaCha20-Poly1305 AEAD support"
268 select CRYPTO_CHACHA20
269 select CRYPTO_POLY1305
272 ChaCha20-Poly1305 AEAD support, RFC7539.
274 Support for the AEAD wrapper using the ChaCha20 stream cipher combined
275 with the Poly1305 authenticator. It is defined in RFC7539 for use in
279 tristate "Sequence Number IV Generator"
281 select CRYPTO_BLKCIPHER
283 select CRYPTO_RNG_DEFAULT
285 This IV generator generates an IV based on a sequence number by
286 xoring it with a salt. This algorithm is mainly useful for CTR
288 config CRYPTO_ECHAINIV
289 tristate "Encrypted Chain IV Generator"
292 select CRYPTO_RNG_DEFAULT
295 This IV generator generates an IV based on the encryption of
296 a sequence number xored with a salt. This is the default
299 comment "Block modes"
302 tristate "CBC support"
303 select CRYPTO_BLKCIPHER
304 select CRYPTO_MANAGER
306 CBC: Cipher Block Chaining mode
307 This block cipher algorithm is required for IPSec.
310 tristate "CTR support"
311 select CRYPTO_BLKCIPHER
313 select CRYPTO_MANAGER
316 This block cipher algorithm is required for IPSec.
319 tristate "CTS support"
320 select CRYPTO_BLKCIPHER
322 CTS: Cipher Text Stealing
323 This is the Cipher Text Stealing mode as described by
324 Section 8 of rfc2040 and referenced by rfc3962.
325 (rfc3962 includes errata information in its Appendix A)
326 This mode is required for Kerberos gss mechanism support
330 tristate "ECB support"
331 select CRYPTO_BLKCIPHER
332 select CRYPTO_MANAGER
334 ECB: Electronic CodeBook mode
335 This is the simplest block cipher algorithm. It simply encrypts
336 the input block by block.
339 tristate "LRW support"
340 select CRYPTO_BLKCIPHER
341 select CRYPTO_MANAGER
342 select CRYPTO_GF128MUL
344 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
345 narrow block cipher mode for dm-crypt. Use it with cipher
346 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
347 The first 128, 192 or 256 bits in the key are used for AES and the
348 rest is used to tie each cipher block to its logical position.
351 tristate "PCBC support"
352 select CRYPTO_BLKCIPHER
353 select CRYPTO_MANAGER
355 PCBC: Propagating Cipher Block Chaining mode
356 This block cipher algorithm is required for RxRPC.
359 tristate "XTS support"
360 select CRYPTO_BLKCIPHER
361 select CRYPTO_MANAGER
362 select CRYPTO_GF128MUL
364 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
365 key size 256, 384 or 512 bits. This implementation currently
366 can't handle a sectorsize which is not a multiple of 16 bytes.
368 config CRYPTO_KEYWRAP
369 tristate "Key wrapping support"
370 select CRYPTO_BLKCIPHER
372 Support for key wrapping (NIST SP800-38F / RFC3394) without
378 tristate "CMAC support"
380 select CRYPTO_MANAGER
382 Cipher-based Message Authentication Code (CMAC) specified by
383 The National Institute of Standards and Technology (NIST).
385 https://tools.ietf.org/html/rfc4493
386 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
389 tristate "HMAC support"
391 select CRYPTO_MANAGER
393 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
394 This is required for IPSec.
397 tristate "XCBC support"
399 select CRYPTO_MANAGER
401 XCBC: Keyed-Hashing with encryption algorithm
402 http://www.ietf.org/rfc/rfc3566.txt
403 http://csrc.nist.gov/encryption/modes/proposedmodes/
404 xcbc-mac/xcbc-mac-spec.pdf
407 tristate "VMAC support"
409 select CRYPTO_MANAGER
411 VMAC is a message authentication algorithm designed for
412 very high speed on 64-bit architectures.
415 <http://fastcrypto.org/vmac>
420 tristate "CRC32c CRC algorithm"
424 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
425 by iSCSI for header and data digests and by others.
426 See Castagnoli93. Module will be crc32c.
428 config CRYPTO_CRC32C_INTEL
429 tristate "CRC32c INTEL hardware acceleration"
433 In Intel processor with SSE4.2 supported, the processor will
434 support CRC32C implementation using hardware accelerated CRC32
435 instruction. This option will create 'crc32c-intel' module,
436 which will enable any routine to use the CRC32 instruction to
437 gain performance compared with software implementation.
438 Module will be crc32c-intel.
440 config CRYPTO_CRC32C_SPARC64
441 tristate "CRC32c CRC algorithm (SPARC64)"
446 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
450 tristate "CRC32 CRC algorithm"
454 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
455 Shash crypto api wrappers to crc32_le function.
457 config CRYPTO_CRC32_PCLMUL
458 tristate "CRC32 PCLMULQDQ hardware acceleration"
463 From Intel Westmere and AMD Bulldozer processor with SSE4.2
464 and PCLMULQDQ supported, the processor will support
465 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
466 instruction. This option will create 'crc32-plcmul' module,
467 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
468 and gain better performance as compared with the table implementation.
470 config CRYPTO_CRCT10DIF
471 tristate "CRCT10DIF algorithm"
474 CRC T10 Data Integrity Field computation is being cast as
475 a crypto transform. This allows for faster crc t10 diff
476 transforms to be used if they are available.
478 config CRYPTO_CRCT10DIF_PCLMUL
479 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
480 depends on X86 && 64BIT && CRC_T10DIF
483 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
484 CRC T10 DIF PCLMULQDQ computation can be hardware
485 accelerated PCLMULQDQ instruction. This option will create
486 'crct10dif-plcmul' module, which is faster when computing the
487 crct10dif checksum as compared with the generic table implementation.
490 tristate "GHASH digest algorithm"
491 select CRYPTO_GF128MUL
494 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
496 config CRYPTO_POLY1305
497 tristate "Poly1305 authenticator algorithm"
500 Poly1305 authenticator algorithm, RFC7539.
502 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
503 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
504 in IETF protocols. This is the portable C implementation of Poly1305.
506 config CRYPTO_POLY1305_X86_64
507 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
508 depends on X86 && 64BIT
509 select CRYPTO_POLY1305
511 Poly1305 authenticator algorithm, RFC7539.
513 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
514 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
515 in IETF protocols. This is the x86_64 assembler implementation using SIMD
519 tristate "MD4 digest algorithm"
522 MD4 message digest algorithm (RFC1320).
525 tristate "MD5 digest algorithm"
528 MD5 message digest algorithm (RFC1321).
530 config CRYPTO_MD5_OCTEON
531 tristate "MD5 digest algorithm (OCTEON)"
532 depends on CPU_CAVIUM_OCTEON
536 MD5 message digest algorithm (RFC1321) implemented
537 using OCTEON crypto instructions, when available.
539 config CRYPTO_MD5_PPC
540 tristate "MD5 digest algorithm (PPC)"
544 MD5 message digest algorithm (RFC1321) implemented
547 config CRYPTO_MD5_SPARC64
548 tristate "MD5 digest algorithm (SPARC64)"
553 MD5 message digest algorithm (RFC1321) implemented
554 using sparc64 crypto instructions, when available.
556 config CRYPTO_MICHAEL_MIC
557 tristate "Michael MIC keyed digest algorithm"
560 Michael MIC is used for message integrity protection in TKIP
561 (IEEE 802.11i). This algorithm is required for TKIP, but it
562 should not be used for other purposes because of the weakness
566 tristate "RIPEMD-128 digest algorithm"
569 RIPEMD-128 (ISO/IEC 10118-3:2004).
571 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
572 be used as a secure replacement for RIPEMD. For other use cases,
573 RIPEMD-160 should be used.
575 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
576 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
579 tristate "RIPEMD-160 digest algorithm"
582 RIPEMD-160 (ISO/IEC 10118-3:2004).
584 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
585 to be used as a secure replacement for the 128-bit hash functions
586 MD4, MD5 and it's predecessor RIPEMD
587 (not to be confused with RIPEMD-128).
589 It's speed is comparable to SHA1 and there are no known attacks
592 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
593 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
596 tristate "RIPEMD-256 digest algorithm"
599 RIPEMD-256 is an optional extension of RIPEMD-128 with a
600 256 bit hash. It is intended for applications that require
601 longer hash-results, without needing a larger security level
604 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
605 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
608 tristate "RIPEMD-320 digest algorithm"
611 RIPEMD-320 is an optional extension of RIPEMD-160 with a
612 320 bit hash. It is intended for applications that require
613 longer hash-results, without needing a larger security level
616 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
617 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
620 tristate "SHA1 digest algorithm"
623 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
625 config CRYPTO_SHA1_SSSE3
626 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
627 depends on X86 && 64BIT
631 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
632 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
633 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
636 config CRYPTO_SHA256_SSSE3
637 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
638 depends on X86 && 64BIT
642 SHA-256 secure hash standard (DFIPS 180-2) implemented
643 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
644 Extensions version 1 (AVX1), or Advanced Vector Extensions
645 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
646 Instructions) when available.
648 config CRYPTO_SHA512_SSSE3
649 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
650 depends on X86 && 64BIT
654 SHA-512 secure hash standard (DFIPS 180-2) implemented
655 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
656 Extensions version 1 (AVX1), or Advanced Vector Extensions
657 version 2 (AVX2) instructions, when available.
659 config CRYPTO_SHA1_OCTEON
660 tristate "SHA1 digest algorithm (OCTEON)"
661 depends on CPU_CAVIUM_OCTEON
665 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
666 using OCTEON crypto instructions, when available.
668 config CRYPTO_SHA1_SPARC64
669 tristate "SHA1 digest algorithm (SPARC64)"
674 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
675 using sparc64 crypto instructions, when available.
677 config CRYPTO_SHA1_PPC
678 tristate "SHA1 digest algorithm (powerpc)"
681 This is the powerpc hardware accelerated implementation of the
682 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
684 config CRYPTO_SHA1_PPC_SPE
685 tristate "SHA1 digest algorithm (PPC SPE)"
686 depends on PPC && SPE
688 SHA-1 secure hash standard (DFIPS 180-4) implemented
689 using powerpc SPE SIMD instruction set.
691 config CRYPTO_SHA1_MB
692 tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
693 depends on X86 && 64BIT
696 select CRYPTO_MCRYPTD
698 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
699 using multi-buffer technique. This algorithm computes on
700 multiple data lanes concurrently with SIMD instructions for
701 better throughput. It should not be enabled by default but
702 used when there is significant amount of work to keep the keep
703 the data lanes filled to get performance benefit. If the data
704 lanes remain unfilled, a flush operation will be initiated to
705 process the crypto jobs, adding a slight latency.
707 config CRYPTO_SHA256_MB
708 tristate "SHA256 digest algorithm (x86_64 Multi-Buffer, Experimental)"
709 depends on X86 && 64BIT
712 select CRYPTO_MCRYPTD
714 SHA-256 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
715 using multi-buffer technique. This algorithm computes on
716 multiple data lanes concurrently with SIMD instructions for
717 better throughput. It should not be enabled by default but
718 used when there is significant amount of work to keep the keep
719 the data lanes filled to get performance benefit. If the data
720 lanes remain unfilled, a flush operation will be initiated to
721 process the crypto jobs, adding a slight latency.
723 config CRYPTO_SHA512_MB
724 tristate "SHA512 digest algorithm (x86_64 Multi-Buffer, Experimental)"
725 depends on X86 && 64BIT
728 select CRYPTO_MCRYPTD
730 SHA-512 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
731 using multi-buffer technique. This algorithm computes on
732 multiple data lanes concurrently with SIMD instructions for
733 better throughput. It should not be enabled by default but
734 used when there is significant amount of work to keep the keep
735 the data lanes filled to get performance benefit. If the data
736 lanes remain unfilled, a flush operation will be initiated to
737 process the crypto jobs, adding a slight latency.
740 tristate "SHA224 and SHA256 digest algorithm"
743 SHA256 secure hash standard (DFIPS 180-2).
745 This version of SHA implements a 256 bit hash with 128 bits of
746 security against collision attacks.
748 This code also includes SHA-224, a 224 bit hash with 112 bits
749 of security against collision attacks.
751 config CRYPTO_SHA256_PPC_SPE
752 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
753 depends on PPC && SPE
757 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
758 implemented using powerpc SPE SIMD instruction set.
760 config CRYPTO_SHA256_OCTEON
761 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
762 depends on CPU_CAVIUM_OCTEON
766 SHA-256 secure hash standard (DFIPS 180-2) implemented
767 using OCTEON crypto instructions, when available.
769 config CRYPTO_SHA256_SPARC64
770 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
775 SHA-256 secure hash standard (DFIPS 180-2) implemented
776 using sparc64 crypto instructions, when available.
779 tristate "SHA384 and SHA512 digest algorithms"
782 SHA512 secure hash standard (DFIPS 180-2).
784 This version of SHA implements a 512 bit hash with 256 bits of
785 security against collision attacks.
787 This code also includes SHA-384, a 384 bit hash with 192 bits
788 of security against collision attacks.
790 config CRYPTO_SHA512_OCTEON
791 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
792 depends on CPU_CAVIUM_OCTEON
796 SHA-512 secure hash standard (DFIPS 180-2) implemented
797 using OCTEON crypto instructions, when available.
799 config CRYPTO_SHA512_SPARC64
800 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
805 SHA-512 secure hash standard (DFIPS 180-2) implemented
806 using sparc64 crypto instructions, when available.
809 tristate "SHA3 digest algorithm"
812 SHA-3 secure hash standard (DFIPS 202). It's based on
813 cryptographic sponge function family called Keccak.
816 http://keccak.noekeon.org/
819 tristate "Tiger digest algorithms"
822 Tiger hash algorithm 192, 160 and 128-bit hashes
824 Tiger is a hash function optimized for 64-bit processors while
825 still having decent performance on 32-bit processors.
826 Tiger was developed by Ross Anderson and Eli Biham.
829 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
832 tristate "Whirlpool digest algorithms"
835 Whirlpool hash algorithm 512, 384 and 256-bit hashes
837 Whirlpool-512 is part of the NESSIE cryptographic primitives.
838 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
841 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
843 config CRYPTO_GHASH_CLMUL_NI_INTEL
844 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
845 depends on X86 && 64BIT
848 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
849 The implementation is accelerated by CLMUL-NI of Intel.
854 tristate "AES cipher algorithms"
857 AES cipher algorithms (FIPS-197). AES uses the Rijndael
860 Rijndael appears to be consistently a very good performer in
861 both hardware and software across a wide range of computing
862 environments regardless of its use in feedback or non-feedback
863 modes. Its key setup time is excellent, and its key agility is
864 good. Rijndael's very low memory requirements make it very well
865 suited for restricted-space environments, in which it also
866 demonstrates excellent performance. Rijndael's operations are
867 among the easiest to defend against power and timing attacks.
869 The AES specifies three key sizes: 128, 192 and 256 bits
871 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
873 config CRYPTO_AES_586
874 tristate "AES cipher algorithms (i586)"
875 depends on (X86 || UML_X86) && !64BIT
879 AES cipher algorithms (FIPS-197). AES uses the Rijndael
882 Rijndael appears to be consistently a very good performer in
883 both hardware and software across a wide range of computing
884 environments regardless of its use in feedback or non-feedback
885 modes. Its key setup time is excellent, and its key agility is
886 good. Rijndael's very low memory requirements make it very well
887 suited for restricted-space environments, in which it also
888 demonstrates excellent performance. Rijndael's operations are
889 among the easiest to defend against power and timing attacks.
891 The AES specifies three key sizes: 128, 192 and 256 bits
893 See <http://csrc.nist.gov/encryption/aes/> for more information.
895 config CRYPTO_AES_X86_64
896 tristate "AES cipher algorithms (x86_64)"
897 depends on (X86 || UML_X86) && 64BIT
901 AES cipher algorithms (FIPS-197). AES uses the Rijndael
904 Rijndael appears to be consistently a very good performer in
905 both hardware and software across a wide range of computing
906 environments regardless of its use in feedback or non-feedback
907 modes. Its key setup time is excellent, and its key agility is
908 good. Rijndael's very low memory requirements make it very well
909 suited for restricted-space environments, in which it also
910 demonstrates excellent performance. Rijndael's operations are
911 among the easiest to defend against power and timing attacks.
913 The AES specifies three key sizes: 128, 192 and 256 bits
915 See <http://csrc.nist.gov/encryption/aes/> for more information.
917 config CRYPTO_AES_NI_INTEL
918 tristate "AES cipher algorithms (AES-NI)"
920 select CRYPTO_AES_X86_64 if 64BIT
921 select CRYPTO_AES_586 if !64BIT
923 select CRYPTO_ABLK_HELPER
925 select CRYPTO_GLUE_HELPER_X86 if 64BIT
929 Use Intel AES-NI instructions for AES algorithm.
931 AES cipher algorithms (FIPS-197). AES uses the Rijndael
934 Rijndael appears to be consistently a very good performer in
935 both hardware and software across a wide range of computing
936 environments regardless of its use in feedback or non-feedback
937 modes. Its key setup time is excellent, and its key agility is
938 good. Rijndael's very low memory requirements make it very well
939 suited for restricted-space environments, in which it also
940 demonstrates excellent performance. Rijndael's operations are
941 among the easiest to defend against power and timing attacks.
943 The AES specifies three key sizes: 128, 192 and 256 bits
945 See <http://csrc.nist.gov/encryption/aes/> for more information.
947 In addition to AES cipher algorithm support, the acceleration
948 for some popular block cipher mode is supported too, including
949 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
950 acceleration for CTR.
952 config CRYPTO_AES_SPARC64
953 tristate "AES cipher algorithms (SPARC64)"
958 Use SPARC64 crypto opcodes for AES algorithm.
960 AES cipher algorithms (FIPS-197). AES uses the Rijndael
963 Rijndael appears to be consistently a very good performer in
964 both hardware and software across a wide range of computing
965 environments regardless of its use in feedback or non-feedback
966 modes. Its key setup time is excellent, and its key agility is
967 good. Rijndael's very low memory requirements make it very well
968 suited for restricted-space environments, in which it also
969 demonstrates excellent performance. Rijndael's operations are
970 among the easiest to defend against power and timing attacks.
972 The AES specifies three key sizes: 128, 192 and 256 bits
974 See <http://csrc.nist.gov/encryption/aes/> for more information.
976 In addition to AES cipher algorithm support, the acceleration
977 for some popular block cipher mode is supported too, including
980 config CRYPTO_AES_PPC_SPE
981 tristate "AES cipher algorithms (PPC SPE)"
982 depends on PPC && SPE
984 AES cipher algorithms (FIPS-197). Additionally the acceleration
985 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
986 This module should only be used for low power (router) devices
987 without hardware AES acceleration (e.g. caam crypto). It reduces the
988 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
989 timining attacks. Nevertheless it might be not as secure as other
990 architecture specific assembler implementations that work on 1KB
991 tables or 256 bytes S-boxes.
994 tristate "Anubis cipher algorithm"
997 Anubis cipher algorithm.
999 Anubis is a variable key length cipher which can use keys from
1000 128 bits to 320 bits in length. It was evaluated as a entrant
1001 in the NESSIE competition.
1004 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1005 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1008 tristate "ARC4 cipher algorithm"
1009 select CRYPTO_BLKCIPHER
1011 ARC4 cipher algorithm.
1013 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1014 bits in length. This algorithm is required for driver-based
1015 WEP, but it should not be for other purposes because of the
1016 weakness of the algorithm.
1018 config CRYPTO_BLOWFISH
1019 tristate "Blowfish cipher algorithm"
1020 select CRYPTO_ALGAPI
1021 select CRYPTO_BLOWFISH_COMMON
1023 Blowfish cipher algorithm, by Bruce Schneier.
1025 This is a variable key length cipher which can use keys from 32
1026 bits to 448 bits in length. It's fast, simple and specifically
1027 designed for use on "large microprocessors".
1030 <http://www.schneier.com/blowfish.html>
1032 config CRYPTO_BLOWFISH_COMMON
1035 Common parts of the Blowfish cipher algorithm shared by the
1036 generic c and the assembler implementations.
1039 <http://www.schneier.com/blowfish.html>
1041 config CRYPTO_BLOWFISH_X86_64
1042 tristate "Blowfish cipher algorithm (x86_64)"
1043 depends on X86 && 64BIT
1044 select CRYPTO_ALGAPI
1045 select CRYPTO_BLOWFISH_COMMON
1047 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1049 This is a variable key length cipher which can use keys from 32
1050 bits to 448 bits in length. It's fast, simple and specifically
1051 designed for use on "large microprocessors".
1054 <http://www.schneier.com/blowfish.html>
1056 config CRYPTO_CAMELLIA
1057 tristate "Camellia cipher algorithms"
1059 select CRYPTO_ALGAPI
1061 Camellia cipher algorithms module.
1063 Camellia is a symmetric key block cipher developed jointly
1064 at NTT and Mitsubishi Electric Corporation.
1066 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1069 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1071 config CRYPTO_CAMELLIA_X86_64
1072 tristate "Camellia cipher algorithm (x86_64)"
1073 depends on X86 && 64BIT
1075 select CRYPTO_ALGAPI
1076 select CRYPTO_GLUE_HELPER_X86
1080 Camellia cipher algorithm module (x86_64).
1082 Camellia is a symmetric key block cipher developed jointly
1083 at NTT and Mitsubishi Electric Corporation.
1085 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1088 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1090 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1091 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1092 depends on X86 && 64BIT
1094 select CRYPTO_ALGAPI
1095 select CRYPTO_CRYPTD
1096 select CRYPTO_ABLK_HELPER
1097 select CRYPTO_GLUE_HELPER_X86
1098 select CRYPTO_CAMELLIA_X86_64
1102 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1104 Camellia is a symmetric key block cipher developed jointly
1105 at NTT and Mitsubishi Electric Corporation.
1107 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1110 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1112 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1113 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1114 depends on X86 && 64BIT
1116 select CRYPTO_ALGAPI
1117 select CRYPTO_CRYPTD
1118 select CRYPTO_ABLK_HELPER
1119 select CRYPTO_GLUE_HELPER_X86
1120 select CRYPTO_CAMELLIA_X86_64
1121 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1125 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1127 Camellia is a symmetric key block cipher developed jointly
1128 at NTT and Mitsubishi Electric Corporation.
1130 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1133 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1135 config CRYPTO_CAMELLIA_SPARC64
1136 tristate "Camellia cipher algorithm (SPARC64)"
1139 select CRYPTO_ALGAPI
1141 Camellia cipher algorithm module (SPARC64).
1143 Camellia is a symmetric key block cipher developed jointly
1144 at NTT and Mitsubishi Electric Corporation.
1146 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1149 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1151 config CRYPTO_CAST_COMMON
1154 Common parts of the CAST cipher algorithms shared by the
1155 generic c and the assembler implementations.
1158 tristate "CAST5 (CAST-128) cipher algorithm"
1159 select CRYPTO_ALGAPI
1160 select CRYPTO_CAST_COMMON
1162 The CAST5 encryption algorithm (synonymous with CAST-128) is
1163 described in RFC2144.
1165 config CRYPTO_CAST5_AVX_X86_64
1166 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1167 depends on X86 && 64BIT
1168 select CRYPTO_ALGAPI
1169 select CRYPTO_CRYPTD
1170 select CRYPTO_ABLK_HELPER
1171 select CRYPTO_CAST_COMMON
1174 The CAST5 encryption algorithm (synonymous with CAST-128) is
1175 described in RFC2144.
1177 This module provides the Cast5 cipher algorithm that processes
1178 sixteen blocks parallel using the AVX instruction set.
1181 tristate "CAST6 (CAST-256) cipher algorithm"
1182 select CRYPTO_ALGAPI
1183 select CRYPTO_CAST_COMMON
1185 The CAST6 encryption algorithm (synonymous with CAST-256) is
1186 described in RFC2612.
1188 config CRYPTO_CAST6_AVX_X86_64
1189 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1190 depends on X86 && 64BIT
1191 select CRYPTO_ALGAPI
1192 select CRYPTO_CRYPTD
1193 select CRYPTO_ABLK_HELPER
1194 select CRYPTO_GLUE_HELPER_X86
1195 select CRYPTO_CAST_COMMON
1200 The CAST6 encryption algorithm (synonymous with CAST-256) is
1201 described in RFC2612.
1203 This module provides the Cast6 cipher algorithm that processes
1204 eight blocks parallel using the AVX instruction set.
1207 tristate "DES and Triple DES EDE cipher algorithms"
1208 select CRYPTO_ALGAPI
1210 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1212 config CRYPTO_DES_SPARC64
1213 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1215 select CRYPTO_ALGAPI
1218 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1219 optimized using SPARC64 crypto opcodes.
1221 config CRYPTO_DES3_EDE_X86_64
1222 tristate "Triple DES EDE cipher algorithm (x86-64)"
1223 depends on X86 && 64BIT
1224 select CRYPTO_ALGAPI
1227 Triple DES EDE (FIPS 46-3) algorithm.
1229 This module provides implementation of the Triple DES EDE cipher
1230 algorithm that is optimized for x86-64 processors. Two versions of
1231 algorithm are provided; regular processing one input block and
1232 one that processes three blocks parallel.
1234 config CRYPTO_FCRYPT
1235 tristate "FCrypt cipher algorithm"
1236 select CRYPTO_ALGAPI
1237 select CRYPTO_BLKCIPHER
1239 FCrypt algorithm used by RxRPC.
1241 config CRYPTO_KHAZAD
1242 tristate "Khazad cipher algorithm"
1243 select CRYPTO_ALGAPI
1245 Khazad cipher algorithm.
1247 Khazad was a finalist in the initial NESSIE competition. It is
1248 an algorithm optimized for 64-bit processors with good performance
1249 on 32-bit processors. Khazad uses an 128 bit key size.
1252 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1254 config CRYPTO_SALSA20
1255 tristate "Salsa20 stream cipher algorithm"
1256 select CRYPTO_BLKCIPHER
1258 Salsa20 stream cipher algorithm.
1260 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1261 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1263 The Salsa20 stream cipher algorithm is designed by Daniel J.
1264 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1266 config CRYPTO_SALSA20_586
1267 tristate "Salsa20 stream cipher algorithm (i586)"
1268 depends on (X86 || UML_X86) && !64BIT
1269 select CRYPTO_BLKCIPHER
1271 Salsa20 stream cipher algorithm.
1273 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1274 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1276 The Salsa20 stream cipher algorithm is designed by Daniel J.
1277 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1279 config CRYPTO_SALSA20_X86_64
1280 tristate "Salsa20 stream cipher algorithm (x86_64)"
1281 depends on (X86 || UML_X86) && 64BIT
1282 select CRYPTO_BLKCIPHER
1284 Salsa20 stream cipher algorithm.
1286 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1287 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1289 The Salsa20 stream cipher algorithm is designed by Daniel J.
1290 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1292 config CRYPTO_CHACHA20
1293 tristate "ChaCha20 cipher algorithm"
1294 select CRYPTO_BLKCIPHER
1296 ChaCha20 cipher algorithm, RFC7539.
1298 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1299 Bernstein and further specified in RFC7539 for use in IETF protocols.
1300 This is the portable C implementation of ChaCha20.
1303 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1305 config CRYPTO_CHACHA20_X86_64
1306 tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1307 depends on X86 && 64BIT
1308 select CRYPTO_BLKCIPHER
1309 select CRYPTO_CHACHA20
1311 ChaCha20 cipher algorithm, RFC7539.
1313 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1314 Bernstein and further specified in RFC7539 for use in IETF protocols.
1315 This is the x86_64 assembler implementation using SIMD instructions.
1318 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1321 tristate "SEED cipher algorithm"
1322 select CRYPTO_ALGAPI
1324 SEED cipher algorithm (RFC4269).
1326 SEED is a 128-bit symmetric key block cipher that has been
1327 developed by KISA (Korea Information Security Agency) as a
1328 national standard encryption algorithm of the Republic of Korea.
1329 It is a 16 round block cipher with the key size of 128 bit.
1332 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1334 config CRYPTO_SERPENT
1335 tristate "Serpent cipher algorithm"
1336 select CRYPTO_ALGAPI
1338 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1340 Keys are allowed to be from 0 to 256 bits in length, in steps
1341 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1342 variant of Serpent for compatibility with old kerneli.org code.
1345 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1347 config CRYPTO_SERPENT_SSE2_X86_64
1348 tristate "Serpent cipher algorithm (x86_64/SSE2)"
1349 depends on X86 && 64BIT
1350 select CRYPTO_ALGAPI
1351 select CRYPTO_CRYPTD
1352 select CRYPTO_ABLK_HELPER
1353 select CRYPTO_GLUE_HELPER_X86
1354 select CRYPTO_SERPENT
1358 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1360 Keys are allowed to be from 0 to 256 bits in length, in steps
1363 This module provides Serpent cipher algorithm that processes eight
1364 blocks parallel using SSE2 instruction set.
1367 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1369 config CRYPTO_SERPENT_SSE2_586
1370 tristate "Serpent cipher algorithm (i586/SSE2)"
1371 depends on X86 && !64BIT
1372 select CRYPTO_ALGAPI
1373 select CRYPTO_CRYPTD
1374 select CRYPTO_ABLK_HELPER
1375 select CRYPTO_GLUE_HELPER_X86
1376 select CRYPTO_SERPENT
1380 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1382 Keys are allowed to be from 0 to 256 bits in length, in steps
1385 This module provides Serpent cipher algorithm that processes four
1386 blocks parallel using SSE2 instruction set.
1389 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1391 config CRYPTO_SERPENT_AVX_X86_64
1392 tristate "Serpent cipher algorithm (x86_64/AVX)"
1393 depends on X86 && 64BIT
1394 select CRYPTO_ALGAPI
1395 select CRYPTO_CRYPTD
1396 select CRYPTO_ABLK_HELPER
1397 select CRYPTO_GLUE_HELPER_X86
1398 select CRYPTO_SERPENT
1402 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1404 Keys are allowed to be from 0 to 256 bits in length, in steps
1407 This module provides the Serpent cipher algorithm that processes
1408 eight blocks parallel using the AVX instruction set.
1411 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1413 config CRYPTO_SERPENT_AVX2_X86_64
1414 tristate "Serpent cipher algorithm (x86_64/AVX2)"
1415 depends on X86 && 64BIT
1416 select CRYPTO_ALGAPI
1417 select CRYPTO_CRYPTD
1418 select CRYPTO_ABLK_HELPER
1419 select CRYPTO_GLUE_HELPER_X86
1420 select CRYPTO_SERPENT
1421 select CRYPTO_SERPENT_AVX_X86_64
1425 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1427 Keys are allowed to be from 0 to 256 bits in length, in steps
1430 This module provides Serpent cipher algorithm that processes 16
1431 blocks parallel using AVX2 instruction set.
1434 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1437 tristate "TEA, XTEA and XETA cipher algorithms"
1438 select CRYPTO_ALGAPI
1440 TEA cipher algorithm.
1442 Tiny Encryption Algorithm is a simple cipher that uses
1443 many rounds for security. It is very fast and uses
1446 Xtendend Tiny Encryption Algorithm is a modification to
1447 the TEA algorithm to address a potential key weakness
1448 in the TEA algorithm.
1450 Xtendend Encryption Tiny Algorithm is a mis-implementation
1451 of the XTEA algorithm for compatibility purposes.
1453 config CRYPTO_TWOFISH
1454 tristate "Twofish cipher algorithm"
1455 select CRYPTO_ALGAPI
1456 select CRYPTO_TWOFISH_COMMON
1458 Twofish cipher algorithm.
1460 Twofish was submitted as an AES (Advanced Encryption Standard)
1461 candidate cipher by researchers at CounterPane Systems. It is a
1462 16 round block cipher supporting key sizes of 128, 192, and 256
1466 <http://www.schneier.com/twofish.html>
1468 config CRYPTO_TWOFISH_COMMON
1471 Common parts of the Twofish cipher algorithm shared by the
1472 generic c and the assembler implementations.
1474 config CRYPTO_TWOFISH_586
1475 tristate "Twofish cipher algorithms (i586)"
1476 depends on (X86 || UML_X86) && !64BIT
1477 select CRYPTO_ALGAPI
1478 select CRYPTO_TWOFISH_COMMON
1480 Twofish cipher algorithm.
1482 Twofish was submitted as an AES (Advanced Encryption Standard)
1483 candidate cipher by researchers at CounterPane Systems. It is a
1484 16 round block cipher supporting key sizes of 128, 192, and 256
1488 <http://www.schneier.com/twofish.html>
1490 config CRYPTO_TWOFISH_X86_64
1491 tristate "Twofish cipher algorithm (x86_64)"
1492 depends on (X86 || UML_X86) && 64BIT
1493 select CRYPTO_ALGAPI
1494 select CRYPTO_TWOFISH_COMMON
1496 Twofish cipher algorithm (x86_64).
1498 Twofish was submitted as an AES (Advanced Encryption Standard)
1499 candidate cipher by researchers at CounterPane Systems. It is a
1500 16 round block cipher supporting key sizes of 128, 192, and 256
1504 <http://www.schneier.com/twofish.html>
1506 config CRYPTO_TWOFISH_X86_64_3WAY
1507 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1508 depends on X86 && 64BIT
1509 select CRYPTO_ALGAPI
1510 select CRYPTO_TWOFISH_COMMON
1511 select CRYPTO_TWOFISH_X86_64
1512 select CRYPTO_GLUE_HELPER_X86
1516 Twofish cipher algorithm (x86_64, 3-way parallel).
1518 Twofish was submitted as an AES (Advanced Encryption Standard)
1519 candidate cipher by researchers at CounterPane Systems. It is a
1520 16 round block cipher supporting key sizes of 128, 192, and 256
1523 This module provides Twofish cipher algorithm that processes three
1524 blocks parallel, utilizing resources of out-of-order CPUs better.
1527 <http://www.schneier.com/twofish.html>
1529 config CRYPTO_TWOFISH_AVX_X86_64
1530 tristate "Twofish cipher algorithm (x86_64/AVX)"
1531 depends on X86 && 64BIT
1532 select CRYPTO_ALGAPI
1533 select CRYPTO_CRYPTD
1534 select CRYPTO_ABLK_HELPER
1535 select CRYPTO_GLUE_HELPER_X86
1536 select CRYPTO_TWOFISH_COMMON
1537 select CRYPTO_TWOFISH_X86_64
1538 select CRYPTO_TWOFISH_X86_64_3WAY
1542 Twofish cipher algorithm (x86_64/AVX).
1544 Twofish was submitted as an AES (Advanced Encryption Standard)
1545 candidate cipher by researchers at CounterPane Systems. It is a
1546 16 round block cipher supporting key sizes of 128, 192, and 256
1549 This module provides the Twofish cipher algorithm that processes
1550 eight blocks parallel using the AVX Instruction Set.
1553 <http://www.schneier.com/twofish.html>
1555 comment "Compression"
1557 config CRYPTO_DEFLATE
1558 tristate "Deflate compression algorithm"
1559 select CRYPTO_ALGAPI
1563 This is the Deflate algorithm (RFC1951), specified for use in
1564 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1566 You will most probably want this if using IPSec.
1569 tristate "LZO compression algorithm"
1570 select CRYPTO_ALGAPI
1572 select LZO_DECOMPRESS
1574 This is the LZO algorithm.
1577 tristate "842 compression algorithm"
1578 select CRYPTO_ALGAPI
1580 select 842_DECOMPRESS
1582 This is the 842 algorithm.
1585 tristate "LZ4 compression algorithm"
1586 select CRYPTO_ALGAPI
1588 select LZ4_DECOMPRESS
1590 This is the LZ4 algorithm.
1593 tristate "LZ4HC compression algorithm"
1594 select CRYPTO_ALGAPI
1595 select LZ4HC_COMPRESS
1596 select LZ4_DECOMPRESS
1598 This is the LZ4 high compression mode algorithm.
1600 comment "Random Number Generation"
1602 config CRYPTO_ANSI_CPRNG
1603 tristate "Pseudo Random Number Generation for Cryptographic modules"
1607 This option enables the generic pseudo random number generator
1608 for cryptographic modules. Uses the Algorithm specified in
1609 ANSI X9.31 A.2.4. Note that this option must be enabled if
1610 CRYPTO_FIPS is selected
1612 menuconfig CRYPTO_DRBG_MENU
1613 tristate "NIST SP800-90A DRBG"
1615 NIST SP800-90A compliant DRBG. In the following submenu, one or
1616 more of the DRBG types must be selected.
1620 config CRYPTO_DRBG_HMAC
1624 select CRYPTO_SHA256
1626 config CRYPTO_DRBG_HASH
1627 bool "Enable Hash DRBG"
1628 select CRYPTO_SHA256
1630 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1632 config CRYPTO_DRBG_CTR
1633 bool "Enable CTR DRBG"
1635 depends on CRYPTO_CTR
1637 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1641 default CRYPTO_DRBG_MENU
1643 select CRYPTO_JITTERENTROPY
1645 endif # if CRYPTO_DRBG_MENU
1647 config CRYPTO_JITTERENTROPY
1648 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1651 The Jitterentropy RNG is a noise that is intended
1652 to provide seed to another RNG. The RNG does not
1653 perform any cryptographic whitening of the generated
1654 random numbers. This Jitterentropy RNG registers with
1655 the kernel crypto API and can be used by any caller.
1657 config CRYPTO_USER_API
1660 config CRYPTO_USER_API_HASH
1661 tristate "User-space interface for hash algorithms"
1664 select CRYPTO_USER_API
1666 This option enables the user-spaces interface for hash
1669 config CRYPTO_USER_API_SKCIPHER
1670 tristate "User-space interface for symmetric key cipher algorithms"
1672 select CRYPTO_BLKCIPHER
1673 select CRYPTO_USER_API
1675 This option enables the user-spaces interface for symmetric
1676 key cipher algorithms.
1678 config CRYPTO_USER_API_RNG
1679 tristate "User-space interface for random number generator algorithms"
1682 select CRYPTO_USER_API
1684 This option enables the user-spaces interface for random
1685 number generator algorithms.
1687 config CRYPTO_USER_API_AEAD
1688 tristate "User-space interface for AEAD cipher algorithms"
1691 select CRYPTO_USER_API
1693 This option enables the user-spaces interface for AEAD
1696 config CRYPTO_HASH_INFO
1699 source "drivers/crypto/Kconfig"
1700 source crypto/asymmetric_keys/Kconfig
1701 source certs/Kconfig