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
96 config CRYPTO_AKCIPHER2
100 config CRYPTO_AKCIPHER
102 select CRYPTO_AKCIPHER2
106 tristate "RSA algorithm"
107 select CRYPTO_AKCIPHER
111 Generic implementation of the RSA public key algorithm.
113 config CRYPTO_MANAGER
114 tristate "Cryptographic algorithm manager"
115 select CRYPTO_MANAGER2
117 Create default cryptographic template instantiations such as
120 config CRYPTO_MANAGER2
121 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
124 select CRYPTO_BLKCIPHER2
126 select CRYPTO_AKCIPHER2
129 tristate "Userspace cryptographic algorithm configuration"
131 select CRYPTO_MANAGER
133 Userspace configuration for cryptographic instantiations such as
136 config CRYPTO_MANAGER_DISABLE_TESTS
137 bool "Disable run-time self tests"
139 depends on CRYPTO_MANAGER2
141 Disable run-time self tests that normally take place at
142 algorithm registration.
144 config CRYPTO_GF128MUL
145 tristate "GF(2^128) multiplication functions"
147 Efficient table driven implementation of multiplications in the
148 field GF(2^128). This is needed by some cypher modes. This
149 option will be selected automatically if you select such a
150 cipher mode. Only select this option by hand if you expect to load
151 an external module that requires these functions.
154 tristate "Null algorithms"
157 These are 'Null' algorithms, used by IPsec, which do nothing.
161 select CRYPTO_ALGAPI2
162 select CRYPTO_BLKCIPHER2
166 tristate "Parallel crypto engine"
169 select CRYPTO_MANAGER
172 This converts an arbitrary crypto algorithm into a parallel
173 algorithm that executes in kernel threads.
175 config CRYPTO_WORKQUEUE
179 tristate "Software async crypto daemon"
180 select CRYPTO_BLKCIPHER
182 select CRYPTO_MANAGER
183 select CRYPTO_WORKQUEUE
185 This is a generic software asynchronous crypto daemon that
186 converts an arbitrary synchronous software crypto algorithm
187 into an asynchronous algorithm that executes in a kernel thread.
189 config CRYPTO_MCRYPTD
190 tristate "Software async multi-buffer crypto daemon"
191 select CRYPTO_BLKCIPHER
193 select CRYPTO_MANAGER
194 select CRYPTO_WORKQUEUE
196 This is a generic software asynchronous crypto daemon that
197 provides the kernel thread to assist multi-buffer crypto
198 algorithms for submitting jobs and flushing jobs in multi-buffer
199 crypto algorithms. Multi-buffer crypto algorithms are executed
200 in the context of this kernel thread and drivers can post
201 their crypto request asynchronously to be processed by this daemon.
203 config CRYPTO_AUTHENC
204 tristate "Authenc support"
206 select CRYPTO_BLKCIPHER
207 select CRYPTO_MANAGER
211 Authenc: Combined mode wrapper for IPsec.
212 This is required for IPSec.
215 tristate "Testing module"
217 select CRYPTO_MANAGER
219 Quick & dirty crypto test module.
221 config CRYPTO_ABLK_HELPER
225 config CRYPTO_GLUE_HELPER_X86
230 comment "Authenticated Encryption with Associated Data"
233 tristate "CCM support"
237 Support for Counter with CBC MAC. Required for IPsec.
240 tristate "GCM/GMAC support"
246 Support for Galois/Counter Mode (GCM) and Galois Message
247 Authentication Code (GMAC). Required for IPSec.
249 config CRYPTO_CHACHA20POLY1305
250 tristate "ChaCha20-Poly1305 AEAD support"
251 select CRYPTO_CHACHA20
252 select CRYPTO_POLY1305
255 ChaCha20-Poly1305 AEAD support, RFC7539.
257 Support for the AEAD wrapper using the ChaCha20 stream cipher combined
258 with the Poly1305 authenticator. It is defined in RFC7539 for use in
262 tristate "Sequence Number IV Generator"
264 select CRYPTO_BLKCIPHER
266 select CRYPTO_RNG_DEFAULT
268 This IV generator generates an IV based on a sequence number by
269 xoring it with a salt. This algorithm is mainly useful for CTR
271 config CRYPTO_ECHAINIV
272 tristate "Encrypted Chain IV Generator"
275 select CRYPTO_RNG_DEFAULT
278 This IV generator generates an IV based on the encryption of
279 a sequence number xored with a salt. This is the default
282 comment "Block modes"
285 tristate "CBC support"
286 select CRYPTO_BLKCIPHER
287 select CRYPTO_MANAGER
289 CBC: Cipher Block Chaining mode
290 This block cipher algorithm is required for IPSec.
293 tristate "CTR support"
294 select CRYPTO_BLKCIPHER
296 select CRYPTO_MANAGER
299 This block cipher algorithm is required for IPSec.
302 tristate "CTS support"
303 select CRYPTO_BLKCIPHER
305 CTS: Cipher Text Stealing
306 This is the Cipher Text Stealing mode as described by
307 Section 8 of rfc2040 and referenced by rfc3962.
308 (rfc3962 includes errata information in its Appendix A)
309 This mode is required for Kerberos gss mechanism support
313 tristate "ECB support"
314 select CRYPTO_BLKCIPHER
315 select CRYPTO_MANAGER
317 ECB: Electronic CodeBook mode
318 This is the simplest block cipher algorithm. It simply encrypts
319 the input block by block.
322 tristate "LRW support"
323 select CRYPTO_BLKCIPHER
324 select CRYPTO_MANAGER
325 select CRYPTO_GF128MUL
327 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
328 narrow block cipher mode for dm-crypt. Use it with cipher
329 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
330 The first 128, 192 or 256 bits in the key are used for AES and the
331 rest is used to tie each cipher block to its logical position.
334 tristate "PCBC support"
335 select CRYPTO_BLKCIPHER
336 select CRYPTO_MANAGER
338 PCBC: Propagating Cipher Block Chaining mode
339 This block cipher algorithm is required for RxRPC.
342 tristate "XTS support"
343 select CRYPTO_BLKCIPHER
344 select CRYPTO_MANAGER
345 select CRYPTO_GF128MUL
347 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
348 key size 256, 384 or 512 bits. This implementation currently
349 can't handle a sectorsize which is not a multiple of 16 bytes.
351 config CRYPTO_KEYWRAP
352 tristate "Key wrapping support"
353 select CRYPTO_BLKCIPHER
355 Support for key wrapping (NIST SP800-38F / RFC3394) without
361 tristate "CMAC support"
363 select CRYPTO_MANAGER
365 Cipher-based Message Authentication Code (CMAC) specified by
366 The National Institute of Standards and Technology (NIST).
368 https://tools.ietf.org/html/rfc4493
369 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
372 tristate "HMAC support"
374 select CRYPTO_MANAGER
376 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
377 This is required for IPSec.
380 tristate "XCBC support"
382 select CRYPTO_MANAGER
384 XCBC: Keyed-Hashing with encryption algorithm
385 http://www.ietf.org/rfc/rfc3566.txt
386 http://csrc.nist.gov/encryption/modes/proposedmodes/
387 xcbc-mac/xcbc-mac-spec.pdf
390 tristate "VMAC support"
392 select CRYPTO_MANAGER
394 VMAC is a message authentication algorithm designed for
395 very high speed on 64-bit architectures.
398 <http://fastcrypto.org/vmac>
403 tristate "CRC32c CRC algorithm"
407 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
408 by iSCSI for header and data digests and by others.
409 See Castagnoli93. Module will be crc32c.
411 config CRYPTO_CRC32C_INTEL
412 tristate "CRC32c INTEL hardware acceleration"
416 In Intel processor with SSE4.2 supported, the processor will
417 support CRC32C implementation using hardware accelerated CRC32
418 instruction. This option will create 'crc32c-intel' module,
419 which will enable any routine to use the CRC32 instruction to
420 gain performance compared with software implementation.
421 Module will be crc32c-intel.
423 config CRYPTO_CRC32C_SPARC64
424 tristate "CRC32c CRC algorithm (SPARC64)"
429 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
433 tristate "CRC32 CRC algorithm"
437 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
438 Shash crypto api wrappers to crc32_le function.
440 config CRYPTO_CRC32_PCLMUL
441 tristate "CRC32 PCLMULQDQ hardware acceleration"
446 From Intel Westmere and AMD Bulldozer processor with SSE4.2
447 and PCLMULQDQ supported, the processor will support
448 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
449 instruction. This option will create 'crc32-plcmul' module,
450 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
451 and gain better performance as compared with the table implementation.
453 config CRYPTO_CRCT10DIF
454 tristate "CRCT10DIF algorithm"
457 CRC T10 Data Integrity Field computation is being cast as
458 a crypto transform. This allows for faster crc t10 diff
459 transforms to be used if they are available.
461 config CRYPTO_CRCT10DIF_PCLMUL
462 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
463 depends on X86 && 64BIT && CRC_T10DIF
466 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
467 CRC T10 DIF PCLMULQDQ computation can be hardware
468 accelerated PCLMULQDQ instruction. This option will create
469 'crct10dif-plcmul' module, which is faster when computing the
470 crct10dif checksum as compared with the generic table implementation.
473 tristate "GHASH digest algorithm"
474 select CRYPTO_GF128MUL
476 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
478 config CRYPTO_POLY1305
479 tristate "Poly1305 authenticator algorithm"
481 Poly1305 authenticator algorithm, RFC7539.
483 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
484 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
485 in IETF protocols. This is the portable C implementation of Poly1305.
487 config CRYPTO_POLY1305_X86_64
488 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
489 depends on X86 && 64BIT
490 select CRYPTO_POLY1305
492 Poly1305 authenticator algorithm, RFC7539.
494 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
495 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
496 in IETF protocols. This is the x86_64 assembler implementation using SIMD
500 tristate "MD4 digest algorithm"
503 MD4 message digest algorithm (RFC1320).
506 tristate "MD5 digest algorithm"
509 MD5 message digest algorithm (RFC1321).
511 config CRYPTO_MD5_OCTEON
512 tristate "MD5 digest algorithm (OCTEON)"
513 depends on CPU_CAVIUM_OCTEON
517 MD5 message digest algorithm (RFC1321) implemented
518 using OCTEON crypto instructions, when available.
520 config CRYPTO_MD5_PPC
521 tristate "MD5 digest algorithm (PPC)"
525 MD5 message digest algorithm (RFC1321) implemented
528 config CRYPTO_MD5_SPARC64
529 tristate "MD5 digest algorithm (SPARC64)"
534 MD5 message digest algorithm (RFC1321) implemented
535 using sparc64 crypto instructions, when available.
537 config CRYPTO_MICHAEL_MIC
538 tristate "Michael MIC keyed digest algorithm"
541 Michael MIC is used for message integrity protection in TKIP
542 (IEEE 802.11i). This algorithm is required for TKIP, but it
543 should not be used for other purposes because of the weakness
547 tristate "RIPEMD-128 digest algorithm"
550 RIPEMD-128 (ISO/IEC 10118-3:2004).
552 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
553 be used as a secure replacement for RIPEMD. For other use cases,
554 RIPEMD-160 should be used.
556 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
557 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
560 tristate "RIPEMD-160 digest algorithm"
563 RIPEMD-160 (ISO/IEC 10118-3:2004).
565 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
566 to be used as a secure replacement for the 128-bit hash functions
567 MD4, MD5 and it's predecessor RIPEMD
568 (not to be confused with RIPEMD-128).
570 It's speed is comparable to SHA1 and there are no known attacks
573 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
574 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
577 tristate "RIPEMD-256 digest algorithm"
580 RIPEMD-256 is an optional extension of RIPEMD-128 with a
581 256 bit hash. It is intended for applications that require
582 longer hash-results, without needing a larger security level
585 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
586 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
589 tristate "RIPEMD-320 digest algorithm"
592 RIPEMD-320 is an optional extension of RIPEMD-160 with a
593 320 bit hash. It is intended for applications that require
594 longer hash-results, without needing a larger security level
597 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
598 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
601 tristate "SHA1 digest algorithm"
604 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
606 config CRYPTO_SHA1_SSSE3
607 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
608 depends on X86 && 64BIT
612 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
613 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
614 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
617 config CRYPTO_SHA256_SSSE3
618 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
619 depends on X86 && 64BIT
623 SHA-256 secure hash standard (DFIPS 180-2) implemented
624 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
625 Extensions version 1 (AVX1), or Advanced Vector Extensions
626 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
627 Instructions) when available.
629 config CRYPTO_SHA512_SSSE3
630 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
631 depends on X86 && 64BIT
635 SHA-512 secure hash standard (DFIPS 180-2) implemented
636 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
637 Extensions version 1 (AVX1), or Advanced Vector Extensions
638 version 2 (AVX2) instructions, when available.
640 config CRYPTO_SHA1_OCTEON
641 tristate "SHA1 digest algorithm (OCTEON)"
642 depends on CPU_CAVIUM_OCTEON
646 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
647 using OCTEON crypto instructions, when available.
649 config CRYPTO_SHA1_SPARC64
650 tristate "SHA1 digest algorithm (SPARC64)"
655 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
656 using sparc64 crypto instructions, when available.
658 config CRYPTO_SHA1_PPC
659 tristate "SHA1 digest algorithm (powerpc)"
662 This is the powerpc hardware accelerated implementation of the
663 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
665 config CRYPTO_SHA1_PPC_SPE
666 tristate "SHA1 digest algorithm (PPC SPE)"
667 depends on PPC && SPE
669 SHA-1 secure hash standard (DFIPS 180-4) implemented
670 using powerpc SPE SIMD instruction set.
672 config CRYPTO_SHA1_MB
673 tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
674 depends on X86 && 64BIT
677 select CRYPTO_MCRYPTD
679 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
680 using multi-buffer technique. This algorithm computes on
681 multiple data lanes concurrently with SIMD instructions for
682 better throughput. It should not be enabled by default but
683 used when there is significant amount of work to keep the keep
684 the data lanes filled to get performance benefit. If the data
685 lanes remain unfilled, a flush operation will be initiated to
686 process the crypto jobs, adding a slight latency.
689 tristate "SHA224 and SHA256 digest algorithm"
692 SHA256 secure hash standard (DFIPS 180-2).
694 This version of SHA implements a 256 bit hash with 128 bits of
695 security against collision attacks.
697 This code also includes SHA-224, a 224 bit hash with 112 bits
698 of security against collision attacks.
700 config CRYPTO_SHA256_PPC_SPE
701 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
702 depends on PPC && SPE
706 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
707 implemented using powerpc SPE SIMD instruction set.
709 config CRYPTO_SHA256_OCTEON
710 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
711 depends on CPU_CAVIUM_OCTEON
715 SHA-256 secure hash standard (DFIPS 180-2) implemented
716 using OCTEON crypto instructions, when available.
718 config CRYPTO_SHA256_SPARC64
719 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
724 SHA-256 secure hash standard (DFIPS 180-2) implemented
725 using sparc64 crypto instructions, when available.
728 tristate "SHA384 and SHA512 digest algorithms"
731 SHA512 secure hash standard (DFIPS 180-2).
733 This version of SHA implements a 512 bit hash with 256 bits of
734 security against collision attacks.
736 This code also includes SHA-384, a 384 bit hash with 192 bits
737 of security against collision attacks.
739 config CRYPTO_SHA512_OCTEON
740 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
741 depends on CPU_CAVIUM_OCTEON
745 SHA-512 secure hash standard (DFIPS 180-2) implemented
746 using OCTEON crypto instructions, when available.
748 config CRYPTO_SHA512_SPARC64
749 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
754 SHA-512 secure hash standard (DFIPS 180-2) implemented
755 using sparc64 crypto instructions, when available.
758 tristate "Tiger digest algorithms"
761 Tiger hash algorithm 192, 160 and 128-bit hashes
763 Tiger is a hash function optimized for 64-bit processors while
764 still having decent performance on 32-bit processors.
765 Tiger was developed by Ross Anderson and Eli Biham.
768 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
771 tristate "Whirlpool digest algorithms"
774 Whirlpool hash algorithm 512, 384 and 256-bit hashes
776 Whirlpool-512 is part of the NESSIE cryptographic primitives.
777 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
780 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
782 config CRYPTO_GHASH_CLMUL_NI_INTEL
783 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
784 depends on X86 && 64BIT
787 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
788 The implementation is accelerated by CLMUL-NI of Intel.
793 tristate "AES cipher algorithms"
796 AES cipher algorithms (FIPS-197). AES uses the Rijndael
799 Rijndael appears to be consistently a very good performer in
800 both hardware and software across a wide range of computing
801 environments regardless of its use in feedback or non-feedback
802 modes. Its key setup time is excellent, and its key agility is
803 good. Rijndael's very low memory requirements make it very well
804 suited for restricted-space environments, in which it also
805 demonstrates excellent performance. Rijndael's operations are
806 among the easiest to defend against power and timing attacks.
808 The AES specifies three key sizes: 128, 192 and 256 bits
810 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
812 config CRYPTO_AES_586
813 tristate "AES cipher algorithms (i586)"
814 depends on (X86 || UML_X86) && !64BIT
818 AES cipher algorithms (FIPS-197). AES uses the Rijndael
821 Rijndael appears to be consistently a very good performer in
822 both hardware and software across a wide range of computing
823 environments regardless of its use in feedback or non-feedback
824 modes. Its key setup time is excellent, and its key agility is
825 good. Rijndael's very low memory requirements make it very well
826 suited for restricted-space environments, in which it also
827 demonstrates excellent performance. Rijndael's operations are
828 among the easiest to defend against power and timing attacks.
830 The AES specifies three key sizes: 128, 192 and 256 bits
832 See <http://csrc.nist.gov/encryption/aes/> for more information.
834 config CRYPTO_AES_X86_64
835 tristate "AES cipher algorithms (x86_64)"
836 depends on (X86 || UML_X86) && 64BIT
840 AES cipher algorithms (FIPS-197). AES uses the Rijndael
843 Rijndael appears to be consistently a very good performer in
844 both hardware and software across a wide range of computing
845 environments regardless of its use in feedback or non-feedback
846 modes. Its key setup time is excellent, and its key agility is
847 good. Rijndael's very low memory requirements make it very well
848 suited for restricted-space environments, in which it also
849 demonstrates excellent performance. Rijndael's operations are
850 among the easiest to defend against power and timing attacks.
852 The AES specifies three key sizes: 128, 192 and 256 bits
854 See <http://csrc.nist.gov/encryption/aes/> for more information.
856 config CRYPTO_AES_NI_INTEL
857 tristate "AES cipher algorithms (AES-NI)"
859 select CRYPTO_AES_X86_64 if 64BIT
860 select CRYPTO_AES_586 if !64BIT
862 select CRYPTO_ABLK_HELPER
864 select CRYPTO_GLUE_HELPER_X86 if 64BIT
868 Use Intel AES-NI instructions for AES algorithm.
870 AES cipher algorithms (FIPS-197). AES uses the Rijndael
873 Rijndael appears to be consistently a very good performer in
874 both hardware and software across a wide range of computing
875 environments regardless of its use in feedback or non-feedback
876 modes. Its key setup time is excellent, and its key agility is
877 good. Rijndael's very low memory requirements make it very well
878 suited for restricted-space environments, in which it also
879 demonstrates excellent performance. Rijndael's operations are
880 among the easiest to defend against power and timing attacks.
882 The AES specifies three key sizes: 128, 192 and 256 bits
884 See <http://csrc.nist.gov/encryption/aes/> for more information.
886 In addition to AES cipher algorithm support, the acceleration
887 for some popular block cipher mode is supported too, including
888 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
889 acceleration for CTR.
891 config CRYPTO_AES_SPARC64
892 tristate "AES cipher algorithms (SPARC64)"
897 Use SPARC64 crypto opcodes for AES algorithm.
899 AES cipher algorithms (FIPS-197). AES uses the Rijndael
902 Rijndael appears to be consistently a very good performer in
903 both hardware and software across a wide range of computing
904 environments regardless of its use in feedback or non-feedback
905 modes. Its key setup time is excellent, and its key agility is
906 good. Rijndael's very low memory requirements make it very well
907 suited for restricted-space environments, in which it also
908 demonstrates excellent performance. Rijndael's operations are
909 among the easiest to defend against power and timing attacks.
911 The AES specifies three key sizes: 128, 192 and 256 bits
913 See <http://csrc.nist.gov/encryption/aes/> for more information.
915 In addition to AES cipher algorithm support, the acceleration
916 for some popular block cipher mode is supported too, including
919 config CRYPTO_AES_PPC_SPE
920 tristate "AES cipher algorithms (PPC SPE)"
921 depends on PPC && SPE
923 AES cipher algorithms (FIPS-197). Additionally the acceleration
924 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
925 This module should only be used for low power (router) devices
926 without hardware AES acceleration (e.g. caam crypto). It reduces the
927 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
928 timining attacks. Nevertheless it might be not as secure as other
929 architecture specific assembler implementations that work on 1KB
930 tables or 256 bytes S-boxes.
933 tristate "Anubis cipher algorithm"
936 Anubis cipher algorithm.
938 Anubis is a variable key length cipher which can use keys from
939 128 bits to 320 bits in length. It was evaluated as a entrant
940 in the NESSIE competition.
943 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
944 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
947 tristate "ARC4 cipher algorithm"
948 select CRYPTO_BLKCIPHER
950 ARC4 cipher algorithm.
952 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
953 bits in length. This algorithm is required for driver-based
954 WEP, but it should not be for other purposes because of the
955 weakness of the algorithm.
957 config CRYPTO_BLOWFISH
958 tristate "Blowfish cipher algorithm"
960 select CRYPTO_BLOWFISH_COMMON
962 Blowfish cipher algorithm, by Bruce Schneier.
964 This is a variable key length cipher which can use keys from 32
965 bits to 448 bits in length. It's fast, simple and specifically
966 designed for use on "large microprocessors".
969 <http://www.schneier.com/blowfish.html>
971 config CRYPTO_BLOWFISH_COMMON
974 Common parts of the Blowfish cipher algorithm shared by the
975 generic c and the assembler implementations.
978 <http://www.schneier.com/blowfish.html>
980 config CRYPTO_BLOWFISH_X86_64
981 tristate "Blowfish cipher algorithm (x86_64)"
982 depends on X86 && 64BIT
984 select CRYPTO_BLOWFISH_COMMON
986 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
988 This is a variable key length cipher which can use keys from 32
989 bits to 448 bits in length. It's fast, simple and specifically
990 designed for use on "large microprocessors".
993 <http://www.schneier.com/blowfish.html>
995 config CRYPTO_CAMELLIA
996 tristate "Camellia cipher algorithms"
1000 Camellia cipher algorithms module.
1002 Camellia is a symmetric key block cipher developed jointly
1003 at NTT and Mitsubishi Electric Corporation.
1005 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1008 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1010 config CRYPTO_CAMELLIA_X86_64
1011 tristate "Camellia cipher algorithm (x86_64)"
1012 depends on X86 && 64BIT
1014 select CRYPTO_ALGAPI
1015 select CRYPTO_GLUE_HELPER_X86
1019 Camellia cipher algorithm module (x86_64).
1021 Camellia is a symmetric key block cipher developed jointly
1022 at NTT and Mitsubishi Electric Corporation.
1024 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1027 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1029 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1030 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1031 depends on X86 && 64BIT
1033 select CRYPTO_ALGAPI
1034 select CRYPTO_CRYPTD
1035 select CRYPTO_ABLK_HELPER
1036 select CRYPTO_GLUE_HELPER_X86
1037 select CRYPTO_CAMELLIA_X86_64
1041 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1043 Camellia is a symmetric key block cipher developed jointly
1044 at NTT and Mitsubishi Electric Corporation.
1046 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1049 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1051 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1052 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1053 depends on X86 && 64BIT
1055 select CRYPTO_ALGAPI
1056 select CRYPTO_CRYPTD
1057 select CRYPTO_ABLK_HELPER
1058 select CRYPTO_GLUE_HELPER_X86
1059 select CRYPTO_CAMELLIA_X86_64
1060 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1064 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1066 Camellia is a symmetric key block cipher developed jointly
1067 at NTT and Mitsubishi Electric Corporation.
1069 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1072 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1074 config CRYPTO_CAMELLIA_SPARC64
1075 tristate "Camellia cipher algorithm (SPARC64)"
1078 select CRYPTO_ALGAPI
1080 Camellia cipher algorithm module (SPARC64).
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_CAST_COMMON
1093 Common parts of the CAST cipher algorithms shared by the
1094 generic c and the assembler implementations.
1097 tristate "CAST5 (CAST-128) cipher algorithm"
1098 select CRYPTO_ALGAPI
1099 select CRYPTO_CAST_COMMON
1101 The CAST5 encryption algorithm (synonymous with CAST-128) is
1102 described in RFC2144.
1104 config CRYPTO_CAST5_AVX_X86_64
1105 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1106 depends on X86 && 64BIT
1107 select CRYPTO_ALGAPI
1108 select CRYPTO_CRYPTD
1109 select CRYPTO_ABLK_HELPER
1110 select CRYPTO_CAST_COMMON
1113 The CAST5 encryption algorithm (synonymous with CAST-128) is
1114 described in RFC2144.
1116 This module provides the Cast5 cipher algorithm that processes
1117 sixteen blocks parallel using the AVX instruction set.
1120 tristate "CAST6 (CAST-256) cipher algorithm"
1121 select CRYPTO_ALGAPI
1122 select CRYPTO_CAST_COMMON
1124 The CAST6 encryption algorithm (synonymous with CAST-256) is
1125 described in RFC2612.
1127 config CRYPTO_CAST6_AVX_X86_64
1128 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1129 depends on X86 && 64BIT
1130 select CRYPTO_ALGAPI
1131 select CRYPTO_CRYPTD
1132 select CRYPTO_ABLK_HELPER
1133 select CRYPTO_GLUE_HELPER_X86
1134 select CRYPTO_CAST_COMMON
1139 The CAST6 encryption algorithm (synonymous with CAST-256) is
1140 described in RFC2612.
1142 This module provides the Cast6 cipher algorithm that processes
1143 eight blocks parallel using the AVX instruction set.
1146 tristate "DES and Triple DES EDE cipher algorithms"
1147 select CRYPTO_ALGAPI
1149 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1151 config CRYPTO_DES_SPARC64
1152 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1154 select CRYPTO_ALGAPI
1157 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1158 optimized using SPARC64 crypto opcodes.
1160 config CRYPTO_DES3_EDE_X86_64
1161 tristate "Triple DES EDE cipher algorithm (x86-64)"
1162 depends on X86 && 64BIT
1163 select CRYPTO_ALGAPI
1166 Triple DES EDE (FIPS 46-3) algorithm.
1168 This module provides implementation of the Triple DES EDE cipher
1169 algorithm that is optimized for x86-64 processors. Two versions of
1170 algorithm are provided; regular processing one input block and
1171 one that processes three blocks parallel.
1173 config CRYPTO_FCRYPT
1174 tristate "FCrypt cipher algorithm"
1175 select CRYPTO_ALGAPI
1176 select CRYPTO_BLKCIPHER
1178 FCrypt algorithm used by RxRPC.
1180 config CRYPTO_KHAZAD
1181 tristate "Khazad cipher algorithm"
1182 select CRYPTO_ALGAPI
1184 Khazad cipher algorithm.
1186 Khazad was a finalist in the initial NESSIE competition. It is
1187 an algorithm optimized for 64-bit processors with good performance
1188 on 32-bit processors. Khazad uses an 128 bit key size.
1191 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1193 config CRYPTO_SALSA20
1194 tristate "Salsa20 stream cipher algorithm"
1195 select CRYPTO_BLKCIPHER
1197 Salsa20 stream cipher algorithm.
1199 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1200 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1202 The Salsa20 stream cipher algorithm is designed by Daniel J.
1203 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1205 config CRYPTO_SALSA20_586
1206 tristate "Salsa20 stream cipher algorithm (i586)"
1207 depends on (X86 || UML_X86) && !64BIT
1208 select CRYPTO_BLKCIPHER
1210 Salsa20 stream cipher algorithm.
1212 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1213 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1215 The Salsa20 stream cipher algorithm is designed by Daniel J.
1216 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1218 config CRYPTO_SALSA20_X86_64
1219 tristate "Salsa20 stream cipher algorithm (x86_64)"
1220 depends on (X86 || UML_X86) && 64BIT
1221 select CRYPTO_BLKCIPHER
1223 Salsa20 stream cipher algorithm.
1225 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1226 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1228 The Salsa20 stream cipher algorithm is designed by Daniel J.
1229 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1231 config CRYPTO_CHACHA20
1232 tristate "ChaCha20 cipher algorithm"
1233 select CRYPTO_BLKCIPHER
1235 ChaCha20 cipher algorithm, RFC7539.
1237 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1238 Bernstein and further specified in RFC7539 for use in IETF protocols.
1239 This is the portable C implementation of ChaCha20.
1242 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1244 config CRYPTO_CHACHA20_X86_64
1245 tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1246 depends on X86 && 64BIT
1247 select CRYPTO_BLKCIPHER
1248 select CRYPTO_CHACHA20
1250 ChaCha20 cipher algorithm, RFC7539.
1252 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1253 Bernstein and further specified in RFC7539 for use in IETF protocols.
1254 This is the x86_64 assembler implementation using SIMD instructions.
1257 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1260 tristate "SEED cipher algorithm"
1261 select CRYPTO_ALGAPI
1263 SEED cipher algorithm (RFC4269).
1265 SEED is a 128-bit symmetric key block cipher that has been
1266 developed by KISA (Korea Information Security Agency) as a
1267 national standard encryption algorithm of the Republic of Korea.
1268 It is a 16 round block cipher with the key size of 128 bit.
1271 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1273 config CRYPTO_SERPENT
1274 tristate "Serpent cipher algorithm"
1275 select CRYPTO_ALGAPI
1277 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1279 Keys are allowed to be from 0 to 256 bits in length, in steps
1280 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1281 variant of Serpent for compatibility with old kerneli.org code.
1284 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1286 config CRYPTO_SERPENT_SSE2_X86_64
1287 tristate "Serpent cipher algorithm (x86_64/SSE2)"
1288 depends on X86 && 64BIT
1289 select CRYPTO_ALGAPI
1290 select CRYPTO_CRYPTD
1291 select CRYPTO_ABLK_HELPER
1292 select CRYPTO_GLUE_HELPER_X86
1293 select CRYPTO_SERPENT
1297 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1299 Keys are allowed to be from 0 to 256 bits in length, in steps
1302 This module provides Serpent cipher algorithm that processes eight
1303 blocks parallel using SSE2 instruction set.
1306 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1308 config CRYPTO_SERPENT_SSE2_586
1309 tristate "Serpent cipher algorithm (i586/SSE2)"
1310 depends on X86 && !64BIT
1311 select CRYPTO_ALGAPI
1312 select CRYPTO_CRYPTD
1313 select CRYPTO_ABLK_HELPER
1314 select CRYPTO_GLUE_HELPER_X86
1315 select CRYPTO_SERPENT
1319 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1321 Keys are allowed to be from 0 to 256 bits in length, in steps
1324 This module provides Serpent cipher algorithm that processes four
1325 blocks parallel using SSE2 instruction set.
1328 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1330 config CRYPTO_SERPENT_AVX_X86_64
1331 tristate "Serpent cipher algorithm (x86_64/AVX)"
1332 depends on X86 && 64BIT
1333 select CRYPTO_ALGAPI
1334 select CRYPTO_CRYPTD
1335 select CRYPTO_ABLK_HELPER
1336 select CRYPTO_GLUE_HELPER_X86
1337 select CRYPTO_SERPENT
1341 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1343 Keys are allowed to be from 0 to 256 bits in length, in steps
1346 This module provides the Serpent cipher algorithm that processes
1347 eight blocks parallel using the AVX instruction set.
1350 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1352 config CRYPTO_SERPENT_AVX2_X86_64
1353 tristate "Serpent cipher algorithm (x86_64/AVX2)"
1354 depends on X86 && 64BIT
1355 select CRYPTO_ALGAPI
1356 select CRYPTO_CRYPTD
1357 select CRYPTO_ABLK_HELPER
1358 select CRYPTO_GLUE_HELPER_X86
1359 select CRYPTO_SERPENT
1360 select CRYPTO_SERPENT_AVX_X86_64
1364 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1366 Keys are allowed to be from 0 to 256 bits in length, in steps
1369 This module provides Serpent cipher algorithm that processes 16
1370 blocks parallel using AVX2 instruction set.
1373 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1376 tristate "TEA, XTEA and XETA cipher algorithms"
1377 select CRYPTO_ALGAPI
1379 TEA cipher algorithm.
1381 Tiny Encryption Algorithm is a simple cipher that uses
1382 many rounds for security. It is very fast and uses
1385 Xtendend Tiny Encryption Algorithm is a modification to
1386 the TEA algorithm to address a potential key weakness
1387 in the TEA algorithm.
1389 Xtendend Encryption Tiny Algorithm is a mis-implementation
1390 of the XTEA algorithm for compatibility purposes.
1392 config CRYPTO_TWOFISH
1393 tristate "Twofish cipher algorithm"
1394 select CRYPTO_ALGAPI
1395 select CRYPTO_TWOFISH_COMMON
1397 Twofish cipher algorithm.
1399 Twofish was submitted as an AES (Advanced Encryption Standard)
1400 candidate cipher by researchers at CounterPane Systems. It is a
1401 16 round block cipher supporting key sizes of 128, 192, and 256
1405 <http://www.schneier.com/twofish.html>
1407 config CRYPTO_TWOFISH_COMMON
1410 Common parts of the Twofish cipher algorithm shared by the
1411 generic c and the assembler implementations.
1413 config CRYPTO_TWOFISH_586
1414 tristate "Twofish cipher algorithms (i586)"
1415 depends on (X86 || UML_X86) && !64BIT
1416 select CRYPTO_ALGAPI
1417 select CRYPTO_TWOFISH_COMMON
1419 Twofish cipher algorithm.
1421 Twofish was submitted as an AES (Advanced Encryption Standard)
1422 candidate cipher by researchers at CounterPane Systems. It is a
1423 16 round block cipher supporting key sizes of 128, 192, and 256
1427 <http://www.schneier.com/twofish.html>
1429 config CRYPTO_TWOFISH_X86_64
1430 tristate "Twofish cipher algorithm (x86_64)"
1431 depends on (X86 || UML_X86) && 64BIT
1432 select CRYPTO_ALGAPI
1433 select CRYPTO_TWOFISH_COMMON
1435 Twofish cipher algorithm (x86_64).
1437 Twofish was submitted as an AES (Advanced Encryption Standard)
1438 candidate cipher by researchers at CounterPane Systems. It is a
1439 16 round block cipher supporting key sizes of 128, 192, and 256
1443 <http://www.schneier.com/twofish.html>
1445 config CRYPTO_TWOFISH_X86_64_3WAY
1446 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1447 depends on X86 && 64BIT
1448 select CRYPTO_ALGAPI
1449 select CRYPTO_TWOFISH_COMMON
1450 select CRYPTO_TWOFISH_X86_64
1451 select CRYPTO_GLUE_HELPER_X86
1455 Twofish cipher algorithm (x86_64, 3-way parallel).
1457 Twofish was submitted as an AES (Advanced Encryption Standard)
1458 candidate cipher by researchers at CounterPane Systems. It is a
1459 16 round block cipher supporting key sizes of 128, 192, and 256
1462 This module provides Twofish cipher algorithm that processes three
1463 blocks parallel, utilizing resources of out-of-order CPUs better.
1466 <http://www.schneier.com/twofish.html>
1468 config CRYPTO_TWOFISH_AVX_X86_64
1469 tristate "Twofish cipher algorithm (x86_64/AVX)"
1470 depends on X86 && 64BIT
1471 select CRYPTO_ALGAPI
1472 select CRYPTO_CRYPTD
1473 select CRYPTO_ABLK_HELPER
1474 select CRYPTO_GLUE_HELPER_X86
1475 select CRYPTO_TWOFISH_COMMON
1476 select CRYPTO_TWOFISH_X86_64
1477 select CRYPTO_TWOFISH_X86_64_3WAY
1481 Twofish cipher algorithm (x86_64/AVX).
1483 Twofish was submitted as an AES (Advanced Encryption Standard)
1484 candidate cipher by researchers at CounterPane Systems. It is a
1485 16 round block cipher supporting key sizes of 128, 192, and 256
1488 This module provides the Twofish cipher algorithm that processes
1489 eight blocks parallel using the AVX Instruction Set.
1492 <http://www.schneier.com/twofish.html>
1494 comment "Compression"
1496 config CRYPTO_DEFLATE
1497 tristate "Deflate compression algorithm"
1498 select CRYPTO_ALGAPI
1502 This is the Deflate algorithm (RFC1951), specified for use in
1503 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1505 You will most probably want this if using IPSec.
1508 tristate "Zlib compression algorithm"
1514 This is the zlib algorithm.
1517 tristate "LZO compression algorithm"
1518 select CRYPTO_ALGAPI
1520 select LZO_DECOMPRESS
1522 This is the LZO algorithm.
1525 tristate "842 compression algorithm"
1526 select CRYPTO_ALGAPI
1528 select 842_DECOMPRESS
1530 This is the 842 algorithm.
1533 tristate "LZ4 compression algorithm"
1534 select CRYPTO_ALGAPI
1536 select LZ4_DECOMPRESS
1538 This is the LZ4 algorithm.
1541 tristate "LZ4HC compression algorithm"
1542 select CRYPTO_ALGAPI
1543 select LZ4HC_COMPRESS
1544 select LZ4_DECOMPRESS
1546 This is the LZ4 high compression mode algorithm.
1548 comment "Random Number Generation"
1550 config CRYPTO_ANSI_CPRNG
1551 tristate "Pseudo Random Number Generation for Cryptographic modules"
1555 This option enables the generic pseudo random number generator
1556 for cryptographic modules. Uses the Algorithm specified in
1557 ANSI X9.31 A.2.4. Note that this option must be enabled if
1558 CRYPTO_FIPS is selected
1560 menuconfig CRYPTO_DRBG_MENU
1561 tristate "NIST SP800-90A DRBG"
1563 NIST SP800-90A compliant DRBG. In the following submenu, one or
1564 more of the DRBG types must be selected.
1568 config CRYPTO_DRBG_HMAC
1572 select CRYPTO_SHA256
1574 config CRYPTO_DRBG_HASH
1575 bool "Enable Hash DRBG"
1576 select CRYPTO_SHA256
1578 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1580 config CRYPTO_DRBG_CTR
1581 bool "Enable CTR DRBG"
1584 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1588 default CRYPTO_DRBG_MENU
1590 select CRYPTO_JITTERENTROPY
1592 endif # if CRYPTO_DRBG_MENU
1594 config CRYPTO_JITTERENTROPY
1595 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1597 The Jitterentropy RNG is a noise that is intended
1598 to provide seed to another RNG. The RNG does not
1599 perform any cryptographic whitening of the generated
1600 random numbers. This Jitterentropy RNG registers with
1601 the kernel crypto API and can be used by any caller.
1603 config CRYPTO_USER_API
1606 config CRYPTO_USER_API_HASH
1607 tristate "User-space interface for hash algorithms"
1610 select CRYPTO_USER_API
1612 This option enables the user-spaces interface for hash
1615 config CRYPTO_USER_API_SKCIPHER
1616 tristate "User-space interface for symmetric key cipher algorithms"
1618 select CRYPTO_BLKCIPHER
1619 select CRYPTO_USER_API
1621 This option enables the user-spaces interface for symmetric
1622 key cipher algorithms.
1624 config CRYPTO_USER_API_RNG
1625 tristate "User-space interface for random number generator algorithms"
1628 select CRYPTO_USER_API
1630 This option enables the user-spaces interface for random
1631 number generator algorithms.
1633 config CRYPTO_USER_API_AEAD
1634 tristate "User-space interface for AEAD cipher algorithms"
1637 select CRYPTO_USER_API
1639 This option enables the user-spaces interface for AEAD
1642 config CRYPTO_HASH_INFO
1645 source "drivers/crypto/Kconfig"
1646 source crypto/asymmetric_keys/Kconfig
1647 source certs/Kconfig