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_AUTHENC
217 tristate "Authenc support"
219 select CRYPTO_BLKCIPHER
220 select CRYPTO_MANAGER
224 Authenc: Combined mode wrapper for IPsec.
225 This is required for IPSec.
228 tristate "Testing module"
230 select CRYPTO_MANAGER
232 Quick & dirty crypto test module.
238 config CRYPTO_GLUE_HELPER_X86
241 select CRYPTO_BLKCIPHER
246 comment "Authenticated Encryption with Associated Data"
249 tristate "CCM support"
254 Support for Counter with CBC MAC. Required for IPsec.
257 tristate "GCM/GMAC support"
263 Support for Galois/Counter Mode (GCM) and Galois Message
264 Authentication Code (GMAC). Required for IPSec.
266 config CRYPTO_CHACHA20POLY1305
267 tristate "ChaCha20-Poly1305 AEAD support"
268 select CRYPTO_CHACHA20
269 select CRYPTO_POLY1305
272 ChaCha20-Poly1305 AEAD support, RFC7539.
274 Support for the AEAD wrapper using the ChaCha20 stream cipher combined
275 with the Poly1305 authenticator. It is defined in RFC7539 for use in
278 config CRYPTO_AEGIS128
279 tristate "AEGIS-128 AEAD algorithm"
281 select CRYPTO_AES # for AES S-box tables
283 Support for the AEGIS-128 dedicated AEAD algorithm.
285 config CRYPTO_AEGIS128L
286 tristate "AEGIS-128L AEAD algorithm"
288 select CRYPTO_AES # for AES S-box tables
290 Support for the AEGIS-128L dedicated AEAD algorithm.
292 config CRYPTO_AEGIS256
293 tristate "AEGIS-256 AEAD algorithm"
295 select CRYPTO_AES # for AES S-box tables
297 Support for the AEGIS-256 dedicated AEAD algorithm.
299 config CRYPTO_AEGIS128_AESNI_SSE2
300 tristate "AEGIS-128 AEAD algorithm (x86_64 AESNI+SSE2 implementation)"
301 depends on X86 && 64BIT
305 AESNI+SSE2 implementation of the AEGSI-128 dedicated AEAD algorithm.
307 config CRYPTO_AEGIS128L_AESNI_SSE2
308 tristate "AEGIS-128L AEAD algorithm (x86_64 AESNI+SSE2 implementation)"
309 depends on X86 && 64BIT
313 AESNI+SSE2 implementation of the AEGSI-128L dedicated AEAD algorithm.
315 config CRYPTO_AEGIS256_AESNI_SSE2
316 tristate "AEGIS-256 AEAD algorithm (x86_64 AESNI+SSE2 implementation)"
317 depends on X86 && 64BIT
321 AESNI+SSE2 implementation of the AEGSI-256 dedicated AEAD algorithm.
323 config CRYPTO_MORUS640
324 tristate "MORUS-640 AEAD algorithm"
327 Support for the MORUS-640 dedicated AEAD algorithm.
329 config CRYPTO_MORUS640_GLUE
335 Common glue for SIMD optimizations of the MORUS-640 dedicated AEAD
338 config CRYPTO_MORUS640_SSE2
339 tristate "MORUS-640 AEAD algorithm (x86_64 SSE2 implementation)"
340 depends on X86 && 64BIT
342 select CRYPTO_MORUS640_GLUE
344 SSE2 implementation of the MORUS-640 dedicated AEAD algorithm.
346 config CRYPTO_MORUS1280
347 tristate "MORUS-1280 AEAD algorithm"
350 Support for the MORUS-1280 dedicated AEAD algorithm.
352 config CRYPTO_MORUS1280_GLUE
358 Common glue for SIMD optimizations of the MORUS-1280 dedicated AEAD
361 config CRYPTO_MORUS1280_SSE2
362 tristate "MORUS-1280 AEAD algorithm (x86_64 SSE2 implementation)"
363 depends on X86 && 64BIT
365 select CRYPTO_MORUS1280_GLUE
367 SSE2 optimizedimplementation of the MORUS-1280 dedicated AEAD
370 config CRYPTO_MORUS1280_AVX2
371 tristate "MORUS-1280 AEAD algorithm (x86_64 AVX2 implementation)"
372 depends on X86 && 64BIT
374 select CRYPTO_MORUS1280_GLUE
376 AVX2 optimized implementation of the MORUS-1280 dedicated AEAD
380 tristate "Sequence Number IV Generator"
382 select CRYPTO_BLKCIPHER
384 select CRYPTO_RNG_DEFAULT
386 This IV generator generates an IV based on a sequence number by
387 xoring it with a salt. This algorithm is mainly useful for CTR
389 config CRYPTO_ECHAINIV
390 tristate "Encrypted Chain IV Generator"
393 select CRYPTO_RNG_DEFAULT
396 This IV generator generates an IV based on the encryption of
397 a sequence number xored with a salt. This is the default
400 comment "Block modes"
403 tristate "CBC support"
404 select CRYPTO_BLKCIPHER
405 select CRYPTO_MANAGER
407 CBC: Cipher Block Chaining mode
408 This block cipher algorithm is required for IPSec.
411 tristate "CFB support"
412 select CRYPTO_BLKCIPHER
413 select CRYPTO_MANAGER
415 CFB: Cipher FeedBack mode
416 This block cipher algorithm is required for TPM2 Cryptography.
419 tristate "CTR support"
420 select CRYPTO_BLKCIPHER
422 select CRYPTO_MANAGER
425 This block cipher algorithm is required for IPSec.
428 tristate "CTS support"
429 select CRYPTO_BLKCIPHER
431 CTS: Cipher Text Stealing
432 This is the Cipher Text Stealing mode as described by
433 Section 8 of rfc2040 and referenced by rfc3962.
434 (rfc3962 includes errata information in its Appendix A)
435 This mode is required for Kerberos gss mechanism support
439 tristate "ECB support"
440 select CRYPTO_BLKCIPHER
441 select CRYPTO_MANAGER
443 ECB: Electronic CodeBook mode
444 This is the simplest block cipher algorithm. It simply encrypts
445 the input block by block.
448 tristate "LRW support"
449 select CRYPTO_BLKCIPHER
450 select CRYPTO_MANAGER
451 select CRYPTO_GF128MUL
453 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
454 narrow block cipher mode for dm-crypt. Use it with cipher
455 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
456 The first 128, 192 or 256 bits in the key are used for AES and the
457 rest is used to tie each cipher block to its logical position.
460 tristate "OFB support"
461 select CRYPTO_BLKCIPHER
462 select CRYPTO_MANAGER
464 OFB: the Output Feedback mode makes a block cipher into a synchronous
465 stream cipher. It generates keystream blocks, which are then XORed
466 with the plaintext blocks to get the ciphertext. Flipping a bit in the
467 ciphertext produces a flipped bit in the plaintext at the same
468 location. This property allows many error correcting codes to function
469 normally even when applied before encryption.
472 tristate "PCBC support"
473 select CRYPTO_BLKCIPHER
474 select CRYPTO_MANAGER
476 PCBC: Propagating Cipher Block Chaining mode
477 This block cipher algorithm is required for RxRPC.
480 tristate "XTS support"
481 select CRYPTO_BLKCIPHER
482 select CRYPTO_MANAGER
485 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
486 key size 256, 384 or 512 bits. This implementation currently
487 can't handle a sectorsize which is not a multiple of 16 bytes.
489 config CRYPTO_KEYWRAP
490 tristate "Key wrapping support"
491 select CRYPTO_BLKCIPHER
493 Support for key wrapping (NIST SP800-38F / RFC3394) without
499 tristate "CMAC support"
501 select CRYPTO_MANAGER
503 Cipher-based Message Authentication Code (CMAC) specified by
504 The National Institute of Standards and Technology (NIST).
506 https://tools.ietf.org/html/rfc4493
507 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
510 tristate "HMAC support"
512 select CRYPTO_MANAGER
514 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
515 This is required for IPSec.
518 tristate "XCBC support"
520 select CRYPTO_MANAGER
522 XCBC: Keyed-Hashing with encryption algorithm
523 http://www.ietf.org/rfc/rfc3566.txt
524 http://csrc.nist.gov/encryption/modes/proposedmodes/
525 xcbc-mac/xcbc-mac-spec.pdf
528 tristate "VMAC support"
530 select CRYPTO_MANAGER
532 VMAC is a message authentication algorithm designed for
533 very high speed on 64-bit architectures.
536 <http://fastcrypto.org/vmac>
541 tristate "CRC32c CRC algorithm"
545 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
546 by iSCSI for header and data digests and by others.
547 See Castagnoli93. Module will be crc32c.
549 config CRYPTO_CRC32C_INTEL
550 tristate "CRC32c INTEL hardware acceleration"
554 In Intel processor with SSE4.2 supported, the processor will
555 support CRC32C implementation using hardware accelerated CRC32
556 instruction. This option will create 'crc32c-intel' module,
557 which will enable any routine to use the CRC32 instruction to
558 gain performance compared with software implementation.
559 Module will be crc32c-intel.
561 config CRYPTO_CRC32C_VPMSUM
562 tristate "CRC32c CRC algorithm (powerpc64)"
563 depends on PPC64 && ALTIVEC
567 CRC32c algorithm implemented using vector polynomial multiply-sum
568 (vpmsum) instructions, introduced in POWER8. Enable on POWER8
569 and newer processors for improved performance.
572 config CRYPTO_CRC32C_SPARC64
573 tristate "CRC32c CRC algorithm (SPARC64)"
578 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
582 tristate "CRC32 CRC algorithm"
586 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
587 Shash crypto api wrappers to crc32_le function.
589 config CRYPTO_CRC32_PCLMUL
590 tristate "CRC32 PCLMULQDQ hardware acceleration"
595 From Intel Westmere and AMD Bulldozer processor with SSE4.2
596 and PCLMULQDQ supported, the processor will support
597 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
598 instruction. This option will create 'crc32-plcmul' module,
599 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
600 and gain better performance as compared with the table implementation.
602 config CRYPTO_CRC32_MIPS
603 tristate "CRC32c and CRC32 CRC algorithm (MIPS)"
604 depends on MIPS_CRC_SUPPORT
607 CRC32c and CRC32 CRC algorithms implemented using mips crypto
608 instructions, when available.
611 config CRYPTO_CRCT10DIF
612 tristate "CRCT10DIF algorithm"
615 CRC T10 Data Integrity Field computation is being cast as
616 a crypto transform. This allows for faster crc t10 diff
617 transforms to be used if they are available.
619 config CRYPTO_CRCT10DIF_PCLMUL
620 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
621 depends on X86 && 64BIT && CRC_T10DIF
624 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
625 CRC T10 DIF PCLMULQDQ computation can be hardware
626 accelerated PCLMULQDQ instruction. This option will create
627 'crct10dif-plcmul' module, which is faster when computing the
628 crct10dif checksum as compared with the generic table implementation.
630 config CRYPTO_CRCT10DIF_VPMSUM
631 tristate "CRC32T10DIF powerpc64 hardware acceleration"
632 depends on PPC64 && ALTIVEC && CRC_T10DIF
635 CRC10T10DIF algorithm implemented using vector polynomial
636 multiply-sum (vpmsum) instructions, introduced in POWER8. Enable on
637 POWER8 and newer processors for improved performance.
639 config CRYPTO_VPMSUM_TESTER
640 tristate "Powerpc64 vpmsum hardware acceleration tester"
641 depends on CRYPTO_CRCT10DIF_VPMSUM && CRYPTO_CRC32C_VPMSUM
643 Stress test for CRC32c and CRC-T10DIF algorithms implemented with
644 POWER8 vpmsum instructions.
645 Unless you are testing these algorithms, you don't need this.
648 tristate "GHASH digest algorithm"
649 select CRYPTO_GF128MUL
652 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
654 config CRYPTO_POLY1305
655 tristate "Poly1305 authenticator algorithm"
658 Poly1305 authenticator algorithm, RFC7539.
660 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
661 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
662 in IETF protocols. This is the portable C implementation of Poly1305.
664 config CRYPTO_POLY1305_X86_64
665 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
666 depends on X86 && 64BIT
667 select CRYPTO_POLY1305
669 Poly1305 authenticator algorithm, RFC7539.
671 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
672 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
673 in IETF protocols. This is the x86_64 assembler implementation using SIMD
677 tristate "MD4 digest algorithm"
680 MD4 message digest algorithm (RFC1320).
683 tristate "MD5 digest algorithm"
686 MD5 message digest algorithm (RFC1321).
688 config CRYPTO_MD5_OCTEON
689 tristate "MD5 digest algorithm (OCTEON)"
690 depends on CPU_CAVIUM_OCTEON
694 MD5 message digest algorithm (RFC1321) implemented
695 using OCTEON crypto instructions, when available.
697 config CRYPTO_MD5_PPC
698 tristate "MD5 digest algorithm (PPC)"
702 MD5 message digest algorithm (RFC1321) implemented
705 config CRYPTO_MD5_SPARC64
706 tristate "MD5 digest algorithm (SPARC64)"
711 MD5 message digest algorithm (RFC1321) implemented
712 using sparc64 crypto instructions, when available.
714 config CRYPTO_MICHAEL_MIC
715 tristate "Michael MIC keyed digest algorithm"
718 Michael MIC is used for message integrity protection in TKIP
719 (IEEE 802.11i). This algorithm is required for TKIP, but it
720 should not be used for other purposes because of the weakness
724 tristate "RIPEMD-128 digest algorithm"
727 RIPEMD-128 (ISO/IEC 10118-3:2004).
729 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
730 be used as a secure replacement for RIPEMD. For other use cases,
731 RIPEMD-160 should be used.
733 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
734 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
737 tristate "RIPEMD-160 digest algorithm"
740 RIPEMD-160 (ISO/IEC 10118-3:2004).
742 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
743 to be used as a secure replacement for the 128-bit hash functions
744 MD4, MD5 and it's predecessor RIPEMD
745 (not to be confused with RIPEMD-128).
747 It's speed is comparable to SHA1 and there are no known attacks
750 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
751 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
754 tristate "RIPEMD-256 digest algorithm"
757 RIPEMD-256 is an optional extension of RIPEMD-128 with a
758 256 bit hash. It is intended for applications that require
759 longer hash-results, without needing a larger security level
762 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
763 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
766 tristate "RIPEMD-320 digest algorithm"
769 RIPEMD-320 is an optional extension of RIPEMD-160 with a
770 320 bit hash. It is intended for applications that require
771 longer hash-results, without needing a larger security level
774 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
775 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
778 tristate "SHA1 digest algorithm"
781 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
783 config CRYPTO_SHA1_SSSE3
784 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
785 depends on X86 && 64BIT
789 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
790 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
791 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
794 config CRYPTO_SHA256_SSSE3
795 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
796 depends on X86 && 64BIT
800 SHA-256 secure hash standard (DFIPS 180-2) implemented
801 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
802 Extensions version 1 (AVX1), or Advanced Vector Extensions
803 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
804 Instructions) when available.
806 config CRYPTO_SHA512_SSSE3
807 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
808 depends on X86 && 64BIT
812 SHA-512 secure hash standard (DFIPS 180-2) implemented
813 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
814 Extensions version 1 (AVX1), or Advanced Vector Extensions
815 version 2 (AVX2) instructions, when available.
817 config CRYPTO_SHA1_OCTEON
818 tristate "SHA1 digest algorithm (OCTEON)"
819 depends on CPU_CAVIUM_OCTEON
823 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
824 using OCTEON crypto instructions, when available.
826 config CRYPTO_SHA1_SPARC64
827 tristate "SHA1 digest algorithm (SPARC64)"
832 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
833 using sparc64 crypto instructions, when available.
835 config CRYPTO_SHA1_PPC
836 tristate "SHA1 digest algorithm (powerpc)"
839 This is the powerpc hardware accelerated implementation of the
840 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
842 config CRYPTO_SHA1_PPC_SPE
843 tristate "SHA1 digest algorithm (PPC SPE)"
844 depends on PPC && SPE
846 SHA-1 secure hash standard (DFIPS 180-4) implemented
847 using powerpc SPE SIMD instruction set.
850 tristate "SHA224 and SHA256 digest algorithm"
853 SHA256 secure hash standard (DFIPS 180-2).
855 This version of SHA implements a 256 bit hash with 128 bits of
856 security against collision attacks.
858 This code also includes SHA-224, a 224 bit hash with 112 bits
859 of security against collision attacks.
861 config CRYPTO_SHA256_PPC_SPE
862 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
863 depends on PPC && SPE
867 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
868 implemented using powerpc SPE SIMD instruction set.
870 config CRYPTO_SHA256_OCTEON
871 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
872 depends on CPU_CAVIUM_OCTEON
876 SHA-256 secure hash standard (DFIPS 180-2) implemented
877 using OCTEON crypto instructions, when available.
879 config CRYPTO_SHA256_SPARC64
880 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
885 SHA-256 secure hash standard (DFIPS 180-2) implemented
886 using sparc64 crypto instructions, when available.
889 tristate "SHA384 and SHA512 digest algorithms"
892 SHA512 secure hash standard (DFIPS 180-2).
894 This version of SHA implements a 512 bit hash with 256 bits of
895 security against collision attacks.
897 This code also includes SHA-384, a 384 bit hash with 192 bits
898 of security against collision attacks.
900 config CRYPTO_SHA512_OCTEON
901 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
902 depends on CPU_CAVIUM_OCTEON
906 SHA-512 secure hash standard (DFIPS 180-2) implemented
907 using OCTEON crypto instructions, when available.
909 config CRYPTO_SHA512_SPARC64
910 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
915 SHA-512 secure hash standard (DFIPS 180-2) implemented
916 using sparc64 crypto instructions, when available.
919 tristate "SHA3 digest algorithm"
922 SHA-3 secure hash standard (DFIPS 202). It's based on
923 cryptographic sponge function family called Keccak.
926 http://keccak.noekeon.org/
929 tristate "SM3 digest algorithm"
932 SM3 secure hash function as defined by OSCCA GM/T 0004-2012 SM3).
933 It is part of the Chinese Commercial Cryptography suite.
936 http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
937 https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
940 tristate "Tiger digest algorithms"
943 Tiger hash algorithm 192, 160 and 128-bit hashes
945 Tiger is a hash function optimized for 64-bit processors while
946 still having decent performance on 32-bit processors.
947 Tiger was developed by Ross Anderson and Eli Biham.
950 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
953 tristate "Whirlpool digest algorithms"
956 Whirlpool hash algorithm 512, 384 and 256-bit hashes
958 Whirlpool-512 is part of the NESSIE cryptographic primitives.
959 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
962 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
964 config CRYPTO_GHASH_CLMUL_NI_INTEL
965 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
966 depends on X86 && 64BIT
969 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
970 The implementation is accelerated by CLMUL-NI of Intel.
975 tristate "AES cipher algorithms"
978 AES cipher algorithms (FIPS-197). AES uses the Rijndael
981 Rijndael appears to be consistently a very good performer in
982 both hardware and software across a wide range of computing
983 environments regardless of its use in feedback or non-feedback
984 modes. Its key setup time is excellent, and its key agility is
985 good. Rijndael's very low memory requirements make it very well
986 suited for restricted-space environments, in which it also
987 demonstrates excellent performance. Rijndael's operations are
988 among the easiest to defend against power and timing attacks.
990 The AES specifies three key sizes: 128, 192 and 256 bits
992 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
995 tristate "Fixed time AES cipher"
998 This is a generic implementation of AES that attempts to eliminate
999 data dependent latencies as much as possible without affecting
1000 performance too much. It is intended for use by the generic CCM
1001 and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
1002 solely on encryption (although decryption is supported as well, but
1003 with a more dramatic performance hit)
1005 Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
1006 8 for decryption), this implementation only uses just two S-boxes of
1007 256 bytes each, and attempts to eliminate data dependent latencies by
1008 prefetching the entire table into the cache at the start of each
1009 block. Interrupts are also disabled to avoid races where cachelines
1010 are evicted when the CPU is interrupted to do something else.
1012 config CRYPTO_AES_586
1013 tristate "AES cipher algorithms (i586)"
1014 depends on (X86 || UML_X86) && !64BIT
1015 select CRYPTO_ALGAPI
1018 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1021 Rijndael appears to be consistently a very good performer in
1022 both hardware and software across a wide range of computing
1023 environments regardless of its use in feedback or non-feedback
1024 modes. Its key setup time is excellent, and its key agility is
1025 good. Rijndael's very low memory requirements make it very well
1026 suited for restricted-space environments, in which it also
1027 demonstrates excellent performance. Rijndael's operations are
1028 among the easiest to defend against power and timing attacks.
1030 The AES specifies three key sizes: 128, 192 and 256 bits
1032 See <http://csrc.nist.gov/encryption/aes/> for more information.
1034 config CRYPTO_AES_X86_64
1035 tristate "AES cipher algorithms (x86_64)"
1036 depends on (X86 || UML_X86) && 64BIT
1037 select CRYPTO_ALGAPI
1040 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1043 Rijndael appears to be consistently a very good performer in
1044 both hardware and software across a wide range of computing
1045 environments regardless of its use in feedback or non-feedback
1046 modes. Its key setup time is excellent, and its key agility is
1047 good. Rijndael's very low memory requirements make it very well
1048 suited for restricted-space environments, in which it also
1049 demonstrates excellent performance. Rijndael's operations are
1050 among the easiest to defend against power and timing attacks.
1052 The AES specifies three key sizes: 128, 192 and 256 bits
1054 See <http://csrc.nist.gov/encryption/aes/> for more information.
1056 config CRYPTO_AES_NI_INTEL
1057 tristate "AES cipher algorithms (AES-NI)"
1060 select CRYPTO_AES_X86_64 if 64BIT
1061 select CRYPTO_AES_586 if !64BIT
1062 select CRYPTO_ALGAPI
1063 select CRYPTO_BLKCIPHER
1064 select CRYPTO_GLUE_HELPER_X86 if 64BIT
1067 Use Intel AES-NI instructions for AES algorithm.
1069 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1072 Rijndael appears to be consistently a very good performer in
1073 both hardware and software across a wide range of computing
1074 environments regardless of its use in feedback or non-feedback
1075 modes. Its key setup time is excellent, and its key agility is
1076 good. Rijndael's very low memory requirements make it very well
1077 suited for restricted-space environments, in which it also
1078 demonstrates excellent performance. Rijndael's operations are
1079 among the easiest to defend against power and timing attacks.
1081 The AES specifies three key sizes: 128, 192 and 256 bits
1083 See <http://csrc.nist.gov/encryption/aes/> for more information.
1085 In addition to AES cipher algorithm support, the acceleration
1086 for some popular block cipher mode is supported too, including
1087 ECB, CBC, LRW, XTS. The 64 bit version has additional
1088 acceleration for CTR.
1090 config CRYPTO_AES_SPARC64
1091 tristate "AES cipher algorithms (SPARC64)"
1093 select CRYPTO_CRYPTD
1094 select CRYPTO_ALGAPI
1096 Use SPARC64 crypto opcodes for AES algorithm.
1098 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1101 Rijndael appears to be consistently a very good performer in
1102 both hardware and software across a wide range of computing
1103 environments regardless of its use in feedback or non-feedback
1104 modes. Its key setup time is excellent, and its key agility is
1105 good. Rijndael's very low memory requirements make it very well
1106 suited for restricted-space environments, in which it also
1107 demonstrates excellent performance. Rijndael's operations are
1108 among the easiest to defend against power and timing attacks.
1110 The AES specifies three key sizes: 128, 192 and 256 bits
1112 See <http://csrc.nist.gov/encryption/aes/> for more information.
1114 In addition to AES cipher algorithm support, the acceleration
1115 for some popular block cipher mode is supported too, including
1118 config CRYPTO_AES_PPC_SPE
1119 tristate "AES cipher algorithms (PPC SPE)"
1120 depends on PPC && SPE
1122 AES cipher algorithms (FIPS-197). Additionally the acceleration
1123 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
1124 This module should only be used for low power (router) devices
1125 without hardware AES acceleration (e.g. caam crypto). It reduces the
1126 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
1127 timining attacks. Nevertheless it might be not as secure as other
1128 architecture specific assembler implementations that work on 1KB
1129 tables or 256 bytes S-boxes.
1131 config CRYPTO_ANUBIS
1132 tristate "Anubis cipher algorithm"
1133 select CRYPTO_ALGAPI
1135 Anubis cipher algorithm.
1137 Anubis is a variable key length cipher which can use keys from
1138 128 bits to 320 bits in length. It was evaluated as a entrant
1139 in the NESSIE competition.
1142 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1143 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1146 tristate "ARC4 cipher algorithm"
1147 select CRYPTO_BLKCIPHER
1149 ARC4 cipher algorithm.
1151 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1152 bits in length. This algorithm is required for driver-based
1153 WEP, but it should not be for other purposes because of the
1154 weakness of the algorithm.
1156 config CRYPTO_BLOWFISH
1157 tristate "Blowfish cipher algorithm"
1158 select CRYPTO_ALGAPI
1159 select CRYPTO_BLOWFISH_COMMON
1161 Blowfish cipher algorithm, by Bruce Schneier.
1163 This is a variable key length cipher which can use keys from 32
1164 bits to 448 bits in length. It's fast, simple and specifically
1165 designed for use on "large microprocessors".
1168 <http://www.schneier.com/blowfish.html>
1170 config CRYPTO_BLOWFISH_COMMON
1173 Common parts of the Blowfish cipher algorithm shared by the
1174 generic c and the assembler implementations.
1177 <http://www.schneier.com/blowfish.html>
1179 config CRYPTO_BLOWFISH_X86_64
1180 tristate "Blowfish cipher algorithm (x86_64)"
1181 depends on X86 && 64BIT
1182 select CRYPTO_BLKCIPHER
1183 select CRYPTO_BLOWFISH_COMMON
1185 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1187 This is a variable key length cipher which can use keys from 32
1188 bits to 448 bits in length. It's fast, simple and specifically
1189 designed for use on "large microprocessors".
1192 <http://www.schneier.com/blowfish.html>
1194 config CRYPTO_CAMELLIA
1195 tristate "Camellia cipher algorithms"
1197 select CRYPTO_ALGAPI
1199 Camellia cipher algorithms module.
1201 Camellia is a symmetric key block cipher developed jointly
1202 at NTT and Mitsubishi Electric Corporation.
1204 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1207 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1209 config CRYPTO_CAMELLIA_X86_64
1210 tristate "Camellia cipher algorithm (x86_64)"
1211 depends on X86 && 64BIT
1213 select CRYPTO_BLKCIPHER
1214 select CRYPTO_GLUE_HELPER_X86
1216 Camellia cipher algorithm module (x86_64).
1218 Camellia is a symmetric key block cipher developed jointly
1219 at NTT and Mitsubishi Electric Corporation.
1221 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1224 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1226 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1227 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1228 depends on X86 && 64BIT
1230 select CRYPTO_BLKCIPHER
1231 select CRYPTO_CAMELLIA_X86_64
1232 select CRYPTO_GLUE_HELPER_X86
1236 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1238 Camellia is a symmetric key block cipher developed jointly
1239 at NTT and Mitsubishi Electric Corporation.
1241 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1244 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1246 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1247 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1248 depends on X86 && 64BIT
1250 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1252 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1254 Camellia is a symmetric key block cipher developed jointly
1255 at NTT and Mitsubishi Electric Corporation.
1257 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1260 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1262 config CRYPTO_CAMELLIA_SPARC64
1263 tristate "Camellia cipher algorithm (SPARC64)"
1266 select CRYPTO_ALGAPI
1268 Camellia cipher algorithm module (SPARC64).
1270 Camellia is a symmetric key block cipher developed jointly
1271 at NTT and Mitsubishi Electric Corporation.
1273 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1276 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1278 config CRYPTO_CAST_COMMON
1281 Common parts of the CAST cipher algorithms shared by the
1282 generic c and the assembler implementations.
1285 tristate "CAST5 (CAST-128) cipher algorithm"
1286 select CRYPTO_ALGAPI
1287 select CRYPTO_CAST_COMMON
1289 The CAST5 encryption algorithm (synonymous with CAST-128) is
1290 described in RFC2144.
1292 config CRYPTO_CAST5_AVX_X86_64
1293 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1294 depends on X86 && 64BIT
1295 select CRYPTO_BLKCIPHER
1297 select CRYPTO_CAST_COMMON
1300 The CAST5 encryption algorithm (synonymous with CAST-128) is
1301 described in RFC2144.
1303 This module provides the Cast5 cipher algorithm that processes
1304 sixteen blocks parallel using the AVX instruction set.
1307 tristate "CAST6 (CAST-256) cipher algorithm"
1308 select CRYPTO_ALGAPI
1309 select CRYPTO_CAST_COMMON
1311 The CAST6 encryption algorithm (synonymous with CAST-256) is
1312 described in RFC2612.
1314 config CRYPTO_CAST6_AVX_X86_64
1315 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1316 depends on X86 && 64BIT
1317 select CRYPTO_BLKCIPHER
1319 select CRYPTO_CAST_COMMON
1320 select CRYPTO_GLUE_HELPER_X86
1324 The CAST6 encryption algorithm (synonymous with CAST-256) is
1325 described in RFC2612.
1327 This module provides the Cast6 cipher algorithm that processes
1328 eight blocks parallel using the AVX instruction set.
1331 tristate "DES and Triple DES EDE cipher algorithms"
1332 select CRYPTO_ALGAPI
1334 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1336 config CRYPTO_DES_SPARC64
1337 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1339 select CRYPTO_ALGAPI
1342 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1343 optimized using SPARC64 crypto opcodes.
1345 config CRYPTO_DES3_EDE_X86_64
1346 tristate "Triple DES EDE cipher algorithm (x86-64)"
1347 depends on X86 && 64BIT
1348 select CRYPTO_BLKCIPHER
1351 Triple DES EDE (FIPS 46-3) algorithm.
1353 This module provides implementation of the Triple DES EDE cipher
1354 algorithm that is optimized for x86-64 processors. Two versions of
1355 algorithm are provided; regular processing one input block and
1356 one that processes three blocks parallel.
1358 config CRYPTO_FCRYPT
1359 tristate "FCrypt cipher algorithm"
1360 select CRYPTO_ALGAPI
1361 select CRYPTO_BLKCIPHER
1363 FCrypt algorithm used by RxRPC.
1365 config CRYPTO_KHAZAD
1366 tristate "Khazad cipher algorithm"
1367 select CRYPTO_ALGAPI
1369 Khazad cipher algorithm.
1371 Khazad was a finalist in the initial NESSIE competition. It is
1372 an algorithm optimized for 64-bit processors with good performance
1373 on 32-bit processors. Khazad uses an 128 bit key size.
1376 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1378 config CRYPTO_SALSA20
1379 tristate "Salsa20 stream cipher algorithm"
1380 select CRYPTO_BLKCIPHER
1382 Salsa20 stream cipher algorithm.
1384 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1385 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1387 The Salsa20 stream cipher algorithm is designed by Daniel J.
1388 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1390 config CRYPTO_CHACHA20
1391 tristate "ChaCha20 cipher algorithm"
1392 select CRYPTO_BLKCIPHER
1394 ChaCha20 cipher algorithm, RFC7539.
1396 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1397 Bernstein and further specified in RFC7539 for use in IETF protocols.
1398 This is the portable C implementation of ChaCha20.
1401 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1403 config CRYPTO_CHACHA20_X86_64
1404 tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1405 depends on X86 && 64BIT
1406 select CRYPTO_BLKCIPHER
1407 select CRYPTO_CHACHA20
1409 ChaCha20 cipher algorithm, RFC7539.
1411 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1412 Bernstein and further specified in RFC7539 for use in IETF protocols.
1413 This is the x86_64 assembler implementation using SIMD instructions.
1416 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1419 tristate "SEED cipher algorithm"
1420 select CRYPTO_ALGAPI
1422 SEED cipher algorithm (RFC4269).
1424 SEED is a 128-bit symmetric key block cipher that has been
1425 developed by KISA (Korea Information Security Agency) as a
1426 national standard encryption algorithm of the Republic of Korea.
1427 It is a 16 round block cipher with the key size of 128 bit.
1430 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1432 config CRYPTO_SERPENT
1433 tristate "Serpent cipher algorithm"
1434 select CRYPTO_ALGAPI
1436 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1438 Keys are allowed to be from 0 to 256 bits in length, in steps
1439 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1440 variant of Serpent for compatibility with old kerneli.org code.
1443 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1445 config CRYPTO_SERPENT_SSE2_X86_64
1446 tristate "Serpent cipher algorithm (x86_64/SSE2)"
1447 depends on X86 && 64BIT
1448 select CRYPTO_BLKCIPHER
1449 select CRYPTO_GLUE_HELPER_X86
1450 select CRYPTO_SERPENT
1453 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1455 Keys are allowed to be from 0 to 256 bits in length, in steps
1458 This module provides Serpent cipher algorithm that processes eight
1459 blocks parallel using SSE2 instruction set.
1462 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1464 config CRYPTO_SERPENT_SSE2_586
1465 tristate "Serpent cipher algorithm (i586/SSE2)"
1466 depends on X86 && !64BIT
1467 select CRYPTO_BLKCIPHER
1468 select CRYPTO_GLUE_HELPER_X86
1469 select CRYPTO_SERPENT
1472 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1474 Keys are allowed to be from 0 to 256 bits in length, in steps
1477 This module provides Serpent cipher algorithm that processes four
1478 blocks parallel using SSE2 instruction set.
1481 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1483 config CRYPTO_SERPENT_AVX_X86_64
1484 tristate "Serpent cipher algorithm (x86_64/AVX)"
1485 depends on X86 && 64BIT
1486 select CRYPTO_BLKCIPHER
1487 select CRYPTO_GLUE_HELPER_X86
1488 select CRYPTO_SERPENT
1492 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1494 Keys are allowed to be from 0 to 256 bits in length, in steps
1497 This module provides the Serpent cipher algorithm that processes
1498 eight blocks parallel using the AVX instruction set.
1501 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1503 config CRYPTO_SERPENT_AVX2_X86_64
1504 tristate "Serpent cipher algorithm (x86_64/AVX2)"
1505 depends on X86 && 64BIT
1506 select CRYPTO_SERPENT_AVX_X86_64
1508 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1510 Keys are allowed to be from 0 to 256 bits in length, in steps
1513 This module provides Serpent cipher algorithm that processes 16
1514 blocks parallel using AVX2 instruction set.
1517 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1520 tristate "SM4 cipher algorithm"
1521 select CRYPTO_ALGAPI
1523 SM4 cipher algorithms (OSCCA GB/T 32907-2016).
1525 SM4 (GBT.32907-2016) is a cryptographic standard issued by the
1526 Organization of State Commercial Administration of China (OSCCA)
1527 as an authorized cryptographic algorithms for the use within China.
1529 SMS4 was originally created for use in protecting wireless
1530 networks, and is mandated in the Chinese National Standard for
1531 Wireless LAN WAPI (Wired Authentication and Privacy Infrastructure)
1534 The latest SM4 standard (GBT.32907-2016) was proposed by OSCCA and
1535 standardized through TC 260 of the Standardization Administration
1536 of the People's Republic of China (SAC).
1538 The input, output, and key of SMS4 are each 128 bits.
1540 See also: <https://eprint.iacr.org/2008/329.pdf>
1545 tristate "TEA, XTEA and XETA cipher algorithms"
1546 select CRYPTO_ALGAPI
1548 TEA cipher algorithm.
1550 Tiny Encryption Algorithm is a simple cipher that uses
1551 many rounds for security. It is very fast and uses
1554 Xtendend Tiny Encryption Algorithm is a modification to
1555 the TEA algorithm to address a potential key weakness
1556 in the TEA algorithm.
1558 Xtendend Encryption Tiny Algorithm is a mis-implementation
1559 of the XTEA algorithm for compatibility purposes.
1561 config CRYPTO_TWOFISH
1562 tristate "Twofish cipher algorithm"
1563 select CRYPTO_ALGAPI
1564 select CRYPTO_TWOFISH_COMMON
1566 Twofish cipher algorithm.
1568 Twofish was submitted as an AES (Advanced Encryption Standard)
1569 candidate cipher by researchers at CounterPane Systems. It is a
1570 16 round block cipher supporting key sizes of 128, 192, and 256
1574 <http://www.schneier.com/twofish.html>
1576 config CRYPTO_TWOFISH_COMMON
1579 Common parts of the Twofish cipher algorithm shared by the
1580 generic c and the assembler implementations.
1582 config CRYPTO_TWOFISH_586
1583 tristate "Twofish cipher algorithms (i586)"
1584 depends on (X86 || UML_X86) && !64BIT
1585 select CRYPTO_ALGAPI
1586 select CRYPTO_TWOFISH_COMMON
1588 Twofish cipher algorithm.
1590 Twofish was submitted as an AES (Advanced Encryption Standard)
1591 candidate cipher by researchers at CounterPane Systems. It is a
1592 16 round block cipher supporting key sizes of 128, 192, and 256
1596 <http://www.schneier.com/twofish.html>
1598 config CRYPTO_TWOFISH_X86_64
1599 tristate "Twofish cipher algorithm (x86_64)"
1600 depends on (X86 || UML_X86) && 64BIT
1601 select CRYPTO_ALGAPI
1602 select CRYPTO_TWOFISH_COMMON
1604 Twofish cipher algorithm (x86_64).
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
1612 <http://www.schneier.com/twofish.html>
1614 config CRYPTO_TWOFISH_X86_64_3WAY
1615 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1616 depends on X86 && 64BIT
1617 select CRYPTO_BLKCIPHER
1618 select CRYPTO_TWOFISH_COMMON
1619 select CRYPTO_TWOFISH_X86_64
1620 select CRYPTO_GLUE_HELPER_X86
1622 Twofish cipher algorithm (x86_64, 3-way parallel).
1624 Twofish was submitted as an AES (Advanced Encryption Standard)
1625 candidate cipher by researchers at CounterPane Systems. It is a
1626 16 round block cipher supporting key sizes of 128, 192, and 256
1629 This module provides Twofish cipher algorithm that processes three
1630 blocks parallel, utilizing resources of out-of-order CPUs better.
1633 <http://www.schneier.com/twofish.html>
1635 config CRYPTO_TWOFISH_AVX_X86_64
1636 tristate "Twofish cipher algorithm (x86_64/AVX)"
1637 depends on X86 && 64BIT
1638 select CRYPTO_BLKCIPHER
1639 select CRYPTO_GLUE_HELPER_X86
1641 select CRYPTO_TWOFISH_COMMON
1642 select CRYPTO_TWOFISH_X86_64
1643 select CRYPTO_TWOFISH_X86_64_3WAY
1645 Twofish cipher algorithm (x86_64/AVX).
1647 Twofish was submitted as an AES (Advanced Encryption Standard)
1648 candidate cipher by researchers at CounterPane Systems. It is a
1649 16 round block cipher supporting key sizes of 128, 192, and 256
1652 This module provides the Twofish cipher algorithm that processes
1653 eight blocks parallel using the AVX Instruction Set.
1656 <http://www.schneier.com/twofish.html>
1658 comment "Compression"
1660 config CRYPTO_DEFLATE
1661 tristate "Deflate compression algorithm"
1662 select CRYPTO_ALGAPI
1663 select CRYPTO_ACOMP2
1667 This is the Deflate algorithm (RFC1951), specified for use in
1668 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1670 You will most probably want this if using IPSec.
1673 tristate "LZO compression algorithm"
1674 select CRYPTO_ALGAPI
1675 select CRYPTO_ACOMP2
1677 select LZO_DECOMPRESS
1679 This is the LZO algorithm.
1682 tristate "842 compression algorithm"
1683 select CRYPTO_ALGAPI
1684 select CRYPTO_ACOMP2
1686 select 842_DECOMPRESS
1688 This is the 842 algorithm.
1691 tristate "LZ4 compression algorithm"
1692 select CRYPTO_ALGAPI
1693 select CRYPTO_ACOMP2
1695 select LZ4_DECOMPRESS
1697 This is the LZ4 algorithm.
1700 tristate "LZ4HC compression algorithm"
1701 select CRYPTO_ALGAPI
1702 select CRYPTO_ACOMP2
1703 select LZ4HC_COMPRESS
1704 select LZ4_DECOMPRESS
1706 This is the LZ4 high compression mode algorithm.
1709 tristate "Zstd compression algorithm"
1710 select CRYPTO_ALGAPI
1711 select CRYPTO_ACOMP2
1712 select ZSTD_COMPRESS
1713 select ZSTD_DECOMPRESS
1715 This is the zstd algorithm.
1717 comment "Random Number Generation"
1719 config CRYPTO_ANSI_CPRNG
1720 tristate "Pseudo Random Number Generation for Cryptographic modules"
1724 This option enables the generic pseudo random number generator
1725 for cryptographic modules. Uses the Algorithm specified in
1726 ANSI X9.31 A.2.4. Note that this option must be enabled if
1727 CRYPTO_FIPS is selected
1729 menuconfig CRYPTO_DRBG_MENU
1730 tristate "NIST SP800-90A DRBG"
1732 NIST SP800-90A compliant DRBG. In the following submenu, one or
1733 more of the DRBG types must be selected.
1737 config CRYPTO_DRBG_HMAC
1741 select CRYPTO_SHA256
1743 config CRYPTO_DRBG_HASH
1744 bool "Enable Hash DRBG"
1745 select CRYPTO_SHA256
1747 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1749 config CRYPTO_DRBG_CTR
1750 bool "Enable CTR DRBG"
1752 depends on CRYPTO_CTR
1754 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1758 default CRYPTO_DRBG_MENU
1760 select CRYPTO_JITTERENTROPY
1762 endif # if CRYPTO_DRBG_MENU
1764 config CRYPTO_JITTERENTROPY
1765 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1768 The Jitterentropy RNG is a noise that is intended
1769 to provide seed to another RNG. The RNG does not
1770 perform any cryptographic whitening of the generated
1771 random numbers. This Jitterentropy RNG registers with
1772 the kernel crypto API and can be used by any caller.
1774 config CRYPTO_USER_API
1777 config CRYPTO_USER_API_HASH
1778 tristate "User-space interface for hash algorithms"
1781 select CRYPTO_USER_API
1783 This option enables the user-spaces interface for hash
1786 config CRYPTO_USER_API_SKCIPHER
1787 tristate "User-space interface for symmetric key cipher algorithms"
1789 select CRYPTO_BLKCIPHER
1790 select CRYPTO_USER_API
1792 This option enables the user-spaces interface for symmetric
1793 key cipher algorithms.
1795 config CRYPTO_USER_API_RNG
1796 tristate "User-space interface for random number generator algorithms"
1799 select CRYPTO_USER_API
1801 This option enables the user-spaces interface for random
1802 number generator algorithms.
1804 config CRYPTO_USER_API_AEAD
1805 tristate "User-space interface for AEAD cipher algorithms"
1808 select CRYPTO_BLKCIPHER
1810 select CRYPTO_USER_API
1812 This option enables the user-spaces interface for AEAD
1816 bool "Crypto usage statistics for User-space"
1818 This option enables the gathering of crypto stats.
1820 - encrypt/decrypt size and numbers of symmeric operations
1821 - compress/decompress size and numbers of compress operations
1822 - size and numbers of hash operations
1823 - encrypt/decrypt/sign/verify numbers for asymmetric operations
1824 - generate/seed numbers for rng operations
1826 config CRYPTO_HASH_INFO
1829 source "drivers/crypto/Kconfig"
1830 source crypto/asymmetric_keys/Kconfig
1831 source certs/Kconfig