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