Merge tag 'amd-drm-next-5.13-2021-03-23' of https://gitlab.freedesktop.org/agd5f...
[platform/kernel/linux-starfive.git] / crypto / Kconfig
1 # SPDX-License-Identifier: GPL-2.0
2 #
3 # Generic algorithms support
4 #
5 config XOR_BLOCKS
6         tristate
7
8 #
9 # async_tx api: hardware offloaded memory transfer/transform support
10 #
11 source "crypto/async_tx/Kconfig"
12
13 #
14 # Cryptographic API Configuration
15 #
16 menuconfig CRYPTO
17         tristate "Cryptographic API"
18         help
19           This option provides the core Cryptographic API.
20
21 if CRYPTO
22
23 comment "Crypto core or helper"
24
25 config CRYPTO_FIPS
26         bool "FIPS 200 compliance"
27         depends on (CRYPTO_ANSI_CPRNG || CRYPTO_DRBG) && !CRYPTO_MANAGER_DISABLE_TESTS
28         depends on (MODULE_SIG || !MODULES)
29         help
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
33           this is.
34
35 config CRYPTO_ALGAPI
36         tristate
37         select CRYPTO_ALGAPI2
38         help
39           This option provides the API for cryptographic algorithms.
40
41 config CRYPTO_ALGAPI2
42         tristate
43
44 config CRYPTO_AEAD
45         tristate
46         select CRYPTO_AEAD2
47         select CRYPTO_ALGAPI
48
49 config CRYPTO_AEAD2
50         tristate
51         select CRYPTO_ALGAPI2
52         select CRYPTO_NULL2
53         select CRYPTO_RNG2
54
55 config CRYPTO_SKCIPHER
56         tristate
57         select CRYPTO_SKCIPHER2
58         select CRYPTO_ALGAPI
59
60 config CRYPTO_SKCIPHER2
61         tristate
62         select CRYPTO_ALGAPI2
63         select CRYPTO_RNG2
64
65 config CRYPTO_HASH
66         tristate
67         select CRYPTO_HASH2
68         select CRYPTO_ALGAPI
69
70 config CRYPTO_HASH2
71         tristate
72         select CRYPTO_ALGAPI2
73
74 config CRYPTO_RNG
75         tristate
76         select CRYPTO_RNG2
77         select CRYPTO_ALGAPI
78
79 config CRYPTO_RNG2
80         tristate
81         select CRYPTO_ALGAPI2
82
83 config CRYPTO_RNG_DEFAULT
84         tristate
85         select CRYPTO_DRBG_MENU
86
87 config CRYPTO_AKCIPHER2
88         tristate
89         select CRYPTO_ALGAPI2
90
91 config CRYPTO_AKCIPHER
92         tristate
93         select CRYPTO_AKCIPHER2
94         select CRYPTO_ALGAPI
95
96 config CRYPTO_KPP2
97         tristate
98         select CRYPTO_ALGAPI2
99
100 config CRYPTO_KPP
101         tristate
102         select CRYPTO_ALGAPI
103         select CRYPTO_KPP2
104
105 config CRYPTO_ACOMP2
106         tristate
107         select CRYPTO_ALGAPI2
108         select SGL_ALLOC
109
110 config CRYPTO_ACOMP
111         tristate
112         select CRYPTO_ALGAPI
113         select CRYPTO_ACOMP2
114
115 config CRYPTO_MANAGER
116         tristate "Cryptographic algorithm manager"
117         select CRYPTO_MANAGER2
118         help
119           Create default cryptographic template instantiations such as
120           cbc(aes).
121
122 config CRYPTO_MANAGER2
123         def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
124         select CRYPTO_AEAD2
125         select CRYPTO_HASH2
126         select CRYPTO_SKCIPHER2
127         select CRYPTO_AKCIPHER2
128         select CRYPTO_KPP2
129         select CRYPTO_ACOMP2
130
131 config CRYPTO_USER
132         tristate "Userspace cryptographic algorithm configuration"
133         depends on NET
134         select CRYPTO_MANAGER
135         help
136           Userspace configuration for cryptographic instantiations such as
137           cbc(aes).
138
139 config CRYPTO_MANAGER_DISABLE_TESTS
140         bool "Disable run-time self tests"
141         default y
142         help
143           Disable run-time self tests that normally take place at
144           algorithm registration.
145
146 config CRYPTO_MANAGER_EXTRA_TESTS
147         bool "Enable extra run-time crypto self tests"
148         depends on DEBUG_KERNEL && !CRYPTO_MANAGER_DISABLE_TESTS && CRYPTO_MANAGER
149         help
150           Enable extra run-time self tests of registered crypto algorithms,
151           including randomized fuzz tests.
152
153           This is intended for developer use only, as these tests take much
154           longer to run than the normal self tests.
155
156 config CRYPTO_GF128MUL
157         tristate
158
159 config CRYPTO_NULL
160         tristate "Null algorithms"
161         select CRYPTO_NULL2
162         help
163           These are 'Null' algorithms, used by IPsec, which do nothing.
164
165 config CRYPTO_NULL2
166         tristate
167         select CRYPTO_ALGAPI2
168         select CRYPTO_SKCIPHER2
169         select CRYPTO_HASH2
170
171 config CRYPTO_PCRYPT
172         tristate "Parallel crypto engine"
173         depends on SMP
174         select PADATA
175         select CRYPTO_MANAGER
176         select CRYPTO_AEAD
177         help
178           This converts an arbitrary crypto algorithm into a parallel
179           algorithm that executes in kernel threads.
180
181 config CRYPTO_CRYPTD
182         tristate "Software async crypto daemon"
183         select CRYPTO_SKCIPHER
184         select CRYPTO_HASH
185         select CRYPTO_MANAGER
186         help
187           This is a generic software asynchronous crypto daemon that
188           converts an arbitrary synchronous software crypto algorithm
189           into an asynchronous algorithm that executes in a kernel thread.
190
191 config CRYPTO_AUTHENC
192         tristate "Authenc support"
193         select CRYPTO_AEAD
194         select CRYPTO_SKCIPHER
195         select CRYPTO_MANAGER
196         select CRYPTO_HASH
197         select CRYPTO_NULL
198         help
199           Authenc: Combined mode wrapper for IPsec.
200           This is required for IPSec.
201
202 config CRYPTO_TEST
203         tristate "Testing module"
204         depends on m || EXPERT
205         select CRYPTO_MANAGER
206         help
207           Quick & dirty crypto test module.
208
209 config CRYPTO_SIMD
210         tristate
211         select CRYPTO_CRYPTD
212
213 config CRYPTO_ENGINE
214         tristate
215
216 comment "Public-key cryptography"
217
218 config CRYPTO_RSA
219         tristate "RSA algorithm"
220         select CRYPTO_AKCIPHER
221         select CRYPTO_MANAGER
222         select MPILIB
223         select ASN1
224         help
225           Generic implementation of the RSA public key algorithm.
226
227 config CRYPTO_DH
228         tristate "Diffie-Hellman algorithm"
229         select CRYPTO_KPP
230         select MPILIB
231         help
232           Generic implementation of the Diffie-Hellman algorithm.
233
234 config CRYPTO_ECC
235         tristate
236
237 config CRYPTO_ECDH
238         tristate "ECDH algorithm"
239         select CRYPTO_ECC
240         select CRYPTO_KPP
241         select CRYPTO_RNG_DEFAULT
242         help
243           Generic implementation of the ECDH algorithm
244
245 config CRYPTO_ECRDSA
246         tristate "EC-RDSA (GOST 34.10) algorithm"
247         select CRYPTO_ECC
248         select CRYPTO_AKCIPHER
249         select CRYPTO_STREEBOG
250         select OID_REGISTRY
251         select ASN1
252         help
253           Elliptic Curve Russian Digital Signature Algorithm (GOST R 34.10-2012,
254           RFC 7091, ISO/IEC 14888-3:2018) is one of the Russian cryptographic
255           standard algorithms (called GOST algorithms). Only signature verification
256           is implemented.
257
258 config CRYPTO_SM2
259         tristate "SM2 algorithm"
260         select CRYPTO_SM3
261         select CRYPTO_AKCIPHER
262         select CRYPTO_MANAGER
263         select MPILIB
264         select ASN1
265         help
266           Generic implementation of the SM2 public key algorithm. It was
267           published by State Encryption Management Bureau, China.
268           as specified by OSCCA GM/T 0003.1-2012 -- 0003.5-2012.
269
270           References:
271           https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02
272           http://www.oscca.gov.cn/sca/xxgk/2010-12/17/content_1002386.shtml
273           http://www.gmbz.org.cn/main/bzlb.html
274
275 config CRYPTO_CURVE25519
276         tristate "Curve25519 algorithm"
277         select CRYPTO_KPP
278         select CRYPTO_LIB_CURVE25519_GENERIC
279
280 config CRYPTO_CURVE25519_X86
281         tristate "x86_64 accelerated Curve25519 scalar multiplication library"
282         depends on X86 && 64BIT
283         select CRYPTO_LIB_CURVE25519_GENERIC
284         select CRYPTO_ARCH_HAVE_LIB_CURVE25519
285
286 comment "Authenticated Encryption with Associated Data"
287
288 config CRYPTO_CCM
289         tristate "CCM support"
290         select CRYPTO_CTR
291         select CRYPTO_HASH
292         select CRYPTO_AEAD
293         select CRYPTO_MANAGER
294         help
295           Support for Counter with CBC MAC. Required for IPsec.
296
297 config CRYPTO_GCM
298         tristate "GCM/GMAC support"
299         select CRYPTO_CTR
300         select CRYPTO_AEAD
301         select CRYPTO_GHASH
302         select CRYPTO_NULL
303         select CRYPTO_MANAGER
304         help
305           Support for Galois/Counter Mode (GCM) and Galois Message
306           Authentication Code (GMAC). Required for IPSec.
307
308 config CRYPTO_CHACHA20POLY1305
309         tristate "ChaCha20-Poly1305 AEAD support"
310         select CRYPTO_CHACHA20
311         select CRYPTO_POLY1305
312         select CRYPTO_AEAD
313         select CRYPTO_MANAGER
314         help
315           ChaCha20-Poly1305 AEAD support, RFC7539.
316
317           Support for the AEAD wrapper using the ChaCha20 stream cipher combined
318           with the Poly1305 authenticator. It is defined in RFC7539 for use in
319           IETF protocols.
320
321 config CRYPTO_AEGIS128
322         tristate "AEGIS-128 AEAD algorithm"
323         select CRYPTO_AEAD
324         select CRYPTO_AES  # for AES S-box tables
325         help
326          Support for the AEGIS-128 dedicated AEAD algorithm.
327
328 config CRYPTO_AEGIS128_SIMD
329         bool "Support SIMD acceleration for AEGIS-128"
330         depends on CRYPTO_AEGIS128 && ((ARM || ARM64) && KERNEL_MODE_NEON)
331         default y
332
333 config CRYPTO_AEGIS128_AESNI_SSE2
334         tristate "AEGIS-128 AEAD algorithm (x86_64 AESNI+SSE2 implementation)"
335         depends on X86 && 64BIT
336         select CRYPTO_AEAD
337         select CRYPTO_SIMD
338         help
339          AESNI+SSE2 implementation of the AEGIS-128 dedicated AEAD algorithm.
340
341 config CRYPTO_SEQIV
342         tristate "Sequence Number IV Generator"
343         select CRYPTO_AEAD
344         select CRYPTO_SKCIPHER
345         select CRYPTO_NULL
346         select CRYPTO_RNG_DEFAULT
347         select CRYPTO_MANAGER
348         help
349           This IV generator generates an IV based on a sequence number by
350           xoring it with a salt.  This algorithm is mainly useful for CTR
351
352 config CRYPTO_ECHAINIV
353         tristate "Encrypted Chain IV Generator"
354         select CRYPTO_AEAD
355         select CRYPTO_NULL
356         select CRYPTO_RNG_DEFAULT
357         select CRYPTO_MANAGER
358         help
359           This IV generator generates an IV based on the encryption of
360           a sequence number xored with a salt.  This is the default
361           algorithm for CBC.
362
363 comment "Block modes"
364
365 config CRYPTO_CBC
366         tristate "CBC support"
367         select CRYPTO_SKCIPHER
368         select CRYPTO_MANAGER
369         help
370           CBC: Cipher Block Chaining mode
371           This block cipher algorithm is required for IPSec.
372
373 config CRYPTO_CFB
374         tristate "CFB support"
375         select CRYPTO_SKCIPHER
376         select CRYPTO_MANAGER
377         help
378           CFB: Cipher FeedBack mode
379           This block cipher algorithm is required for TPM2 Cryptography.
380
381 config CRYPTO_CTR
382         tristate "CTR support"
383         select CRYPTO_SKCIPHER
384         select CRYPTO_MANAGER
385         help
386           CTR: Counter mode
387           This block cipher algorithm is required for IPSec.
388
389 config CRYPTO_CTS
390         tristate "CTS support"
391         select CRYPTO_SKCIPHER
392         select CRYPTO_MANAGER
393         help
394           CTS: Cipher Text Stealing
395           This is the Cipher Text Stealing mode as described by
396           Section 8 of rfc2040 and referenced by rfc3962
397           (rfc3962 includes errata information in its Appendix A) or
398           CBC-CS3 as defined by NIST in Sp800-38A addendum from Oct 2010.
399           This mode is required for Kerberos gss mechanism support
400           for AES encryption.
401
402           See: https://csrc.nist.gov/publications/detail/sp/800-38a/addendum/final
403
404 config CRYPTO_ECB
405         tristate "ECB support"
406         select CRYPTO_SKCIPHER
407         select CRYPTO_MANAGER
408         help
409           ECB: Electronic CodeBook mode
410           This is the simplest block cipher algorithm.  It simply encrypts
411           the input block by block.
412
413 config CRYPTO_LRW
414         tristate "LRW support"
415         select CRYPTO_SKCIPHER
416         select CRYPTO_MANAGER
417         select CRYPTO_GF128MUL
418         help
419           LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
420           narrow block cipher mode for dm-crypt.  Use it with cipher
421           specification string aes-lrw-benbi, the key must be 256, 320 or 384.
422           The first 128, 192 or 256 bits in the key are used for AES and the
423           rest is used to tie each cipher block to its logical position.
424
425 config CRYPTO_OFB
426         tristate "OFB support"
427         select CRYPTO_SKCIPHER
428         select CRYPTO_MANAGER
429         help
430           OFB: the Output Feedback mode makes a block cipher into a synchronous
431           stream cipher. It generates keystream blocks, which are then XORed
432           with the plaintext blocks to get the ciphertext. Flipping a bit in the
433           ciphertext produces a flipped bit in the plaintext at the same
434           location. This property allows many error correcting codes to function
435           normally even when applied before encryption.
436
437 config CRYPTO_PCBC
438         tristate "PCBC support"
439         select CRYPTO_SKCIPHER
440         select CRYPTO_MANAGER
441         help
442           PCBC: Propagating Cipher Block Chaining mode
443           This block cipher algorithm is required for RxRPC.
444
445 config CRYPTO_XTS
446         tristate "XTS support"
447         select CRYPTO_SKCIPHER
448         select CRYPTO_MANAGER
449         select CRYPTO_ECB
450         help
451           XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
452           key size 256, 384 or 512 bits. This implementation currently
453           can't handle a sectorsize which is not a multiple of 16 bytes.
454
455 config CRYPTO_KEYWRAP
456         tristate "Key wrapping support"
457         select CRYPTO_SKCIPHER
458         select CRYPTO_MANAGER
459         help
460           Support for key wrapping (NIST SP800-38F / RFC3394) without
461           padding.
462
463 config CRYPTO_NHPOLY1305
464         tristate
465         select CRYPTO_HASH
466         select CRYPTO_LIB_POLY1305_GENERIC
467
468 config CRYPTO_NHPOLY1305_SSE2
469         tristate "NHPoly1305 hash function (x86_64 SSE2 implementation)"
470         depends on X86 && 64BIT
471         select CRYPTO_NHPOLY1305
472         help
473           SSE2 optimized implementation of the hash function used by the
474           Adiantum encryption mode.
475
476 config CRYPTO_NHPOLY1305_AVX2
477         tristate "NHPoly1305 hash function (x86_64 AVX2 implementation)"
478         depends on X86 && 64BIT
479         select CRYPTO_NHPOLY1305
480         help
481           AVX2 optimized implementation of the hash function used by the
482           Adiantum encryption mode.
483
484 config CRYPTO_ADIANTUM
485         tristate "Adiantum support"
486         select CRYPTO_CHACHA20
487         select CRYPTO_LIB_POLY1305_GENERIC
488         select CRYPTO_NHPOLY1305
489         select CRYPTO_MANAGER
490         help
491           Adiantum is a tweakable, length-preserving encryption mode
492           designed for fast and secure disk encryption, especially on
493           CPUs without dedicated crypto instructions.  It encrypts
494           each sector using the XChaCha12 stream cipher, two passes of
495           an Îµ-almost-∆-universal hash function, and an invocation of
496           the AES-256 block cipher on a single 16-byte block.  On CPUs
497           without AES instructions, Adiantum is much faster than
498           AES-XTS.
499
500           Adiantum's security is provably reducible to that of its
501           underlying stream and block ciphers, subject to a security
502           bound.  Unlike XTS, Adiantum is a true wide-block encryption
503           mode, so it actually provides an even stronger notion of
504           security than XTS, subject to the security bound.
505
506           If unsure, say N.
507
508 config CRYPTO_ESSIV
509         tristate "ESSIV support for block encryption"
510         select CRYPTO_AUTHENC
511         help
512           Encrypted salt-sector initialization vector (ESSIV) is an IV
513           generation method that is used in some cases by fscrypt and/or
514           dm-crypt. It uses the hash of the block encryption key as the
515           symmetric key for a block encryption pass applied to the input
516           IV, making low entropy IV sources more suitable for block
517           encryption.
518
519           This driver implements a crypto API template that can be
520           instantiated either as an skcipher or as an AEAD (depending on the
521           type of the first template argument), and which defers encryption
522           and decryption requests to the encapsulated cipher after applying
523           ESSIV to the input IV. Note that in the AEAD case, it is assumed
524           that the keys are presented in the same format used by the authenc
525           template, and that the IV appears at the end of the authenticated
526           associated data (AAD) region (which is how dm-crypt uses it.)
527
528           Note that the use of ESSIV is not recommended for new deployments,
529           and so this only needs to be enabled when interoperability with
530           existing encrypted volumes of filesystems is required, or when
531           building for a particular system that requires it (e.g., when
532           the SoC in question has accelerated CBC but not XTS, making CBC
533           combined with ESSIV the only feasible mode for h/w accelerated
534           block encryption)
535
536 comment "Hash modes"
537
538 config CRYPTO_CMAC
539         tristate "CMAC support"
540         select CRYPTO_HASH
541         select CRYPTO_MANAGER
542         help
543           Cipher-based Message Authentication Code (CMAC) specified by
544           The National Institute of Standards and Technology (NIST).
545
546           https://tools.ietf.org/html/rfc4493
547           http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
548
549 config CRYPTO_HMAC
550         tristate "HMAC support"
551         select CRYPTO_HASH
552         select CRYPTO_MANAGER
553         help
554           HMAC: Keyed-Hashing for Message Authentication (RFC2104).
555           This is required for IPSec.
556
557 config CRYPTO_XCBC
558         tristate "XCBC support"
559         select CRYPTO_HASH
560         select CRYPTO_MANAGER
561         help
562           XCBC: Keyed-Hashing with encryption algorithm
563                 https://www.ietf.org/rfc/rfc3566.txt
564                 http://csrc.nist.gov/encryption/modes/proposedmodes/
565                  xcbc-mac/xcbc-mac-spec.pdf
566
567 config CRYPTO_VMAC
568         tristate "VMAC support"
569         select CRYPTO_HASH
570         select CRYPTO_MANAGER
571         help
572           VMAC is a message authentication algorithm designed for
573           very high speed on 64-bit architectures.
574
575           See also:
576           <https://fastcrypto.org/vmac>
577
578 comment "Digest"
579
580 config CRYPTO_CRC32C
581         tristate "CRC32c CRC algorithm"
582         select CRYPTO_HASH
583         select CRC32
584         help
585           Castagnoli, et al Cyclic Redundancy-Check Algorithm.  Used
586           by iSCSI for header and data digests and by others.
587           See Castagnoli93.  Module will be crc32c.
588
589 config CRYPTO_CRC32C_INTEL
590         tristate "CRC32c INTEL hardware acceleration"
591         depends on X86
592         select CRYPTO_HASH
593         help
594           In Intel processor with SSE4.2 supported, the processor will
595           support CRC32C implementation using hardware accelerated CRC32
596           instruction. This option will create 'crc32c-intel' module,
597           which will enable any routine to use the CRC32 instruction to
598           gain performance compared with software implementation.
599           Module will be crc32c-intel.
600
601 config CRYPTO_CRC32C_VPMSUM
602         tristate "CRC32c CRC algorithm (powerpc64)"
603         depends on PPC64 && ALTIVEC
604         select CRYPTO_HASH
605         select CRC32
606         help
607           CRC32c algorithm implemented using vector polynomial multiply-sum
608           (vpmsum) instructions, introduced in POWER8. Enable on POWER8
609           and newer processors for improved performance.
610
611
612 config CRYPTO_CRC32C_SPARC64
613         tristate "CRC32c CRC algorithm (SPARC64)"
614         depends on SPARC64
615         select CRYPTO_HASH
616         select CRC32
617         help
618           CRC32c CRC algorithm implemented using sparc64 crypto instructions,
619           when available.
620
621 config CRYPTO_CRC32
622         tristate "CRC32 CRC algorithm"
623         select CRYPTO_HASH
624         select CRC32
625         help
626           CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
627           Shash crypto api wrappers to crc32_le function.
628
629 config CRYPTO_CRC32_PCLMUL
630         tristate "CRC32 PCLMULQDQ hardware acceleration"
631         depends on X86
632         select CRYPTO_HASH
633         select CRC32
634         help
635           From Intel Westmere and AMD Bulldozer processor with SSE4.2
636           and PCLMULQDQ supported, the processor will support
637           CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
638           instruction. This option will create 'crc32-pclmul' module,
639           which will enable any routine to use the CRC-32-IEEE 802.3 checksum
640           and gain better performance as compared with the table implementation.
641
642 config CRYPTO_CRC32_MIPS
643         tristate "CRC32c and CRC32 CRC algorithm (MIPS)"
644         depends on MIPS_CRC_SUPPORT
645         select CRYPTO_HASH
646         help
647           CRC32c and CRC32 CRC algorithms implemented using mips crypto
648           instructions, when available.
649
650
651 config CRYPTO_XXHASH
652         tristate "xxHash hash algorithm"
653         select CRYPTO_HASH
654         select XXHASH
655         help
656           xxHash non-cryptographic hash algorithm. Extremely fast, working at
657           speeds close to RAM limits.
658
659 config CRYPTO_BLAKE2B
660         tristate "BLAKE2b digest algorithm"
661         select CRYPTO_HASH
662         help
663           Implementation of cryptographic hash function BLAKE2b (or just BLAKE2),
664           optimized for 64bit platforms and can produce digests of any size
665           between 1 to 64.  The keyed hash is also implemented.
666
667           This module provides the following algorithms:
668
669           - blake2b-160
670           - blake2b-256
671           - blake2b-384
672           - blake2b-512
673
674           See https://blake2.net for further information.
675
676 config CRYPTO_BLAKE2S
677         tristate "BLAKE2s digest algorithm"
678         select CRYPTO_LIB_BLAKE2S_GENERIC
679         select CRYPTO_HASH
680         help
681           Implementation of cryptographic hash function BLAKE2s
682           optimized for 8-32bit platforms and can produce digests of any size
683           between 1 to 32.  The keyed hash is also implemented.
684
685           This module provides the following algorithms:
686
687           - blake2s-128
688           - blake2s-160
689           - blake2s-224
690           - blake2s-256
691
692           See https://blake2.net for further information.
693
694 config CRYPTO_BLAKE2S_X86
695         tristate "BLAKE2s digest algorithm (x86 accelerated version)"
696         depends on X86 && 64BIT
697         select CRYPTO_LIB_BLAKE2S_GENERIC
698         select CRYPTO_ARCH_HAVE_LIB_BLAKE2S
699
700 config CRYPTO_CRCT10DIF
701         tristate "CRCT10DIF algorithm"
702         select CRYPTO_HASH
703         help
704           CRC T10 Data Integrity Field computation is being cast as
705           a crypto transform.  This allows for faster crc t10 diff
706           transforms to be used if they are available.
707
708 config CRYPTO_CRCT10DIF_PCLMUL
709         tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
710         depends on X86 && 64BIT && CRC_T10DIF
711         select CRYPTO_HASH
712         help
713           For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
714           CRC T10 DIF PCLMULQDQ computation can be hardware
715           accelerated PCLMULQDQ instruction. This option will create
716           'crct10dif-pclmul' module, which is faster when computing the
717           crct10dif checksum as compared with the generic table implementation.
718
719 config CRYPTO_CRCT10DIF_VPMSUM
720         tristate "CRC32T10DIF powerpc64 hardware acceleration"
721         depends on PPC64 && ALTIVEC && CRC_T10DIF
722         select CRYPTO_HASH
723         help
724           CRC10T10DIF algorithm implemented using vector polynomial
725           multiply-sum (vpmsum) instructions, introduced in POWER8. Enable on
726           POWER8 and newer processors for improved performance.
727
728 config CRYPTO_VPMSUM_TESTER
729         tristate "Powerpc64 vpmsum hardware acceleration tester"
730         depends on CRYPTO_CRCT10DIF_VPMSUM && CRYPTO_CRC32C_VPMSUM
731         help
732           Stress test for CRC32c and CRC-T10DIF algorithms implemented with
733           POWER8 vpmsum instructions.
734           Unless you are testing these algorithms, you don't need this.
735
736 config CRYPTO_GHASH
737         tristate "GHASH hash function"
738         select CRYPTO_GF128MUL
739         select CRYPTO_HASH
740         help
741           GHASH is the hash function used in GCM (Galois/Counter Mode).
742           It is not a general-purpose cryptographic hash function.
743
744 config CRYPTO_POLY1305
745         tristate "Poly1305 authenticator algorithm"
746         select CRYPTO_HASH
747         select CRYPTO_LIB_POLY1305_GENERIC
748         help
749           Poly1305 authenticator algorithm, RFC7539.
750
751           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
752           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
753           in IETF protocols. This is the portable C implementation of Poly1305.
754
755 config CRYPTO_POLY1305_X86_64
756         tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
757         depends on X86 && 64BIT
758         select CRYPTO_LIB_POLY1305_GENERIC
759         select CRYPTO_ARCH_HAVE_LIB_POLY1305
760         help
761           Poly1305 authenticator algorithm, RFC7539.
762
763           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
764           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
765           in IETF protocols. This is the x86_64 assembler implementation using SIMD
766           instructions.
767
768 config CRYPTO_POLY1305_MIPS
769         tristate "Poly1305 authenticator algorithm (MIPS optimized)"
770         depends on MIPS
771         select CRYPTO_ARCH_HAVE_LIB_POLY1305
772
773 config CRYPTO_MD4
774         tristate "MD4 digest algorithm"
775         select CRYPTO_HASH
776         help
777           MD4 message digest algorithm (RFC1320).
778
779 config CRYPTO_MD5
780         tristate "MD5 digest algorithm"
781         select CRYPTO_HASH
782         help
783           MD5 message digest algorithm (RFC1321).
784
785 config CRYPTO_MD5_OCTEON
786         tristate "MD5 digest algorithm (OCTEON)"
787         depends on CPU_CAVIUM_OCTEON
788         select CRYPTO_MD5
789         select CRYPTO_HASH
790         help
791           MD5 message digest algorithm (RFC1321) implemented
792           using OCTEON crypto instructions, when available.
793
794 config CRYPTO_MD5_PPC
795         tristate "MD5 digest algorithm (PPC)"
796         depends on PPC
797         select CRYPTO_HASH
798         help
799           MD5 message digest algorithm (RFC1321) implemented
800           in PPC assembler.
801
802 config CRYPTO_MD5_SPARC64
803         tristate "MD5 digest algorithm (SPARC64)"
804         depends on SPARC64
805         select CRYPTO_MD5
806         select CRYPTO_HASH
807         help
808           MD5 message digest algorithm (RFC1321) implemented
809           using sparc64 crypto instructions, when available.
810
811 config CRYPTO_MICHAEL_MIC
812         tristate "Michael MIC keyed digest algorithm"
813         select CRYPTO_HASH
814         help
815           Michael MIC is used for message integrity protection in TKIP
816           (IEEE 802.11i). This algorithm is required for TKIP, but it
817           should not be used for other purposes because of the weakness
818           of the algorithm.
819
820 config CRYPTO_RMD160
821         tristate "RIPEMD-160 digest algorithm"
822         select CRYPTO_HASH
823         help
824           RIPEMD-160 (ISO/IEC 10118-3:2004).
825
826           RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
827           to be used as a secure replacement for the 128-bit hash functions
828           MD4, MD5 and it's predecessor RIPEMD
829           (not to be confused with RIPEMD-128).
830
831           It's speed is comparable to SHA1 and there are no known attacks
832           against RIPEMD-160.
833
834           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
835           See <https://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
836
837 config CRYPTO_SHA1
838         tristate "SHA1 digest algorithm"
839         select CRYPTO_HASH
840         help
841           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
842
843 config CRYPTO_SHA1_SSSE3
844         tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
845         depends on X86 && 64BIT
846         select CRYPTO_SHA1
847         select CRYPTO_HASH
848         help
849           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
850           using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
851           Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
852           when available.
853
854 config CRYPTO_SHA256_SSSE3
855         tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
856         depends on X86 && 64BIT
857         select CRYPTO_SHA256
858         select CRYPTO_HASH
859         help
860           SHA-256 secure hash standard (DFIPS 180-2) implemented
861           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
862           Extensions version 1 (AVX1), or Advanced Vector Extensions
863           version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
864           Instructions) when available.
865
866 config CRYPTO_SHA512_SSSE3
867         tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
868         depends on X86 && 64BIT
869         select CRYPTO_SHA512
870         select CRYPTO_HASH
871         help
872           SHA-512 secure hash standard (DFIPS 180-2) implemented
873           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
874           Extensions version 1 (AVX1), or Advanced Vector Extensions
875           version 2 (AVX2) instructions, when available.
876
877 config CRYPTO_SHA1_OCTEON
878         tristate "SHA1 digest algorithm (OCTEON)"
879         depends on CPU_CAVIUM_OCTEON
880         select CRYPTO_SHA1
881         select CRYPTO_HASH
882         help
883           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
884           using OCTEON crypto instructions, when available.
885
886 config CRYPTO_SHA1_SPARC64
887         tristate "SHA1 digest algorithm (SPARC64)"
888         depends on SPARC64
889         select CRYPTO_SHA1
890         select CRYPTO_HASH
891         help
892           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
893           using sparc64 crypto instructions, when available.
894
895 config CRYPTO_SHA1_PPC
896         tristate "SHA1 digest algorithm (powerpc)"
897         depends on PPC
898         help
899           This is the powerpc hardware accelerated implementation of the
900           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
901
902 config CRYPTO_SHA1_PPC_SPE
903         tristate "SHA1 digest algorithm (PPC SPE)"
904         depends on PPC && SPE
905         help
906           SHA-1 secure hash standard (DFIPS 180-4) implemented
907           using powerpc SPE SIMD instruction set.
908
909 config CRYPTO_SHA256
910         tristate "SHA224 and SHA256 digest algorithm"
911         select CRYPTO_HASH
912         select CRYPTO_LIB_SHA256
913         help
914           SHA256 secure hash standard (DFIPS 180-2).
915
916           This version of SHA implements a 256 bit hash with 128 bits of
917           security against collision attacks.
918
919           This code also includes SHA-224, a 224 bit hash with 112 bits
920           of security against collision attacks.
921
922 config CRYPTO_SHA256_PPC_SPE
923         tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
924         depends on PPC && SPE
925         select CRYPTO_SHA256
926         select CRYPTO_HASH
927         help
928           SHA224 and SHA256 secure hash standard (DFIPS 180-2)
929           implemented using powerpc SPE SIMD instruction set.
930
931 config CRYPTO_SHA256_OCTEON
932         tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
933         depends on CPU_CAVIUM_OCTEON
934         select CRYPTO_SHA256
935         select CRYPTO_HASH
936         help
937           SHA-256 secure hash standard (DFIPS 180-2) implemented
938           using OCTEON crypto instructions, when available.
939
940 config CRYPTO_SHA256_SPARC64
941         tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
942         depends on SPARC64
943         select CRYPTO_SHA256
944         select CRYPTO_HASH
945         help
946           SHA-256 secure hash standard (DFIPS 180-2) implemented
947           using sparc64 crypto instructions, when available.
948
949 config CRYPTO_SHA512
950         tristate "SHA384 and SHA512 digest algorithms"
951         select CRYPTO_HASH
952         help
953           SHA512 secure hash standard (DFIPS 180-2).
954
955           This version of SHA implements a 512 bit hash with 256 bits of
956           security against collision attacks.
957
958           This code also includes SHA-384, a 384 bit hash with 192 bits
959           of security against collision attacks.
960
961 config CRYPTO_SHA512_OCTEON
962         tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
963         depends on CPU_CAVIUM_OCTEON
964         select CRYPTO_SHA512
965         select CRYPTO_HASH
966         help
967           SHA-512 secure hash standard (DFIPS 180-2) implemented
968           using OCTEON crypto instructions, when available.
969
970 config CRYPTO_SHA512_SPARC64
971         tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
972         depends on SPARC64
973         select CRYPTO_SHA512
974         select CRYPTO_HASH
975         help
976           SHA-512 secure hash standard (DFIPS 180-2) implemented
977           using sparc64 crypto instructions, when available.
978
979 config CRYPTO_SHA3
980         tristate "SHA3 digest algorithm"
981         select CRYPTO_HASH
982         help
983           SHA-3 secure hash standard (DFIPS 202). It's based on
984           cryptographic sponge function family called Keccak.
985
986           References:
987           http://keccak.noekeon.org/
988
989 config CRYPTO_SM3
990         tristate "SM3 digest algorithm"
991         select CRYPTO_HASH
992         help
993           SM3 secure hash function as defined by OSCCA GM/T 0004-2012 SM3).
994           It is part of the Chinese Commercial Cryptography suite.
995
996           References:
997           http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
998           https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
999
1000 config CRYPTO_STREEBOG
1001         tristate "Streebog Hash Function"
1002         select CRYPTO_HASH
1003         help
1004           Streebog Hash Function (GOST R 34.11-2012, RFC 6986) is one of the Russian
1005           cryptographic standard algorithms (called GOST algorithms).
1006           This setting enables two hash algorithms with 256 and 512 bits output.
1007
1008           References:
1009           https://tc26.ru/upload/iblock/fed/feddbb4d26b685903faa2ba11aea43f6.pdf
1010           https://tools.ietf.org/html/rfc6986
1011
1012 config CRYPTO_WP512
1013         tristate "Whirlpool digest algorithms"
1014         select CRYPTO_HASH
1015         help
1016           Whirlpool hash algorithm 512, 384 and 256-bit hashes
1017
1018           Whirlpool-512 is part of the NESSIE cryptographic primitives.
1019           Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
1020
1021           See also:
1022           <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
1023
1024 config CRYPTO_GHASH_CLMUL_NI_INTEL
1025         tristate "GHASH hash function (CLMUL-NI accelerated)"
1026         depends on X86 && 64BIT
1027         select CRYPTO_CRYPTD
1028         help
1029           This is the x86_64 CLMUL-NI accelerated implementation of
1030           GHASH, the hash function used in GCM (Galois/Counter mode).
1031
1032 comment "Ciphers"
1033
1034 config CRYPTO_AES
1035         tristate "AES cipher algorithms"
1036         select CRYPTO_ALGAPI
1037         select CRYPTO_LIB_AES
1038         help
1039           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1040           algorithm.
1041
1042           Rijndael appears to be consistently a very good performer in
1043           both hardware and software across a wide range of computing
1044           environments regardless of its use in feedback or non-feedback
1045           modes. Its key setup time is excellent, and its key agility is
1046           good. Rijndael's very low memory requirements make it very well
1047           suited for restricted-space environments, in which it also
1048           demonstrates excellent performance. Rijndael's operations are
1049           among the easiest to defend against power and timing attacks.
1050
1051           The AES specifies three key sizes: 128, 192 and 256 bits
1052
1053           See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
1054
1055 config CRYPTO_AES_TI
1056         tristate "Fixed time AES cipher"
1057         select CRYPTO_ALGAPI
1058         select CRYPTO_LIB_AES
1059         help
1060           This is a generic implementation of AES that attempts to eliminate
1061           data dependent latencies as much as possible without affecting
1062           performance too much. It is intended for use by the generic CCM
1063           and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
1064           solely on encryption (although decryption is supported as well, but
1065           with a more dramatic performance hit)
1066
1067           Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
1068           8 for decryption), this implementation only uses just two S-boxes of
1069           256 bytes each, and attempts to eliminate data dependent latencies by
1070           prefetching the entire table into the cache at the start of each
1071           block. Interrupts are also disabled to avoid races where cachelines
1072           are evicted when the CPU is interrupted to do something else.
1073
1074 config CRYPTO_AES_NI_INTEL
1075         tristate "AES cipher algorithms (AES-NI)"
1076         depends on X86
1077         select CRYPTO_AEAD
1078         select CRYPTO_LIB_AES
1079         select CRYPTO_ALGAPI
1080         select CRYPTO_SKCIPHER
1081         select CRYPTO_SIMD
1082         help
1083           Use Intel AES-NI instructions for AES algorithm.
1084
1085           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1086           algorithm.
1087
1088           Rijndael appears to be consistently a very good performer in
1089           both hardware and software across a wide range of computing
1090           environments regardless of its use in feedback or non-feedback
1091           modes. Its key setup time is excellent, and its key agility is
1092           good. Rijndael's very low memory requirements make it very well
1093           suited for restricted-space environments, in which it also
1094           demonstrates excellent performance. Rijndael's operations are
1095           among the easiest to defend against power and timing attacks.
1096
1097           The AES specifies three key sizes: 128, 192 and 256 bits
1098
1099           See <http://csrc.nist.gov/encryption/aes/> for more information.
1100
1101           In addition to AES cipher algorithm support, the acceleration
1102           for some popular block cipher mode is supported too, including
1103           ECB, CBC, LRW, XTS. The 64 bit version has additional
1104           acceleration for CTR.
1105
1106 config CRYPTO_AES_SPARC64
1107         tristate "AES cipher algorithms (SPARC64)"
1108         depends on SPARC64
1109         select CRYPTO_SKCIPHER
1110         help
1111           Use SPARC64 crypto opcodes for AES algorithm.
1112
1113           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1114           algorithm.
1115
1116           Rijndael appears to be consistently a very good performer in
1117           both hardware and software across a wide range of computing
1118           environments regardless of its use in feedback or non-feedback
1119           modes. Its key setup time is excellent, and its key agility is
1120           good. Rijndael's very low memory requirements make it very well
1121           suited for restricted-space environments, in which it also
1122           demonstrates excellent performance. Rijndael's operations are
1123           among the easiest to defend against power and timing attacks.
1124
1125           The AES specifies three key sizes: 128, 192 and 256 bits
1126
1127           See <http://csrc.nist.gov/encryption/aes/> for more information.
1128
1129           In addition to AES cipher algorithm support, the acceleration
1130           for some popular block cipher mode is supported too, including
1131           ECB and CBC.
1132
1133 config CRYPTO_AES_PPC_SPE
1134         tristate "AES cipher algorithms (PPC SPE)"
1135         depends on PPC && SPE
1136         select CRYPTO_SKCIPHER
1137         help
1138           AES cipher algorithms (FIPS-197). Additionally the acceleration
1139           for popular block cipher modes ECB, CBC, CTR and XTS is supported.
1140           This module should only be used for low power (router) devices
1141           without hardware AES acceleration (e.g. caam crypto). It reduces the
1142           size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
1143           timining attacks. Nevertheless it might be not as secure as other
1144           architecture specific assembler implementations that work on 1KB
1145           tables or 256 bytes S-boxes.
1146
1147 config CRYPTO_ANUBIS
1148         tristate "Anubis cipher algorithm"
1149         depends on CRYPTO_USER_API_ENABLE_OBSOLETE
1150         select CRYPTO_ALGAPI
1151         help
1152           Anubis cipher algorithm.
1153
1154           Anubis is a variable key length cipher which can use keys from
1155           128 bits to 320 bits in length.  It was evaluated as a entrant
1156           in the NESSIE competition.
1157
1158           See also:
1159           <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1160           <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1161
1162 config CRYPTO_ARC4
1163         tristate "ARC4 cipher algorithm"
1164         depends on CRYPTO_USER_API_ENABLE_OBSOLETE
1165         select CRYPTO_SKCIPHER
1166         select CRYPTO_LIB_ARC4
1167         help
1168           ARC4 cipher algorithm.
1169
1170           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1171           bits in length.  This algorithm is required for driver-based
1172           WEP, but it should not be for other purposes because of the
1173           weakness of the algorithm.
1174
1175 config CRYPTO_BLOWFISH
1176         tristate "Blowfish cipher algorithm"
1177         select CRYPTO_ALGAPI
1178         select CRYPTO_BLOWFISH_COMMON
1179         help
1180           Blowfish cipher algorithm, by Bruce Schneier.
1181
1182           This is a variable key length cipher which can use keys from 32
1183           bits to 448 bits in length.  It's fast, simple and specifically
1184           designed for use on "large microprocessors".
1185
1186           See also:
1187           <https://www.schneier.com/blowfish.html>
1188
1189 config CRYPTO_BLOWFISH_COMMON
1190         tristate
1191         help
1192           Common parts of the Blowfish cipher algorithm shared by the
1193           generic c and the assembler implementations.
1194
1195           See also:
1196           <https://www.schneier.com/blowfish.html>
1197
1198 config CRYPTO_BLOWFISH_X86_64
1199         tristate "Blowfish cipher algorithm (x86_64)"
1200         depends on X86 && 64BIT
1201         select CRYPTO_SKCIPHER
1202         select CRYPTO_BLOWFISH_COMMON
1203         imply CRYPTO_CTR
1204         help
1205           Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1206
1207           This is a variable key length cipher which can use keys from 32
1208           bits to 448 bits in length.  It's fast, simple and specifically
1209           designed for use on "large microprocessors".
1210
1211           See also:
1212           <https://www.schneier.com/blowfish.html>
1213
1214 config CRYPTO_CAMELLIA
1215         tristate "Camellia cipher algorithms"
1216         depends on CRYPTO
1217         select CRYPTO_ALGAPI
1218         help
1219           Camellia cipher algorithms module.
1220
1221           Camellia is a symmetric key block cipher developed jointly
1222           at NTT and Mitsubishi Electric Corporation.
1223
1224           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1225
1226           See also:
1227           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1228
1229 config CRYPTO_CAMELLIA_X86_64
1230         tristate "Camellia cipher algorithm (x86_64)"
1231         depends on X86 && 64BIT
1232         depends on CRYPTO
1233         select CRYPTO_SKCIPHER
1234         imply CRYPTO_CTR
1235         help
1236           Camellia cipher algorithm module (x86_64).
1237
1238           Camellia is a symmetric key block cipher developed jointly
1239           at NTT and Mitsubishi Electric Corporation.
1240
1241           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1242
1243           See also:
1244           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1245
1246 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1247         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1248         depends on X86 && 64BIT
1249         depends on CRYPTO
1250         select CRYPTO_SKCIPHER
1251         select CRYPTO_CAMELLIA_X86_64
1252         select CRYPTO_SIMD
1253         imply CRYPTO_XTS
1254         help
1255           Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1256
1257           Camellia is a symmetric key block cipher developed jointly
1258           at NTT and Mitsubishi Electric Corporation.
1259
1260           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1261
1262           See also:
1263           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1264
1265 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1266         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1267         depends on X86 && 64BIT
1268         depends on CRYPTO
1269         select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1270         help
1271           Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1272
1273           Camellia is a symmetric key block cipher developed jointly
1274           at NTT and Mitsubishi Electric Corporation.
1275
1276           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1277
1278           See also:
1279           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1280
1281 config CRYPTO_CAMELLIA_SPARC64
1282         tristate "Camellia cipher algorithm (SPARC64)"
1283         depends on SPARC64
1284         depends on CRYPTO
1285         select CRYPTO_ALGAPI
1286         select CRYPTO_SKCIPHER
1287         help
1288           Camellia cipher algorithm module (SPARC64).
1289
1290           Camellia is a symmetric key block cipher developed jointly
1291           at NTT and Mitsubishi Electric Corporation.
1292
1293           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1294
1295           See also:
1296           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1297
1298 config CRYPTO_CAST_COMMON
1299         tristate
1300         help
1301           Common parts of the CAST cipher algorithms shared by the
1302           generic c and the assembler implementations.
1303
1304 config CRYPTO_CAST5
1305         tristate "CAST5 (CAST-128) cipher algorithm"
1306         select CRYPTO_ALGAPI
1307         select CRYPTO_CAST_COMMON
1308         help
1309           The CAST5 encryption algorithm (synonymous with CAST-128) is
1310           described in RFC2144.
1311
1312 config CRYPTO_CAST5_AVX_X86_64
1313         tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1314         depends on X86 && 64BIT
1315         select CRYPTO_SKCIPHER
1316         select CRYPTO_CAST5
1317         select CRYPTO_CAST_COMMON
1318         select CRYPTO_SIMD
1319         imply CRYPTO_CTR
1320         help
1321           The CAST5 encryption algorithm (synonymous with CAST-128) is
1322           described in RFC2144.
1323
1324           This module provides the Cast5 cipher algorithm that processes
1325           sixteen blocks parallel using the AVX instruction set.
1326
1327 config CRYPTO_CAST6
1328         tristate "CAST6 (CAST-256) cipher algorithm"
1329         select CRYPTO_ALGAPI
1330         select CRYPTO_CAST_COMMON
1331         help
1332           The CAST6 encryption algorithm (synonymous with CAST-256) is
1333           described in RFC2612.
1334
1335 config CRYPTO_CAST6_AVX_X86_64
1336         tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1337         depends on X86 && 64BIT
1338         select CRYPTO_SKCIPHER
1339         select CRYPTO_CAST6
1340         select CRYPTO_CAST_COMMON
1341         select CRYPTO_SIMD
1342         imply CRYPTO_XTS
1343         imply CRYPTO_CTR
1344         help
1345           The CAST6 encryption algorithm (synonymous with CAST-256) is
1346           described in RFC2612.
1347
1348           This module provides the Cast6 cipher algorithm that processes
1349           eight blocks parallel using the AVX instruction set.
1350
1351 config CRYPTO_DES
1352         tristate "DES and Triple DES EDE cipher algorithms"
1353         select CRYPTO_ALGAPI
1354         select CRYPTO_LIB_DES
1355         help
1356           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1357
1358 config CRYPTO_DES_SPARC64
1359         tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1360         depends on SPARC64
1361         select CRYPTO_ALGAPI
1362         select CRYPTO_LIB_DES
1363         select CRYPTO_SKCIPHER
1364         help
1365           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1366           optimized using SPARC64 crypto opcodes.
1367
1368 config CRYPTO_DES3_EDE_X86_64
1369         tristate "Triple DES EDE cipher algorithm (x86-64)"
1370         depends on X86 && 64BIT
1371         select CRYPTO_SKCIPHER
1372         select CRYPTO_LIB_DES
1373         imply CRYPTO_CTR
1374         help
1375           Triple DES EDE (FIPS 46-3) algorithm.
1376
1377           This module provides implementation of the Triple DES EDE cipher
1378           algorithm that is optimized for x86-64 processors. Two versions of
1379           algorithm are provided; regular processing one input block and
1380           one that processes three blocks parallel.
1381
1382 config CRYPTO_FCRYPT
1383         tristate "FCrypt cipher algorithm"
1384         select CRYPTO_ALGAPI
1385         select CRYPTO_SKCIPHER
1386         help
1387           FCrypt algorithm used by RxRPC.
1388
1389 config CRYPTO_KHAZAD
1390         tristate "Khazad cipher algorithm"
1391         depends on CRYPTO_USER_API_ENABLE_OBSOLETE
1392         select CRYPTO_ALGAPI
1393         help
1394           Khazad cipher algorithm.
1395
1396           Khazad was a finalist in the initial NESSIE competition.  It is
1397           an algorithm optimized for 64-bit processors with good performance
1398           on 32-bit processors.  Khazad uses an 128 bit key size.
1399
1400           See also:
1401           <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1402
1403 config CRYPTO_CHACHA20
1404         tristate "ChaCha stream cipher algorithms"
1405         select CRYPTO_LIB_CHACHA_GENERIC
1406         select CRYPTO_SKCIPHER
1407         help
1408           The ChaCha20, XChaCha20, and XChaCha12 stream cipher algorithms.
1409
1410           ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1411           Bernstein and further specified in RFC7539 for use in IETF protocols.
1412           This is the portable C implementation of ChaCha20.  See also:
1413           <https://cr.yp.to/chacha/chacha-20080128.pdf>
1414
1415           XChaCha20 is the application of the XSalsa20 construction to ChaCha20
1416           rather than to Salsa20.  XChaCha20 extends ChaCha20's nonce length
1417           from 64 bits (or 96 bits using the RFC7539 convention) to 192 bits,
1418           while provably retaining ChaCha20's security.  See also:
1419           <https://cr.yp.to/snuffle/xsalsa-20081128.pdf>
1420
1421           XChaCha12 is XChaCha20 reduced to 12 rounds, with correspondingly
1422           reduced security margin but increased performance.  It can be needed
1423           in some performance-sensitive scenarios.
1424
1425 config CRYPTO_CHACHA20_X86_64
1426         tristate "ChaCha stream cipher algorithms (x86_64/SSSE3/AVX2/AVX-512VL)"
1427         depends on X86 && 64BIT
1428         select CRYPTO_SKCIPHER
1429         select CRYPTO_LIB_CHACHA_GENERIC
1430         select CRYPTO_ARCH_HAVE_LIB_CHACHA
1431         help
1432           SSSE3, AVX2, and AVX-512VL optimized implementations of the ChaCha20,
1433           XChaCha20, and XChaCha12 stream ciphers.
1434
1435 config CRYPTO_CHACHA_MIPS
1436         tristate "ChaCha stream cipher algorithms (MIPS 32r2 optimized)"
1437         depends on CPU_MIPS32_R2
1438         select CRYPTO_SKCIPHER
1439         select CRYPTO_ARCH_HAVE_LIB_CHACHA
1440
1441 config CRYPTO_SEED
1442         tristate "SEED cipher algorithm"
1443         depends on CRYPTO_USER_API_ENABLE_OBSOLETE
1444         select CRYPTO_ALGAPI
1445         help
1446           SEED cipher algorithm (RFC4269).
1447
1448           SEED is a 128-bit symmetric key block cipher that has been
1449           developed by KISA (Korea Information Security Agency) as a
1450           national standard encryption algorithm of the Republic of Korea.
1451           It is a 16 round block cipher with the key size of 128 bit.
1452
1453           See also:
1454           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1455
1456 config CRYPTO_SERPENT
1457         tristate "Serpent cipher algorithm"
1458         select CRYPTO_ALGAPI
1459         help
1460           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1461
1462           Keys are allowed to be from 0 to 256 bits in length, in steps
1463           of 8 bits.
1464
1465           See also:
1466           <https://www.cl.cam.ac.uk/~rja14/serpent.html>
1467
1468 config CRYPTO_SERPENT_SSE2_X86_64
1469         tristate "Serpent cipher algorithm (x86_64/SSE2)"
1470         depends on X86 && 64BIT
1471         select CRYPTO_SKCIPHER
1472         select CRYPTO_SERPENT
1473         select CRYPTO_SIMD
1474         imply CRYPTO_CTR
1475         help
1476           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1477
1478           Keys are allowed to be from 0 to 256 bits in length, in steps
1479           of 8 bits.
1480
1481           This module provides Serpent cipher algorithm that processes eight
1482           blocks parallel using SSE2 instruction set.
1483
1484           See also:
1485           <https://www.cl.cam.ac.uk/~rja14/serpent.html>
1486
1487 config CRYPTO_SERPENT_SSE2_586
1488         tristate "Serpent cipher algorithm (i586/SSE2)"
1489         depends on X86 && !64BIT
1490         select CRYPTO_SKCIPHER
1491         select CRYPTO_SERPENT
1492         select CRYPTO_SIMD
1493         imply CRYPTO_CTR
1494         help
1495           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1496
1497           Keys are allowed to be from 0 to 256 bits in length, in steps
1498           of 8 bits.
1499
1500           This module provides Serpent cipher algorithm that processes four
1501           blocks parallel using SSE2 instruction set.
1502
1503           See also:
1504           <https://www.cl.cam.ac.uk/~rja14/serpent.html>
1505
1506 config CRYPTO_SERPENT_AVX_X86_64
1507         tristate "Serpent cipher algorithm (x86_64/AVX)"
1508         depends on X86 && 64BIT
1509         select CRYPTO_SKCIPHER
1510         select CRYPTO_SERPENT
1511         select CRYPTO_SIMD
1512         imply CRYPTO_XTS
1513         imply CRYPTO_CTR
1514         help
1515           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1516
1517           Keys are allowed to be from 0 to 256 bits in length, in steps
1518           of 8 bits.
1519
1520           This module provides the Serpent cipher algorithm that processes
1521           eight blocks parallel using the AVX instruction set.
1522
1523           See also:
1524           <https://www.cl.cam.ac.uk/~rja14/serpent.html>
1525
1526 config CRYPTO_SERPENT_AVX2_X86_64
1527         tristate "Serpent cipher algorithm (x86_64/AVX2)"
1528         depends on X86 && 64BIT
1529         select CRYPTO_SERPENT_AVX_X86_64
1530         help
1531           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1532
1533           Keys are allowed to be from 0 to 256 bits in length, in steps
1534           of 8 bits.
1535
1536           This module provides Serpent cipher algorithm that processes 16
1537           blocks parallel using AVX2 instruction set.
1538
1539           See also:
1540           <https://www.cl.cam.ac.uk/~rja14/serpent.html>
1541
1542 config CRYPTO_SM4
1543         tristate "SM4 cipher algorithm"
1544         select CRYPTO_ALGAPI
1545         help
1546           SM4 cipher algorithms (OSCCA GB/T 32907-2016).
1547
1548           SM4 (GBT.32907-2016) is a cryptographic standard issued by the
1549           Organization of State Commercial Administration of China (OSCCA)
1550           as an authorized cryptographic algorithms for the use within China.
1551
1552           SMS4 was originally created for use in protecting wireless
1553           networks, and is mandated in the Chinese National Standard for
1554           Wireless LAN WAPI (Wired Authentication and Privacy Infrastructure)
1555           (GB.15629.11-2003).
1556
1557           The latest SM4 standard (GBT.32907-2016) was proposed by OSCCA and
1558           standardized through TC 260 of the Standardization Administration
1559           of the People's Republic of China (SAC).
1560
1561           The input, output, and key of SMS4 are each 128 bits.
1562
1563           See also: <https://eprint.iacr.org/2008/329.pdf>
1564
1565           If unsure, say N.
1566
1567 config CRYPTO_TEA
1568         tristate "TEA, XTEA and XETA cipher algorithms"
1569         depends on CRYPTO_USER_API_ENABLE_OBSOLETE
1570         select CRYPTO_ALGAPI
1571         help
1572           TEA cipher algorithm.
1573
1574           Tiny Encryption Algorithm is a simple cipher that uses
1575           many rounds for security.  It is very fast and uses
1576           little memory.
1577
1578           Xtendend Tiny Encryption Algorithm is a modification to
1579           the TEA algorithm to address a potential key weakness
1580           in the TEA algorithm.
1581
1582           Xtendend Encryption Tiny Algorithm is a mis-implementation
1583           of the XTEA algorithm for compatibility purposes.
1584
1585 config CRYPTO_TWOFISH
1586         tristate "Twofish cipher algorithm"
1587         select CRYPTO_ALGAPI
1588         select CRYPTO_TWOFISH_COMMON
1589         help
1590           Twofish cipher algorithm.
1591
1592           Twofish was submitted as an AES (Advanced Encryption Standard)
1593           candidate cipher by researchers at CounterPane Systems.  It is a
1594           16 round block cipher supporting key sizes of 128, 192, and 256
1595           bits.
1596
1597           See also:
1598           <https://www.schneier.com/twofish.html>
1599
1600 config CRYPTO_TWOFISH_COMMON
1601         tristate
1602         help
1603           Common parts of the Twofish cipher algorithm shared by the
1604           generic c and the assembler implementations.
1605
1606 config CRYPTO_TWOFISH_586
1607         tristate "Twofish cipher algorithms (i586)"
1608         depends on (X86 || UML_X86) && !64BIT
1609         select CRYPTO_ALGAPI
1610         select CRYPTO_TWOFISH_COMMON
1611         imply CRYPTO_CTR
1612         help
1613           Twofish cipher algorithm.
1614
1615           Twofish was submitted as an AES (Advanced Encryption Standard)
1616           candidate cipher by researchers at CounterPane Systems.  It is a
1617           16 round block cipher supporting key sizes of 128, 192, and 256
1618           bits.
1619
1620           See also:
1621           <https://www.schneier.com/twofish.html>
1622
1623 config CRYPTO_TWOFISH_X86_64
1624         tristate "Twofish cipher algorithm (x86_64)"
1625         depends on (X86 || UML_X86) && 64BIT
1626         select CRYPTO_ALGAPI
1627         select CRYPTO_TWOFISH_COMMON
1628         imply CRYPTO_CTR
1629         help
1630           Twofish cipher algorithm (x86_64).
1631
1632           Twofish was submitted as an AES (Advanced Encryption Standard)
1633           candidate cipher by researchers at CounterPane Systems.  It is a
1634           16 round block cipher supporting key sizes of 128, 192, and 256
1635           bits.
1636
1637           See also:
1638           <https://www.schneier.com/twofish.html>
1639
1640 config CRYPTO_TWOFISH_X86_64_3WAY
1641         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1642         depends on X86 && 64BIT
1643         select CRYPTO_SKCIPHER
1644         select CRYPTO_TWOFISH_COMMON
1645         select CRYPTO_TWOFISH_X86_64
1646         help
1647           Twofish cipher algorithm (x86_64, 3-way parallel).
1648
1649           Twofish was submitted as an AES (Advanced Encryption Standard)
1650           candidate cipher by researchers at CounterPane Systems.  It is a
1651           16 round block cipher supporting key sizes of 128, 192, and 256
1652           bits.
1653
1654           This module provides Twofish cipher algorithm that processes three
1655           blocks parallel, utilizing resources of out-of-order CPUs better.
1656
1657           See also:
1658           <https://www.schneier.com/twofish.html>
1659
1660 config CRYPTO_TWOFISH_AVX_X86_64
1661         tristate "Twofish cipher algorithm (x86_64/AVX)"
1662         depends on X86 && 64BIT
1663         select CRYPTO_SKCIPHER
1664         select CRYPTO_SIMD
1665         select CRYPTO_TWOFISH_COMMON
1666         select CRYPTO_TWOFISH_X86_64
1667         select CRYPTO_TWOFISH_X86_64_3WAY
1668         imply CRYPTO_XTS
1669         help
1670           Twofish cipher algorithm (x86_64/AVX).
1671
1672           Twofish was submitted as an AES (Advanced Encryption Standard)
1673           candidate cipher by researchers at CounterPane Systems.  It is a
1674           16 round block cipher supporting key sizes of 128, 192, and 256
1675           bits.
1676
1677           This module provides the Twofish cipher algorithm that processes
1678           eight blocks parallel using the AVX Instruction Set.
1679
1680           See also:
1681           <https://www.schneier.com/twofish.html>
1682
1683 comment "Compression"
1684
1685 config CRYPTO_DEFLATE
1686         tristate "Deflate compression algorithm"
1687         select CRYPTO_ALGAPI
1688         select CRYPTO_ACOMP2
1689         select ZLIB_INFLATE
1690         select ZLIB_DEFLATE
1691         help
1692           This is the Deflate algorithm (RFC1951), specified for use in
1693           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1694
1695           You will most probably want this if using IPSec.
1696
1697 config CRYPTO_LZO
1698         tristate "LZO compression algorithm"
1699         select CRYPTO_ALGAPI
1700         select CRYPTO_ACOMP2
1701         select LZO_COMPRESS
1702         select LZO_DECOMPRESS
1703         help
1704           This is the LZO algorithm.
1705
1706 config CRYPTO_842
1707         tristate "842 compression algorithm"
1708         select CRYPTO_ALGAPI
1709         select CRYPTO_ACOMP2
1710         select 842_COMPRESS
1711         select 842_DECOMPRESS
1712         help
1713           This is the 842 algorithm.
1714
1715 config CRYPTO_LZ4
1716         tristate "LZ4 compression algorithm"
1717         select CRYPTO_ALGAPI
1718         select CRYPTO_ACOMP2
1719         select LZ4_COMPRESS
1720         select LZ4_DECOMPRESS
1721         help
1722           This is the LZ4 algorithm.
1723
1724 config CRYPTO_LZ4HC
1725         tristate "LZ4HC compression algorithm"
1726         select CRYPTO_ALGAPI
1727         select CRYPTO_ACOMP2
1728         select LZ4HC_COMPRESS
1729         select LZ4_DECOMPRESS
1730         help
1731           This is the LZ4 high compression mode algorithm.
1732
1733 config CRYPTO_ZSTD
1734         tristate "Zstd compression algorithm"
1735         select CRYPTO_ALGAPI
1736         select CRYPTO_ACOMP2
1737         select ZSTD_COMPRESS
1738         select ZSTD_DECOMPRESS
1739         help
1740           This is the zstd algorithm.
1741
1742 comment "Random Number Generation"
1743
1744 config CRYPTO_ANSI_CPRNG
1745         tristate "Pseudo Random Number Generation for Cryptographic modules"
1746         select CRYPTO_AES
1747         select CRYPTO_RNG
1748         help
1749           This option enables the generic pseudo random number generator
1750           for cryptographic modules.  Uses the Algorithm specified in
1751           ANSI X9.31 A.2.4. Note that this option must be enabled if
1752           CRYPTO_FIPS is selected
1753
1754 menuconfig CRYPTO_DRBG_MENU
1755         tristate "NIST SP800-90A DRBG"
1756         help
1757           NIST SP800-90A compliant DRBG. In the following submenu, one or
1758           more of the DRBG types must be selected.
1759
1760 if CRYPTO_DRBG_MENU
1761
1762 config CRYPTO_DRBG_HMAC
1763         bool
1764         default y
1765         select CRYPTO_HMAC
1766         select CRYPTO_SHA256
1767
1768 config CRYPTO_DRBG_HASH
1769         bool "Enable Hash DRBG"
1770         select CRYPTO_SHA256
1771         help
1772           Enable the Hash DRBG variant as defined in NIST SP800-90A.
1773
1774 config CRYPTO_DRBG_CTR
1775         bool "Enable CTR DRBG"
1776         select CRYPTO_AES
1777         select CRYPTO_CTR
1778         help
1779           Enable the CTR DRBG variant as defined in NIST SP800-90A.
1780
1781 config CRYPTO_DRBG
1782         tristate
1783         default CRYPTO_DRBG_MENU
1784         select CRYPTO_RNG
1785         select CRYPTO_JITTERENTROPY
1786
1787 endif   # if CRYPTO_DRBG_MENU
1788
1789 config CRYPTO_JITTERENTROPY
1790         tristate "Jitterentropy Non-Deterministic Random Number Generator"
1791         select CRYPTO_RNG
1792         help
1793           The Jitterentropy RNG is a noise that is intended
1794           to provide seed to another RNG. The RNG does not
1795           perform any cryptographic whitening of the generated
1796           random numbers. This Jitterentropy RNG registers with
1797           the kernel crypto API and can be used by any caller.
1798
1799 config CRYPTO_USER_API
1800         tristate
1801
1802 config CRYPTO_USER_API_HASH
1803         tristate "User-space interface for hash algorithms"
1804         depends on NET
1805         select CRYPTO_HASH
1806         select CRYPTO_USER_API
1807         help
1808           This option enables the user-spaces interface for hash
1809           algorithms.
1810
1811 config CRYPTO_USER_API_SKCIPHER
1812         tristate "User-space interface for symmetric key cipher algorithms"
1813         depends on NET
1814         select CRYPTO_SKCIPHER
1815         select CRYPTO_USER_API
1816         help
1817           This option enables the user-spaces interface for symmetric
1818           key cipher algorithms.
1819
1820 config CRYPTO_USER_API_RNG
1821         tristate "User-space interface for random number generator algorithms"
1822         depends on NET
1823         select CRYPTO_RNG
1824         select CRYPTO_USER_API
1825         help
1826           This option enables the user-spaces interface for random
1827           number generator algorithms.
1828
1829 config CRYPTO_USER_API_RNG_CAVP
1830         bool "Enable CAVP testing of DRBG"
1831         depends on CRYPTO_USER_API_RNG && CRYPTO_DRBG
1832         help
1833           This option enables extra API for CAVP testing via the user-space
1834           interface: resetting of DRBG entropy, and providing Additional Data.
1835           This should only be enabled for CAVP testing. You should say
1836           no unless you know what this is.
1837
1838 config CRYPTO_USER_API_AEAD
1839         tristate "User-space interface for AEAD cipher algorithms"
1840         depends on NET
1841         select CRYPTO_AEAD
1842         select CRYPTO_SKCIPHER
1843         select CRYPTO_NULL
1844         select CRYPTO_USER_API
1845         help
1846           This option enables the user-spaces interface for AEAD
1847           cipher algorithms.
1848
1849 config CRYPTO_USER_API_ENABLE_OBSOLETE
1850         bool "Enable obsolete cryptographic algorithms for userspace"
1851         depends on CRYPTO_USER_API
1852         default y
1853         help
1854           Allow obsolete cryptographic algorithms to be selected that have
1855           already been phased out from internal use by the kernel, and are
1856           only useful for userspace clients that still rely on them.
1857
1858 config CRYPTO_STATS
1859         bool "Crypto usage statistics for User-space"
1860         depends on CRYPTO_USER
1861         help
1862           This option enables the gathering of crypto stats.
1863           This will collect:
1864           - encrypt/decrypt size and numbers of symmeric operations
1865           - compress/decompress size and numbers of compress operations
1866           - size and numbers of hash operations
1867           - encrypt/decrypt/sign/verify numbers for asymmetric operations
1868           - generate/seed numbers for rng operations
1869
1870 config CRYPTO_HASH_INFO
1871         bool
1872
1873 source "lib/crypto/Kconfig"
1874 source "drivers/crypto/Kconfig"
1875 source "crypto/asymmetric_keys/Kconfig"
1876 source "certs/Kconfig"
1877
1878 endif   # if CRYPTO