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"
18 select CRYPTO_LIB_UTILS
20 This option provides the core Cryptographic API.
24 menu "Crypto core or helper"
27 bool "FIPS 200 compliance"
28 depends on (CRYPTO_ANSI_CPRNG || CRYPTO_DRBG) && !CRYPTO_MANAGER_DISABLE_TESTS
29 depends on (MODULE_SIG || !MODULES)
31 This option enables the fips boot option which is
32 required if you want the system to operate in a FIPS 200
33 certification. You should say no unless you know what
36 config CRYPTO_FIPS_NAME
37 string "FIPS Module Name"
38 default "Linux Kernel Cryptographic API"
39 depends on CRYPTO_FIPS
41 This option sets the FIPS Module name reported by the Crypto API via
42 the /proc/sys/crypto/fips_name file.
44 config CRYPTO_FIPS_CUSTOM_VERSION
45 bool "Use Custom FIPS Module Version"
46 depends on CRYPTO_FIPS
49 config CRYPTO_FIPS_VERSION
50 string "FIPS Module Version"
52 depends on CRYPTO_FIPS_CUSTOM_VERSION
54 This option provides the ability to override the FIPS Module Version.
55 By default the KERNELRELEASE value is used.
61 This option provides the API for cryptographic algorithms.
84 config CRYPTO_SKCIPHER
86 select CRYPTO_SKCIPHER2
90 config CRYPTO_SKCIPHER2
101 select CRYPTO_ALGAPI2
110 select CRYPTO_ALGAPI2
112 config CRYPTO_RNG_DEFAULT
114 select CRYPTO_DRBG_MENU
116 config CRYPTO_AKCIPHER2
118 select CRYPTO_ALGAPI2
120 config CRYPTO_AKCIPHER
122 select CRYPTO_AKCIPHER2
127 select CRYPTO_ALGAPI2
136 select CRYPTO_ALGAPI2
144 config CRYPTO_MANAGER
145 tristate "Cryptographic algorithm manager"
146 select CRYPTO_MANAGER2
148 Create default cryptographic template instantiations such as
151 config CRYPTO_MANAGER2
152 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
155 select CRYPTO_AKCIPHER2
160 select CRYPTO_SKCIPHER2
163 tristate "Userspace cryptographic algorithm configuration"
165 select CRYPTO_MANAGER
167 Userspace configuration for cryptographic instantiations such as
170 config CRYPTO_MANAGER_DISABLE_TESTS
171 bool "Disable run-time self tests"
174 Disable run-time self tests that normally take place at
175 algorithm registration.
177 config CRYPTO_MANAGER_EXTRA_TESTS
178 bool "Enable extra run-time crypto self tests"
179 depends on DEBUG_KERNEL && !CRYPTO_MANAGER_DISABLE_TESTS && CRYPTO_MANAGER
181 Enable extra run-time self tests of registered crypto algorithms,
182 including randomized fuzz tests.
184 This is intended for developer use only, as these tests take much
185 longer to run than the normal self tests.
188 tristate "Null algorithms"
191 These are 'Null' algorithms, used by IPsec, which do nothing.
195 select CRYPTO_ALGAPI2
196 select CRYPTO_SKCIPHER2
200 tristate "Parallel crypto engine"
203 select CRYPTO_MANAGER
206 This converts an arbitrary crypto algorithm into a parallel
207 algorithm that executes in kernel threads.
210 tristate "Software async crypto daemon"
211 select CRYPTO_SKCIPHER
213 select CRYPTO_MANAGER
215 This is a generic software asynchronous crypto daemon that
216 converts an arbitrary synchronous software crypto algorithm
217 into an asynchronous algorithm that executes in a kernel thread.
219 config CRYPTO_AUTHENC
220 tristate "Authenc support"
222 select CRYPTO_SKCIPHER
223 select CRYPTO_MANAGER
227 Authenc: Combined mode wrapper for IPsec.
229 This is required for IPSec ESP (XFRM_ESP).
232 tristate "Testing module"
233 depends on m || EXPERT
234 select CRYPTO_MANAGER
236 Quick & dirty crypto test module.
247 menu "Public-key cryptography"
250 tristate "RSA (Rivest-Shamir-Adleman)"
251 select CRYPTO_AKCIPHER
252 select CRYPTO_MANAGER
256 RSA (Rivest-Shamir-Adleman) public key algorithm (RFC8017)
259 tristate "DH (Diffie-Hellman)"
263 DH (Diffie-Hellman) key exchange algorithm
265 config CRYPTO_DH_RFC7919_GROUPS
266 bool "RFC 7919 FFDHE groups"
268 select CRYPTO_RNG_DEFAULT
270 FFDHE (Finite-Field-based Diffie-Hellman Ephemeral) groups
273 Support these finite-field groups in DH key exchanges:
274 - ffdhe2048, ffdhe3072, ffdhe4096, ffdhe6144, ffdhe8192
280 select CRYPTO_RNG_DEFAULT
283 tristate "ECDH (Elliptic Curve Diffie-Hellman)"
287 ECDH (Elliptic Curve Diffie-Hellman) key exchange algorithm
288 using curves P-192, P-256, and P-384 (FIPS 186)
291 tristate "ECDSA (Elliptic Curve Digital Signature Algorithm)"
293 select CRYPTO_AKCIPHER
296 ECDSA (Elliptic Curve Digital Signature Algorithm) (FIPS 186,
298 using curves P-192, P-256, and P-384
300 Only signature verification is implemented.
303 tristate "EC-RDSA (Elliptic Curve Russian Digital Signature Algorithm)"
305 select CRYPTO_AKCIPHER
306 select CRYPTO_STREEBOG
310 Elliptic Curve Russian Digital Signature Algorithm (GOST R 34.10-2012,
311 RFC 7091, ISO/IEC 14888-3)
313 One of the Russian cryptographic standard algorithms (called GOST
314 algorithms). Only signature verification is implemented.
317 tristate "SM2 (ShangMi 2)"
319 select CRYPTO_AKCIPHER
320 select CRYPTO_MANAGER
324 SM2 (ShangMi 2) public key algorithm
326 Published by State Encryption Management Bureau, China,
327 as specified by OSCCA GM/T 0003.1-2012 -- 0003.5-2012.
330 https://datatracker.ietf.org/doc/draft-shen-sm2-ecdsa/
331 http://www.oscca.gov.cn/sca/xxgk/2010-12/17/content_1002386.shtml
332 http://www.gmbz.org.cn/main/bzlb.html
334 config CRYPTO_CURVE25519
335 tristate "Curve25519"
337 select CRYPTO_LIB_CURVE25519_GENERIC
339 Curve25519 elliptic curve (RFC7748)
346 tristate "AES (Advanced Encryption Standard)"
348 select CRYPTO_LIB_AES
350 AES cipher algorithms (Rijndael)(FIPS-197, ISO/IEC 18033-3)
352 Rijndael appears to be consistently a very good performer in
353 both hardware and software across a wide range of computing
354 environments regardless of its use in feedback or non-feedback
355 modes. Its key setup time is excellent, and its key agility is
356 good. Rijndael's very low memory requirements make it very well
357 suited for restricted-space environments, in which it also
358 demonstrates excellent performance. Rijndael's operations are
359 among the easiest to defend against power and timing attacks.
361 The AES specifies three key sizes: 128, 192 and 256 bits
364 tristate "AES (Advanced Encryption Standard) (fixed time)"
366 select CRYPTO_LIB_AES
368 AES cipher algorithms (Rijndael)(FIPS-197, ISO/IEC 18033-3)
370 This is a generic implementation of AES that attempts to eliminate
371 data dependent latencies as much as possible without affecting
372 performance too much. It is intended for use by the generic CCM
373 and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
374 solely on encryption (although decryption is supported as well, but
375 with a more dramatic performance hit)
377 Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
378 8 for decryption), this implementation only uses just two S-boxes of
379 256 bytes each, and attempts to eliminate data dependent latencies by
380 prefetching the entire table into the cache at the start of each
381 block. Interrupts are also disabled to avoid races where cachelines
382 are evicted when the CPU is interrupted to do something else.
386 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
389 Anubis cipher algorithm
391 Anubis is a variable key length cipher which can use keys from
392 128 bits to 320 bits in length. It was evaluated as a entrant
393 in the NESSIE competition.
395 See https://web.archive.org/web/20160606112246/http://www.larc.usp.br/~pbarreto/AnubisPage.html
396 for further information.
402 ARIA cipher algorithm (RFC5794)
404 ARIA is a standard encryption algorithm of the Republic of Korea.
405 The ARIA specifies three key sizes and rounds.
411 https://seed.kisa.or.kr/kisa/algorithm/EgovAriaInfo.do
413 config CRYPTO_BLOWFISH
416 select CRYPTO_BLOWFISH_COMMON
418 Blowfish cipher algorithm, by Bruce Schneier
420 This is a variable key length cipher which can use keys from 32
421 bits to 448 bits in length. It's fast, simple and specifically
422 designed for use on "large microprocessors".
424 See https://www.schneier.com/blowfish.html for further information.
426 config CRYPTO_BLOWFISH_COMMON
429 Common parts of the Blowfish cipher algorithm shared by the
430 generic c and the assembler implementations.
432 config CRYPTO_CAMELLIA
436 Camellia cipher algorithms (ISO/IEC 18033-3)
438 Camellia is a symmetric key block cipher developed jointly
439 at NTT and Mitsubishi Electric Corporation.
441 The Camellia specifies three key sizes: 128, 192 and 256 bits.
443 See https://info.isl.ntt.co.jp/crypt/eng/camellia/ for further information.
445 config CRYPTO_CAST_COMMON
448 Common parts of the CAST cipher algorithms shared by the
449 generic c and the assembler implementations.
452 tristate "CAST5 (CAST-128)"
454 select CRYPTO_CAST_COMMON
456 CAST5 (CAST-128) cipher algorithm (RFC2144, ISO/IEC 18033-3)
459 tristate "CAST6 (CAST-256)"
461 select CRYPTO_CAST_COMMON
463 CAST6 (CAST-256) encryption algorithm (RFC2612)
466 tristate "DES and Triple DES EDE"
468 select CRYPTO_LIB_DES
470 DES (Data Encryption Standard)(FIPS 46-2, ISO/IEC 18033-3) and
471 Triple DES EDE (Encrypt/Decrypt/Encrypt) (FIPS 46-3, ISO/IEC 18033-3)
477 select CRYPTO_SKCIPHER
479 FCrypt algorithm used by RxRPC
481 See https://ota.polyonymo.us/fcrypt-paper.txt
485 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
488 Khazad cipher algorithm
490 Khazad was a finalist in the initial NESSIE competition. It is
491 an algorithm optimized for 64-bit processors with good performance
492 on 32-bit processors. Khazad uses an 128 bit key size.
494 See https://web.archive.org/web/20171011071731/http://www.larc.usp.br/~pbarreto/KhazadPage.html
495 for further information.
499 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
502 SEED cipher algorithm (RFC4269, ISO/IEC 18033-3)
504 SEED is a 128-bit symmetric key block cipher that has been
505 developed by KISA (Korea Information Security Agency) as a
506 national standard encryption algorithm of the Republic of Korea.
507 It is a 16 round block cipher with the key size of 128 bit.
509 See https://seed.kisa.or.kr/kisa/algorithm/EgovSeedInfo.do
510 for further information.
512 config CRYPTO_SERPENT
516 Serpent cipher algorithm, by Anderson, Biham & Knudsen
518 Keys are allowed to be from 0 to 256 bits in length, in steps
521 See https://www.cl.cam.ac.uk/~rja14/serpent.html for further information.
526 config CRYPTO_SM4_GENERIC
527 tristate "SM4 (ShangMi 4)"
531 SM4 cipher algorithms (OSCCA GB/T 32907-2016,
532 ISO/IEC 18033-3:2010/Amd 1:2021)
534 SM4 (GBT.32907-2016) is a cryptographic standard issued by the
535 Organization of State Commercial Administration of China (OSCCA)
536 as an authorized cryptographic algorithms for the use within China.
538 SMS4 was originally created for use in protecting wireless
539 networks, and is mandated in the Chinese National Standard for
540 Wireless LAN WAPI (Wired Authentication and Privacy Infrastructure)
543 The latest SM4 standard (GBT.32907-2016) was proposed by OSCCA and
544 standardized through TC 260 of the Standardization Administration
545 of the People's Republic of China (SAC).
547 The input, output, and key of SMS4 are each 128 bits.
549 See https://eprint.iacr.org/2008/329.pdf for further information.
554 tristate "TEA, XTEA and XETA"
555 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
558 TEA (Tiny Encryption Algorithm) cipher algorithms
560 Tiny Encryption Algorithm is a simple cipher that uses
561 many rounds for security. It is very fast and uses
564 Xtendend Tiny Encryption Algorithm is a modification to
565 the TEA algorithm to address a potential key weakness
566 in the TEA algorithm.
568 Xtendend Encryption Tiny Algorithm is a mis-implementation
569 of the XTEA algorithm for compatibility purposes.
571 config CRYPTO_TWOFISH
574 select CRYPTO_TWOFISH_COMMON
576 Twofish cipher algorithm
578 Twofish was submitted as an AES (Advanced Encryption Standard)
579 candidate cipher by researchers at CounterPane Systems. It is a
580 16 round block cipher supporting key sizes of 128, 192, and 256
583 See https://www.schneier.com/twofish.html for further information.
585 config CRYPTO_TWOFISH_COMMON
588 Common parts of the Twofish cipher algorithm shared by the
589 generic c and the assembler implementations.
593 menu "Length-preserving ciphers and modes"
595 config CRYPTO_ADIANTUM
597 select CRYPTO_CHACHA20
598 select CRYPTO_LIB_POLY1305_GENERIC
599 select CRYPTO_NHPOLY1305
600 select CRYPTO_MANAGER
602 Adiantum tweakable, length-preserving encryption mode
604 Designed for fast and secure disk encryption, especially on
605 CPUs without dedicated crypto instructions. It encrypts
606 each sector using the XChaCha12 stream cipher, two passes of
607 an ε-almost-∆-universal hash function, and an invocation of
608 the AES-256 block cipher on a single 16-byte block. On CPUs
609 without AES instructions, Adiantum is much faster than
612 Adiantum's security is provably reducible to that of its
613 underlying stream and block ciphers, subject to a security
614 bound. Unlike XTS, Adiantum is a true wide-block encryption
615 mode, so it actually provides an even stronger notion of
616 security than XTS, subject to the security bound.
621 tristate "ARC4 (Alleged Rivest Cipher 4)"
622 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
623 select CRYPTO_SKCIPHER
624 select CRYPTO_LIB_ARC4
626 ARC4 cipher algorithm
628 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
629 bits in length. This algorithm is required for driver-based
630 WEP, but it should not be for other purposes because of the
631 weakness of the algorithm.
633 config CRYPTO_CHACHA20
635 select CRYPTO_LIB_CHACHA_GENERIC
636 select CRYPTO_SKCIPHER
638 The ChaCha20, XChaCha20, and XChaCha12 stream cipher algorithms
640 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
641 Bernstein and further specified in RFC7539 for use in IETF protocols.
642 This is the portable C implementation of ChaCha20. See
643 https://cr.yp.to/chacha/chacha-20080128.pdf for further information.
645 XChaCha20 is the application of the XSalsa20 construction to ChaCha20
646 rather than to Salsa20. XChaCha20 extends ChaCha20's nonce length
647 from 64 bits (or 96 bits using the RFC7539 convention) to 192 bits,
648 while provably retaining ChaCha20's security. See
649 https://cr.yp.to/snuffle/xsalsa-20081128.pdf for further information.
651 XChaCha12 is XChaCha20 reduced to 12 rounds, with correspondingly
652 reduced security margin but increased performance. It can be needed
653 in some performance-sensitive scenarios.
656 tristate "CBC (Cipher Block Chaining)"
657 select CRYPTO_SKCIPHER
658 select CRYPTO_MANAGER
660 CBC (Cipher Block Chaining) mode (NIST SP800-38A)
662 This block cipher mode is required for IPSec ESP (XFRM_ESP).
665 tristate "CTR (Counter)"
666 select CRYPTO_SKCIPHER
667 select CRYPTO_MANAGER
669 CTR (Counter) mode (NIST SP800-38A)
672 tristate "CTS (Cipher Text Stealing)"
673 select CRYPTO_SKCIPHER
674 select CRYPTO_MANAGER
676 CBC-CS3 variant of CTS (Cipher Text Stealing) (NIST
677 Addendum to SP800-38A (October 2010))
679 This mode is required for Kerberos gss mechanism support
683 tristate "ECB (Electronic Codebook)"
684 select CRYPTO_SKCIPHER2
685 select CRYPTO_MANAGER
687 ECB (Electronic Codebook) mode (NIST SP800-38A)
692 select CRYPTO_POLYVAL
693 select CRYPTO_MANAGER
695 HCTR2 length-preserving encryption mode
697 A mode for storage encryption that is efficient on processors with
698 instructions to accelerate AES and carryless multiplication, e.g.
699 x86 processors with AES-NI and CLMUL, and ARM processors with the
700 ARMv8 crypto extensions.
702 See https://eprint.iacr.org/2021/1441
704 config CRYPTO_KEYWRAP
705 tristate "KW (AES Key Wrap)"
706 select CRYPTO_SKCIPHER
707 select CRYPTO_MANAGER
709 KW (AES Key Wrap) authenticated encryption mode (NIST SP800-38F
710 and RFC3394) without padding.
713 tristate "LRW (Liskov Rivest Wagner)"
714 select CRYPTO_LIB_GF128MUL
715 select CRYPTO_SKCIPHER
716 select CRYPTO_MANAGER
719 LRW (Liskov Rivest Wagner) mode
721 A tweakable, non malleable, non movable
722 narrow block cipher mode for dm-crypt. Use it with cipher
723 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
724 The first 128, 192 or 256 bits in the key are used for AES and the
725 rest is used to tie each cipher block to its logical position.
727 See https://people.csail.mit.edu/rivest/pubs/LRW02.pdf
730 tristate "PCBC (Propagating Cipher Block Chaining)"
731 select CRYPTO_SKCIPHER
732 select CRYPTO_MANAGER
734 PCBC (Propagating Cipher Block Chaining) mode
736 This block cipher mode is required for RxRPC.
740 select CRYPTO_SKCIPHER
741 select CRYPTO_MANAGER
743 XCTR (XOR Counter) mode for HCTR2
745 This blockcipher mode is a variant of CTR mode using XORs and little-endian
746 addition rather than big-endian arithmetic.
748 XCTR mode is used to implement HCTR2.
751 tristate "XTS (XOR Encrypt XOR with ciphertext stealing)"
752 select CRYPTO_SKCIPHER
753 select CRYPTO_MANAGER
756 XTS (XOR Encrypt XOR with ciphertext stealing) mode (NIST SP800-38E
759 Use with aes-xts-plain, key size 256, 384 or 512 bits. This
760 implementation currently can't handle a sectorsize which is not a
761 multiple of 16 bytes.
763 config CRYPTO_NHPOLY1305
766 select CRYPTO_LIB_POLY1305_GENERIC
770 menu "AEAD (authenticated encryption with associated data) ciphers"
772 config CRYPTO_AEGIS128
775 select CRYPTO_AES # for AES S-box tables
777 AEGIS-128 AEAD algorithm
779 config CRYPTO_AEGIS128_SIMD
780 bool "AEGIS-128 (arm NEON, arm64 NEON)"
781 depends on CRYPTO_AEGIS128 && ((ARM || ARM64) && KERNEL_MODE_NEON)
784 AEGIS-128 AEAD algorithm
786 Architecture: arm or arm64 using:
787 - NEON (Advanced SIMD) extension
789 config CRYPTO_CHACHA20POLY1305
790 tristate "ChaCha20-Poly1305"
791 select CRYPTO_CHACHA20
792 select CRYPTO_POLY1305
794 select CRYPTO_MANAGER
796 ChaCha20 stream cipher and Poly1305 authenticator combined
800 tristate "CCM (Counter with Cipher Block Chaining-MAC)"
804 select CRYPTO_MANAGER
806 CCM (Counter with Cipher Block Chaining-Message Authentication Code)
807 authenticated encryption mode (NIST SP800-38C)
810 tristate "GCM (Galois/Counter Mode) and GMAC (GCM MAC)"
815 select CRYPTO_MANAGER
817 GCM (Galois/Counter Mode) authenticated encryption mode and GMAC
818 (GCM Message Authentication Code) (NIST SP800-38D)
820 This is required for IPSec ESP (XFRM_ESP).
826 select CRYPTO_MANAGER
827 select CRYPTO_RNG_DEFAULT
830 tristate "Sequence Number IV Generator"
833 Sequence Number IV generator
835 This IV generator generates an IV based on a sequence number by
836 xoring it with a salt. This algorithm is mainly useful for CTR.
838 This is required for IPsec ESP (XFRM_ESP).
840 config CRYPTO_ECHAINIV
841 tristate "Encrypted Chain IV Generator"
844 Encrypted Chain IV generator
846 This IV generator generates an IV based on the encryption of
847 a sequence number xored with a salt. This is the default
851 tristate "Encrypted Salt-Sector IV Generator"
852 select CRYPTO_AUTHENC
854 Encrypted Salt-Sector IV generator
856 This IV generator is used in some cases by fscrypt and/or
857 dm-crypt. It uses the hash of the block encryption key as the
858 symmetric key for a block encryption pass applied to the input
859 IV, making low entropy IV sources more suitable for block
862 This driver implements a crypto API template that can be
863 instantiated either as an skcipher or as an AEAD (depending on the
864 type of the first template argument), and which defers encryption
865 and decryption requests to the encapsulated cipher after applying
866 ESSIV to the input IV. Note that in the AEAD case, it is assumed
867 that the keys are presented in the same format used by the authenc
868 template, and that the IV appears at the end of the authenticated
869 associated data (AAD) region (which is how dm-crypt uses it.)
871 Note that the use of ESSIV is not recommended for new deployments,
872 and so this only needs to be enabled when interoperability with
873 existing encrypted volumes of filesystems is required, or when
874 building for a particular system that requires it (e.g., when
875 the SoC in question has accelerated CBC but not XTS, making CBC
876 combined with ESSIV the only feasible mode for h/w accelerated
881 menu "Hashes, digests, and MACs"
883 config CRYPTO_BLAKE2B
887 BLAKE2b cryptographic hash function (RFC 7693)
889 BLAKE2b is optimized for 64-bit platforms and can produce digests
890 of any size between 1 and 64 bytes. The keyed hash is also implemented.
892 This module provides the following algorithms:
898 Used by the btrfs filesystem.
900 See https://blake2.net for further information.
903 tristate "CMAC (Cipher-based MAC)"
905 select CRYPTO_MANAGER
907 CMAC (Cipher-based Message Authentication Code) authentication
908 mode (NIST SP800-38B and IETF RFC4493)
913 select CRYPTO_LIB_GF128MUL
915 GCM GHASH function (NIST SP800-38D)
918 tristate "HMAC (Keyed-Hash MAC)"
920 select CRYPTO_MANAGER
922 HMAC (Keyed-Hash Message Authentication Code) (FIPS 198 and
925 This is required for IPsec AH (XFRM_AH) and IPsec ESP (XFRM_ESP).
931 MD4 message digest algorithm (RFC1320)
937 MD5 message digest algorithm (RFC1321)
939 config CRYPTO_MICHAEL_MIC
940 tristate "Michael MIC"
943 Michael MIC (Message Integrity Code) (IEEE 802.11i)
945 Defined by the IEEE 802.11i TKIP (Temporal Key Integrity Protocol),
946 known as WPA (Wif-Fi Protected Access).
948 This algorithm is required for TKIP, but it should not be used for
949 other purposes because of the weakness of the algorithm.
951 config CRYPTO_POLYVAL
954 select CRYPTO_LIB_GF128MUL
956 POLYVAL hash function for HCTR2
958 This is used in HCTR2. It is not a general-purpose
959 cryptographic hash function.
961 config CRYPTO_POLY1305
964 select CRYPTO_LIB_POLY1305_GENERIC
966 Poly1305 authenticator algorithm (RFC7539)
968 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
969 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
970 in IETF protocols. This is the portable C implementation of Poly1305.
973 tristate "RIPEMD-160"
976 RIPEMD-160 hash function (ISO/IEC 10118-3)
978 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
979 to be used as a secure replacement for the 128-bit hash functions
980 MD4, MD5 and its predecessor RIPEMD
981 (not to be confused with RIPEMD-128).
983 Its speed is comparable to SHA-1 and there are no known attacks
986 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
987 See https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
988 for further information.
993 select CRYPTO_LIB_SHA1
995 SHA-1 secure hash algorithm (FIPS 180, ISO/IEC 10118-3)
998 tristate "SHA-224 and SHA-256"
1000 select CRYPTO_LIB_SHA256
1002 SHA-224 and SHA-256 secure hash algorithms (FIPS 180, ISO/IEC 10118-3)
1004 This is required for IPsec AH (XFRM_AH) and IPsec ESP (XFRM_ESP).
1005 Used by the btrfs filesystem, Ceph, NFS, and SMB.
1007 config CRYPTO_SHA512
1008 tristate "SHA-384 and SHA-512"
1011 SHA-384 and SHA-512 secure hash algorithms (FIPS 180, ISO/IEC 10118-3)
1017 SHA-3 secure hash algorithms (FIPS 202, ISO/IEC 10118-3)
1022 config CRYPTO_SM3_GENERIC
1023 tristate "SM3 (ShangMi 3)"
1027 SM3 (ShangMi 3) secure hash function (OSCCA GM/T 0004-2012, ISO/IEC 10118-3)
1029 This is part of the Chinese Commercial Cryptography suite.
1032 http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
1033 https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
1035 config CRYPTO_STREEBOG
1039 Streebog Hash Function (GOST R 34.11-2012, RFC 6986, ISO/IEC 10118-3)
1041 This is one of the Russian cryptographic standard algorithms (called
1042 GOST algorithms). This setting enables two hash algorithms with
1043 256 and 512 bits output.
1046 https://tc26.ru/upload/iblock/fed/feddbb4d26b685903faa2ba11aea43f6.pdf
1047 https://tools.ietf.org/html/rfc6986
1052 select CRYPTO_MANAGER
1054 VMAC is a message authentication algorithm designed for
1055 very high speed on 64-bit architectures.
1057 See https://fastcrypto.org/vmac for further information.
1060 tristate "Whirlpool"
1063 Whirlpool hash function (ISO/IEC 10118-3)
1065 512, 384 and 256-bit hashes.
1067 Whirlpool-512 is part of the NESSIE cryptographic primitives.
1069 See https://web.archive.org/web/20171129084214/http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html
1070 for further information.
1073 tristate "XCBC-MAC (Extended Cipher Block Chaining MAC)"
1075 select CRYPTO_MANAGER
1077 XCBC-MAC (Extended Cipher Block Chaining Message Authentication
1080 config CRYPTO_XXHASH
1085 xxHash non-cryptographic hash algorithm
1087 Extremely fast, working at speeds close to RAM limits.
1089 Used by the btrfs filesystem.
1093 menu "CRCs (cyclic redundancy checks)"
1095 config CRYPTO_CRC32C
1100 CRC32c CRC algorithm with the iSCSI polynomial (RFC 3385 and RFC 3720)
1102 A 32-bit CRC (cyclic redundancy check) with a polynomial defined
1103 by G. Castagnoli, S. Braeuer and M. Herrman in "Optimization of Cyclic
1104 Redundancy-Check Codes with 24 and 32 Parity Bits", IEEE Transactions
1105 on Communications, Vol. 41, No. 6, June 1993, selected for use with
1108 Used by btrfs, ext4, jbd2, NVMeoF/TCP, and iSCSI.
1115 CRC32 CRC algorithm (IEEE 802.3)
1117 Used by RoCEv2 and f2fs.
1119 config CRYPTO_CRCT10DIF
1120 tristate "CRCT10DIF"
1123 CRC16 CRC algorithm used for the T10 (SCSI) Data Integrity Field (DIF)
1125 CRC algorithm used by the SCSI Block Commands standard.
1127 config CRYPTO_CRC64_ROCKSOFT
1128 tristate "CRC64 based on Rocksoft Model algorithm"
1132 CRC64 CRC algorithm based on the Rocksoft Model CRC Algorithm
1134 Used by the NVMe implementation of T10 DIF (BLK_DEV_INTEGRITY)
1136 See https://zlib.net/crc_v3.txt
1142 config CRYPTO_DEFLATE
1144 select CRYPTO_ALGAPI
1145 select CRYPTO_ACOMP2
1149 Deflate compression algorithm (RFC1951)
1151 Used by IPSec with the IPCOMP protocol (RFC3173, RFC2394)
1155 select CRYPTO_ALGAPI
1156 select CRYPTO_ACOMP2
1158 select LZO_DECOMPRESS
1160 LZO compression algorithm
1162 See https://www.oberhumer.com/opensource/lzo/ for further information.
1166 select CRYPTO_ALGAPI
1167 select CRYPTO_ACOMP2
1169 select 842_DECOMPRESS
1171 842 compression algorithm by IBM
1173 See https://github.com/plauth/lib842 for further information.
1177 select CRYPTO_ALGAPI
1178 select CRYPTO_ACOMP2
1180 select LZ4_DECOMPRESS
1182 LZ4 compression algorithm
1184 See https://github.com/lz4/lz4 for further information.
1188 select CRYPTO_ALGAPI
1189 select CRYPTO_ACOMP2
1190 select LZ4HC_COMPRESS
1191 select LZ4_DECOMPRESS
1193 LZ4 high compression mode algorithm
1195 See https://github.com/lz4/lz4 for further information.
1199 select CRYPTO_ALGAPI
1200 select CRYPTO_ACOMP2
1201 select ZSTD_COMPRESS
1202 select ZSTD_DECOMPRESS
1204 zstd compression algorithm
1206 See https://github.com/facebook/zstd for further information.
1210 menu "Random number generation"
1212 config CRYPTO_ANSI_CPRNG
1213 tristate "ANSI PRNG (Pseudo Random Number Generator)"
1217 Pseudo RNG (random number generator) (ANSI X9.31 Appendix A.2.4)
1219 This uses the AES cipher algorithm.
1221 Note that this option must be enabled if CRYPTO_FIPS is selected
1223 menuconfig CRYPTO_DRBG_MENU
1224 tristate "NIST SP800-90A DRBG (Deterministic Random Bit Generator)"
1226 DRBG (Deterministic Random Bit Generator) (NIST SP800-90A)
1228 In the following submenu, one or more of the DRBG types must be selected.
1232 config CRYPTO_DRBG_HMAC
1236 select CRYPTO_SHA512
1238 config CRYPTO_DRBG_HASH
1240 select CRYPTO_SHA256
1242 Hash_DRBG variant as defined in NIST SP800-90A.
1244 This uses the SHA-1, SHA-256, SHA-384, or SHA-512 hash algorithms.
1246 config CRYPTO_DRBG_CTR
1251 CTR_DRBG variant as defined in NIST SP800-90A.
1253 This uses the AES cipher algorithm with the counter block mode.
1257 default CRYPTO_DRBG_MENU
1259 select CRYPTO_JITTERENTROPY
1261 endif # if CRYPTO_DRBG_MENU
1263 config CRYPTO_JITTERENTROPY
1264 tristate "CPU Jitter Non-Deterministic RNG (Random Number Generator)"
1268 CPU Jitter RNG (Random Number Generator) from the Jitterentropy library
1270 A non-physical non-deterministic ("true") RNG (e.g., an entropy source
1271 compliant with NIST SP800-90B) intended to provide a seed to a
1272 deterministic RNG (e.g., per NIST SP800-90C).
1273 This RNG does not perform any cryptographic whitening of the generated
1276 See https://www.chronox.de/jent/
1278 if CRYPTO_JITTERENTROPY
1279 if CRYPTO_FIPS && EXPERT
1282 prompt "CPU Jitter RNG Memory Size"
1283 default CRYPTO_JITTERENTROPY_MEMSIZE_2
1285 The Jitter RNG measures the execution time of memory accesses.
1286 Multiple consecutive memory accesses are performed. If the memory
1287 size fits into a cache (e.g. L1), only the memory access timing
1288 to that cache is measured. The closer the cache is to the CPU
1289 the less variations are measured and thus the less entropy is
1290 obtained. Thus, if the memory size fits into the L1 cache, the
1291 obtained entropy is less than if the memory size fits within
1292 L1 + L2, which in turn is less if the memory fits into
1293 L1 + L2 + L3. Thus, by selecting a different memory size,
1294 the entropy rate produced by the Jitter RNG can be modified.
1296 config CRYPTO_JITTERENTROPY_MEMSIZE_2
1297 bool "2048 Bytes (default)"
1299 config CRYPTO_JITTERENTROPY_MEMSIZE_128
1302 config CRYPTO_JITTERENTROPY_MEMSIZE_1024
1305 config CRYPTO_JITTERENTROPY_MEMSIZE_8192
1309 config CRYPTO_JITTERENTROPY_MEMORY_BLOCKS
1311 default 64 if CRYPTO_JITTERENTROPY_MEMSIZE_2
1312 default 512 if CRYPTO_JITTERENTROPY_MEMSIZE_128
1313 default 1024 if CRYPTO_JITTERENTROPY_MEMSIZE_1024
1314 default 4096 if CRYPTO_JITTERENTROPY_MEMSIZE_8192
1316 config CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE
1318 default 32 if CRYPTO_JITTERENTROPY_MEMSIZE_2
1319 default 256 if CRYPTO_JITTERENTROPY_MEMSIZE_128
1320 default 1024 if CRYPTO_JITTERENTROPY_MEMSIZE_1024
1321 default 2048 if CRYPTO_JITTERENTROPY_MEMSIZE_8192
1323 config CRYPTO_JITTERENTROPY_OSR
1324 int "CPU Jitter RNG Oversampling Rate"
1328 The Jitter RNG allows the specification of an oversampling rate (OSR).
1329 The Jitter RNG operation requires a fixed amount of timing
1330 measurements to produce one output block of random numbers. The
1331 OSR value is multiplied with the amount of timing measurements to
1332 generate one output block. Thus, the timing measurement is oversampled
1333 by the OSR factor. The oversampling allows the Jitter RNG to operate
1334 on hardware whose timers deliver limited amount of entropy (e.g.
1335 the timer is coarse) by setting the OSR to a higher value. The
1336 trade-off, however, is that the Jitter RNG now requires more time
1337 to generate random numbers.
1339 config CRYPTO_JITTERENTROPY_TESTINTERFACE
1340 bool "CPU Jitter RNG Test Interface"
1342 The test interface allows a privileged process to capture
1343 the raw unconditioned high resolution time stamp noise that
1344 is collected by the Jitter RNG for statistical analysis. As
1345 this data is used at the same time to generate random bits,
1346 the Jitter RNG operates in an insecure mode as long as the
1347 recording is enabled. This interface therefore is only
1348 intended for testing purposes and is not suitable for
1351 The raw noise data can be obtained using the jent_raw_hires
1352 debugfs file. Using the option
1353 jitterentropy_testing.boot_raw_hires_test=1 the raw noise of
1354 the first 1000 entropy events since boot can be sampled.
1356 If unsure, select N.
1358 endif # if CRYPTO_FIPS && EXPERT
1360 if !(CRYPTO_FIPS && EXPERT)
1362 config CRYPTO_JITTERENTROPY_MEMORY_BLOCKS
1366 config CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE
1370 config CRYPTO_JITTERENTROPY_OSR
1374 config CRYPTO_JITTERENTROPY_TESTINTERFACE
1377 endif # if !(CRYPTO_FIPS && EXPERT)
1378 endif # if CRYPTO_JITTERENTROPY
1380 config CRYPTO_KDF800108_CTR
1383 select CRYPTO_SHA256
1386 menu "Userspace interface"
1388 config CRYPTO_USER_API
1391 config CRYPTO_USER_API_HASH
1392 tristate "Hash algorithms"
1395 select CRYPTO_USER_API
1397 Enable the userspace interface for hash algorithms.
1399 See Documentation/crypto/userspace-if.rst and
1400 https://www.chronox.de/libkcapi/html/index.html
1402 config CRYPTO_USER_API_SKCIPHER
1403 tristate "Symmetric key cipher algorithms"
1405 select CRYPTO_SKCIPHER
1406 select CRYPTO_USER_API
1408 Enable the userspace interface for symmetric key cipher algorithms.
1410 See Documentation/crypto/userspace-if.rst and
1411 https://www.chronox.de/libkcapi/html/index.html
1413 config CRYPTO_USER_API_RNG
1414 tristate "RNG (random number generator) algorithms"
1417 select CRYPTO_USER_API
1419 Enable the userspace interface for RNG (random number generator)
1422 See Documentation/crypto/userspace-if.rst and
1423 https://www.chronox.de/libkcapi/html/index.html
1425 config CRYPTO_USER_API_RNG_CAVP
1426 bool "Enable CAVP testing of DRBG"
1427 depends on CRYPTO_USER_API_RNG && CRYPTO_DRBG
1429 Enable extra APIs in the userspace interface for NIST CAVP
1430 (Cryptographic Algorithm Validation Program) testing:
1431 - resetting DRBG entropy
1432 - providing Additional Data
1434 This should only be enabled for CAVP testing. You should say
1435 no unless you know what this is.
1437 config CRYPTO_USER_API_AEAD
1438 tristate "AEAD cipher algorithms"
1441 select CRYPTO_SKCIPHER
1443 select CRYPTO_USER_API
1445 Enable the userspace interface for AEAD cipher algorithms.
1447 See Documentation/crypto/userspace-if.rst and
1448 https://www.chronox.de/libkcapi/html/index.html
1450 config CRYPTO_USER_API_ENABLE_OBSOLETE
1451 bool "Obsolete cryptographic algorithms"
1452 depends on CRYPTO_USER_API
1455 Allow obsolete cryptographic algorithms to be selected that have
1456 already been phased out from internal use by the kernel, and are
1457 only useful for userspace clients that still rely on them.
1460 bool "Crypto usage statistics"
1461 depends on CRYPTO_USER
1463 Enable the gathering of crypto stats.
1465 Enabling this option reduces the performance of the crypto API. It
1466 should only be enabled when there is actually a use case for it.
1468 This collects data sizes, numbers of requests, and numbers
1469 of errors processed by:
1470 - AEAD ciphers (encrypt, decrypt)
1471 - asymmetric key ciphers (encrypt, decrypt, verify, sign)
1472 - symmetric key ciphers (encrypt, decrypt)
1473 - compression algorithms (compress, decompress)
1474 - hash algorithms (hash)
1475 - key-agreement protocol primitives (setsecret, generate
1476 public key, compute shared secret)
1477 - RNG (generate, seed)
1481 config CRYPTO_HASH_INFO
1484 if !KMSAN # avoid false positives from assembly
1486 source "arch/arm/crypto/Kconfig"
1489 source "arch/arm64/crypto/Kconfig"
1492 source "arch/loongarch/crypto/Kconfig"
1495 source "arch/mips/crypto/Kconfig"
1498 source "arch/powerpc/crypto/Kconfig"
1501 source "arch/riscv/crypto/Kconfig"
1504 source "arch/s390/crypto/Kconfig"
1507 source "arch/sparc/crypto/Kconfig"
1510 source "arch/x86/crypto/Kconfig"
1514 source "drivers/crypto/Kconfig"
1515 source "crypto/asymmetric_keys/Kconfig"
1516 source "certs/Kconfig"