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 "HEH support"
296 select CRYPTO_GF128MUL
297 select CRYPTO_MANAGER
298 select CRYPTO_POLY_HASH_ARM64_CE if ARM64 && KERNEL_MODE_NEON
300 HEH: Hash-Encrypt-Hash mode
301 HEH is a proposed block cipher mode of operation which extends the
302 strong pseudo-random permutation (SPRP) property of block ciphers to
303 arbitrary-length input strings. This provides a stronger notion of
304 security than existing block cipher modes of operation (e.g. CBC, CTR,
305 XTS), though it is usually less performant. Applications include disk
306 encryption and encryption of file names and contents. Currently, this
307 implementation only provides a symmetric cipher interface, so it can't
308 yet be used as an AEAD.
311 tristate "CTR support"
312 select CRYPTO_BLKCIPHER
314 select CRYPTO_MANAGER
317 This block cipher algorithm is required for IPSec.
320 tristate "CTS support"
321 select CRYPTO_BLKCIPHER
323 CTS: Cipher Text Stealing
324 This is the Cipher Text Stealing mode as described by
325 Section 8 of rfc2040 and referenced by rfc3962.
326 (rfc3962 includes errata information in its Appendix A)
327 This mode is required for Kerberos gss mechanism support
331 tristate "ECB support"
332 select CRYPTO_BLKCIPHER
333 select CRYPTO_MANAGER
335 ECB: Electronic CodeBook mode
336 This is the simplest block cipher algorithm. It simply encrypts
337 the input block by block.
340 tristate "LRW support"
341 select CRYPTO_BLKCIPHER
342 select CRYPTO_MANAGER
343 select CRYPTO_GF128MUL
345 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
346 narrow block cipher mode for dm-crypt. Use it with cipher
347 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
348 The first 128, 192 or 256 bits in the key are used for AES and the
349 rest is used to tie each cipher block to its logical position.
352 tristate "PCBC support"
353 select CRYPTO_BLKCIPHER
354 select CRYPTO_MANAGER
356 PCBC: Propagating Cipher Block Chaining mode
357 This block cipher algorithm is required for RxRPC.
360 tristate "XTS support"
361 select CRYPTO_BLKCIPHER
362 select CRYPTO_MANAGER
363 select CRYPTO_GF128MUL
365 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
366 key size 256, 384 or 512 bits. This implementation currently
367 can't handle a sectorsize which is not a multiple of 16 bytes.
369 config CRYPTO_KEYWRAP
370 tristate "Key wrapping support"
371 select CRYPTO_BLKCIPHER
373 Support for key wrapping (NIST SP800-38F / RFC3394) without
379 tristate "CMAC support"
381 select CRYPTO_MANAGER
383 Cipher-based Message Authentication Code (CMAC) specified by
384 The National Institute of Standards and Technology (NIST).
386 https://tools.ietf.org/html/rfc4493
387 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
390 tristate "HMAC support"
392 select CRYPTO_MANAGER
394 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
395 This is required for IPSec.
398 tristate "XCBC support"
400 select CRYPTO_MANAGER
402 XCBC: Keyed-Hashing with encryption algorithm
403 http://www.ietf.org/rfc/rfc3566.txt
404 http://csrc.nist.gov/encryption/modes/proposedmodes/
405 xcbc-mac/xcbc-mac-spec.pdf
408 tristate "VMAC support"
410 select CRYPTO_MANAGER
412 VMAC is a message authentication algorithm designed for
413 very high speed on 64-bit architectures.
416 <http://fastcrypto.org/vmac>
421 tristate "CRC32c CRC algorithm"
425 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
426 by iSCSI for header and data digests and by others.
427 See Castagnoli93. Module will be crc32c.
429 config CRYPTO_CRC32C_INTEL
430 tristate "CRC32c INTEL hardware acceleration"
434 In Intel processor with SSE4.2 supported, the processor will
435 support CRC32C implementation using hardware accelerated CRC32
436 instruction. This option will create 'crc32c-intel' module,
437 which will enable any routine to use the CRC32 instruction to
438 gain performance compared with software implementation.
439 Module will be crc32c-intel.
441 config CRYPTO_CRC32C_SPARC64
442 tristate "CRC32c CRC algorithm (SPARC64)"
447 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
451 tristate "CRC32 CRC algorithm"
455 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
456 Shash crypto api wrappers to crc32_le function.
458 config CRYPTO_CRC32_PCLMUL
459 tristate "CRC32 PCLMULQDQ hardware acceleration"
464 From Intel Westmere and AMD Bulldozer processor with SSE4.2
465 and PCLMULQDQ supported, the processor will support
466 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
467 instruction. This option will create 'crc32-plcmul' module,
468 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
469 and gain better performance as compared with the table implementation.
471 config CRYPTO_CRCT10DIF
472 tristate "CRCT10DIF algorithm"
475 CRC T10 Data Integrity Field computation is being cast as
476 a crypto transform. This allows for faster crc t10 diff
477 transforms to be used if they are available.
479 config CRYPTO_CRCT10DIF_PCLMUL
480 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
481 depends on X86 && 64BIT && CRC_T10DIF
484 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
485 CRC T10 DIF PCLMULQDQ computation can be hardware
486 accelerated PCLMULQDQ instruction. This option will create
487 'crct10dif-plcmul' module, which is faster when computing the
488 crct10dif checksum as compared with the generic table implementation.
491 tristate "GHASH digest algorithm"
492 select CRYPTO_GF128MUL
494 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
496 config CRYPTO_POLY1305
497 tristate "Poly1305 authenticator algorithm"
499 Poly1305 authenticator algorithm, RFC7539.
501 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
502 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
503 in IETF protocols. This is the portable C implementation of Poly1305.
505 config CRYPTO_POLY1305_X86_64
506 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
507 depends on X86 && 64BIT
508 select CRYPTO_POLY1305
510 Poly1305 authenticator algorithm, RFC7539.
512 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
513 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
514 in IETF protocols. This is the x86_64 assembler implementation using SIMD
518 tristate "MD4 digest algorithm"
521 MD4 message digest algorithm (RFC1320).
524 tristate "MD5 digest algorithm"
527 MD5 message digest algorithm (RFC1321).
529 config CRYPTO_MD5_OCTEON
530 tristate "MD5 digest algorithm (OCTEON)"
531 depends on CPU_CAVIUM_OCTEON
535 MD5 message digest algorithm (RFC1321) implemented
536 using OCTEON crypto instructions, when available.
538 config CRYPTO_MD5_PPC
539 tristate "MD5 digest algorithm (PPC)"
543 MD5 message digest algorithm (RFC1321) implemented
546 config CRYPTO_MD5_SPARC64
547 tristate "MD5 digest algorithm (SPARC64)"
552 MD5 message digest algorithm (RFC1321) implemented
553 using sparc64 crypto instructions, when available.
555 config CRYPTO_MICHAEL_MIC
556 tristate "Michael MIC keyed digest algorithm"
559 Michael MIC is used for message integrity protection in TKIP
560 (IEEE 802.11i). This algorithm is required for TKIP, but it
561 should not be used for other purposes because of the weakness
565 tristate "RIPEMD-128 digest algorithm"
568 RIPEMD-128 (ISO/IEC 10118-3:2004).
570 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
571 be used as a secure replacement for RIPEMD. For other use cases,
572 RIPEMD-160 should be used.
574 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
575 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
578 tristate "RIPEMD-160 digest algorithm"
581 RIPEMD-160 (ISO/IEC 10118-3:2004).
583 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
584 to be used as a secure replacement for the 128-bit hash functions
585 MD4, MD5 and it's predecessor RIPEMD
586 (not to be confused with RIPEMD-128).
588 It's speed is comparable to SHA1 and there are no known attacks
591 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
592 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
595 tristate "RIPEMD-256 digest algorithm"
598 RIPEMD-256 is an optional extension of RIPEMD-128 with a
599 256 bit hash. It is intended for applications that require
600 longer hash-results, without needing a larger security level
603 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
604 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
607 tristate "RIPEMD-320 digest algorithm"
610 RIPEMD-320 is an optional extension of RIPEMD-160 with a
611 320 bit hash. It is intended for applications that require
612 longer hash-results, without needing a larger security level
615 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
616 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
619 tristate "SHA1 digest algorithm"
622 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
624 config CRYPTO_SHA1_SSSE3
625 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
626 depends on X86 && 64BIT
630 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
631 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
632 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
635 config CRYPTO_SHA256_SSSE3
636 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
637 depends on X86 && 64BIT
641 SHA-256 secure hash standard (DFIPS 180-2) implemented
642 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
643 Extensions version 1 (AVX1), or Advanced Vector Extensions
644 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
645 Instructions) when available.
647 config CRYPTO_SHA512_SSSE3
648 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
649 depends on X86 && 64BIT
653 SHA-512 secure hash standard (DFIPS 180-2) implemented
654 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
655 Extensions version 1 (AVX1), or Advanced Vector Extensions
656 version 2 (AVX2) instructions, when available.
658 config CRYPTO_SHA1_OCTEON
659 tristate "SHA1 digest algorithm (OCTEON)"
660 depends on CPU_CAVIUM_OCTEON
664 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
665 using OCTEON crypto instructions, when available.
667 config CRYPTO_SHA1_SPARC64
668 tristate "SHA1 digest algorithm (SPARC64)"
673 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
674 using sparc64 crypto instructions, when available.
676 config CRYPTO_SHA1_PPC
677 tristate "SHA1 digest algorithm (powerpc)"
680 This is the powerpc hardware accelerated implementation of the
681 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
683 config CRYPTO_SHA1_PPC_SPE
684 tristate "SHA1 digest algorithm (PPC SPE)"
685 depends on PPC && SPE
687 SHA-1 secure hash standard (DFIPS 180-4) implemented
688 using powerpc SPE SIMD instruction set.
690 config CRYPTO_SHA1_MB
691 tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
692 depends on X86 && 64BIT
695 select CRYPTO_MCRYPTD
697 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
698 using multi-buffer technique. This algorithm computes on
699 multiple data lanes concurrently with SIMD instructions for
700 better throughput. It should not be enabled by default but
701 used when there is significant amount of work to keep the keep
702 the data lanes filled to get performance benefit. If the data
703 lanes remain unfilled, a flush operation will be initiated to
704 process the crypto jobs, adding a slight latency.
707 tristate "SHA224 and SHA256 digest algorithm"
710 SHA256 secure hash standard (DFIPS 180-2).
712 This version of SHA implements a 256 bit hash with 128 bits of
713 security against collision attacks.
715 This code also includes SHA-224, a 224 bit hash with 112 bits
716 of security against collision attacks.
718 config CRYPTO_SHA256_PPC_SPE
719 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
720 depends on PPC && SPE
724 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
725 implemented using powerpc SPE SIMD instruction set.
727 config CRYPTO_SHA256_OCTEON
728 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
729 depends on CPU_CAVIUM_OCTEON
733 SHA-256 secure hash standard (DFIPS 180-2) implemented
734 using OCTEON crypto instructions, when available.
736 config CRYPTO_SHA256_SPARC64
737 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
742 SHA-256 secure hash standard (DFIPS 180-2) implemented
743 using sparc64 crypto instructions, when available.
746 tristate "SHA384 and SHA512 digest algorithms"
749 SHA512 secure hash standard (DFIPS 180-2).
751 This version of SHA implements a 512 bit hash with 256 bits of
752 security against collision attacks.
754 This code also includes SHA-384, a 384 bit hash with 192 bits
755 of security against collision attacks.
757 config CRYPTO_SHA512_OCTEON
758 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
759 depends on CPU_CAVIUM_OCTEON
763 SHA-512 secure hash standard (DFIPS 180-2) implemented
764 using OCTEON crypto instructions, when available.
766 config CRYPTO_SHA512_SPARC64
767 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
772 SHA-512 secure hash standard (DFIPS 180-2) implemented
773 using sparc64 crypto instructions, when available.
776 tristate "Tiger digest algorithms"
779 Tiger hash algorithm 192, 160 and 128-bit hashes
781 Tiger is a hash function optimized for 64-bit processors while
782 still having decent performance on 32-bit processors.
783 Tiger was developed by Ross Anderson and Eli Biham.
786 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
789 tristate "Whirlpool digest algorithms"
792 Whirlpool hash algorithm 512, 384 and 256-bit hashes
794 Whirlpool-512 is part of the NESSIE cryptographic primitives.
795 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
798 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
800 config CRYPTO_GHASH_CLMUL_NI_INTEL
801 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
802 depends on X86 && 64BIT
805 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
806 The implementation is accelerated by CLMUL-NI of Intel.
811 tristate "AES cipher algorithms"
814 AES cipher algorithms (FIPS-197). AES uses the Rijndael
817 Rijndael appears to be consistently a very good performer in
818 both hardware and software across a wide range of computing
819 environments regardless of its use in feedback or non-feedback
820 modes. Its key setup time is excellent, and its key agility is
821 good. Rijndael's very low memory requirements make it very well
822 suited for restricted-space environments, in which it also
823 demonstrates excellent performance. Rijndael's operations are
824 among the easiest to defend against power and timing attacks.
826 The AES specifies three key sizes: 128, 192 and 256 bits
828 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
830 config CRYPTO_AES_586
831 tristate "AES cipher algorithms (i586)"
832 depends on (X86 || UML_X86) && !64BIT
836 AES cipher algorithms (FIPS-197). AES uses the Rijndael
839 Rijndael appears to be consistently a very good performer in
840 both hardware and software across a wide range of computing
841 environments regardless of its use in feedback or non-feedback
842 modes. Its key setup time is excellent, and its key agility is
843 good. Rijndael's very low memory requirements make it very well
844 suited for restricted-space environments, in which it also
845 demonstrates excellent performance. Rijndael's operations are
846 among the easiest to defend against power and timing attacks.
848 The AES specifies three key sizes: 128, 192 and 256 bits
850 See <http://csrc.nist.gov/encryption/aes/> for more information.
852 config CRYPTO_AES_X86_64
853 tristate "AES cipher algorithms (x86_64)"
854 depends on (X86 || UML_X86) && 64BIT
858 AES cipher algorithms (FIPS-197). AES uses the Rijndael
861 Rijndael appears to be consistently a very good performer in
862 both hardware and software across a wide range of computing
863 environments regardless of its use in feedback or non-feedback
864 modes. Its key setup time is excellent, and its key agility is
865 good. Rijndael's very low memory requirements make it very well
866 suited for restricted-space environments, in which it also
867 demonstrates excellent performance. Rijndael's operations are
868 among the easiest to defend against power and timing attacks.
870 The AES specifies three key sizes: 128, 192 and 256 bits
872 See <http://csrc.nist.gov/encryption/aes/> for more information.
874 config CRYPTO_AES_NI_INTEL
875 tristate "AES cipher algorithms (AES-NI)"
877 select CRYPTO_AES_X86_64 if 64BIT
878 select CRYPTO_AES_586 if !64BIT
880 select CRYPTO_ABLK_HELPER
882 select CRYPTO_GLUE_HELPER_X86 if 64BIT
886 Use Intel AES-NI instructions for AES algorithm.
888 AES cipher algorithms (FIPS-197). AES uses the Rijndael
891 Rijndael appears to be consistently a very good performer in
892 both hardware and software across a wide range of computing
893 environments regardless of its use in feedback or non-feedback
894 modes. Its key setup time is excellent, and its key agility is
895 good. Rijndael's very low memory requirements make it very well
896 suited for restricted-space environments, in which it also
897 demonstrates excellent performance. Rijndael's operations are
898 among the easiest to defend against power and timing attacks.
900 The AES specifies three key sizes: 128, 192 and 256 bits
902 See <http://csrc.nist.gov/encryption/aes/> for more information.
904 In addition to AES cipher algorithm support, the acceleration
905 for some popular block cipher mode is supported too, including
906 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
907 acceleration for CTR.
909 config CRYPTO_AES_SPARC64
910 tristate "AES cipher algorithms (SPARC64)"
915 Use SPARC64 crypto opcodes for AES algorithm.
917 AES cipher algorithms (FIPS-197). AES uses the Rijndael
920 Rijndael appears to be consistently a very good performer in
921 both hardware and software across a wide range of computing
922 environments regardless of its use in feedback or non-feedback
923 modes. Its key setup time is excellent, and its key agility is
924 good. Rijndael's very low memory requirements make it very well
925 suited for restricted-space environments, in which it also
926 demonstrates excellent performance. Rijndael's operations are
927 among the easiest to defend against power and timing attacks.
929 The AES specifies three key sizes: 128, 192 and 256 bits
931 See <http://csrc.nist.gov/encryption/aes/> for more information.
933 In addition to AES cipher algorithm support, the acceleration
934 for some popular block cipher mode is supported too, including
937 config CRYPTO_AES_PPC_SPE
938 tristate "AES cipher algorithms (PPC SPE)"
939 depends on PPC && SPE
941 AES cipher algorithms (FIPS-197). Additionally the acceleration
942 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
943 This module should only be used for low power (router) devices
944 without hardware AES acceleration (e.g. caam crypto). It reduces the
945 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
946 timining attacks. Nevertheless it might be not as secure as other
947 architecture specific assembler implementations that work on 1KB
948 tables or 256 bytes S-boxes.
951 tristate "Anubis cipher algorithm"
954 Anubis cipher algorithm.
956 Anubis is a variable key length cipher which can use keys from
957 128 bits to 320 bits in length. It was evaluated as a entrant
958 in the NESSIE competition.
961 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
962 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
965 tristate "ARC4 cipher algorithm"
966 select CRYPTO_BLKCIPHER
968 ARC4 cipher algorithm.
970 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
971 bits in length. This algorithm is required for driver-based
972 WEP, but it should not be for other purposes because of the
973 weakness of the algorithm.
975 config CRYPTO_BLOWFISH
976 tristate "Blowfish cipher algorithm"
978 select CRYPTO_BLOWFISH_COMMON
980 Blowfish cipher algorithm, by Bruce Schneier.
982 This is a variable key length cipher which can use keys from 32
983 bits to 448 bits in length. It's fast, simple and specifically
984 designed for use on "large microprocessors".
987 <http://www.schneier.com/blowfish.html>
989 config CRYPTO_BLOWFISH_COMMON
992 Common parts of the Blowfish cipher algorithm shared by the
993 generic c and the assembler implementations.
996 <http://www.schneier.com/blowfish.html>
998 config CRYPTO_BLOWFISH_X86_64
999 tristate "Blowfish cipher algorithm (x86_64)"
1000 depends on X86 && 64BIT
1001 select CRYPTO_ALGAPI
1002 select CRYPTO_BLOWFISH_COMMON
1004 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1006 This is a variable key length cipher which can use keys from 32
1007 bits to 448 bits in length. It's fast, simple and specifically
1008 designed for use on "large microprocessors".
1011 <http://www.schneier.com/blowfish.html>
1013 config CRYPTO_CAMELLIA
1014 tristate "Camellia cipher algorithms"
1016 select CRYPTO_ALGAPI
1018 Camellia cipher algorithms module.
1020 Camellia is a symmetric key block cipher developed jointly
1021 at NTT and Mitsubishi Electric Corporation.
1023 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1026 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1028 config CRYPTO_CAMELLIA_X86_64
1029 tristate "Camellia cipher algorithm (x86_64)"
1030 depends on X86 && 64BIT
1032 select CRYPTO_ALGAPI
1033 select CRYPTO_GLUE_HELPER_X86
1037 Camellia cipher algorithm module (x86_64).
1039 Camellia is a symmetric key block cipher developed jointly
1040 at NTT and Mitsubishi Electric Corporation.
1042 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1045 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1047 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1048 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1049 depends on X86 && 64BIT
1051 select CRYPTO_ALGAPI
1052 select CRYPTO_CRYPTD
1053 select CRYPTO_ABLK_HELPER
1054 select CRYPTO_GLUE_HELPER_X86
1055 select CRYPTO_CAMELLIA_X86_64
1059 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1061 Camellia is a symmetric key block cipher developed jointly
1062 at NTT and Mitsubishi Electric Corporation.
1064 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1067 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1069 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1070 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1071 depends on X86 && 64BIT
1073 select CRYPTO_ALGAPI
1074 select CRYPTO_CRYPTD
1075 select CRYPTO_ABLK_HELPER
1076 select CRYPTO_GLUE_HELPER_X86
1077 select CRYPTO_CAMELLIA_X86_64
1078 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1082 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1084 Camellia is a symmetric key block cipher developed jointly
1085 at NTT and Mitsubishi Electric Corporation.
1087 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1090 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1092 config CRYPTO_CAMELLIA_SPARC64
1093 tristate "Camellia cipher algorithm (SPARC64)"
1096 select CRYPTO_ALGAPI
1098 Camellia cipher algorithm module (SPARC64).
1100 Camellia is a symmetric key block cipher developed jointly
1101 at NTT and Mitsubishi Electric Corporation.
1103 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1106 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1108 config CRYPTO_CAST_COMMON
1111 Common parts of the CAST cipher algorithms shared by the
1112 generic c and the assembler implementations.
1115 tristate "CAST5 (CAST-128) cipher algorithm"
1116 select CRYPTO_ALGAPI
1117 select CRYPTO_CAST_COMMON
1119 The CAST5 encryption algorithm (synonymous with CAST-128) is
1120 described in RFC2144.
1122 config CRYPTO_CAST5_AVX_X86_64
1123 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1124 depends on X86 && 64BIT
1125 select CRYPTO_ALGAPI
1126 select CRYPTO_CRYPTD
1127 select CRYPTO_ABLK_HELPER
1128 select CRYPTO_CAST_COMMON
1131 The CAST5 encryption algorithm (synonymous with CAST-128) is
1132 described in RFC2144.
1134 This module provides the Cast5 cipher algorithm that processes
1135 sixteen blocks parallel using the AVX instruction set.
1138 tristate "CAST6 (CAST-256) cipher algorithm"
1139 select CRYPTO_ALGAPI
1140 select CRYPTO_CAST_COMMON
1142 The CAST6 encryption algorithm (synonymous with CAST-256) is
1143 described in RFC2612.
1145 config CRYPTO_CAST6_AVX_X86_64
1146 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1147 depends on X86 && 64BIT
1148 select CRYPTO_ALGAPI
1149 select CRYPTO_CRYPTD
1150 select CRYPTO_ABLK_HELPER
1151 select CRYPTO_GLUE_HELPER_X86
1152 select CRYPTO_CAST_COMMON
1157 The CAST6 encryption algorithm (synonymous with CAST-256) is
1158 described in RFC2612.
1160 This module provides the Cast6 cipher algorithm that processes
1161 eight blocks parallel using the AVX instruction set.
1164 tristate "DES and Triple DES EDE cipher algorithms"
1165 select CRYPTO_ALGAPI
1167 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1169 config CRYPTO_DES_SPARC64
1170 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1172 select CRYPTO_ALGAPI
1175 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1176 optimized using SPARC64 crypto opcodes.
1178 config CRYPTO_DES3_EDE_X86_64
1179 tristate "Triple DES EDE cipher algorithm (x86-64)"
1180 depends on X86 && 64BIT
1181 select CRYPTO_ALGAPI
1184 Triple DES EDE (FIPS 46-3) algorithm.
1186 This module provides implementation of the Triple DES EDE cipher
1187 algorithm that is optimized for x86-64 processors. Two versions of
1188 algorithm are provided; regular processing one input block and
1189 one that processes three blocks parallel.
1191 config CRYPTO_FCRYPT
1192 tristate "FCrypt cipher algorithm"
1193 select CRYPTO_ALGAPI
1194 select CRYPTO_BLKCIPHER
1196 FCrypt algorithm used by RxRPC.
1198 config CRYPTO_KHAZAD
1199 tristate "Khazad cipher algorithm"
1200 select CRYPTO_ALGAPI
1202 Khazad cipher algorithm.
1204 Khazad was a finalist in the initial NESSIE competition. It is
1205 an algorithm optimized for 64-bit processors with good performance
1206 on 32-bit processors. Khazad uses an 128 bit key size.
1209 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1211 config CRYPTO_SALSA20
1212 tristate "Salsa20 stream cipher algorithm"
1213 select CRYPTO_BLKCIPHER
1215 Salsa20 stream cipher algorithm.
1217 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1218 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1220 The Salsa20 stream cipher algorithm is designed by Daniel J.
1221 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1223 config CRYPTO_SALSA20_586
1224 tristate "Salsa20 stream cipher algorithm (i586)"
1225 depends on (X86 || UML_X86) && !64BIT
1226 select CRYPTO_BLKCIPHER
1228 Salsa20 stream cipher algorithm.
1230 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1231 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1233 The Salsa20 stream cipher algorithm is designed by Daniel J.
1234 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1236 config CRYPTO_SALSA20_X86_64
1237 tristate "Salsa20 stream cipher algorithm (x86_64)"
1238 depends on (X86 || UML_X86) && 64BIT
1239 select CRYPTO_BLKCIPHER
1241 Salsa20 stream cipher algorithm.
1243 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1244 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1246 The Salsa20 stream cipher algorithm is designed by Daniel J.
1247 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1249 config CRYPTO_CHACHA20
1250 tristate "ChaCha20 cipher algorithm"
1251 select CRYPTO_BLKCIPHER
1253 ChaCha20 cipher algorithm, RFC7539.
1255 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1256 Bernstein and further specified in RFC7539 for use in IETF protocols.
1257 This is the portable C implementation of ChaCha20.
1260 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1262 config CRYPTO_CHACHA20_X86_64
1263 tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1264 depends on X86 && 64BIT
1265 select CRYPTO_BLKCIPHER
1266 select CRYPTO_CHACHA20
1268 ChaCha20 cipher algorithm, RFC7539.
1270 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1271 Bernstein and further specified in RFC7539 for use in IETF protocols.
1272 This is the x86_64 assembler implementation using SIMD instructions.
1275 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1278 tristate "SEED cipher algorithm"
1279 select CRYPTO_ALGAPI
1281 SEED cipher algorithm (RFC4269).
1283 SEED is a 128-bit symmetric key block cipher that has been
1284 developed by KISA (Korea Information Security Agency) as a
1285 national standard encryption algorithm of the Republic of Korea.
1286 It is a 16 round block cipher with the key size of 128 bit.
1289 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1291 config CRYPTO_SERPENT
1292 tristate "Serpent cipher algorithm"
1293 select CRYPTO_ALGAPI
1295 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1297 Keys are allowed to be from 0 to 256 bits in length, in steps
1298 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1299 variant of Serpent for compatibility with old kerneli.org code.
1302 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1304 config CRYPTO_SERPENT_SSE2_X86_64
1305 tristate "Serpent cipher algorithm (x86_64/SSE2)"
1306 depends on X86 && 64BIT
1307 select CRYPTO_ALGAPI
1308 select CRYPTO_CRYPTD
1309 select CRYPTO_ABLK_HELPER
1310 select CRYPTO_GLUE_HELPER_X86
1311 select CRYPTO_SERPENT
1315 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1317 Keys are allowed to be from 0 to 256 bits in length, in steps
1320 This module provides Serpent cipher algorithm that processes eight
1321 blocks parallel using SSE2 instruction set.
1324 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1326 config CRYPTO_SERPENT_SSE2_586
1327 tristate "Serpent cipher algorithm (i586/SSE2)"
1328 depends on X86 && !64BIT
1329 select CRYPTO_ALGAPI
1330 select CRYPTO_CRYPTD
1331 select CRYPTO_ABLK_HELPER
1332 select CRYPTO_GLUE_HELPER_X86
1333 select CRYPTO_SERPENT
1337 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1339 Keys are allowed to be from 0 to 256 bits in length, in steps
1342 This module provides Serpent cipher algorithm that processes four
1343 blocks parallel using SSE2 instruction set.
1346 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1348 config CRYPTO_SERPENT_AVX_X86_64
1349 tristate "Serpent cipher algorithm (x86_64/AVX)"
1350 depends on X86 && 64BIT
1351 select CRYPTO_ALGAPI
1352 select CRYPTO_CRYPTD
1353 select CRYPTO_ABLK_HELPER
1354 select CRYPTO_GLUE_HELPER_X86
1355 select CRYPTO_SERPENT
1359 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1361 Keys are allowed to be from 0 to 256 bits in length, in steps
1364 This module provides the Serpent cipher algorithm that processes
1365 eight blocks parallel using the AVX instruction set.
1368 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1370 config CRYPTO_SERPENT_AVX2_X86_64
1371 tristate "Serpent cipher algorithm (x86_64/AVX2)"
1372 depends on X86 && 64BIT
1373 select CRYPTO_ALGAPI
1374 select CRYPTO_CRYPTD
1375 select CRYPTO_ABLK_HELPER
1376 select CRYPTO_GLUE_HELPER_X86
1377 select CRYPTO_SERPENT
1378 select CRYPTO_SERPENT_AVX_X86_64
1382 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1384 Keys are allowed to be from 0 to 256 bits in length, in steps
1387 This module provides Serpent cipher algorithm that processes 16
1388 blocks parallel using AVX2 instruction set.
1391 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1394 tristate "TEA, XTEA and XETA cipher algorithms"
1395 select CRYPTO_ALGAPI
1397 TEA cipher algorithm.
1399 Tiny Encryption Algorithm is a simple cipher that uses
1400 many rounds for security. It is very fast and uses
1403 Xtendend Tiny Encryption Algorithm is a modification to
1404 the TEA algorithm to address a potential key weakness
1405 in the TEA algorithm.
1407 Xtendend Encryption Tiny Algorithm is a mis-implementation
1408 of the XTEA algorithm for compatibility purposes.
1410 config CRYPTO_TWOFISH
1411 tristate "Twofish cipher algorithm"
1412 select CRYPTO_ALGAPI
1413 select CRYPTO_TWOFISH_COMMON
1415 Twofish cipher algorithm.
1417 Twofish was submitted as an AES (Advanced Encryption Standard)
1418 candidate cipher by researchers at CounterPane Systems. It is a
1419 16 round block cipher supporting key sizes of 128, 192, and 256
1423 <http://www.schneier.com/twofish.html>
1425 config CRYPTO_TWOFISH_COMMON
1428 Common parts of the Twofish cipher algorithm shared by the
1429 generic c and the assembler implementations.
1431 config CRYPTO_TWOFISH_586
1432 tristate "Twofish cipher algorithms (i586)"
1433 depends on (X86 || UML_X86) && !64BIT
1434 select CRYPTO_ALGAPI
1435 select CRYPTO_TWOFISH_COMMON
1437 Twofish cipher algorithm.
1439 Twofish was submitted as an AES (Advanced Encryption Standard)
1440 candidate cipher by researchers at CounterPane Systems. It is a
1441 16 round block cipher supporting key sizes of 128, 192, and 256
1445 <http://www.schneier.com/twofish.html>
1447 config CRYPTO_TWOFISH_X86_64
1448 tristate "Twofish cipher algorithm (x86_64)"
1449 depends on (X86 || UML_X86) && 64BIT
1450 select CRYPTO_ALGAPI
1451 select CRYPTO_TWOFISH_COMMON
1453 Twofish cipher algorithm (x86_64).
1455 Twofish was submitted as an AES (Advanced Encryption Standard)
1456 candidate cipher by researchers at CounterPane Systems. It is a
1457 16 round block cipher supporting key sizes of 128, 192, and 256
1461 <http://www.schneier.com/twofish.html>
1463 config CRYPTO_TWOFISH_X86_64_3WAY
1464 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1465 depends on X86 && 64BIT
1466 select CRYPTO_ALGAPI
1467 select CRYPTO_TWOFISH_COMMON
1468 select CRYPTO_TWOFISH_X86_64
1469 select CRYPTO_GLUE_HELPER_X86
1473 Twofish cipher algorithm (x86_64, 3-way parallel).
1475 Twofish was submitted as an AES (Advanced Encryption Standard)
1476 candidate cipher by researchers at CounterPane Systems. It is a
1477 16 round block cipher supporting key sizes of 128, 192, and 256
1480 This module provides Twofish cipher algorithm that processes three
1481 blocks parallel, utilizing resources of out-of-order CPUs better.
1484 <http://www.schneier.com/twofish.html>
1486 config CRYPTO_TWOFISH_AVX_X86_64
1487 tristate "Twofish cipher algorithm (x86_64/AVX)"
1488 depends on X86 && 64BIT
1489 select CRYPTO_ALGAPI
1490 select CRYPTO_CRYPTD
1491 select CRYPTO_ABLK_HELPER
1492 select CRYPTO_GLUE_HELPER_X86
1493 select CRYPTO_TWOFISH_COMMON
1494 select CRYPTO_TWOFISH_X86_64
1495 select CRYPTO_TWOFISH_X86_64_3WAY
1499 Twofish cipher algorithm (x86_64/AVX).
1501 Twofish was submitted as an AES (Advanced Encryption Standard)
1502 candidate cipher by researchers at CounterPane Systems. It is a
1503 16 round block cipher supporting key sizes of 128, 192, and 256
1506 This module provides the Twofish cipher algorithm that processes
1507 eight blocks parallel using the AVX Instruction Set.
1510 <http://www.schneier.com/twofish.html>
1512 comment "Compression"
1514 config CRYPTO_DEFLATE
1515 tristate "Deflate compression algorithm"
1516 select CRYPTO_ALGAPI
1520 This is the Deflate algorithm (RFC1951), specified for use in
1521 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1523 You will most probably want this if using IPSec.
1526 tristate "Zlib compression algorithm"
1532 This is the zlib algorithm.
1535 tristate "LZO compression algorithm"
1536 select CRYPTO_ALGAPI
1538 select LZO_DECOMPRESS
1540 This is the LZO algorithm.
1543 tristate "842 compression algorithm"
1544 select CRYPTO_ALGAPI
1546 select 842_DECOMPRESS
1548 This is the 842 algorithm.
1551 tristate "LZ4 compression algorithm"
1552 select CRYPTO_ALGAPI
1554 select LZ4_DECOMPRESS
1556 This is the LZ4 algorithm.
1559 tristate "LZ4HC compression algorithm"
1560 select CRYPTO_ALGAPI
1561 select LZ4HC_COMPRESS
1562 select LZ4_DECOMPRESS
1564 This is the LZ4 high compression mode algorithm.
1566 comment "Random Number Generation"
1568 config CRYPTO_ANSI_CPRNG
1569 tristate "Pseudo Random Number Generation for Cryptographic modules"
1573 This option enables the generic pseudo random number generator
1574 for cryptographic modules. Uses the Algorithm specified in
1575 ANSI X9.31 A.2.4. Note that this option must be enabled if
1576 CRYPTO_FIPS is selected
1578 menuconfig CRYPTO_DRBG_MENU
1579 tristate "NIST SP800-90A DRBG"
1581 NIST SP800-90A compliant DRBG. In the following submenu, one or
1582 more of the DRBG types must be selected.
1586 config CRYPTO_DRBG_HMAC
1590 select CRYPTO_SHA256
1592 config CRYPTO_DRBG_HASH
1593 bool "Enable Hash DRBG"
1594 select CRYPTO_SHA256
1596 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1598 config CRYPTO_DRBG_CTR
1599 bool "Enable CTR DRBG"
1602 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1606 default CRYPTO_DRBG_MENU
1608 select CRYPTO_JITTERENTROPY
1610 endif # if CRYPTO_DRBG_MENU
1612 config CRYPTO_JITTERENTROPY
1613 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1615 The Jitterentropy RNG is a noise that is intended
1616 to provide seed to another RNG. The RNG does not
1617 perform any cryptographic whitening of the generated
1618 random numbers. This Jitterentropy RNG registers with
1619 the kernel crypto API and can be used by any caller.
1621 config CRYPTO_USER_API
1624 config CRYPTO_USER_API_HASH
1625 tristate "User-space interface for hash algorithms"
1628 select CRYPTO_USER_API
1630 This option enables the user-spaces interface for hash
1633 config CRYPTO_USER_API_SKCIPHER
1634 tristate "User-space interface for symmetric key cipher algorithms"
1636 select CRYPTO_BLKCIPHER
1637 select CRYPTO_USER_API
1639 This option enables the user-spaces interface for symmetric
1640 key cipher algorithms.
1642 config CRYPTO_USER_API_RNG
1643 tristate "User-space interface for random number generator algorithms"
1646 select CRYPTO_USER_API
1648 This option enables the user-spaces interface for random
1649 number generator algorithms.
1651 config CRYPTO_USER_API_AEAD
1652 tristate "User-space interface for AEAD cipher algorithms"
1655 select CRYPTO_USER_API
1657 This option enables the user-spaces interface for AEAD
1660 config CRYPTO_HASH_INFO
1663 source "drivers/crypto/Kconfig"
1664 source crypto/asymmetric_keys/Kconfig
1665 source certs/Kconfig