1 # SPDX-License-Identifier: GPL-2.0
3 # Generic algorithms support
9 # async_tx api: hardware offloaded memory transfer/transform support
11 source "crypto/async_tx/Kconfig"
14 # Cryptographic API Configuration
17 tristate "Cryptographic API"
19 This option provides the core Cryptographic API.
23 comment "Crypto core or helper"
26 bool "FIPS 200 compliance"
27 depends on (CRYPTO_ANSI_CPRNG || CRYPTO_DRBG) && !CRYPTO_MANAGER_DISABLE_TESTS
28 depends on (MODULE_SIG || !MODULES)
30 This options enables the fips boot option which is
31 required if you want to system to operate in a FIPS 200
32 certification. You should say no unless you know what
39 This option provides the API for cryptographic algorithms.
55 config CRYPTO_BLKCIPHER
57 select CRYPTO_BLKCIPHER2
60 config CRYPTO_BLKCIPHER2
64 select CRYPTO_WORKQUEUE
84 config CRYPTO_RNG_DEFAULT
86 select CRYPTO_DRBG_MENU
88 config CRYPTO_AKCIPHER2
92 config CRYPTO_AKCIPHER
94 select CRYPTO_AKCIPHER2
108 select CRYPTO_ALGAPI2
117 tristate "RSA algorithm"
118 select CRYPTO_AKCIPHER
119 select CRYPTO_MANAGER
123 Generic implementation of the RSA public key algorithm.
126 tristate "Diffie-Hellman algorithm"
130 Generic implementation of the Diffie-Hellman algorithm.
133 tristate "ECDH algorithm"
135 select CRYPTO_RNG_DEFAULT
137 Generic implementation of the ECDH algorithm
139 config CRYPTO_MANAGER
140 tristate "Cryptographic algorithm manager"
141 select CRYPTO_MANAGER2
143 Create default cryptographic template instantiations such as
146 config CRYPTO_MANAGER2
147 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
150 select CRYPTO_BLKCIPHER2
151 select CRYPTO_AKCIPHER2
156 tristate "Userspace cryptographic algorithm configuration"
158 select CRYPTO_MANAGER
160 Userspace configuration for cryptographic instantiations such as
163 config CRYPTO_MANAGER_DISABLE_TESTS
164 bool "Disable run-time self tests"
166 depends on CRYPTO_MANAGER2
168 Disable run-time self tests that normally take place at
169 algorithm registration.
171 config CRYPTO_GF128MUL
172 tristate "GF(2^128) multiplication functions"
174 Efficient table driven implementation of multiplications in the
175 field GF(2^128). This is needed by some cypher modes. This
176 option will be selected automatically if you select such a
177 cipher mode. Only select this option by hand if you expect to load
178 an external module that requires these functions.
181 tristate "Null algorithms"
184 These are 'Null' algorithms, used by IPsec, which do nothing.
188 select CRYPTO_ALGAPI2
189 select CRYPTO_BLKCIPHER2
193 tristate "Parallel crypto engine"
196 select CRYPTO_MANAGER
199 This converts an arbitrary crypto algorithm into a parallel
200 algorithm that executes in kernel threads.
202 config CRYPTO_WORKQUEUE
206 tristate "Software async crypto daemon"
207 select CRYPTO_BLKCIPHER
209 select CRYPTO_MANAGER
210 select CRYPTO_WORKQUEUE
212 This is a generic software asynchronous crypto daemon that
213 converts an arbitrary synchronous software crypto algorithm
214 into an asynchronous algorithm that executes in a kernel thread.
216 config CRYPTO_MCRYPTD
217 tristate "Software async multi-buffer crypto daemon"
218 select CRYPTO_BLKCIPHER
220 select CRYPTO_MANAGER
221 select CRYPTO_WORKQUEUE
223 This is a generic software asynchronous crypto daemon that
224 provides the kernel thread to assist multi-buffer crypto
225 algorithms for submitting jobs and flushing jobs in multi-buffer
226 crypto algorithms. Multi-buffer crypto algorithms are executed
227 in the context of this kernel thread and drivers can post
228 their crypto request asynchronously to be processed by this daemon.
230 config CRYPTO_AUTHENC
231 tristate "Authenc support"
233 select CRYPTO_BLKCIPHER
234 select CRYPTO_MANAGER
238 Authenc: Combined mode wrapper for IPsec.
239 This is required for IPSec.
242 tristate "Testing module"
244 select CRYPTO_MANAGER
246 Quick & dirty crypto test module.
248 config CRYPTO_ABLK_HELPER
256 config CRYPTO_GLUE_HELPER_X86
259 select CRYPTO_BLKCIPHER
264 comment "Authenticated Encryption with Associated Data"
267 tristate "CCM support"
272 Support for Counter with CBC MAC. Required for IPsec.
275 tristate "GCM/GMAC support"
281 Support for Galois/Counter Mode (GCM) and Galois Message
282 Authentication Code (GMAC). Required for IPSec.
284 config CRYPTO_CHACHA20POLY1305
285 tristate "ChaCha20-Poly1305 AEAD support"
286 select CRYPTO_CHACHA20
287 select CRYPTO_POLY1305
290 ChaCha20-Poly1305 AEAD support, RFC7539.
292 Support for the AEAD wrapper using the ChaCha20 stream cipher combined
293 with the Poly1305 authenticator. It is defined in RFC7539 for use in
297 tristate "Sequence Number IV Generator"
299 select CRYPTO_BLKCIPHER
301 select CRYPTO_RNG_DEFAULT
303 This IV generator generates an IV based on a sequence number by
304 xoring it with a salt. This algorithm is mainly useful for CTR
306 config CRYPTO_ECHAINIV
307 tristate "Encrypted Chain IV Generator"
310 select CRYPTO_RNG_DEFAULT
313 This IV generator generates an IV based on the encryption of
314 a sequence number xored with a salt. This is the default
317 comment "Block modes"
320 tristate "CBC support"
321 select CRYPTO_BLKCIPHER
322 select CRYPTO_MANAGER
324 CBC: Cipher Block Chaining mode
325 This block cipher algorithm is required for IPSec.
328 tristate "CTR support"
329 select CRYPTO_BLKCIPHER
331 select CRYPTO_MANAGER
334 This block cipher algorithm is required for IPSec.
337 tristate "CTS support"
338 select CRYPTO_BLKCIPHER
340 CTS: Cipher Text Stealing
341 This is the Cipher Text Stealing mode as described by
342 Section 8 of rfc2040 and referenced by rfc3962.
343 (rfc3962 includes errata information in its Appendix A)
344 This mode is required for Kerberos gss mechanism support
348 tristate "ECB support"
349 select CRYPTO_BLKCIPHER
350 select CRYPTO_MANAGER
352 ECB: Electronic CodeBook mode
353 This is the simplest block cipher algorithm. It simply encrypts
354 the input block by block.
357 tristate "LRW support"
358 select CRYPTO_BLKCIPHER
359 select CRYPTO_MANAGER
360 select CRYPTO_GF128MUL
362 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
363 narrow block cipher mode for dm-crypt. Use it with cipher
364 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
365 The first 128, 192 or 256 bits in the key are used for AES and the
366 rest is used to tie each cipher block to its logical position.
369 tristate "PCBC support"
370 select CRYPTO_BLKCIPHER
371 select CRYPTO_MANAGER
373 PCBC: Propagating Cipher Block Chaining mode
374 This block cipher algorithm is required for RxRPC.
377 tristate "XTS support"
378 select CRYPTO_BLKCIPHER
379 select CRYPTO_MANAGER
382 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
383 key size 256, 384 or 512 bits. This implementation currently
384 can't handle a sectorsize which is not a multiple of 16 bytes.
386 config CRYPTO_KEYWRAP
387 tristate "Key wrapping support"
388 select CRYPTO_BLKCIPHER
390 Support for key wrapping (NIST SP800-38F / RFC3394) without
396 tristate "CMAC support"
398 select CRYPTO_MANAGER
400 Cipher-based Message Authentication Code (CMAC) specified by
401 The National Institute of Standards and Technology (NIST).
403 https://tools.ietf.org/html/rfc4493
404 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
407 tristate "HMAC support"
409 select CRYPTO_MANAGER
411 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
412 This is required for IPSec.
415 tristate "XCBC support"
417 select CRYPTO_MANAGER
419 XCBC: Keyed-Hashing with encryption algorithm
420 http://www.ietf.org/rfc/rfc3566.txt
421 http://csrc.nist.gov/encryption/modes/proposedmodes/
422 xcbc-mac/xcbc-mac-spec.pdf
425 tristate "VMAC support"
427 select CRYPTO_MANAGER
429 VMAC is a message authentication algorithm designed for
430 very high speed on 64-bit architectures.
433 <http://fastcrypto.org/vmac>
438 tristate "CRC32c CRC algorithm"
442 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
443 by iSCSI for header and data digests and by others.
444 See Castagnoli93. Module will be crc32c.
446 config CRYPTO_CRC32C_INTEL
447 tristate "CRC32c INTEL hardware acceleration"
451 In Intel processor with SSE4.2 supported, the processor will
452 support CRC32C implementation using hardware accelerated CRC32
453 instruction. This option will create 'crc32c-intel' module,
454 which will enable any routine to use the CRC32 instruction to
455 gain performance compared with software implementation.
456 Module will be crc32c-intel.
458 config CRYPTO_CRC32C_VPMSUM
459 tristate "CRC32c CRC algorithm (powerpc64)"
460 depends on PPC64 && ALTIVEC
464 CRC32c algorithm implemented using vector polynomial multiply-sum
465 (vpmsum) instructions, introduced in POWER8. Enable on POWER8
466 and newer processors for improved performance.
469 config CRYPTO_CRC32C_SPARC64
470 tristate "CRC32c CRC algorithm (SPARC64)"
475 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
479 tristate "CRC32 CRC algorithm"
483 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
484 Shash crypto api wrappers to crc32_le function.
486 config CRYPTO_CRC32_PCLMUL
487 tristate "CRC32 PCLMULQDQ hardware acceleration"
492 From Intel Westmere and AMD Bulldozer processor with SSE4.2
493 and PCLMULQDQ supported, the processor will support
494 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
495 instruction. This option will create 'crc32-plcmul' module,
496 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
497 and gain better performance as compared with the table implementation.
499 config CRYPTO_CRCT10DIF
500 tristate "CRCT10DIF algorithm"
503 CRC T10 Data Integrity Field computation is being cast as
504 a crypto transform. This allows for faster crc t10 diff
505 transforms to be used if they are available.
507 config CRYPTO_CRCT10DIF_PCLMUL
508 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
509 depends on X86 && 64BIT && CRC_T10DIF
512 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
513 CRC T10 DIF PCLMULQDQ computation can be hardware
514 accelerated PCLMULQDQ instruction. This option will create
515 'crct10dif-plcmul' module, which is faster when computing the
516 crct10dif checksum as compared with the generic table implementation.
518 config CRYPTO_CRCT10DIF_VPMSUM
519 tristate "CRC32T10DIF powerpc64 hardware acceleration"
520 depends on PPC64 && ALTIVEC && CRC_T10DIF
523 CRC10T10DIF algorithm implemented using vector polynomial
524 multiply-sum (vpmsum) instructions, introduced in POWER8. Enable on
525 POWER8 and newer processors for improved performance.
527 config CRYPTO_VPMSUM_TESTER
528 tristate "Powerpc64 vpmsum hardware acceleration tester"
529 depends on CRYPTO_CRCT10DIF_VPMSUM && CRYPTO_CRC32C_VPMSUM
531 Stress test for CRC32c and CRC-T10DIF algorithms implemented with
532 POWER8 vpmsum instructions.
533 Unless you are testing these algorithms, you don't need this.
536 tristate "GHASH digest algorithm"
537 select CRYPTO_GF128MUL
540 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
542 config CRYPTO_POLY1305
543 tristate "Poly1305 authenticator algorithm"
546 Poly1305 authenticator algorithm, RFC7539.
548 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
549 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
550 in IETF protocols. This is the portable C implementation of Poly1305.
552 config CRYPTO_POLY1305_X86_64
553 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
554 depends on X86 && 64BIT
555 select CRYPTO_POLY1305
557 Poly1305 authenticator algorithm, RFC7539.
559 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
560 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
561 in IETF protocols. This is the x86_64 assembler implementation using SIMD
565 tristate "MD4 digest algorithm"
568 MD4 message digest algorithm (RFC1320).
571 tristate "MD5 digest algorithm"
574 MD5 message digest algorithm (RFC1321).
576 config CRYPTO_MD5_OCTEON
577 tristate "MD5 digest algorithm (OCTEON)"
578 depends on CPU_CAVIUM_OCTEON
582 MD5 message digest algorithm (RFC1321) implemented
583 using OCTEON crypto instructions, when available.
585 config CRYPTO_MD5_PPC
586 tristate "MD5 digest algorithm (PPC)"
590 MD5 message digest algorithm (RFC1321) implemented
593 config CRYPTO_MD5_SPARC64
594 tristate "MD5 digest algorithm (SPARC64)"
599 MD5 message digest algorithm (RFC1321) implemented
600 using sparc64 crypto instructions, when available.
602 config CRYPTO_MICHAEL_MIC
603 tristate "Michael MIC keyed digest algorithm"
606 Michael MIC is used for message integrity protection in TKIP
607 (IEEE 802.11i). This algorithm is required for TKIP, but it
608 should not be used for other purposes because of the weakness
612 tristate "RIPEMD-128 digest algorithm"
615 RIPEMD-128 (ISO/IEC 10118-3:2004).
617 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
618 be used as a secure replacement for RIPEMD. For other use cases,
619 RIPEMD-160 should be used.
621 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
622 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
625 tristate "RIPEMD-160 digest algorithm"
628 RIPEMD-160 (ISO/IEC 10118-3:2004).
630 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
631 to be used as a secure replacement for the 128-bit hash functions
632 MD4, MD5 and it's predecessor RIPEMD
633 (not to be confused with RIPEMD-128).
635 It's speed is comparable to SHA1 and there are no known attacks
638 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
639 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
642 tristate "RIPEMD-256 digest algorithm"
645 RIPEMD-256 is an optional extension of RIPEMD-128 with a
646 256 bit hash. It is intended for applications that require
647 longer hash-results, without needing a larger security level
650 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
651 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
654 tristate "RIPEMD-320 digest algorithm"
657 RIPEMD-320 is an optional extension of RIPEMD-160 with a
658 320 bit hash. It is intended for applications that require
659 longer hash-results, without needing a larger security level
662 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
663 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
666 tristate "SHA1 digest algorithm"
669 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
671 config CRYPTO_SHA1_SSSE3
672 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
673 depends on X86 && 64BIT
677 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
678 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
679 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
682 config CRYPTO_SHA256_SSSE3
683 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
684 depends on X86 && 64BIT
688 SHA-256 secure hash standard (DFIPS 180-2) implemented
689 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
690 Extensions version 1 (AVX1), or Advanced Vector Extensions
691 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
692 Instructions) when available.
694 config CRYPTO_SHA512_SSSE3
695 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
696 depends on X86 && 64BIT
700 SHA-512 secure hash standard (DFIPS 180-2) implemented
701 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
702 Extensions version 1 (AVX1), or Advanced Vector Extensions
703 version 2 (AVX2) instructions, when available.
705 config CRYPTO_SHA1_OCTEON
706 tristate "SHA1 digest algorithm (OCTEON)"
707 depends on CPU_CAVIUM_OCTEON
711 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
712 using OCTEON crypto instructions, when available.
714 config CRYPTO_SHA1_SPARC64
715 tristate "SHA1 digest algorithm (SPARC64)"
720 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
721 using sparc64 crypto instructions, when available.
723 config CRYPTO_SHA1_PPC
724 tristate "SHA1 digest algorithm (powerpc)"
727 This is the powerpc hardware accelerated implementation of the
728 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
730 config CRYPTO_SHA1_PPC_SPE
731 tristate "SHA1 digest algorithm (PPC SPE)"
732 depends on PPC && SPE
734 SHA-1 secure hash standard (DFIPS 180-4) implemented
735 using powerpc SPE SIMD instruction set.
737 config CRYPTO_SHA1_MB
738 tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
739 depends on X86 && 64BIT
742 select CRYPTO_MCRYPTD
744 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
745 using multi-buffer technique. This algorithm computes on
746 multiple data lanes concurrently with SIMD instructions for
747 better throughput. It should not be enabled by default but
748 used when there is significant amount of work to keep the keep
749 the data lanes filled to get performance benefit. If the data
750 lanes remain unfilled, a flush operation will be initiated to
751 process the crypto jobs, adding a slight latency.
753 config CRYPTO_SHA256_MB
754 tristate "SHA256 digest algorithm (x86_64 Multi-Buffer, Experimental)"
755 depends on X86 && 64BIT
758 select CRYPTO_MCRYPTD
760 SHA-256 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
761 using multi-buffer technique. This algorithm computes on
762 multiple data lanes concurrently with SIMD instructions for
763 better throughput. It should not be enabled by default but
764 used when there is significant amount of work to keep the keep
765 the data lanes filled to get performance benefit. If the data
766 lanes remain unfilled, a flush operation will be initiated to
767 process the crypto jobs, adding a slight latency.
769 config CRYPTO_SHA512_MB
770 tristate "SHA512 digest algorithm (x86_64 Multi-Buffer, Experimental)"
771 depends on X86 && 64BIT
774 select CRYPTO_MCRYPTD
776 SHA-512 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
777 using multi-buffer technique. This algorithm computes on
778 multiple data lanes concurrently with SIMD instructions for
779 better throughput. It should not be enabled by default but
780 used when there is significant amount of work to keep the keep
781 the data lanes filled to get performance benefit. If the data
782 lanes remain unfilled, a flush operation will be initiated to
783 process the crypto jobs, adding a slight latency.
786 tristate "SHA224 and SHA256 digest algorithm"
789 SHA256 secure hash standard (DFIPS 180-2).
791 This version of SHA implements a 256 bit hash with 128 bits of
792 security against collision attacks.
794 This code also includes SHA-224, a 224 bit hash with 112 bits
795 of security against collision attacks.
797 config CRYPTO_SHA256_PPC_SPE
798 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
799 depends on PPC && SPE
803 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
804 implemented using powerpc SPE SIMD instruction set.
806 config CRYPTO_SHA256_OCTEON
807 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
808 depends on CPU_CAVIUM_OCTEON
812 SHA-256 secure hash standard (DFIPS 180-2) implemented
813 using OCTEON crypto instructions, when available.
815 config CRYPTO_SHA256_SPARC64
816 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
821 SHA-256 secure hash standard (DFIPS 180-2) implemented
822 using sparc64 crypto instructions, when available.
825 tristate "SHA384 and SHA512 digest algorithms"
828 SHA512 secure hash standard (DFIPS 180-2).
830 This version of SHA implements a 512 bit hash with 256 bits of
831 security against collision attacks.
833 This code also includes SHA-384, a 384 bit hash with 192 bits
834 of security against collision attacks.
836 config CRYPTO_SHA512_OCTEON
837 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
838 depends on CPU_CAVIUM_OCTEON
842 SHA-512 secure hash standard (DFIPS 180-2) implemented
843 using OCTEON crypto instructions, when available.
845 config CRYPTO_SHA512_SPARC64
846 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
851 SHA-512 secure hash standard (DFIPS 180-2) implemented
852 using sparc64 crypto instructions, when available.
855 tristate "SHA3 digest algorithm"
858 SHA-3 secure hash standard (DFIPS 202). It's based on
859 cryptographic sponge function family called Keccak.
862 http://keccak.noekeon.org/
865 tristate "SM3 digest algorithm"
868 SM3 secure hash function as defined by OSCCA GM/T 0004-2012 SM3).
869 It is part of the Chinese Commercial Cryptography suite.
872 http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
873 https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
876 tristate "Tiger digest algorithms"
879 Tiger hash algorithm 192, 160 and 128-bit hashes
881 Tiger is a hash function optimized for 64-bit processors while
882 still having decent performance on 32-bit processors.
883 Tiger was developed by Ross Anderson and Eli Biham.
886 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
889 tristate "Whirlpool digest algorithms"
892 Whirlpool hash algorithm 512, 384 and 256-bit hashes
894 Whirlpool-512 is part of the NESSIE cryptographic primitives.
895 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
898 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
900 config CRYPTO_GHASH_CLMUL_NI_INTEL
901 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
902 depends on X86 && 64BIT
905 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
906 The implementation is accelerated by CLMUL-NI of Intel.
911 tristate "AES cipher algorithms"
914 AES cipher algorithms (FIPS-197). AES uses the Rijndael
917 Rijndael appears to be consistently a very good performer in
918 both hardware and software across a wide range of computing
919 environments regardless of its use in feedback or non-feedback
920 modes. Its key setup time is excellent, and its key agility is
921 good. Rijndael's very low memory requirements make it very well
922 suited for restricted-space environments, in which it also
923 demonstrates excellent performance. Rijndael's operations are
924 among the easiest to defend against power and timing attacks.
926 The AES specifies three key sizes: 128, 192 and 256 bits
928 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
931 tristate "Fixed time AES cipher"
934 This is a generic implementation of AES that attempts to eliminate
935 data dependent latencies as much as possible without affecting
936 performance too much. It is intended for use by the generic CCM
937 and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
938 solely on encryption (although decryption is supported as well, but
939 with a more dramatic performance hit)
941 Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
942 8 for decryption), this implementation only uses just two S-boxes of
943 256 bytes each, and attempts to eliminate data dependent latencies by
944 prefetching the entire table into the cache at the start of each
947 config CRYPTO_AES_586
948 tristate "AES cipher algorithms (i586)"
949 depends on (X86 || UML_X86) && !64BIT
953 AES cipher algorithms (FIPS-197). AES uses the Rijndael
956 Rijndael appears to be consistently a very good performer in
957 both hardware and software across a wide range of computing
958 environments regardless of its use in feedback or non-feedback
959 modes. Its key setup time is excellent, and its key agility is
960 good. Rijndael's very low memory requirements make it very well
961 suited for restricted-space environments, in which it also
962 demonstrates excellent performance. Rijndael's operations are
963 among the easiest to defend against power and timing attacks.
965 The AES specifies three key sizes: 128, 192 and 256 bits
967 See <http://csrc.nist.gov/encryption/aes/> for more information.
969 config CRYPTO_AES_X86_64
970 tristate "AES cipher algorithms (x86_64)"
971 depends on (X86 || UML_X86) && 64BIT
975 AES cipher algorithms (FIPS-197). AES uses the Rijndael
978 Rijndael appears to be consistently a very good performer in
979 both hardware and software across a wide range of computing
980 environments regardless of its use in feedback or non-feedback
981 modes. Its key setup time is excellent, and its key agility is
982 good. Rijndael's very low memory requirements make it very well
983 suited for restricted-space environments, in which it also
984 demonstrates excellent performance. Rijndael's operations are
985 among the easiest to defend against power and timing attacks.
987 The AES specifies three key sizes: 128, 192 and 256 bits
989 See <http://csrc.nist.gov/encryption/aes/> for more information.
991 config CRYPTO_AES_NI_INTEL
992 tristate "AES cipher algorithms (AES-NI)"
995 select CRYPTO_AES_X86_64 if 64BIT
996 select CRYPTO_AES_586 if !64BIT
998 select CRYPTO_BLKCIPHER
999 select CRYPTO_GLUE_HELPER_X86 if 64BIT
1002 Use Intel AES-NI instructions for AES algorithm.
1004 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1007 Rijndael appears to be consistently a very good performer in
1008 both hardware and software across a wide range of computing
1009 environments regardless of its use in feedback or non-feedback
1010 modes. Its key setup time is excellent, and its key agility is
1011 good. Rijndael's very low memory requirements make it very well
1012 suited for restricted-space environments, in which it also
1013 demonstrates excellent performance. Rijndael's operations are
1014 among the easiest to defend against power and timing attacks.
1016 The AES specifies three key sizes: 128, 192 and 256 bits
1018 See <http://csrc.nist.gov/encryption/aes/> for more information.
1020 In addition to AES cipher algorithm support, the acceleration
1021 for some popular block cipher mode is supported too, including
1022 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
1023 acceleration for CTR.
1025 config CRYPTO_AES_SPARC64
1026 tristate "AES cipher algorithms (SPARC64)"
1028 select CRYPTO_CRYPTD
1029 select CRYPTO_ALGAPI
1031 Use SPARC64 crypto opcodes for AES algorithm.
1033 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1036 Rijndael appears to be consistently a very good performer in
1037 both hardware and software across a wide range of computing
1038 environments regardless of its use in feedback or non-feedback
1039 modes. Its key setup time is excellent, and its key agility is
1040 good. Rijndael's very low memory requirements make it very well
1041 suited for restricted-space environments, in which it also
1042 demonstrates excellent performance. Rijndael's operations are
1043 among the easiest to defend against power and timing attacks.
1045 The AES specifies three key sizes: 128, 192 and 256 bits
1047 See <http://csrc.nist.gov/encryption/aes/> for more information.
1049 In addition to AES cipher algorithm support, the acceleration
1050 for some popular block cipher mode is supported too, including
1053 config CRYPTO_AES_PPC_SPE
1054 tristate "AES cipher algorithms (PPC SPE)"
1055 depends on PPC && SPE
1057 AES cipher algorithms (FIPS-197). Additionally the acceleration
1058 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
1059 This module should only be used for low power (router) devices
1060 without hardware AES acceleration (e.g. caam crypto). It reduces the
1061 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
1062 timining attacks. Nevertheless it might be not as secure as other
1063 architecture specific assembler implementations that work on 1KB
1064 tables or 256 bytes S-boxes.
1066 config CRYPTO_ANUBIS
1067 tristate "Anubis cipher algorithm"
1068 select CRYPTO_ALGAPI
1070 Anubis cipher algorithm.
1072 Anubis is a variable key length cipher which can use keys from
1073 128 bits to 320 bits in length. It was evaluated as a entrant
1074 in the NESSIE competition.
1077 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1078 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1081 tristate "ARC4 cipher algorithm"
1082 select CRYPTO_BLKCIPHER
1084 ARC4 cipher algorithm.
1086 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1087 bits in length. This algorithm is required for driver-based
1088 WEP, but it should not be for other purposes because of the
1089 weakness of the algorithm.
1091 config CRYPTO_BLOWFISH
1092 tristate "Blowfish cipher algorithm"
1093 select CRYPTO_ALGAPI
1094 select CRYPTO_BLOWFISH_COMMON
1096 Blowfish cipher algorithm, by Bruce Schneier.
1098 This is a variable key length cipher which can use keys from 32
1099 bits to 448 bits in length. It's fast, simple and specifically
1100 designed for use on "large microprocessors".
1103 <http://www.schneier.com/blowfish.html>
1105 config CRYPTO_BLOWFISH_COMMON
1108 Common parts of the Blowfish cipher algorithm shared by the
1109 generic c and the assembler implementations.
1112 <http://www.schneier.com/blowfish.html>
1114 config CRYPTO_BLOWFISH_X86_64
1115 tristate "Blowfish cipher algorithm (x86_64)"
1116 depends on X86 && 64BIT
1117 select CRYPTO_BLKCIPHER
1118 select CRYPTO_BLOWFISH_COMMON
1120 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1122 This is a variable key length cipher which can use keys from 32
1123 bits to 448 bits in length. It's fast, simple and specifically
1124 designed for use on "large microprocessors".
1127 <http://www.schneier.com/blowfish.html>
1129 config CRYPTO_CAMELLIA
1130 tristate "Camellia cipher algorithms"
1132 select CRYPTO_ALGAPI
1134 Camellia cipher algorithms module.
1136 Camellia is a symmetric key block cipher developed jointly
1137 at NTT and Mitsubishi Electric Corporation.
1139 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1142 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1144 config CRYPTO_CAMELLIA_X86_64
1145 tristate "Camellia cipher algorithm (x86_64)"
1146 depends on X86 && 64BIT
1148 select CRYPTO_ALGAPI
1149 select CRYPTO_GLUE_HELPER_X86
1151 Camellia cipher algorithm module (x86_64).
1153 Camellia is a symmetric key block cipher developed jointly
1154 at NTT and Mitsubishi Electric Corporation.
1156 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1159 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1161 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1162 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1163 depends on X86 && 64BIT
1165 select CRYPTO_ALGAPI
1166 select CRYPTO_CRYPTD
1167 select CRYPTO_ABLK_HELPER
1168 select CRYPTO_GLUE_HELPER_X86
1169 select CRYPTO_CAMELLIA_X86_64
1172 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1174 Camellia is a symmetric key block cipher developed jointly
1175 at NTT and Mitsubishi Electric Corporation.
1177 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1180 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1182 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1183 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1184 depends on X86 && 64BIT
1186 select CRYPTO_ALGAPI
1187 select CRYPTO_CRYPTD
1188 select CRYPTO_ABLK_HELPER
1189 select CRYPTO_GLUE_HELPER_X86
1190 select CRYPTO_CAMELLIA_X86_64
1191 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1194 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1196 Camellia is a symmetric key block cipher developed jointly
1197 at NTT and Mitsubishi Electric Corporation.
1199 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1202 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1204 config CRYPTO_CAMELLIA_SPARC64
1205 tristate "Camellia cipher algorithm (SPARC64)"
1208 select CRYPTO_ALGAPI
1210 Camellia cipher algorithm module (SPARC64).
1212 Camellia is a symmetric key block cipher developed jointly
1213 at NTT and Mitsubishi Electric Corporation.
1215 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1218 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1220 config CRYPTO_CAST_COMMON
1223 Common parts of the CAST cipher algorithms shared by the
1224 generic c and the assembler implementations.
1227 tristate "CAST5 (CAST-128) cipher algorithm"
1228 select CRYPTO_ALGAPI
1229 select CRYPTO_CAST_COMMON
1231 The CAST5 encryption algorithm (synonymous with CAST-128) is
1232 described in RFC2144.
1234 config CRYPTO_CAST5_AVX_X86_64
1235 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1236 depends on X86 && 64BIT
1237 select CRYPTO_BLKCIPHER
1239 select CRYPTO_CAST_COMMON
1242 The CAST5 encryption algorithm (synonymous with CAST-128) is
1243 described in RFC2144.
1245 This module provides the Cast5 cipher algorithm that processes
1246 sixteen blocks parallel using the AVX instruction set.
1249 tristate "CAST6 (CAST-256) cipher algorithm"
1250 select CRYPTO_ALGAPI
1251 select CRYPTO_CAST_COMMON
1253 The CAST6 encryption algorithm (synonymous with CAST-256) is
1254 described in RFC2612.
1256 config CRYPTO_CAST6_AVX_X86_64
1257 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1258 depends on X86 && 64BIT
1259 select CRYPTO_BLKCIPHER
1261 select CRYPTO_CAST_COMMON
1262 select CRYPTO_GLUE_HELPER_X86
1266 The CAST6 encryption algorithm (synonymous with CAST-256) is
1267 described in RFC2612.
1269 This module provides the Cast6 cipher algorithm that processes
1270 eight blocks parallel using the AVX instruction set.
1273 tristate "DES and Triple DES EDE cipher algorithms"
1274 select CRYPTO_ALGAPI
1276 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1278 config CRYPTO_DES_SPARC64
1279 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1281 select CRYPTO_ALGAPI
1284 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1285 optimized using SPARC64 crypto opcodes.
1287 config CRYPTO_DES3_EDE_X86_64
1288 tristate "Triple DES EDE cipher algorithm (x86-64)"
1289 depends on X86 && 64BIT
1290 select CRYPTO_BLKCIPHER
1293 Triple DES EDE (FIPS 46-3) algorithm.
1295 This module provides implementation of the Triple DES EDE cipher
1296 algorithm that is optimized for x86-64 processors. Two versions of
1297 algorithm are provided; regular processing one input block and
1298 one that processes three blocks parallel.
1300 config CRYPTO_FCRYPT
1301 tristate "FCrypt cipher algorithm"
1302 select CRYPTO_ALGAPI
1303 select CRYPTO_BLKCIPHER
1305 FCrypt algorithm used by RxRPC.
1307 config CRYPTO_KHAZAD
1308 tristate "Khazad cipher algorithm"
1309 select CRYPTO_ALGAPI
1311 Khazad cipher algorithm.
1313 Khazad was a finalist in the initial NESSIE competition. It is
1314 an algorithm optimized for 64-bit processors with good performance
1315 on 32-bit processors. Khazad uses an 128 bit key size.
1318 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1320 config CRYPTO_SALSA20
1321 tristate "Salsa20 stream cipher algorithm"
1322 select CRYPTO_BLKCIPHER
1324 Salsa20 stream cipher algorithm.
1326 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1327 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1329 The Salsa20 stream cipher algorithm is designed by Daniel J.
1330 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1332 config CRYPTO_SALSA20_586
1333 tristate "Salsa20 stream cipher algorithm (i586)"
1334 depends on (X86 || UML_X86) && !64BIT
1335 select CRYPTO_BLKCIPHER
1336 select CRYPTO_SALSA20
1338 Salsa20 stream cipher algorithm.
1340 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1341 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1343 The Salsa20 stream cipher algorithm is designed by Daniel J.
1344 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1346 config CRYPTO_SALSA20_X86_64
1347 tristate "Salsa20 stream cipher algorithm (x86_64)"
1348 depends on (X86 || UML_X86) && 64BIT
1349 select CRYPTO_BLKCIPHER
1350 select CRYPTO_SALSA20
1352 Salsa20 stream cipher algorithm.
1354 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1355 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1357 The Salsa20 stream cipher algorithm is designed by Daniel J.
1358 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1360 config CRYPTO_CHACHA20
1361 tristate "ChaCha20 cipher algorithm"
1362 select CRYPTO_BLKCIPHER
1364 ChaCha20 cipher algorithm, RFC7539.
1366 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1367 Bernstein and further specified in RFC7539 for use in IETF protocols.
1368 This is the portable C implementation of ChaCha20.
1371 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1373 config CRYPTO_CHACHA20_X86_64
1374 tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1375 depends on X86 && 64BIT
1376 select CRYPTO_BLKCIPHER
1377 select CRYPTO_CHACHA20
1379 ChaCha20 cipher algorithm, RFC7539.
1381 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1382 Bernstein and further specified in RFC7539 for use in IETF protocols.
1383 This is the x86_64 assembler implementation using SIMD instructions.
1386 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1389 tristate "SEED cipher algorithm"
1390 select CRYPTO_ALGAPI
1392 SEED cipher algorithm (RFC4269).
1394 SEED is a 128-bit symmetric key block cipher that has been
1395 developed by KISA (Korea Information Security Agency) as a
1396 national standard encryption algorithm of the Republic of Korea.
1397 It is a 16 round block cipher with the key size of 128 bit.
1400 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1402 config CRYPTO_SERPENT
1403 tristate "Serpent cipher algorithm"
1404 select CRYPTO_ALGAPI
1406 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1408 Keys are allowed to be from 0 to 256 bits in length, in steps
1409 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1410 variant of Serpent for compatibility with old kerneli.org code.
1413 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1415 config CRYPTO_SERPENT_SSE2_X86_64
1416 tristate "Serpent cipher algorithm (x86_64/SSE2)"
1417 depends on X86 && 64BIT
1418 select CRYPTO_BLKCIPHER
1419 select CRYPTO_GLUE_HELPER_X86
1420 select CRYPTO_SERPENT
1423 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1425 Keys are allowed to be from 0 to 256 bits in length, in steps
1428 This module provides Serpent cipher algorithm that processes eight
1429 blocks parallel using SSE2 instruction set.
1432 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1434 config CRYPTO_SERPENT_SSE2_586
1435 tristate "Serpent cipher algorithm (i586/SSE2)"
1436 depends on X86 && !64BIT
1437 select CRYPTO_BLKCIPHER
1438 select CRYPTO_GLUE_HELPER_X86
1439 select CRYPTO_SERPENT
1442 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1444 Keys are allowed to be from 0 to 256 bits in length, in steps
1447 This module provides Serpent cipher algorithm that processes four
1448 blocks parallel using SSE2 instruction set.
1451 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1453 config CRYPTO_SERPENT_AVX_X86_64
1454 tristate "Serpent cipher algorithm (x86_64/AVX)"
1455 depends on X86 && 64BIT
1456 select CRYPTO_BLKCIPHER
1457 select CRYPTO_GLUE_HELPER_X86
1458 select CRYPTO_SERPENT
1462 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1464 Keys are allowed to be from 0 to 256 bits in length, in steps
1467 This module provides the Serpent cipher algorithm that processes
1468 eight blocks parallel using the AVX instruction set.
1471 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1473 config CRYPTO_SERPENT_AVX2_X86_64
1474 tristate "Serpent cipher algorithm (x86_64/AVX2)"
1475 depends on X86 && 64BIT
1476 select CRYPTO_SERPENT_AVX_X86_64
1478 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1480 Keys are allowed to be from 0 to 256 bits in length, in steps
1483 This module provides Serpent cipher algorithm that processes 16
1484 blocks parallel using AVX2 instruction set.
1487 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1490 tristate "Speck cipher algorithm"
1491 select CRYPTO_ALGAPI
1493 Speck is a lightweight block cipher that is tuned for optimal
1494 performance in software (rather than hardware).
1496 Speck may not be as secure as AES, and should only be used on systems
1497 where AES is not fast enough.
1499 See also: <https://eprint.iacr.org/2013/404.pdf>
1504 tristate "TEA, XTEA and XETA cipher algorithms"
1505 select CRYPTO_ALGAPI
1507 TEA cipher algorithm.
1509 Tiny Encryption Algorithm is a simple cipher that uses
1510 many rounds for security. It is very fast and uses
1513 Xtendend Tiny Encryption Algorithm is a modification to
1514 the TEA algorithm to address a potential key weakness
1515 in the TEA algorithm.
1517 Xtendend Encryption Tiny Algorithm is a mis-implementation
1518 of the XTEA algorithm for compatibility purposes.
1520 config CRYPTO_TWOFISH
1521 tristate "Twofish cipher algorithm"
1522 select CRYPTO_ALGAPI
1523 select CRYPTO_TWOFISH_COMMON
1525 Twofish cipher algorithm.
1527 Twofish was submitted as an AES (Advanced Encryption Standard)
1528 candidate cipher by researchers at CounterPane Systems. It is a
1529 16 round block cipher supporting key sizes of 128, 192, and 256
1533 <http://www.schneier.com/twofish.html>
1535 config CRYPTO_TWOFISH_COMMON
1538 Common parts of the Twofish cipher algorithm shared by the
1539 generic c and the assembler implementations.
1541 config CRYPTO_TWOFISH_586
1542 tristate "Twofish cipher algorithms (i586)"
1543 depends on (X86 || UML_X86) && !64BIT
1544 select CRYPTO_ALGAPI
1545 select CRYPTO_TWOFISH_COMMON
1547 Twofish cipher algorithm.
1549 Twofish was submitted as an AES (Advanced Encryption Standard)
1550 candidate cipher by researchers at CounterPane Systems. It is a
1551 16 round block cipher supporting key sizes of 128, 192, and 256
1555 <http://www.schneier.com/twofish.html>
1557 config CRYPTO_TWOFISH_X86_64
1558 tristate "Twofish cipher algorithm (x86_64)"
1559 depends on (X86 || UML_X86) && 64BIT
1560 select CRYPTO_ALGAPI
1561 select CRYPTO_TWOFISH_COMMON
1563 Twofish cipher algorithm (x86_64).
1565 Twofish was submitted as an AES (Advanced Encryption Standard)
1566 candidate cipher by researchers at CounterPane Systems. It is a
1567 16 round block cipher supporting key sizes of 128, 192, and 256
1571 <http://www.schneier.com/twofish.html>
1573 config CRYPTO_TWOFISH_X86_64_3WAY
1574 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1575 depends on X86 && 64BIT
1576 select CRYPTO_BLKCIPHER
1577 select CRYPTO_TWOFISH_COMMON
1578 select CRYPTO_TWOFISH_X86_64
1579 select CRYPTO_GLUE_HELPER_X86
1581 Twofish cipher algorithm (x86_64, 3-way parallel).
1583 Twofish was submitted as an AES (Advanced Encryption Standard)
1584 candidate cipher by researchers at CounterPane Systems. It is a
1585 16 round block cipher supporting key sizes of 128, 192, and 256
1588 This module provides Twofish cipher algorithm that processes three
1589 blocks parallel, utilizing resources of out-of-order CPUs better.
1592 <http://www.schneier.com/twofish.html>
1594 config CRYPTO_TWOFISH_AVX_X86_64
1595 tristate "Twofish cipher algorithm (x86_64/AVX)"
1596 depends on X86 && 64BIT
1597 select CRYPTO_BLKCIPHER
1598 select CRYPTO_GLUE_HELPER_X86
1600 select CRYPTO_TWOFISH_COMMON
1601 select CRYPTO_TWOFISH_X86_64
1602 select CRYPTO_TWOFISH_X86_64_3WAY
1604 Twofish cipher algorithm (x86_64/AVX).
1606 Twofish was submitted as an AES (Advanced Encryption Standard)
1607 candidate cipher by researchers at CounterPane Systems. It is a
1608 16 round block cipher supporting key sizes of 128, 192, and 256
1611 This module provides the Twofish cipher algorithm that processes
1612 eight blocks parallel using the AVX Instruction Set.
1615 <http://www.schneier.com/twofish.html>
1617 comment "Compression"
1619 config CRYPTO_DEFLATE
1620 tristate "Deflate compression algorithm"
1621 select CRYPTO_ALGAPI
1622 select CRYPTO_ACOMP2
1626 This is the Deflate algorithm (RFC1951), specified for use in
1627 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1629 You will most probably want this if using IPSec.
1632 tristate "LZO compression algorithm"
1633 select CRYPTO_ALGAPI
1634 select CRYPTO_ACOMP2
1636 select LZO_DECOMPRESS
1638 This is the LZO algorithm.
1641 tristate "842 compression algorithm"
1642 select CRYPTO_ALGAPI
1643 select CRYPTO_ACOMP2
1645 select 842_DECOMPRESS
1647 This is the 842 algorithm.
1650 tristate "LZ4 compression algorithm"
1651 select CRYPTO_ALGAPI
1652 select CRYPTO_ACOMP2
1654 select LZ4_DECOMPRESS
1656 This is the LZ4 algorithm.
1659 tristate "LZ4HC compression algorithm"
1660 select CRYPTO_ALGAPI
1661 select CRYPTO_ACOMP2
1662 select LZ4HC_COMPRESS
1663 select LZ4_DECOMPRESS
1665 This is the LZ4 high compression mode algorithm.
1667 comment "Random Number Generation"
1669 config CRYPTO_ANSI_CPRNG
1670 tristate "Pseudo Random Number Generation for Cryptographic modules"
1674 This option enables the generic pseudo random number generator
1675 for cryptographic modules. Uses the Algorithm specified in
1676 ANSI X9.31 A.2.4. Note that this option must be enabled if
1677 CRYPTO_FIPS is selected
1679 menuconfig CRYPTO_DRBG_MENU
1680 tristate "NIST SP800-90A DRBG"
1682 NIST SP800-90A compliant DRBG. In the following submenu, one or
1683 more of the DRBG types must be selected.
1687 config CRYPTO_DRBG_HMAC
1691 select CRYPTO_SHA256
1693 config CRYPTO_DRBG_HASH
1694 bool "Enable Hash DRBG"
1695 select CRYPTO_SHA256
1697 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1699 config CRYPTO_DRBG_CTR
1700 bool "Enable CTR DRBG"
1702 depends on CRYPTO_CTR
1704 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1708 default CRYPTO_DRBG_MENU
1710 select CRYPTO_JITTERENTROPY
1712 endif # if CRYPTO_DRBG_MENU
1714 config CRYPTO_JITTERENTROPY
1715 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1718 The Jitterentropy RNG is a noise that is intended
1719 to provide seed to another RNG. The RNG does not
1720 perform any cryptographic whitening of the generated
1721 random numbers. This Jitterentropy RNG registers with
1722 the kernel crypto API and can be used by any caller.
1724 config CRYPTO_USER_API
1727 config CRYPTO_USER_API_HASH
1728 tristate "User-space interface for hash algorithms"
1731 select CRYPTO_USER_API
1733 This option enables the user-spaces interface for hash
1736 config CRYPTO_USER_API_SKCIPHER
1737 tristate "User-space interface for symmetric key cipher algorithms"
1739 select CRYPTO_BLKCIPHER
1740 select CRYPTO_USER_API
1742 This option enables the user-spaces interface for symmetric
1743 key cipher algorithms.
1745 config CRYPTO_USER_API_RNG
1746 tristate "User-space interface for random number generator algorithms"
1749 select CRYPTO_USER_API
1751 This option enables the user-spaces interface for random
1752 number generator algorithms.
1754 config CRYPTO_USER_API_AEAD
1755 tristate "User-space interface for AEAD cipher algorithms"
1758 select CRYPTO_BLKCIPHER
1760 select CRYPTO_USER_API
1762 This option enables the user-spaces interface for AEAD
1765 config CRYPTO_HASH_INFO
1768 source "drivers/crypto/Kconfig"
1769 source crypto/asymmetric_keys/Kconfig
1770 source certs/Kconfig