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