Merge tag 'mips_4.17' of git://git.kernel.org/pub/scm/linux/kernel/git/jhogan/mips
[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_CRC32_MIPS
504         tristate "CRC32c and CRC32 CRC algorithm (MIPS)"
505         depends on MIPS_CRC_SUPPORT
506         select CRYPTO_HASH
507         help
508           CRC32c and CRC32 CRC algorithms implemented using mips crypto
509           instructions, when available.
510
511
512 config CRYPTO_CRCT10DIF
513         tristate "CRCT10DIF algorithm"
514         select CRYPTO_HASH
515         help
516           CRC T10 Data Integrity Field computation is being cast as
517           a crypto transform.  This allows for faster crc t10 diff
518           transforms to be used if they are available.
519
520 config CRYPTO_CRCT10DIF_PCLMUL
521         tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
522         depends on X86 && 64BIT && CRC_T10DIF
523         select CRYPTO_HASH
524         help
525           For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
526           CRC T10 DIF PCLMULQDQ computation can be hardware
527           accelerated PCLMULQDQ instruction. This option will create
528           'crct10dif-plcmul' module, which is faster when computing the
529           crct10dif checksum as compared with the generic table implementation.
530
531 config CRYPTO_CRCT10DIF_VPMSUM
532         tristate "CRC32T10DIF powerpc64 hardware acceleration"
533         depends on PPC64 && ALTIVEC && CRC_T10DIF
534         select CRYPTO_HASH
535         help
536           CRC10T10DIF algorithm implemented using vector polynomial
537           multiply-sum (vpmsum) instructions, introduced in POWER8. Enable on
538           POWER8 and newer processors for improved performance.
539
540 config CRYPTO_VPMSUM_TESTER
541         tristate "Powerpc64 vpmsum hardware acceleration tester"
542         depends on CRYPTO_CRCT10DIF_VPMSUM && CRYPTO_CRC32C_VPMSUM
543         help
544           Stress test for CRC32c and CRC-T10DIF algorithms implemented with
545           POWER8 vpmsum instructions.
546           Unless you are testing these algorithms, you don't need this.
547
548 config CRYPTO_GHASH
549         tristate "GHASH digest algorithm"
550         select CRYPTO_GF128MUL
551         select CRYPTO_HASH
552         help
553           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
554
555 config CRYPTO_POLY1305
556         tristate "Poly1305 authenticator algorithm"
557         select CRYPTO_HASH
558         help
559           Poly1305 authenticator algorithm, RFC7539.
560
561           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
562           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
563           in IETF protocols. This is the portable C implementation of Poly1305.
564
565 config CRYPTO_POLY1305_X86_64
566         tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
567         depends on X86 && 64BIT
568         select CRYPTO_POLY1305
569         help
570           Poly1305 authenticator algorithm, RFC7539.
571
572           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
573           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
574           in IETF protocols. This is the x86_64 assembler implementation using SIMD
575           instructions.
576
577 config CRYPTO_MD4
578         tristate "MD4 digest algorithm"
579         select CRYPTO_HASH
580         help
581           MD4 message digest algorithm (RFC1320).
582
583 config CRYPTO_MD5
584         tristate "MD5 digest algorithm"
585         select CRYPTO_HASH
586         help
587           MD5 message digest algorithm (RFC1321).
588
589 config CRYPTO_MD5_OCTEON
590         tristate "MD5 digest algorithm (OCTEON)"
591         depends on CPU_CAVIUM_OCTEON
592         select CRYPTO_MD5
593         select CRYPTO_HASH
594         help
595           MD5 message digest algorithm (RFC1321) implemented
596           using OCTEON crypto instructions, when available.
597
598 config CRYPTO_MD5_PPC
599         tristate "MD5 digest algorithm (PPC)"
600         depends on PPC
601         select CRYPTO_HASH
602         help
603           MD5 message digest algorithm (RFC1321) implemented
604           in PPC assembler.
605
606 config CRYPTO_MD5_SPARC64
607         tristate "MD5 digest algorithm (SPARC64)"
608         depends on SPARC64
609         select CRYPTO_MD5
610         select CRYPTO_HASH
611         help
612           MD5 message digest algorithm (RFC1321) implemented
613           using sparc64 crypto instructions, when available.
614
615 config CRYPTO_MICHAEL_MIC
616         tristate "Michael MIC keyed digest algorithm"
617         select CRYPTO_HASH
618         help
619           Michael MIC is used for message integrity protection in TKIP
620           (IEEE 802.11i). This algorithm is required for TKIP, but it
621           should not be used for other purposes because of the weakness
622           of the algorithm.
623
624 config CRYPTO_RMD128
625         tristate "RIPEMD-128 digest algorithm"
626         select CRYPTO_HASH
627         help
628           RIPEMD-128 (ISO/IEC 10118-3:2004).
629
630           RIPEMD-128 is a 128-bit cryptographic hash function. It should only
631           be used as a secure replacement for RIPEMD. For other use cases,
632           RIPEMD-160 should be used.
633
634           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
635           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
636
637 config CRYPTO_RMD160
638         tristate "RIPEMD-160 digest algorithm"
639         select CRYPTO_HASH
640         help
641           RIPEMD-160 (ISO/IEC 10118-3:2004).
642
643           RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
644           to be used as a secure replacement for the 128-bit hash functions
645           MD4, MD5 and it's predecessor RIPEMD
646           (not to be confused with RIPEMD-128).
647
648           It's speed is comparable to SHA1 and there are no known attacks
649           against RIPEMD-160.
650
651           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
652           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
653
654 config CRYPTO_RMD256
655         tristate "RIPEMD-256 digest algorithm"
656         select CRYPTO_HASH
657         help
658           RIPEMD-256 is an optional extension of RIPEMD-128 with a
659           256 bit hash. It is intended for applications that require
660           longer hash-results, without needing a larger security level
661           (than RIPEMD-128).
662
663           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
664           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
665
666 config CRYPTO_RMD320
667         tristate "RIPEMD-320 digest algorithm"
668         select CRYPTO_HASH
669         help
670           RIPEMD-320 is an optional extension of RIPEMD-160 with a
671           320 bit hash. It is intended for applications that require
672           longer hash-results, without needing a larger security level
673           (than RIPEMD-160).
674
675           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
676           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
677
678 config CRYPTO_SHA1
679         tristate "SHA1 digest algorithm"
680         select CRYPTO_HASH
681         help
682           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
683
684 config CRYPTO_SHA1_SSSE3
685         tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
686         depends on X86 && 64BIT
687         select CRYPTO_SHA1
688         select CRYPTO_HASH
689         help
690           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
691           using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
692           Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
693           when available.
694
695 config CRYPTO_SHA256_SSSE3
696         tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
697         depends on X86 && 64BIT
698         select CRYPTO_SHA256
699         select CRYPTO_HASH
700         help
701           SHA-256 secure hash standard (DFIPS 180-2) implemented
702           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
703           Extensions version 1 (AVX1), or Advanced Vector Extensions
704           version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
705           Instructions) when available.
706
707 config CRYPTO_SHA512_SSSE3
708         tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
709         depends on X86 && 64BIT
710         select CRYPTO_SHA512
711         select CRYPTO_HASH
712         help
713           SHA-512 secure hash standard (DFIPS 180-2) implemented
714           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
715           Extensions version 1 (AVX1), or Advanced Vector Extensions
716           version 2 (AVX2) instructions, when available.
717
718 config CRYPTO_SHA1_OCTEON
719         tristate "SHA1 digest algorithm (OCTEON)"
720         depends on CPU_CAVIUM_OCTEON
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 OCTEON crypto instructions, when available.
726
727 config CRYPTO_SHA1_SPARC64
728         tristate "SHA1 digest algorithm (SPARC64)"
729         depends on SPARC64
730         select CRYPTO_SHA1
731         select CRYPTO_HASH
732         help
733           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
734           using sparc64 crypto instructions, when available.
735
736 config CRYPTO_SHA1_PPC
737         tristate "SHA1 digest algorithm (powerpc)"
738         depends on PPC
739         help
740           This is the powerpc hardware accelerated implementation of the
741           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
742
743 config CRYPTO_SHA1_PPC_SPE
744         tristate "SHA1 digest algorithm (PPC SPE)"
745         depends on PPC && SPE
746         help
747           SHA-1 secure hash standard (DFIPS 180-4) implemented
748           using powerpc SPE SIMD instruction set.
749
750 config CRYPTO_SHA1_MB
751         tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
752         depends on X86 && 64BIT
753         select CRYPTO_SHA1
754         select CRYPTO_HASH
755         select CRYPTO_MCRYPTD
756         help
757           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
758           using multi-buffer technique.  This algorithm computes on
759           multiple data lanes concurrently with SIMD instructions for
760           better throughput.  It should not be enabled by default but
761           used when there is significant amount of work to keep the keep
762           the data lanes filled to get performance benefit.  If the data
763           lanes remain unfilled, a flush operation will be initiated to
764           process the crypto jobs, adding a slight latency.
765
766 config CRYPTO_SHA256_MB
767         tristate "SHA256 digest algorithm (x86_64 Multi-Buffer, Experimental)"
768         depends on X86 && 64BIT
769         select CRYPTO_SHA256
770         select CRYPTO_HASH
771         select CRYPTO_MCRYPTD
772         help
773           SHA-256 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
774           using multi-buffer technique.  This algorithm computes on
775           multiple data lanes concurrently with SIMD instructions for
776           better throughput.  It should not be enabled by default but
777           used when there is significant amount of work to keep the keep
778           the data lanes filled to get performance benefit.  If the data
779           lanes remain unfilled, a flush operation will be initiated to
780           process the crypto jobs, adding a slight latency.
781
782 config CRYPTO_SHA512_MB
783         tristate "SHA512 digest algorithm (x86_64 Multi-Buffer, Experimental)"
784         depends on X86 && 64BIT
785         select CRYPTO_SHA512
786         select CRYPTO_HASH
787         select CRYPTO_MCRYPTD
788         help
789           SHA-512 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
790           using multi-buffer technique.  This algorithm computes on
791           multiple data lanes concurrently with SIMD instructions for
792           better throughput.  It should not be enabled by default but
793           used when there is significant amount of work to keep the keep
794           the data lanes filled to get performance benefit.  If the data
795           lanes remain unfilled, a flush operation will be initiated to
796           process the crypto jobs, adding a slight latency.
797
798 config CRYPTO_SHA256
799         tristate "SHA224 and SHA256 digest algorithm"
800         select CRYPTO_HASH
801         help
802           SHA256 secure hash standard (DFIPS 180-2).
803
804           This version of SHA implements a 256 bit hash with 128 bits of
805           security against collision attacks.
806
807           This code also includes SHA-224, a 224 bit hash with 112 bits
808           of security against collision attacks.
809
810 config CRYPTO_SHA256_PPC_SPE
811         tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
812         depends on PPC && SPE
813         select CRYPTO_SHA256
814         select CRYPTO_HASH
815         help
816           SHA224 and SHA256 secure hash standard (DFIPS 180-2)
817           implemented using powerpc SPE SIMD instruction set.
818
819 config CRYPTO_SHA256_OCTEON
820         tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
821         depends on CPU_CAVIUM_OCTEON
822         select CRYPTO_SHA256
823         select CRYPTO_HASH
824         help
825           SHA-256 secure hash standard (DFIPS 180-2) implemented
826           using OCTEON crypto instructions, when available.
827
828 config CRYPTO_SHA256_SPARC64
829         tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
830         depends on SPARC64
831         select CRYPTO_SHA256
832         select CRYPTO_HASH
833         help
834           SHA-256 secure hash standard (DFIPS 180-2) implemented
835           using sparc64 crypto instructions, when available.
836
837 config CRYPTO_SHA512
838         tristate "SHA384 and SHA512 digest algorithms"
839         select CRYPTO_HASH
840         help
841           SHA512 secure hash standard (DFIPS 180-2).
842
843           This version of SHA implements a 512 bit hash with 256 bits of
844           security against collision attacks.
845
846           This code also includes SHA-384, a 384 bit hash with 192 bits
847           of security against collision attacks.
848
849 config CRYPTO_SHA512_OCTEON
850         tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
851         depends on CPU_CAVIUM_OCTEON
852         select CRYPTO_SHA512
853         select CRYPTO_HASH
854         help
855           SHA-512 secure hash standard (DFIPS 180-2) implemented
856           using OCTEON crypto instructions, when available.
857
858 config CRYPTO_SHA512_SPARC64
859         tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
860         depends on SPARC64
861         select CRYPTO_SHA512
862         select CRYPTO_HASH
863         help
864           SHA-512 secure hash standard (DFIPS 180-2) implemented
865           using sparc64 crypto instructions, when available.
866
867 config CRYPTO_SHA3
868         tristate "SHA3 digest algorithm"
869         select CRYPTO_HASH
870         help
871           SHA-3 secure hash standard (DFIPS 202). It's based on
872           cryptographic sponge function family called Keccak.
873
874           References:
875           http://keccak.noekeon.org/
876
877 config CRYPTO_SM3
878         tristate "SM3 digest algorithm"
879         select CRYPTO_HASH
880         help
881           SM3 secure hash function as defined by OSCCA GM/T 0004-2012 SM3).
882           It is part of the Chinese Commercial Cryptography suite.
883
884           References:
885           http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
886           https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
887
888 config CRYPTO_TGR192
889         tristate "Tiger digest algorithms"
890         select CRYPTO_HASH
891         help
892           Tiger hash algorithm 192, 160 and 128-bit hashes
893
894           Tiger is a hash function optimized for 64-bit processors while
895           still having decent performance on 32-bit processors.
896           Tiger was developed by Ross Anderson and Eli Biham.
897
898           See also:
899           <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
900
901 config CRYPTO_WP512
902         tristate "Whirlpool digest algorithms"
903         select CRYPTO_HASH
904         help
905           Whirlpool hash algorithm 512, 384 and 256-bit hashes
906
907           Whirlpool-512 is part of the NESSIE cryptographic primitives.
908           Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
909
910           See also:
911           <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
912
913 config CRYPTO_GHASH_CLMUL_NI_INTEL
914         tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
915         depends on X86 && 64BIT
916         select CRYPTO_CRYPTD
917         help
918           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
919           The implementation is accelerated by CLMUL-NI of Intel.
920
921 comment "Ciphers"
922
923 config CRYPTO_AES
924         tristate "AES cipher algorithms"
925         select CRYPTO_ALGAPI
926         help
927           AES cipher algorithms (FIPS-197). AES uses the Rijndael
928           algorithm.
929
930           Rijndael appears to be consistently a very good performer in
931           both hardware and software across a wide range of computing
932           environments regardless of its use in feedback or non-feedback
933           modes. Its key setup time is excellent, and its key agility is
934           good. Rijndael's very low memory requirements make it very well
935           suited for restricted-space environments, in which it also
936           demonstrates excellent performance. Rijndael's operations are
937           among the easiest to defend against power and timing attacks.
938
939           The AES specifies three key sizes: 128, 192 and 256 bits
940
941           See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
942
943 config CRYPTO_AES_TI
944         tristate "Fixed time AES cipher"
945         select CRYPTO_ALGAPI
946         help
947           This is a generic implementation of AES that attempts to eliminate
948           data dependent latencies as much as possible without affecting
949           performance too much. It is intended for use by the generic CCM
950           and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
951           solely on encryption (although decryption is supported as well, but
952           with a more dramatic performance hit)
953
954           Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
955           8 for decryption), this implementation only uses just two S-boxes of
956           256 bytes each, and attempts to eliminate data dependent latencies by
957           prefetching the entire table into the cache at the start of each
958           block.
959
960 config CRYPTO_AES_586
961         tristate "AES cipher algorithms (i586)"
962         depends on (X86 || UML_X86) && !64BIT
963         select CRYPTO_ALGAPI
964         select CRYPTO_AES
965         help
966           AES cipher algorithms (FIPS-197). AES uses the Rijndael
967           algorithm.
968
969           Rijndael appears to be consistently a very good performer in
970           both hardware and software across a wide range of computing
971           environments regardless of its use in feedback or non-feedback
972           modes. Its key setup time is excellent, and its key agility is
973           good. Rijndael's very low memory requirements make it very well
974           suited for restricted-space environments, in which it also
975           demonstrates excellent performance. Rijndael's operations are
976           among the easiest to defend against power and timing attacks.
977
978           The AES specifies three key sizes: 128, 192 and 256 bits
979
980           See <http://csrc.nist.gov/encryption/aes/> for more information.
981
982 config CRYPTO_AES_X86_64
983         tristate "AES cipher algorithms (x86_64)"
984         depends on (X86 || UML_X86) && 64BIT
985         select CRYPTO_ALGAPI
986         select CRYPTO_AES
987         help
988           AES cipher algorithms (FIPS-197). AES uses the Rijndael
989           algorithm.
990
991           Rijndael appears to be consistently a very good performer in
992           both hardware and software across a wide range of computing
993           environments regardless of its use in feedback or non-feedback
994           modes. Its key setup time is excellent, and its key agility is
995           good. Rijndael's very low memory requirements make it very well
996           suited for restricted-space environments, in which it also
997           demonstrates excellent performance. Rijndael's operations are
998           among the easiest to defend against power and timing attacks.
999
1000           The AES specifies three key sizes: 128, 192 and 256 bits
1001
1002           See <http://csrc.nist.gov/encryption/aes/> for more information.
1003
1004 config CRYPTO_AES_NI_INTEL
1005         tristate "AES cipher algorithms (AES-NI)"
1006         depends on X86
1007         select CRYPTO_AEAD
1008         select CRYPTO_AES_X86_64 if 64BIT
1009         select CRYPTO_AES_586 if !64BIT
1010         select CRYPTO_ALGAPI
1011         select CRYPTO_BLKCIPHER
1012         select CRYPTO_GLUE_HELPER_X86 if 64BIT
1013         select CRYPTO_SIMD
1014         help
1015           Use Intel AES-NI instructions for AES algorithm.
1016
1017           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1018           algorithm.
1019
1020           Rijndael appears to be consistently a very good performer in
1021           both hardware and software across a wide range of computing
1022           environments regardless of its use in feedback or non-feedback
1023           modes. Its key setup time is excellent, and its key agility is
1024           good. Rijndael's very low memory requirements make it very well
1025           suited for restricted-space environments, in which it also
1026           demonstrates excellent performance. Rijndael's operations are
1027           among the easiest to defend against power and timing attacks.
1028
1029           The AES specifies three key sizes: 128, 192 and 256 bits
1030
1031           See <http://csrc.nist.gov/encryption/aes/> for more information.
1032
1033           In addition to AES cipher algorithm support, the acceleration
1034           for some popular block cipher mode is supported too, including
1035           ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
1036           acceleration for CTR.
1037
1038 config CRYPTO_AES_SPARC64
1039         tristate "AES cipher algorithms (SPARC64)"
1040         depends on SPARC64
1041         select CRYPTO_CRYPTD
1042         select CRYPTO_ALGAPI
1043         help
1044           Use SPARC64 crypto opcodes for AES algorithm.
1045
1046           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1047           algorithm.
1048
1049           Rijndael appears to be consistently a very good performer in
1050           both hardware and software across a wide range of computing
1051           environments regardless of its use in feedback or non-feedback
1052           modes. Its key setup time is excellent, and its key agility is
1053           good. Rijndael's very low memory requirements make it very well
1054           suited for restricted-space environments, in which it also
1055           demonstrates excellent performance. Rijndael's operations are
1056           among the easiest to defend against power and timing attacks.
1057
1058           The AES specifies three key sizes: 128, 192 and 256 bits
1059
1060           See <http://csrc.nist.gov/encryption/aes/> for more information.
1061
1062           In addition to AES cipher algorithm support, the acceleration
1063           for some popular block cipher mode is supported too, including
1064           ECB and CBC.
1065
1066 config CRYPTO_AES_PPC_SPE
1067         tristate "AES cipher algorithms (PPC SPE)"
1068         depends on PPC && SPE
1069         help
1070           AES cipher algorithms (FIPS-197). Additionally the acceleration
1071           for popular block cipher modes ECB, CBC, CTR and XTS is supported.
1072           This module should only be used for low power (router) devices
1073           without hardware AES acceleration (e.g. caam crypto). It reduces the
1074           size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
1075           timining attacks. Nevertheless it might be not as secure as other
1076           architecture specific assembler implementations that work on 1KB
1077           tables or 256 bytes S-boxes.
1078
1079 config CRYPTO_ANUBIS
1080         tristate "Anubis cipher algorithm"
1081         select CRYPTO_ALGAPI
1082         help
1083           Anubis cipher algorithm.
1084
1085           Anubis is a variable key length cipher which can use keys from
1086           128 bits to 320 bits in length.  It was evaluated as a entrant
1087           in the NESSIE competition.
1088
1089           See also:
1090           <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1091           <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1092
1093 config CRYPTO_ARC4
1094         tristate "ARC4 cipher algorithm"
1095         select CRYPTO_BLKCIPHER
1096         help
1097           ARC4 cipher algorithm.
1098
1099           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1100           bits in length.  This algorithm is required for driver-based
1101           WEP, but it should not be for other purposes because of the
1102           weakness of the algorithm.
1103
1104 config CRYPTO_BLOWFISH
1105         tristate "Blowfish cipher algorithm"
1106         select CRYPTO_ALGAPI
1107         select CRYPTO_BLOWFISH_COMMON
1108         help
1109           Blowfish cipher algorithm, by Bruce Schneier.
1110
1111           This is a variable key length cipher which can use keys from 32
1112           bits to 448 bits in length.  It's fast, simple and specifically
1113           designed for use on "large microprocessors".
1114
1115           See also:
1116           <http://www.schneier.com/blowfish.html>
1117
1118 config CRYPTO_BLOWFISH_COMMON
1119         tristate
1120         help
1121           Common parts of the Blowfish cipher algorithm shared by the
1122           generic c and the assembler implementations.
1123
1124           See also:
1125           <http://www.schneier.com/blowfish.html>
1126
1127 config CRYPTO_BLOWFISH_X86_64
1128         tristate "Blowfish cipher algorithm (x86_64)"
1129         depends on X86 && 64BIT
1130         select CRYPTO_BLKCIPHER
1131         select CRYPTO_BLOWFISH_COMMON
1132         help
1133           Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1134
1135           This is a variable key length cipher which can use keys from 32
1136           bits to 448 bits in length.  It's fast, simple and specifically
1137           designed for use on "large microprocessors".
1138
1139           See also:
1140           <http://www.schneier.com/blowfish.html>
1141
1142 config CRYPTO_CAMELLIA
1143         tristate "Camellia cipher algorithms"
1144         depends on CRYPTO
1145         select CRYPTO_ALGAPI
1146         help
1147           Camellia cipher algorithms module.
1148
1149           Camellia is a symmetric key block cipher developed jointly
1150           at NTT and Mitsubishi Electric Corporation.
1151
1152           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1153
1154           See also:
1155           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1156
1157 config CRYPTO_CAMELLIA_X86_64
1158         tristate "Camellia cipher algorithm (x86_64)"
1159         depends on X86 && 64BIT
1160         depends on CRYPTO
1161         select CRYPTO_BLKCIPHER
1162         select CRYPTO_GLUE_HELPER_X86
1163         help
1164           Camellia cipher algorithm module (x86_64).
1165
1166           Camellia is a symmetric key block cipher developed jointly
1167           at NTT and Mitsubishi Electric Corporation.
1168
1169           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1170
1171           See also:
1172           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1173
1174 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1175         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1176         depends on X86 && 64BIT
1177         depends on CRYPTO
1178         select CRYPTO_BLKCIPHER
1179         select CRYPTO_CAMELLIA_X86_64
1180         select CRYPTO_GLUE_HELPER_X86
1181         select CRYPTO_SIMD
1182         select CRYPTO_XTS
1183         help
1184           Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1185
1186           Camellia is a symmetric key block cipher developed jointly
1187           at NTT and Mitsubishi Electric Corporation.
1188
1189           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1190
1191           See also:
1192           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1193
1194 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1195         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1196         depends on X86 && 64BIT
1197         depends on CRYPTO
1198         select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1199         help
1200           Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1201
1202           Camellia is a symmetric key block cipher developed jointly
1203           at NTT and Mitsubishi Electric Corporation.
1204
1205           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1206
1207           See also:
1208           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1209
1210 config CRYPTO_CAMELLIA_SPARC64
1211         tristate "Camellia cipher algorithm (SPARC64)"
1212         depends on SPARC64
1213         depends on CRYPTO
1214         select CRYPTO_ALGAPI
1215         help
1216           Camellia cipher algorithm module (SPARC64).
1217
1218           Camellia is a symmetric key block cipher developed jointly
1219           at NTT and Mitsubishi Electric Corporation.
1220
1221           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1222
1223           See also:
1224           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1225
1226 config CRYPTO_CAST_COMMON
1227         tristate
1228         help
1229           Common parts of the CAST cipher algorithms shared by the
1230           generic c and the assembler implementations.
1231
1232 config CRYPTO_CAST5
1233         tristate "CAST5 (CAST-128) cipher algorithm"
1234         select CRYPTO_ALGAPI
1235         select CRYPTO_CAST_COMMON
1236         help
1237           The CAST5 encryption algorithm (synonymous with CAST-128) is
1238           described in RFC2144.
1239
1240 config CRYPTO_CAST5_AVX_X86_64
1241         tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1242         depends on X86 && 64BIT
1243         select CRYPTO_BLKCIPHER
1244         select CRYPTO_CAST5
1245         select CRYPTO_CAST_COMMON
1246         select CRYPTO_SIMD
1247         help
1248           The CAST5 encryption algorithm (synonymous with CAST-128) is
1249           described in RFC2144.
1250
1251           This module provides the Cast5 cipher algorithm that processes
1252           sixteen blocks parallel using the AVX instruction set.
1253
1254 config CRYPTO_CAST6
1255         tristate "CAST6 (CAST-256) cipher algorithm"
1256         select CRYPTO_ALGAPI
1257         select CRYPTO_CAST_COMMON
1258         help
1259           The CAST6 encryption algorithm (synonymous with CAST-256) is
1260           described in RFC2612.
1261
1262 config CRYPTO_CAST6_AVX_X86_64
1263         tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1264         depends on X86 && 64BIT
1265         select CRYPTO_BLKCIPHER
1266         select CRYPTO_CAST6
1267         select CRYPTO_CAST_COMMON
1268         select CRYPTO_GLUE_HELPER_X86
1269         select CRYPTO_SIMD
1270         select CRYPTO_XTS
1271         help
1272           The CAST6 encryption algorithm (synonymous with CAST-256) is
1273           described in RFC2612.
1274
1275           This module provides the Cast6 cipher algorithm that processes
1276           eight blocks parallel using the AVX instruction set.
1277
1278 config CRYPTO_DES
1279         tristate "DES and Triple DES EDE cipher algorithms"
1280         select CRYPTO_ALGAPI
1281         help
1282           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1283
1284 config CRYPTO_DES_SPARC64
1285         tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1286         depends on SPARC64
1287         select CRYPTO_ALGAPI
1288         select CRYPTO_DES
1289         help
1290           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1291           optimized using SPARC64 crypto opcodes.
1292
1293 config CRYPTO_DES3_EDE_X86_64
1294         tristate "Triple DES EDE cipher algorithm (x86-64)"
1295         depends on X86 && 64BIT
1296         select CRYPTO_BLKCIPHER
1297         select CRYPTO_DES
1298         help
1299           Triple DES EDE (FIPS 46-3) algorithm.
1300
1301           This module provides implementation of the Triple DES EDE cipher
1302           algorithm that is optimized for x86-64 processors. Two versions of
1303           algorithm are provided; regular processing one input block and
1304           one that processes three blocks parallel.
1305
1306 config CRYPTO_FCRYPT
1307         tristate "FCrypt cipher algorithm"
1308         select CRYPTO_ALGAPI
1309         select CRYPTO_BLKCIPHER
1310         help
1311           FCrypt algorithm used by RxRPC.
1312
1313 config CRYPTO_KHAZAD
1314         tristate "Khazad cipher algorithm"
1315         select CRYPTO_ALGAPI
1316         help
1317           Khazad cipher algorithm.
1318
1319           Khazad was a finalist in the initial NESSIE competition.  It is
1320           an algorithm optimized for 64-bit processors with good performance
1321           on 32-bit processors.  Khazad uses an 128 bit key size.
1322
1323           See also:
1324           <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1325
1326 config CRYPTO_SALSA20
1327         tristate "Salsa20 stream cipher algorithm"
1328         select CRYPTO_BLKCIPHER
1329         help
1330           Salsa20 stream cipher algorithm.
1331
1332           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1333           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1334
1335           The Salsa20 stream cipher algorithm is designed by Daniel J.
1336           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1337
1338 config CRYPTO_SALSA20_586
1339         tristate "Salsa20 stream cipher algorithm (i586)"
1340         depends on (X86 || UML_X86) && !64BIT
1341         select CRYPTO_BLKCIPHER
1342         select CRYPTO_SALSA20
1343         help
1344           Salsa20 stream cipher algorithm.
1345
1346           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1347           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1348
1349           The Salsa20 stream cipher algorithm is designed by Daniel J.
1350           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1351
1352 config CRYPTO_SALSA20_X86_64
1353         tristate "Salsa20 stream cipher algorithm (x86_64)"
1354         depends on (X86 || UML_X86) && 64BIT
1355         select CRYPTO_BLKCIPHER
1356         select CRYPTO_SALSA20
1357         help
1358           Salsa20 stream cipher algorithm.
1359
1360           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1361           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1362
1363           The Salsa20 stream cipher algorithm is designed by Daniel J.
1364           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1365
1366 config CRYPTO_CHACHA20
1367         tristate "ChaCha20 cipher algorithm"
1368         select CRYPTO_BLKCIPHER
1369         help
1370           ChaCha20 cipher algorithm, RFC7539.
1371
1372           ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1373           Bernstein and further specified in RFC7539 for use in IETF protocols.
1374           This is the portable C implementation of ChaCha20.
1375
1376           See also:
1377           <http://cr.yp.to/chacha/chacha-20080128.pdf>
1378
1379 config CRYPTO_CHACHA20_X86_64
1380         tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1381         depends on X86 && 64BIT
1382         select CRYPTO_BLKCIPHER
1383         select CRYPTO_CHACHA20
1384         help
1385           ChaCha20 cipher algorithm, RFC7539.
1386
1387           ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1388           Bernstein and further specified in RFC7539 for use in IETF protocols.
1389           This is the x86_64 assembler implementation using SIMD instructions.
1390
1391           See also:
1392           <http://cr.yp.to/chacha/chacha-20080128.pdf>
1393
1394 config CRYPTO_SEED
1395         tristate "SEED cipher algorithm"
1396         select CRYPTO_ALGAPI
1397         help
1398           SEED cipher algorithm (RFC4269).
1399
1400           SEED is a 128-bit symmetric key block cipher that has been
1401           developed by KISA (Korea Information Security Agency) as a
1402           national standard encryption algorithm of the Republic of Korea.
1403           It is a 16 round block cipher with the key size of 128 bit.
1404
1405           See also:
1406           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1407
1408 config CRYPTO_SERPENT
1409         tristate "Serpent cipher algorithm"
1410         select CRYPTO_ALGAPI
1411         help
1412           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1413
1414           Keys are allowed to be from 0 to 256 bits in length, in steps
1415           of 8 bits.  Also includes the 'Tnepres' algorithm, a reversed
1416           variant of Serpent for compatibility with old kerneli.org code.
1417
1418           See also:
1419           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1420
1421 config CRYPTO_SERPENT_SSE2_X86_64
1422         tristate "Serpent cipher algorithm (x86_64/SSE2)"
1423         depends on X86 && 64BIT
1424         select CRYPTO_BLKCIPHER
1425         select CRYPTO_GLUE_HELPER_X86
1426         select CRYPTO_SERPENT
1427         select CRYPTO_SIMD
1428         help
1429           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1430
1431           Keys are allowed to be from 0 to 256 bits in length, in steps
1432           of 8 bits.
1433
1434           This module provides Serpent cipher algorithm that processes eight
1435           blocks parallel using SSE2 instruction set.
1436
1437           See also:
1438           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1439
1440 config CRYPTO_SERPENT_SSE2_586
1441         tristate "Serpent cipher algorithm (i586/SSE2)"
1442         depends on X86 && !64BIT
1443         select CRYPTO_BLKCIPHER
1444         select CRYPTO_GLUE_HELPER_X86
1445         select CRYPTO_SERPENT
1446         select CRYPTO_SIMD
1447         help
1448           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1449
1450           Keys are allowed to be from 0 to 256 bits in length, in steps
1451           of 8 bits.
1452
1453           This module provides Serpent cipher algorithm that processes four
1454           blocks parallel using SSE2 instruction set.
1455
1456           See also:
1457           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1458
1459 config CRYPTO_SERPENT_AVX_X86_64
1460         tristate "Serpent cipher algorithm (x86_64/AVX)"
1461         depends on X86 && 64BIT
1462         select CRYPTO_BLKCIPHER
1463         select CRYPTO_GLUE_HELPER_X86
1464         select CRYPTO_SERPENT
1465         select CRYPTO_SIMD
1466         select CRYPTO_XTS
1467         help
1468           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1469
1470           Keys are allowed to be from 0 to 256 bits in length, in steps
1471           of 8 bits.
1472
1473           This module provides the Serpent cipher algorithm that processes
1474           eight blocks parallel using the AVX instruction set.
1475
1476           See also:
1477           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1478
1479 config CRYPTO_SERPENT_AVX2_X86_64
1480         tristate "Serpent cipher algorithm (x86_64/AVX2)"
1481         depends on X86 && 64BIT
1482         select CRYPTO_SERPENT_AVX_X86_64
1483         help
1484           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1485
1486           Keys are allowed to be from 0 to 256 bits in length, in steps
1487           of 8 bits.
1488
1489           This module provides Serpent cipher algorithm that processes 16
1490           blocks parallel using AVX2 instruction set.
1491
1492           See also:
1493           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1494
1495 config CRYPTO_SM4
1496         tristate "SM4 cipher algorithm"
1497         select CRYPTO_ALGAPI
1498         help
1499           SM4 cipher algorithms (OSCCA GB/T 32907-2016).
1500
1501           SM4 (GBT.32907-2016) is a cryptographic standard issued by the
1502           Organization of State Commercial Administration of China (OSCCA)
1503           as an authorized cryptographic algorithms for the use within China.
1504
1505           SMS4 was originally created for use in protecting wireless
1506           networks, and is mandated in the Chinese National Standard for
1507           Wireless LAN WAPI (Wired Authentication and Privacy Infrastructure)
1508           (GB.15629.11-2003).
1509
1510           The latest SM4 standard (GBT.32907-2016) was proposed by OSCCA and
1511           standardized through TC 260 of the Standardization Administration
1512           of the People's Republic of China (SAC).
1513
1514           The input, output, and key of SMS4 are each 128 bits.
1515
1516           See also: <https://eprint.iacr.org/2008/329.pdf>
1517
1518           If unsure, say N.
1519
1520 config CRYPTO_SPECK
1521         tristate "Speck cipher algorithm"
1522         select CRYPTO_ALGAPI
1523         help
1524           Speck is a lightweight block cipher that is tuned for optimal
1525           performance in software (rather than hardware).
1526
1527           Speck may not be as secure as AES, and should only be used on systems
1528           where AES is not fast enough.
1529
1530           See also: <https://eprint.iacr.org/2013/404.pdf>
1531
1532           If unsure, say N.
1533
1534 config CRYPTO_TEA
1535         tristate "TEA, XTEA and XETA cipher algorithms"
1536         select CRYPTO_ALGAPI
1537         help
1538           TEA cipher algorithm.
1539
1540           Tiny Encryption Algorithm is a simple cipher that uses
1541           many rounds for security.  It is very fast and uses
1542           little memory.
1543
1544           Xtendend Tiny Encryption Algorithm is a modification to
1545           the TEA algorithm to address a potential key weakness
1546           in the TEA algorithm.
1547
1548           Xtendend Encryption Tiny Algorithm is a mis-implementation
1549           of the XTEA algorithm for compatibility purposes.
1550
1551 config CRYPTO_TWOFISH
1552         tristate "Twofish cipher algorithm"
1553         select CRYPTO_ALGAPI
1554         select CRYPTO_TWOFISH_COMMON
1555         help
1556           Twofish cipher algorithm.
1557
1558           Twofish was submitted as an AES (Advanced Encryption Standard)
1559           candidate cipher by researchers at CounterPane Systems.  It is a
1560           16 round block cipher supporting key sizes of 128, 192, and 256
1561           bits.
1562
1563           See also:
1564           <http://www.schneier.com/twofish.html>
1565
1566 config CRYPTO_TWOFISH_COMMON
1567         tristate
1568         help
1569           Common parts of the Twofish cipher algorithm shared by the
1570           generic c and the assembler implementations.
1571
1572 config CRYPTO_TWOFISH_586
1573         tristate "Twofish cipher algorithms (i586)"
1574         depends on (X86 || UML_X86) && !64BIT
1575         select CRYPTO_ALGAPI
1576         select CRYPTO_TWOFISH_COMMON
1577         help
1578           Twofish cipher algorithm.
1579
1580           Twofish was submitted as an AES (Advanced Encryption Standard)
1581           candidate cipher by researchers at CounterPane Systems.  It is a
1582           16 round block cipher supporting key sizes of 128, 192, and 256
1583           bits.
1584
1585           See also:
1586           <http://www.schneier.com/twofish.html>
1587
1588 config CRYPTO_TWOFISH_X86_64
1589         tristate "Twofish cipher algorithm (x86_64)"
1590         depends on (X86 || UML_X86) && 64BIT
1591         select CRYPTO_ALGAPI
1592         select CRYPTO_TWOFISH_COMMON
1593         help
1594           Twofish cipher algorithm (x86_64).
1595
1596           Twofish was submitted as an AES (Advanced Encryption Standard)
1597           candidate cipher by researchers at CounterPane Systems.  It is a
1598           16 round block cipher supporting key sizes of 128, 192, and 256
1599           bits.
1600
1601           See also:
1602           <http://www.schneier.com/twofish.html>
1603
1604 config CRYPTO_TWOFISH_X86_64_3WAY
1605         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1606         depends on X86 && 64BIT
1607         select CRYPTO_BLKCIPHER
1608         select CRYPTO_TWOFISH_COMMON
1609         select CRYPTO_TWOFISH_X86_64
1610         select CRYPTO_GLUE_HELPER_X86
1611         help
1612           Twofish cipher algorithm (x86_64, 3-way parallel).
1613
1614           Twofish was submitted as an AES (Advanced Encryption Standard)
1615           candidate cipher by researchers at CounterPane Systems.  It is a
1616           16 round block cipher supporting key sizes of 128, 192, and 256
1617           bits.
1618
1619           This module provides Twofish cipher algorithm that processes three
1620           blocks parallel, utilizing resources of out-of-order CPUs better.
1621
1622           See also:
1623           <http://www.schneier.com/twofish.html>
1624
1625 config CRYPTO_TWOFISH_AVX_X86_64
1626         tristate "Twofish cipher algorithm (x86_64/AVX)"
1627         depends on X86 && 64BIT
1628         select CRYPTO_BLKCIPHER
1629         select CRYPTO_GLUE_HELPER_X86
1630         select CRYPTO_SIMD
1631         select CRYPTO_TWOFISH_COMMON
1632         select CRYPTO_TWOFISH_X86_64
1633         select CRYPTO_TWOFISH_X86_64_3WAY
1634         help
1635           Twofish cipher algorithm (x86_64/AVX).
1636
1637           Twofish was submitted as an AES (Advanced Encryption Standard)
1638           candidate cipher by researchers at CounterPane Systems.  It is a
1639           16 round block cipher supporting key sizes of 128, 192, and 256
1640           bits.
1641
1642           This module provides the Twofish cipher algorithm that processes
1643           eight blocks parallel using the AVX Instruction Set.
1644
1645           See also:
1646           <http://www.schneier.com/twofish.html>
1647
1648 comment "Compression"
1649
1650 config CRYPTO_DEFLATE
1651         tristate "Deflate compression algorithm"
1652         select CRYPTO_ALGAPI
1653         select CRYPTO_ACOMP2
1654         select ZLIB_INFLATE
1655         select ZLIB_DEFLATE
1656         help
1657           This is the Deflate algorithm (RFC1951), specified for use in
1658           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1659
1660           You will most probably want this if using IPSec.
1661
1662 config CRYPTO_LZO
1663         tristate "LZO compression algorithm"
1664         select CRYPTO_ALGAPI
1665         select CRYPTO_ACOMP2
1666         select LZO_COMPRESS
1667         select LZO_DECOMPRESS
1668         help
1669           This is the LZO algorithm.
1670
1671 config CRYPTO_842
1672         tristate "842 compression algorithm"
1673         select CRYPTO_ALGAPI
1674         select CRYPTO_ACOMP2
1675         select 842_COMPRESS
1676         select 842_DECOMPRESS
1677         help
1678           This is the 842 algorithm.
1679
1680 config CRYPTO_LZ4
1681         tristate "LZ4 compression algorithm"
1682         select CRYPTO_ALGAPI
1683         select CRYPTO_ACOMP2
1684         select LZ4_COMPRESS
1685         select LZ4_DECOMPRESS
1686         help
1687           This is the LZ4 algorithm.
1688
1689 config CRYPTO_LZ4HC
1690         tristate "LZ4HC compression algorithm"
1691         select CRYPTO_ALGAPI
1692         select CRYPTO_ACOMP2
1693         select LZ4HC_COMPRESS
1694         select LZ4_DECOMPRESS
1695         help
1696           This is the LZ4 high compression mode algorithm.
1697
1698 comment "Random Number Generation"
1699
1700 config CRYPTO_ANSI_CPRNG
1701         tristate "Pseudo Random Number Generation for Cryptographic modules"
1702         select CRYPTO_AES
1703         select CRYPTO_RNG
1704         help
1705           This option enables the generic pseudo random number generator
1706           for cryptographic modules.  Uses the Algorithm specified in
1707           ANSI X9.31 A.2.4. Note that this option must be enabled if
1708           CRYPTO_FIPS is selected
1709
1710 menuconfig CRYPTO_DRBG_MENU
1711         tristate "NIST SP800-90A DRBG"
1712         help
1713           NIST SP800-90A compliant DRBG. In the following submenu, one or
1714           more of the DRBG types must be selected.
1715
1716 if CRYPTO_DRBG_MENU
1717
1718 config CRYPTO_DRBG_HMAC
1719         bool
1720         default y
1721         select CRYPTO_HMAC
1722         select CRYPTO_SHA256
1723
1724 config CRYPTO_DRBG_HASH
1725         bool "Enable Hash DRBG"
1726         select CRYPTO_SHA256
1727         help
1728           Enable the Hash DRBG variant as defined in NIST SP800-90A.
1729
1730 config CRYPTO_DRBG_CTR
1731         bool "Enable CTR DRBG"
1732         select CRYPTO_AES
1733         depends on CRYPTO_CTR
1734         help
1735           Enable the CTR DRBG variant as defined in NIST SP800-90A.
1736
1737 config CRYPTO_DRBG
1738         tristate
1739         default CRYPTO_DRBG_MENU
1740         select CRYPTO_RNG
1741         select CRYPTO_JITTERENTROPY
1742
1743 endif   # if CRYPTO_DRBG_MENU
1744
1745 config CRYPTO_JITTERENTROPY
1746         tristate "Jitterentropy Non-Deterministic Random Number Generator"
1747         select CRYPTO_RNG
1748         help
1749           The Jitterentropy RNG is a noise that is intended
1750           to provide seed to another RNG. The RNG does not
1751           perform any cryptographic whitening of the generated
1752           random numbers. This Jitterentropy RNG registers with
1753           the kernel crypto API and can be used by any caller.
1754
1755 config CRYPTO_USER_API
1756         tristate
1757
1758 config CRYPTO_USER_API_HASH
1759         tristate "User-space interface for hash algorithms"
1760         depends on NET
1761         select CRYPTO_HASH
1762         select CRYPTO_USER_API
1763         help
1764           This option enables the user-spaces interface for hash
1765           algorithms.
1766
1767 config CRYPTO_USER_API_SKCIPHER
1768         tristate "User-space interface for symmetric key cipher algorithms"
1769         depends on NET
1770         select CRYPTO_BLKCIPHER
1771         select CRYPTO_USER_API
1772         help
1773           This option enables the user-spaces interface for symmetric
1774           key cipher algorithms.
1775
1776 config CRYPTO_USER_API_RNG
1777         tristate "User-space interface for random number generator algorithms"
1778         depends on NET
1779         select CRYPTO_RNG
1780         select CRYPTO_USER_API
1781         help
1782           This option enables the user-spaces interface for random
1783           number generator algorithms.
1784
1785 config CRYPTO_USER_API_AEAD
1786         tristate "User-space interface for AEAD cipher algorithms"
1787         depends on NET
1788         select CRYPTO_AEAD
1789         select CRYPTO_BLKCIPHER
1790         select CRYPTO_NULL
1791         select CRYPTO_USER_API
1792         help
1793           This option enables the user-spaces interface for AEAD
1794           cipher algorithms.
1795
1796 config CRYPTO_HASH_INFO
1797         bool
1798
1799 source "drivers/crypto/Kconfig"
1800 source crypto/asymmetric_keys/Kconfig
1801 source certs/Kconfig
1802
1803 endif   # if CRYPTO