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