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