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 option enables the fips boot option which is
31 required if you want the 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
83 config CRYPTO_RNG_DEFAULT
85 select CRYPTO_DRBG_MENU
87 config CRYPTO_AKCIPHER2
91 config CRYPTO_AKCIPHER
93 select CRYPTO_AKCIPHER2
107 select CRYPTO_ALGAPI2
115 config CRYPTO_MANAGER
116 tristate "Cryptographic algorithm manager"
117 select CRYPTO_MANAGER2
119 Create default cryptographic template instantiations such as
122 config CRYPTO_MANAGER2
123 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
126 select CRYPTO_BLKCIPHER2
127 select CRYPTO_AKCIPHER2
132 tristate "Userspace cryptographic algorithm configuration"
134 select CRYPTO_MANAGER
136 Userspace configuration for cryptographic instantiations such as
141 config CRYPTO_MANAGER_DISABLE_TESTS
142 bool "Disable run-time self tests"
145 Disable run-time self tests that normally take place at
146 algorithm registration.
148 config CRYPTO_MANAGER_EXTRA_TESTS
149 bool "Enable extra run-time crypto self tests"
150 depends on DEBUG_KERNEL && !CRYPTO_MANAGER_DISABLE_TESTS
152 Enable extra run-time self tests of registered crypto algorithms,
153 including randomized fuzz tests.
155 This is intended for developer use only, as these tests take much
156 longer to run than the normal self tests.
158 endif # if CRYPTO_MANAGER2
160 config CRYPTO_GF128MUL
164 tristate "Null algorithms"
167 These are 'Null' algorithms, used by IPsec, which do nothing.
171 select CRYPTO_ALGAPI2
172 select CRYPTO_BLKCIPHER2
176 tristate "Parallel crypto engine"
179 select CRYPTO_MANAGER
182 This converts an arbitrary crypto algorithm into a parallel
183 algorithm that executes in kernel threads.
186 tristate "Software async crypto daemon"
187 select CRYPTO_BLKCIPHER
189 select CRYPTO_MANAGER
191 This is a generic software asynchronous crypto daemon that
192 converts an arbitrary synchronous software crypto algorithm
193 into an asynchronous algorithm that executes in a kernel thread.
195 config CRYPTO_AUTHENC
196 tristate "Authenc support"
198 select CRYPTO_BLKCIPHER
199 select CRYPTO_MANAGER
203 Authenc: Combined mode wrapper for IPsec.
204 This is required for IPSec.
207 tristate "Testing module"
209 select CRYPTO_MANAGER
211 Quick & dirty crypto test module.
217 config CRYPTO_GLUE_HELPER_X86
220 select CRYPTO_BLKCIPHER
225 comment "Public-key cryptography"
228 tristate "RSA algorithm"
229 select CRYPTO_AKCIPHER
230 select CRYPTO_MANAGER
234 Generic implementation of the RSA public key algorithm.
237 tristate "Diffie-Hellman algorithm"
241 Generic implementation of the Diffie-Hellman algorithm.
247 tristate "ECDH algorithm"
250 select CRYPTO_RNG_DEFAULT
252 Generic implementation of the ECDH algorithm
255 tristate "EC-RDSA (GOST 34.10) algorithm"
257 select CRYPTO_AKCIPHER
258 select CRYPTO_STREEBOG
262 Elliptic Curve Russian Digital Signature Algorithm (GOST R 34.10-2012,
263 RFC 7091, ISO/IEC 14888-3:2018) is one of the Russian cryptographic
264 standard algorithms (called GOST algorithms). Only signature verification
267 comment "Authenticated Encryption with Associated Data"
270 tristate "CCM support"
274 select CRYPTO_MANAGER
276 Support for Counter with CBC MAC. Required for IPsec.
279 tristate "GCM/GMAC support"
284 select CRYPTO_MANAGER
286 Support for Galois/Counter Mode (GCM) and Galois Message
287 Authentication Code (GMAC). Required for IPSec.
289 config CRYPTO_CHACHA20POLY1305
290 tristate "ChaCha20-Poly1305 AEAD support"
291 select CRYPTO_CHACHA20
292 select CRYPTO_POLY1305
294 select CRYPTO_MANAGER
296 ChaCha20-Poly1305 AEAD support, RFC7539.
298 Support for the AEAD wrapper using the ChaCha20 stream cipher combined
299 with the Poly1305 authenticator. It is defined in RFC7539 for use in
302 config CRYPTO_AEGIS128
303 tristate "AEGIS-128 AEAD algorithm"
305 select CRYPTO_AES # for AES S-box tables
307 Support for the AEGIS-128 dedicated AEAD algorithm.
309 config CRYPTO_AEGIS128_SIMD
310 bool "Support SIMD acceleration for AEGIS-128"
311 depends on CRYPTO_AEGIS128 && ((ARM || ARM64) && KERNEL_MODE_NEON)
312 depends on !ARM || CC_IS_CLANG || GCC_VERSION >= 40800
315 config CRYPTO_AEGIS128_AESNI_SSE2
316 tristate "AEGIS-128 AEAD algorithm (x86_64 AESNI+SSE2 implementation)"
317 depends on X86 && 64BIT
321 AESNI+SSE2 implementation of the AEGIS-128 dedicated AEAD algorithm.
324 tristate "Sequence Number IV Generator"
326 select CRYPTO_BLKCIPHER
328 select CRYPTO_RNG_DEFAULT
329 select CRYPTO_MANAGER
331 This IV generator generates an IV based on a sequence number by
332 xoring it with a salt. This algorithm is mainly useful for CTR
334 config CRYPTO_ECHAINIV
335 tristate "Encrypted Chain IV Generator"
338 select CRYPTO_RNG_DEFAULT
339 select CRYPTO_MANAGER
341 This IV generator generates an IV based on the encryption of
342 a sequence number xored with a salt. This is the default
345 comment "Block modes"
348 tristate "CBC support"
349 select CRYPTO_BLKCIPHER
350 select CRYPTO_MANAGER
352 CBC: Cipher Block Chaining mode
353 This block cipher algorithm is required for IPSec.
356 tristate "CFB support"
357 select CRYPTO_BLKCIPHER
358 select CRYPTO_MANAGER
360 CFB: Cipher FeedBack mode
361 This block cipher algorithm is required for TPM2 Cryptography.
364 tristate "CTR support"
365 select CRYPTO_BLKCIPHER
367 select CRYPTO_MANAGER
370 This block cipher algorithm is required for IPSec.
373 tristate "CTS support"
374 select CRYPTO_BLKCIPHER
375 select CRYPTO_MANAGER
377 CTS: Cipher Text Stealing
378 This is the Cipher Text Stealing mode as described by
379 Section 8 of rfc2040 and referenced by rfc3962
380 (rfc3962 includes errata information in its Appendix A) or
381 CBC-CS3 as defined by NIST in Sp800-38A addendum from Oct 2010.
382 This mode is required for Kerberos gss mechanism support
385 See: https://csrc.nist.gov/publications/detail/sp/800-38a/addendum/final
388 tristate "ECB support"
389 select CRYPTO_BLKCIPHER
390 select CRYPTO_MANAGER
392 ECB: Electronic CodeBook mode
393 This is the simplest block cipher algorithm. It simply encrypts
394 the input block by block.
397 tristate "LRW support"
398 select CRYPTO_BLKCIPHER
399 select CRYPTO_MANAGER
400 select CRYPTO_GF128MUL
402 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
403 narrow block cipher mode for dm-crypt. Use it with cipher
404 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
405 The first 128, 192 or 256 bits in the key are used for AES and the
406 rest is used to tie each cipher block to its logical position.
409 tristate "OFB support"
410 select CRYPTO_BLKCIPHER
411 select CRYPTO_MANAGER
413 OFB: the Output Feedback mode makes a block cipher into a synchronous
414 stream cipher. It generates keystream blocks, which are then XORed
415 with the plaintext blocks to get the ciphertext. Flipping a bit in the
416 ciphertext produces a flipped bit in the plaintext at the same
417 location. This property allows many error correcting codes to function
418 normally even when applied before encryption.
421 tristate "PCBC support"
422 select CRYPTO_BLKCIPHER
423 select CRYPTO_MANAGER
425 PCBC: Propagating Cipher Block Chaining mode
426 This block cipher algorithm is required for RxRPC.
429 tristate "XTS support"
430 select CRYPTO_BLKCIPHER
431 select CRYPTO_MANAGER
434 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
435 key size 256, 384 or 512 bits. This implementation currently
436 can't handle a sectorsize which is not a multiple of 16 bytes.
438 config CRYPTO_KEYWRAP
439 tristate "Key wrapping support"
440 select CRYPTO_BLKCIPHER
441 select CRYPTO_MANAGER
443 Support for key wrapping (NIST SP800-38F / RFC3394) without
446 config CRYPTO_NHPOLY1305
449 select CRYPTO_POLY1305
451 config CRYPTO_NHPOLY1305_SSE2
452 tristate "NHPoly1305 hash function (x86_64 SSE2 implementation)"
453 depends on X86 && 64BIT
454 select CRYPTO_NHPOLY1305
456 SSE2 optimized implementation of the hash function used by the
457 Adiantum encryption mode.
459 config CRYPTO_NHPOLY1305_AVX2
460 tristate "NHPoly1305 hash function (x86_64 AVX2 implementation)"
461 depends on X86 && 64BIT
462 select CRYPTO_NHPOLY1305
464 AVX2 optimized implementation of the hash function used by the
465 Adiantum encryption mode.
467 config CRYPTO_ADIANTUM
468 tristate "Adiantum support"
469 select CRYPTO_CHACHA20
470 select CRYPTO_POLY1305
471 select CRYPTO_NHPOLY1305
472 select CRYPTO_MANAGER
474 Adiantum is a tweakable, length-preserving encryption mode
475 designed for fast and secure disk encryption, especially on
476 CPUs without dedicated crypto instructions. It encrypts
477 each sector using the XChaCha12 stream cipher, two passes of
478 an ε-almost-∆-universal hash function, and an invocation of
479 the AES-256 block cipher on a single 16-byte block. On CPUs
480 without AES instructions, Adiantum is much faster than
483 Adiantum's security is provably reducible to that of its
484 underlying stream and block ciphers, subject to a security
485 bound. Unlike XTS, Adiantum is a true wide-block encryption
486 mode, so it actually provides an even stronger notion of
487 security than XTS, subject to the security bound.
492 tristate "ESSIV support for block encryption"
493 select CRYPTO_AUTHENC
495 Encrypted salt-sector initialization vector (ESSIV) is an IV
496 generation method that is used in some cases by fscrypt and/or
497 dm-crypt. It uses the hash of the block encryption key as the
498 symmetric key for a block encryption pass applied to the input
499 IV, making low entropy IV sources more suitable for block
502 This driver implements a crypto API template that can be
503 instantiated either as a skcipher or as a aead (depending on the
504 type of the first template argument), and which defers encryption
505 and decryption requests to the encapsulated cipher after applying
506 ESSIV to the input IV. Note that in the aead case, it is assumed
507 that the keys are presented in the same format used by the authenc
508 template, and that the IV appears at the end of the authenticated
509 associated data (AAD) region (which is how dm-crypt uses it.)
511 Note that the use of ESSIV is not recommended for new deployments,
512 and so this only needs to be enabled when interoperability with
513 existing encrypted volumes of filesystems is required, or when
514 building for a particular system that requires it (e.g., when
515 the SoC in question has accelerated CBC but not XTS, making CBC
516 combined with ESSIV the only feasible mode for h/w accelerated
522 tristate "CMAC support"
524 select CRYPTO_MANAGER
526 Cipher-based Message Authentication Code (CMAC) specified by
527 The National Institute of Standards and Technology (NIST).
529 https://tools.ietf.org/html/rfc4493
530 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
533 tristate "HMAC support"
535 select CRYPTO_MANAGER
537 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
538 This is required for IPSec.
541 tristate "XCBC support"
543 select CRYPTO_MANAGER
545 XCBC: Keyed-Hashing with encryption algorithm
546 http://www.ietf.org/rfc/rfc3566.txt
547 http://csrc.nist.gov/encryption/modes/proposedmodes/
548 xcbc-mac/xcbc-mac-spec.pdf
551 tristate "VMAC support"
553 select CRYPTO_MANAGER
555 VMAC is a message authentication algorithm designed for
556 very high speed on 64-bit architectures.
559 <http://fastcrypto.org/vmac>
564 tristate "CRC32c CRC algorithm"
568 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
569 by iSCSI for header and data digests and by others.
570 See Castagnoli93. Module will be crc32c.
572 config CRYPTO_CRC32C_INTEL
573 tristate "CRC32c INTEL hardware acceleration"
577 In Intel processor with SSE4.2 supported, the processor will
578 support CRC32C implementation using hardware accelerated CRC32
579 instruction. This option will create 'crc32c-intel' module,
580 which will enable any routine to use the CRC32 instruction to
581 gain performance compared with software implementation.
582 Module will be crc32c-intel.
584 config CRYPTO_CRC32C_VPMSUM
585 tristate "CRC32c CRC algorithm (powerpc64)"
586 depends on PPC64 && ALTIVEC
590 CRC32c algorithm implemented using vector polynomial multiply-sum
591 (vpmsum) instructions, introduced in POWER8. Enable on POWER8
592 and newer processors for improved performance.
595 config CRYPTO_CRC32C_SPARC64
596 tristate "CRC32c CRC algorithm (SPARC64)"
601 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
605 tristate "CRC32 CRC algorithm"
609 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
610 Shash crypto api wrappers to crc32_le function.
612 config CRYPTO_CRC32_PCLMUL
613 tristate "CRC32 PCLMULQDQ hardware acceleration"
618 From Intel Westmere and AMD Bulldozer processor with SSE4.2
619 and PCLMULQDQ supported, the processor will support
620 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
621 instruction. This option will create 'crc32-pclmul' module,
622 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
623 and gain better performance as compared with the table implementation.
625 config CRYPTO_CRC32_MIPS
626 tristate "CRC32c and CRC32 CRC algorithm (MIPS)"
627 depends on MIPS_CRC_SUPPORT
630 CRC32c and CRC32 CRC algorithms implemented using mips crypto
631 instructions, when available.
635 tristate "xxHash hash algorithm"
639 xxHash non-cryptographic hash algorithm. Extremely fast, working at
640 speeds close to RAM limits.
642 config CRYPTO_CRCT10DIF
643 tristate "CRCT10DIF algorithm"
646 CRC T10 Data Integrity Field computation is being cast as
647 a crypto transform. This allows for faster crc t10 diff
648 transforms to be used if they are available.
650 config CRYPTO_CRCT10DIF_PCLMUL
651 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
652 depends on X86 && 64BIT && CRC_T10DIF
655 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
656 CRC T10 DIF PCLMULQDQ computation can be hardware
657 accelerated PCLMULQDQ instruction. This option will create
658 'crct10dif-pclmul' module, which is faster when computing the
659 crct10dif checksum as compared with the generic table implementation.
661 config CRYPTO_CRCT10DIF_VPMSUM
662 tristate "CRC32T10DIF powerpc64 hardware acceleration"
663 depends on PPC64 && ALTIVEC && CRC_T10DIF
666 CRC10T10DIF algorithm implemented using vector polynomial
667 multiply-sum (vpmsum) instructions, introduced in POWER8. Enable on
668 POWER8 and newer processors for improved performance.
670 config CRYPTO_VPMSUM_TESTER
671 tristate "Powerpc64 vpmsum hardware acceleration tester"
672 depends on CRYPTO_CRCT10DIF_VPMSUM && CRYPTO_CRC32C_VPMSUM
674 Stress test for CRC32c and CRC-T10DIF algorithms implemented with
675 POWER8 vpmsum instructions.
676 Unless you are testing these algorithms, you don't need this.
679 tristate "GHASH hash function"
680 select CRYPTO_GF128MUL
683 GHASH is the hash function used in GCM (Galois/Counter Mode).
684 It is not a general-purpose cryptographic hash function.
686 config CRYPTO_POLY1305
687 tristate "Poly1305 authenticator algorithm"
690 Poly1305 authenticator algorithm, RFC7539.
692 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
693 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
694 in IETF protocols. This is the portable C implementation of Poly1305.
696 config CRYPTO_POLY1305_X86_64
697 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
698 depends on X86 && 64BIT
699 select CRYPTO_POLY1305
701 Poly1305 authenticator algorithm, RFC7539.
703 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
704 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
705 in IETF protocols. This is the x86_64 assembler implementation using SIMD
709 tristate "MD4 digest algorithm"
712 MD4 message digest algorithm (RFC1320).
715 tristate "MD5 digest algorithm"
718 MD5 message digest algorithm (RFC1321).
720 config CRYPTO_MD5_OCTEON
721 tristate "MD5 digest algorithm (OCTEON)"
722 depends on CPU_CAVIUM_OCTEON
726 MD5 message digest algorithm (RFC1321) implemented
727 using OCTEON crypto instructions, when available.
729 config CRYPTO_MD5_PPC
730 tristate "MD5 digest algorithm (PPC)"
734 MD5 message digest algorithm (RFC1321) implemented
737 config CRYPTO_MD5_SPARC64
738 tristate "MD5 digest algorithm (SPARC64)"
743 MD5 message digest algorithm (RFC1321) implemented
744 using sparc64 crypto instructions, when available.
746 config CRYPTO_MICHAEL_MIC
747 tristate "Michael MIC keyed digest algorithm"
750 Michael MIC is used for message integrity protection in TKIP
751 (IEEE 802.11i). This algorithm is required for TKIP, but it
752 should not be used for other purposes because of the weakness
756 tristate "RIPEMD-128 digest algorithm"
759 RIPEMD-128 (ISO/IEC 10118-3:2004).
761 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
762 be used as a secure replacement for RIPEMD. For other use cases,
763 RIPEMD-160 should be used.
765 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
766 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
769 tristate "RIPEMD-160 digest algorithm"
772 RIPEMD-160 (ISO/IEC 10118-3:2004).
774 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
775 to be used as a secure replacement for the 128-bit hash functions
776 MD4, MD5 and it's predecessor RIPEMD
777 (not to be confused with RIPEMD-128).
779 It's speed is comparable to SHA1 and there are no known attacks
782 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
783 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
786 tristate "RIPEMD-256 digest algorithm"
789 RIPEMD-256 is an optional extension of RIPEMD-128 with a
790 256 bit hash. It is intended for applications that require
791 longer hash-results, without needing a larger security level
794 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
795 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
798 tristate "RIPEMD-320 digest algorithm"
801 RIPEMD-320 is an optional extension of RIPEMD-160 with a
802 320 bit hash. It is intended for applications that require
803 longer hash-results, without needing a larger security level
806 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
807 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
810 tristate "SHA1 digest algorithm"
813 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
815 config CRYPTO_SHA1_SSSE3
816 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
817 depends on X86 && 64BIT
821 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
822 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
823 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
826 config CRYPTO_SHA256_SSSE3
827 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
828 depends on X86 && 64BIT
832 SHA-256 secure hash standard (DFIPS 180-2) implemented
833 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
834 Extensions version 1 (AVX1), or Advanced Vector Extensions
835 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
836 Instructions) when available.
838 config CRYPTO_SHA512_SSSE3
839 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
840 depends on X86 && 64BIT
844 SHA-512 secure hash standard (DFIPS 180-2) implemented
845 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
846 Extensions version 1 (AVX1), or Advanced Vector Extensions
847 version 2 (AVX2) instructions, when available.
849 config CRYPTO_SHA1_OCTEON
850 tristate "SHA1 digest algorithm (OCTEON)"
851 depends on CPU_CAVIUM_OCTEON
855 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
856 using OCTEON crypto instructions, when available.
858 config CRYPTO_SHA1_SPARC64
859 tristate "SHA1 digest algorithm (SPARC64)"
864 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
865 using sparc64 crypto instructions, when available.
867 config CRYPTO_SHA1_PPC
868 tristate "SHA1 digest algorithm (powerpc)"
871 This is the powerpc hardware accelerated implementation of the
872 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
874 config CRYPTO_SHA1_PPC_SPE
875 tristate "SHA1 digest algorithm (PPC SPE)"
876 depends on PPC && SPE
878 SHA-1 secure hash standard (DFIPS 180-4) implemented
879 using powerpc SPE SIMD instruction set.
881 config CRYPTO_LIB_SHA256
885 tristate "SHA224 and SHA256 digest algorithm"
887 select CRYPTO_LIB_SHA256
889 SHA256 secure hash standard (DFIPS 180-2).
891 This version of SHA implements a 256 bit hash with 128 bits of
892 security against collision attacks.
894 This code also includes SHA-224, a 224 bit hash with 112 bits
895 of security against collision attacks.
897 config CRYPTO_SHA256_PPC_SPE
898 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
899 depends on PPC && SPE
903 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
904 implemented using powerpc SPE SIMD instruction set.
906 config CRYPTO_SHA256_OCTEON
907 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
908 depends on CPU_CAVIUM_OCTEON
912 SHA-256 secure hash standard (DFIPS 180-2) implemented
913 using OCTEON crypto instructions, when available.
915 config CRYPTO_SHA256_SPARC64
916 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
921 SHA-256 secure hash standard (DFIPS 180-2) implemented
922 using sparc64 crypto instructions, when available.
925 tristate "SHA384 and SHA512 digest algorithms"
928 SHA512 secure hash standard (DFIPS 180-2).
930 This version of SHA implements a 512 bit hash with 256 bits of
931 security against collision attacks.
933 This code also includes SHA-384, a 384 bit hash with 192 bits
934 of security against collision attacks.
936 config CRYPTO_SHA512_OCTEON
937 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
938 depends on CPU_CAVIUM_OCTEON
942 SHA-512 secure hash standard (DFIPS 180-2) implemented
943 using OCTEON crypto instructions, when available.
945 config CRYPTO_SHA512_SPARC64
946 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
951 SHA-512 secure hash standard (DFIPS 180-2) implemented
952 using sparc64 crypto instructions, when available.
955 tristate "SHA3 digest algorithm"
958 SHA-3 secure hash standard (DFIPS 202). It's based on
959 cryptographic sponge function family called Keccak.
962 http://keccak.noekeon.org/
965 tristate "SM3 digest algorithm"
968 SM3 secure hash function as defined by OSCCA GM/T 0004-2012 SM3).
969 It is part of the Chinese Commercial Cryptography suite.
972 http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
973 https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
975 config CRYPTO_STREEBOG
976 tristate "Streebog Hash Function"
979 Streebog Hash Function (GOST R 34.11-2012, RFC 6986) is one of the Russian
980 cryptographic standard algorithms (called GOST algorithms).
981 This setting enables two hash algorithms with 256 and 512 bits output.
984 https://tc26.ru/upload/iblock/fed/feddbb4d26b685903faa2ba11aea43f6.pdf
985 https://tools.ietf.org/html/rfc6986
988 tristate "Tiger digest algorithms"
991 Tiger hash algorithm 192, 160 and 128-bit hashes
993 Tiger is a hash function optimized for 64-bit processors while
994 still having decent performance on 32-bit processors.
995 Tiger was developed by Ross Anderson and Eli Biham.
998 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
1001 tristate "Whirlpool digest algorithms"
1004 Whirlpool hash algorithm 512, 384 and 256-bit hashes
1006 Whirlpool-512 is part of the NESSIE cryptographic primitives.
1007 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
1010 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
1012 config CRYPTO_GHASH_CLMUL_NI_INTEL
1013 tristate "GHASH hash function (CLMUL-NI accelerated)"
1014 depends on X86 && 64BIT
1015 select CRYPTO_CRYPTD
1017 This is the x86_64 CLMUL-NI accelerated implementation of
1018 GHASH, the hash function used in GCM (Galois/Counter mode).
1022 config CRYPTO_LIB_AES
1026 tristate "AES cipher algorithms"
1027 select CRYPTO_ALGAPI
1028 select CRYPTO_LIB_AES
1030 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1033 Rijndael appears to be consistently a very good performer in
1034 both hardware and software across a wide range of computing
1035 environments regardless of its use in feedback or non-feedback
1036 modes. Its key setup time is excellent, and its key agility is
1037 good. Rijndael's very low memory requirements make it very well
1038 suited for restricted-space environments, in which it also
1039 demonstrates excellent performance. Rijndael's operations are
1040 among the easiest to defend against power and timing attacks.
1042 The AES specifies three key sizes: 128, 192 and 256 bits
1044 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
1046 config CRYPTO_AES_TI
1047 tristate "Fixed time AES cipher"
1048 select CRYPTO_ALGAPI
1049 select CRYPTO_LIB_AES
1051 This is a generic implementation of AES that attempts to eliminate
1052 data dependent latencies as much as possible without affecting
1053 performance too much. It is intended for use by the generic CCM
1054 and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
1055 solely on encryption (although decryption is supported as well, but
1056 with a more dramatic performance hit)
1058 Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
1059 8 for decryption), this implementation only uses just two S-boxes of
1060 256 bytes each, and attempts to eliminate data dependent latencies by
1061 prefetching the entire table into the cache at the start of each
1062 block. Interrupts are also disabled to avoid races where cachelines
1063 are evicted when the CPU is interrupted to do something else.
1065 config CRYPTO_AES_NI_INTEL
1066 tristate "AES cipher algorithms (AES-NI)"
1069 select CRYPTO_LIB_AES
1070 select CRYPTO_ALGAPI
1071 select CRYPTO_BLKCIPHER
1072 select CRYPTO_GLUE_HELPER_X86 if 64BIT
1075 Use Intel AES-NI instructions for AES algorithm.
1077 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1080 Rijndael appears to be consistently a very good performer in
1081 both hardware and software across a wide range of computing
1082 environments regardless of its use in feedback or non-feedback
1083 modes. Its key setup time is excellent, and its key agility is
1084 good. Rijndael's very low memory requirements make it very well
1085 suited for restricted-space environments, in which it also
1086 demonstrates excellent performance. Rijndael's operations are
1087 among the easiest to defend against power and timing attacks.
1089 The AES specifies three key sizes: 128, 192 and 256 bits
1091 See <http://csrc.nist.gov/encryption/aes/> for more information.
1093 In addition to AES cipher algorithm support, the acceleration
1094 for some popular block cipher mode is supported too, including
1095 ECB, CBC, LRW, XTS. The 64 bit version has additional
1096 acceleration for CTR.
1098 config CRYPTO_AES_SPARC64
1099 tristate "AES cipher algorithms (SPARC64)"
1101 select CRYPTO_BLKCIPHER
1103 Use SPARC64 crypto opcodes for AES algorithm.
1105 AES cipher algorithms (FIPS-197). AES uses the Rijndael
1108 Rijndael appears to be consistently a very good performer in
1109 both hardware and software across a wide range of computing
1110 environments regardless of its use in feedback or non-feedback
1111 modes. Its key setup time is excellent, and its key agility is
1112 good. Rijndael's very low memory requirements make it very well
1113 suited for restricted-space environments, in which it also
1114 demonstrates excellent performance. Rijndael's operations are
1115 among the easiest to defend against power and timing attacks.
1117 The AES specifies three key sizes: 128, 192 and 256 bits
1119 See <http://csrc.nist.gov/encryption/aes/> for more information.
1121 In addition to AES cipher algorithm support, the acceleration
1122 for some popular block cipher mode is supported too, including
1125 config CRYPTO_AES_PPC_SPE
1126 tristate "AES cipher algorithms (PPC SPE)"
1127 depends on PPC && SPE
1129 AES cipher algorithms (FIPS-197). Additionally the acceleration
1130 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
1131 This module should only be used for low power (router) devices
1132 without hardware AES acceleration (e.g. caam crypto). It reduces the
1133 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
1134 timining attacks. Nevertheless it might be not as secure as other
1135 architecture specific assembler implementations that work on 1KB
1136 tables or 256 bytes S-boxes.
1138 config CRYPTO_ANUBIS
1139 tristate "Anubis cipher algorithm"
1140 select CRYPTO_ALGAPI
1142 Anubis cipher algorithm.
1144 Anubis is a variable key length cipher which can use keys from
1145 128 bits to 320 bits in length. It was evaluated as a entrant
1146 in the NESSIE competition.
1149 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1150 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1152 config CRYPTO_LIB_ARC4
1156 tristate "ARC4 cipher algorithm"
1157 select CRYPTO_BLKCIPHER
1158 select CRYPTO_LIB_ARC4
1160 ARC4 cipher algorithm.
1162 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1163 bits in length. This algorithm is required for driver-based
1164 WEP, but it should not be for other purposes because of the
1165 weakness of the algorithm.
1167 config CRYPTO_BLOWFISH
1168 tristate "Blowfish cipher algorithm"
1169 select CRYPTO_ALGAPI
1170 select CRYPTO_BLOWFISH_COMMON
1172 Blowfish cipher algorithm, by Bruce Schneier.
1174 This is a variable key length cipher which can use keys from 32
1175 bits to 448 bits in length. It's fast, simple and specifically
1176 designed for use on "large microprocessors".
1179 <http://www.schneier.com/blowfish.html>
1181 config CRYPTO_BLOWFISH_COMMON
1184 Common parts of the Blowfish cipher algorithm shared by the
1185 generic c and the assembler implementations.
1188 <http://www.schneier.com/blowfish.html>
1190 config CRYPTO_BLOWFISH_X86_64
1191 tristate "Blowfish cipher algorithm (x86_64)"
1192 depends on X86 && 64BIT
1193 select CRYPTO_BLKCIPHER
1194 select CRYPTO_BLOWFISH_COMMON
1196 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1198 This is a variable key length cipher which can use keys from 32
1199 bits to 448 bits in length. It's fast, simple and specifically
1200 designed for use on "large microprocessors".
1203 <http://www.schneier.com/blowfish.html>
1205 config CRYPTO_CAMELLIA
1206 tristate "Camellia cipher algorithms"
1208 select CRYPTO_ALGAPI
1210 Camellia cipher algorithms module.
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_CAMELLIA_X86_64
1221 tristate "Camellia cipher algorithm (x86_64)"
1222 depends on X86 && 64BIT
1224 select CRYPTO_BLKCIPHER
1225 select CRYPTO_GLUE_HELPER_X86
1227 Camellia cipher algorithm module (x86_64).
1229 Camellia is a symmetric key block cipher developed jointly
1230 at NTT and Mitsubishi Electric Corporation.
1232 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1235 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1237 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1238 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1239 depends on X86 && 64BIT
1241 select CRYPTO_BLKCIPHER
1242 select CRYPTO_CAMELLIA_X86_64
1243 select CRYPTO_GLUE_HELPER_X86
1247 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1249 Camellia is a symmetric key block cipher developed jointly
1250 at NTT and Mitsubishi Electric Corporation.
1252 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1255 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1257 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1258 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1259 depends on X86 && 64BIT
1261 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1263 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1265 Camellia is a symmetric key block cipher developed jointly
1266 at NTT and Mitsubishi Electric Corporation.
1268 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1271 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1273 config CRYPTO_CAMELLIA_SPARC64
1274 tristate "Camellia cipher algorithm (SPARC64)"
1277 select CRYPTO_ALGAPI
1278 select CRYPTO_BLKCIPHER
1280 Camellia cipher algorithm module (SPARC64).
1282 Camellia is a symmetric key block cipher developed jointly
1283 at NTT and Mitsubishi Electric Corporation.
1285 The Camellia specifies three key sizes: 128, 192 and 256 bits.
1288 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1290 config CRYPTO_CAST_COMMON
1293 Common parts of the CAST cipher algorithms shared by the
1294 generic c and the assembler implementations.
1297 tristate "CAST5 (CAST-128) cipher algorithm"
1298 select CRYPTO_ALGAPI
1299 select CRYPTO_CAST_COMMON
1301 The CAST5 encryption algorithm (synonymous with CAST-128) is
1302 described in RFC2144.
1304 config CRYPTO_CAST5_AVX_X86_64
1305 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1306 depends on X86 && 64BIT
1307 select CRYPTO_BLKCIPHER
1309 select CRYPTO_CAST_COMMON
1312 The CAST5 encryption algorithm (synonymous with CAST-128) is
1313 described in RFC2144.
1315 This module provides the Cast5 cipher algorithm that processes
1316 sixteen blocks parallel using the AVX instruction set.
1319 tristate "CAST6 (CAST-256) cipher algorithm"
1320 select CRYPTO_ALGAPI
1321 select CRYPTO_CAST_COMMON
1323 The CAST6 encryption algorithm (synonymous with CAST-256) is
1324 described in RFC2612.
1326 config CRYPTO_CAST6_AVX_X86_64
1327 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1328 depends on X86 && 64BIT
1329 select CRYPTO_BLKCIPHER
1331 select CRYPTO_CAST_COMMON
1332 select CRYPTO_GLUE_HELPER_X86
1336 The CAST6 encryption algorithm (synonymous with CAST-256) is
1337 described in RFC2612.
1339 This module provides the Cast6 cipher algorithm that processes
1340 eight blocks parallel using the AVX instruction set.
1342 config CRYPTO_LIB_DES
1346 tristate "DES and Triple DES EDE cipher algorithms"
1347 select CRYPTO_ALGAPI
1348 select CRYPTO_LIB_DES
1350 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1352 config CRYPTO_DES_SPARC64
1353 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1355 select CRYPTO_ALGAPI
1356 select CRYPTO_LIB_DES
1357 select CRYPTO_BLKCIPHER
1359 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1360 optimized using SPARC64 crypto opcodes.
1362 config CRYPTO_DES3_EDE_X86_64
1363 tristate "Triple DES EDE cipher algorithm (x86-64)"
1364 depends on X86 && 64BIT
1365 select CRYPTO_BLKCIPHER
1366 select CRYPTO_LIB_DES
1368 Triple DES EDE (FIPS 46-3) algorithm.
1370 This module provides implementation of the Triple DES EDE cipher
1371 algorithm that is optimized for x86-64 processors. Two versions of
1372 algorithm are provided; regular processing one input block and
1373 one that processes three blocks parallel.
1375 config CRYPTO_FCRYPT
1376 tristate "FCrypt cipher algorithm"
1377 select CRYPTO_ALGAPI
1378 select CRYPTO_BLKCIPHER
1380 FCrypt algorithm used by RxRPC.
1382 config CRYPTO_KHAZAD
1383 tristate "Khazad cipher algorithm"
1384 select CRYPTO_ALGAPI
1386 Khazad cipher algorithm.
1388 Khazad was a finalist in the initial NESSIE competition. It is
1389 an algorithm optimized for 64-bit processors with good performance
1390 on 32-bit processors. Khazad uses an 128 bit key size.
1393 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1395 config CRYPTO_SALSA20
1396 tristate "Salsa20 stream cipher algorithm"
1397 select CRYPTO_BLKCIPHER
1399 Salsa20 stream cipher algorithm.
1401 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1402 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1404 The Salsa20 stream cipher algorithm is designed by Daniel J.
1405 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1407 config CRYPTO_CHACHA20
1408 tristate "ChaCha stream cipher algorithms"
1409 select CRYPTO_BLKCIPHER
1411 The ChaCha20, XChaCha20, and XChaCha12 stream cipher algorithms.
1413 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1414 Bernstein and further specified in RFC7539 for use in IETF protocols.
1415 This is the portable C implementation of ChaCha20. See also:
1416 <http://cr.yp.to/chacha/chacha-20080128.pdf>
1418 XChaCha20 is the application of the XSalsa20 construction to ChaCha20
1419 rather than to Salsa20. XChaCha20 extends ChaCha20's nonce length
1420 from 64 bits (or 96 bits using the RFC7539 convention) to 192 bits,
1421 while provably retaining ChaCha20's security. See also:
1422 <https://cr.yp.to/snuffle/xsalsa-20081128.pdf>
1424 XChaCha12 is XChaCha20 reduced to 12 rounds, with correspondingly
1425 reduced security margin but increased performance. It can be needed
1426 in some performance-sensitive scenarios.
1428 config CRYPTO_CHACHA20_X86_64
1429 tristate "ChaCha stream cipher algorithms (x86_64/SSSE3/AVX2/AVX-512VL)"
1430 depends on X86 && 64BIT
1431 select CRYPTO_BLKCIPHER
1432 select CRYPTO_CHACHA20
1434 SSSE3, AVX2, and AVX-512VL optimized implementations of the ChaCha20,
1435 XChaCha20, and XChaCha12 stream ciphers.
1438 tristate "SEED cipher algorithm"
1439 select CRYPTO_ALGAPI
1441 SEED cipher algorithm (RFC4269).
1443 SEED is a 128-bit symmetric key block cipher that has been
1444 developed by KISA (Korea Information Security Agency) as a
1445 national standard encryption algorithm of the Republic of Korea.
1446 It is a 16 round block cipher with the key size of 128 bit.
1449 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1451 config CRYPTO_SERPENT
1452 tristate "Serpent cipher algorithm"
1453 select CRYPTO_ALGAPI
1455 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1457 Keys are allowed to be from 0 to 256 bits in length, in steps
1458 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
1459 variant of Serpent for compatibility with old kerneli.org code.
1462 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1464 config CRYPTO_SERPENT_SSE2_X86_64
1465 tristate "Serpent cipher algorithm (x86_64/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 eight
1478 blocks parallel using SSE2 instruction set.
1481 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1483 config CRYPTO_SERPENT_SSE2_586
1484 tristate "Serpent cipher algorithm (i586/SSE2)"
1485 depends on X86 && !64BIT
1486 select CRYPTO_BLKCIPHER
1487 select CRYPTO_GLUE_HELPER_X86
1488 select CRYPTO_SERPENT
1491 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1493 Keys are allowed to be from 0 to 256 bits in length, in steps
1496 This module provides Serpent cipher algorithm that processes four
1497 blocks parallel using SSE2 instruction set.
1500 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1502 config CRYPTO_SERPENT_AVX_X86_64
1503 tristate "Serpent cipher algorithm (x86_64/AVX)"
1504 depends on X86 && 64BIT
1505 select CRYPTO_BLKCIPHER
1506 select CRYPTO_GLUE_HELPER_X86
1507 select CRYPTO_SERPENT
1511 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1513 Keys are allowed to be from 0 to 256 bits in length, in steps
1516 This module provides the Serpent cipher algorithm that processes
1517 eight blocks parallel using the AVX instruction set.
1520 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1522 config CRYPTO_SERPENT_AVX2_X86_64
1523 tristate "Serpent cipher algorithm (x86_64/AVX2)"
1524 depends on X86 && 64BIT
1525 select CRYPTO_SERPENT_AVX_X86_64
1527 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1529 Keys are allowed to be from 0 to 256 bits in length, in steps
1532 This module provides Serpent cipher algorithm that processes 16
1533 blocks parallel using AVX2 instruction set.
1536 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1539 tristate "SM4 cipher algorithm"
1540 select CRYPTO_ALGAPI
1542 SM4 cipher algorithms (OSCCA GB/T 32907-2016).
1544 SM4 (GBT.32907-2016) is a cryptographic standard issued by the
1545 Organization of State Commercial Administration of China (OSCCA)
1546 as an authorized cryptographic algorithms for the use within China.
1548 SMS4 was originally created for use in protecting wireless
1549 networks, and is mandated in the Chinese National Standard for
1550 Wireless LAN WAPI (Wired Authentication and Privacy Infrastructure)
1553 The latest SM4 standard (GBT.32907-2016) was proposed by OSCCA and
1554 standardized through TC 260 of the Standardization Administration
1555 of the People's Republic of China (SAC).
1557 The input, output, and key of SMS4 are each 128 bits.
1559 See also: <https://eprint.iacr.org/2008/329.pdf>
1564 tristate "TEA, XTEA and XETA cipher algorithms"
1565 select CRYPTO_ALGAPI
1567 TEA cipher algorithm.
1569 Tiny Encryption Algorithm is a simple cipher that uses
1570 many rounds for security. It is very fast and uses
1573 Xtendend Tiny Encryption Algorithm is a modification to
1574 the TEA algorithm to address a potential key weakness
1575 in the TEA algorithm.
1577 Xtendend Encryption Tiny Algorithm is a mis-implementation
1578 of the XTEA algorithm for compatibility purposes.
1580 config CRYPTO_TWOFISH
1581 tristate "Twofish cipher algorithm"
1582 select CRYPTO_ALGAPI
1583 select CRYPTO_TWOFISH_COMMON
1585 Twofish cipher algorithm.
1587 Twofish was submitted as an AES (Advanced Encryption Standard)
1588 candidate cipher by researchers at CounterPane Systems. It is a
1589 16 round block cipher supporting key sizes of 128, 192, and 256
1593 <http://www.schneier.com/twofish.html>
1595 config CRYPTO_TWOFISH_COMMON
1598 Common parts of the Twofish cipher algorithm shared by the
1599 generic c and the assembler implementations.
1601 config CRYPTO_TWOFISH_586
1602 tristate "Twofish cipher algorithms (i586)"
1603 depends on (X86 || UML_X86) && !64BIT
1604 select CRYPTO_ALGAPI
1605 select CRYPTO_TWOFISH_COMMON
1607 Twofish cipher algorithm.
1609 Twofish was submitted as an AES (Advanced Encryption Standard)
1610 candidate cipher by researchers at CounterPane Systems. It is a
1611 16 round block cipher supporting key sizes of 128, 192, and 256
1615 <http://www.schneier.com/twofish.html>
1617 config CRYPTO_TWOFISH_X86_64
1618 tristate "Twofish cipher algorithm (x86_64)"
1619 depends on (X86 || UML_X86) && 64BIT
1620 select CRYPTO_ALGAPI
1621 select CRYPTO_TWOFISH_COMMON
1623 Twofish cipher algorithm (x86_64).
1625 Twofish was submitted as an AES (Advanced Encryption Standard)
1626 candidate cipher by researchers at CounterPane Systems. It is a
1627 16 round block cipher supporting key sizes of 128, 192, and 256
1631 <http://www.schneier.com/twofish.html>
1633 config CRYPTO_TWOFISH_X86_64_3WAY
1634 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1635 depends on X86 && 64BIT
1636 select CRYPTO_BLKCIPHER
1637 select CRYPTO_TWOFISH_COMMON
1638 select CRYPTO_TWOFISH_X86_64
1639 select CRYPTO_GLUE_HELPER_X86
1641 Twofish cipher algorithm (x86_64, 3-way parallel).
1643 Twofish was submitted as an AES (Advanced Encryption Standard)
1644 candidate cipher by researchers at CounterPane Systems. It is a
1645 16 round block cipher supporting key sizes of 128, 192, and 256
1648 This module provides Twofish cipher algorithm that processes three
1649 blocks parallel, utilizing resources of out-of-order CPUs better.
1652 <http://www.schneier.com/twofish.html>
1654 config CRYPTO_TWOFISH_AVX_X86_64
1655 tristate "Twofish cipher algorithm (x86_64/AVX)"
1656 depends on X86 && 64BIT
1657 select CRYPTO_BLKCIPHER
1658 select CRYPTO_GLUE_HELPER_X86
1660 select CRYPTO_TWOFISH_COMMON
1661 select CRYPTO_TWOFISH_X86_64
1662 select CRYPTO_TWOFISH_X86_64_3WAY
1664 Twofish cipher algorithm (x86_64/AVX).
1666 Twofish was submitted as an AES (Advanced Encryption Standard)
1667 candidate cipher by researchers at CounterPane Systems. It is a
1668 16 round block cipher supporting key sizes of 128, 192, and 256
1671 This module provides the Twofish cipher algorithm that processes
1672 eight blocks parallel using the AVX Instruction Set.
1675 <http://www.schneier.com/twofish.html>
1677 comment "Compression"
1679 config CRYPTO_DEFLATE
1680 tristate "Deflate compression algorithm"
1681 select CRYPTO_ALGAPI
1682 select CRYPTO_ACOMP2
1686 This is the Deflate algorithm (RFC1951), specified for use in
1687 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1689 You will most probably want this if using IPSec.
1692 tristate "LZO compression algorithm"
1693 select CRYPTO_ALGAPI
1694 select CRYPTO_ACOMP2
1696 select LZO_DECOMPRESS
1698 This is the LZO algorithm.
1701 tristate "842 compression algorithm"
1702 select CRYPTO_ALGAPI
1703 select CRYPTO_ACOMP2
1705 select 842_DECOMPRESS
1707 This is the 842 algorithm.
1710 tristate "LZ4 compression algorithm"
1711 select CRYPTO_ALGAPI
1712 select CRYPTO_ACOMP2
1714 select LZ4_DECOMPRESS
1716 This is the LZ4 algorithm.
1719 tristate "LZ4HC compression algorithm"
1720 select CRYPTO_ALGAPI
1721 select CRYPTO_ACOMP2
1722 select LZ4HC_COMPRESS
1723 select LZ4_DECOMPRESS
1725 This is the LZ4 high compression mode algorithm.
1728 tristate "Zstd compression algorithm"
1729 select CRYPTO_ALGAPI
1730 select CRYPTO_ACOMP2
1731 select ZSTD_COMPRESS
1732 select ZSTD_DECOMPRESS
1734 This is the zstd algorithm.
1736 comment "Random Number Generation"
1738 config CRYPTO_ANSI_CPRNG
1739 tristate "Pseudo Random Number Generation for Cryptographic modules"
1743 This option enables the generic pseudo random number generator
1744 for cryptographic modules. Uses the Algorithm specified in
1745 ANSI X9.31 A.2.4. Note that this option must be enabled if
1746 CRYPTO_FIPS is selected
1748 menuconfig CRYPTO_DRBG_MENU
1749 tristate "NIST SP800-90A DRBG"
1751 NIST SP800-90A compliant DRBG. In the following submenu, one or
1752 more of the DRBG types must be selected.
1756 config CRYPTO_DRBG_HMAC
1760 select CRYPTO_SHA256
1762 config CRYPTO_DRBG_HASH
1763 bool "Enable Hash DRBG"
1764 select CRYPTO_SHA256
1766 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1768 config CRYPTO_DRBG_CTR
1769 bool "Enable CTR DRBG"
1771 depends on CRYPTO_CTR
1773 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1777 default CRYPTO_DRBG_MENU
1779 select CRYPTO_JITTERENTROPY
1781 endif # if CRYPTO_DRBG_MENU
1783 config CRYPTO_JITTERENTROPY
1784 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1787 The Jitterentropy RNG is a noise that is intended
1788 to provide seed to another RNG. The RNG does not
1789 perform any cryptographic whitening of the generated
1790 random numbers. This Jitterentropy RNG registers with
1791 the kernel crypto API and can be used by any caller.
1793 config CRYPTO_USER_API
1796 config CRYPTO_USER_API_HASH
1797 tristate "User-space interface for hash algorithms"
1800 select CRYPTO_USER_API
1802 This option enables the user-spaces interface for hash
1805 config CRYPTO_USER_API_SKCIPHER
1806 tristate "User-space interface for symmetric key cipher algorithms"
1808 select CRYPTO_BLKCIPHER
1809 select CRYPTO_USER_API
1811 This option enables the user-spaces interface for symmetric
1812 key cipher algorithms.
1814 config CRYPTO_USER_API_RNG
1815 tristate "User-space interface for random number generator algorithms"
1818 select CRYPTO_USER_API
1820 This option enables the user-spaces interface for random
1821 number generator algorithms.
1823 config CRYPTO_USER_API_AEAD
1824 tristate "User-space interface for AEAD cipher algorithms"
1827 select CRYPTO_BLKCIPHER
1829 select CRYPTO_USER_API
1831 This option enables the user-spaces interface for AEAD
1835 bool "Crypto usage statistics for User-space"
1836 depends on CRYPTO_USER
1838 This option enables the gathering of crypto stats.
1840 - encrypt/decrypt size and numbers of symmeric operations
1841 - compress/decompress size and numbers of compress operations
1842 - size and numbers of hash operations
1843 - encrypt/decrypt/sign/verify numbers for asymmetric operations
1844 - generate/seed numbers for rng operations
1846 config CRYPTO_HASH_INFO
1849 source "drivers/crypto/Kconfig"
1850 source "crypto/asymmetric_keys/Kconfig"
1851 source "certs/Kconfig"