sparc64: Add MD5 driver making use of the 'md5' instruction.
[linux-3.10.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 (EXPERIMENTAL)"
138         depends on SMP && EXPERIMENTAL
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         help
202           Support for Galois/Counter Mode (GCM) and Galois Message
203           Authentication Code (GMAC). Required for IPSec.
204
205 config CRYPTO_SEQIV
206         tristate "Sequence Number IV Generator"
207         select CRYPTO_AEAD
208         select CRYPTO_BLKCIPHER
209         select CRYPTO_RNG
210         help
211           This IV generator generates an IV based on a sequence number by
212           xoring it with a salt.  This algorithm is mainly useful for CTR
213
214 comment "Block modes"
215
216 config CRYPTO_CBC
217         tristate "CBC support"
218         select CRYPTO_BLKCIPHER
219         select CRYPTO_MANAGER
220         help
221           CBC: Cipher Block Chaining mode
222           This block cipher algorithm is required for IPSec.
223
224 config CRYPTO_CTR
225         tristate "CTR support"
226         select CRYPTO_BLKCIPHER
227         select CRYPTO_SEQIV
228         select CRYPTO_MANAGER
229         help
230           CTR: Counter mode
231           This block cipher algorithm is required for IPSec.
232
233 config CRYPTO_CTS
234         tristate "CTS support"
235         select CRYPTO_BLKCIPHER
236         help
237           CTS: Cipher Text Stealing
238           This is the Cipher Text Stealing mode as described by
239           Section 8 of rfc2040 and referenced by rfc3962.
240           (rfc3962 includes errata information in its Appendix A)
241           This mode is required for Kerberos gss mechanism support
242           for AES encryption.
243
244 config CRYPTO_ECB
245         tristate "ECB support"
246         select CRYPTO_BLKCIPHER
247         select CRYPTO_MANAGER
248         help
249           ECB: Electronic CodeBook mode
250           This is the simplest block cipher algorithm.  It simply encrypts
251           the input block by block.
252
253 config CRYPTO_LRW
254         tristate "LRW support"
255         select CRYPTO_BLKCIPHER
256         select CRYPTO_MANAGER
257         select CRYPTO_GF128MUL
258         help
259           LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
260           narrow block cipher mode for dm-crypt.  Use it with cipher
261           specification string aes-lrw-benbi, the key must be 256, 320 or 384.
262           The first 128, 192 or 256 bits in the key are used for AES and the
263           rest is used to tie each cipher block to its logical position.
264
265 config CRYPTO_PCBC
266         tristate "PCBC support"
267         select CRYPTO_BLKCIPHER
268         select CRYPTO_MANAGER
269         help
270           PCBC: Propagating Cipher Block Chaining mode
271           This block cipher algorithm is required for RxRPC.
272
273 config CRYPTO_XTS
274         tristate "XTS support"
275         select CRYPTO_BLKCIPHER
276         select CRYPTO_MANAGER
277         select CRYPTO_GF128MUL
278         help
279           XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
280           key size 256, 384 or 512 bits. This implementation currently
281           can't handle a sectorsize which is not a multiple of 16 bytes.
282
283 comment "Hash modes"
284
285 config CRYPTO_HMAC
286         tristate "HMAC support"
287         select CRYPTO_HASH
288         select CRYPTO_MANAGER
289         help
290           HMAC: Keyed-Hashing for Message Authentication (RFC2104).
291           This is required for IPSec.
292
293 config CRYPTO_XCBC
294         tristate "XCBC support"
295         depends on EXPERIMENTAL
296         select CRYPTO_HASH
297         select CRYPTO_MANAGER
298         help
299           XCBC: Keyed-Hashing with encryption algorithm
300                 http://www.ietf.org/rfc/rfc3566.txt
301                 http://csrc.nist.gov/encryption/modes/proposedmodes/
302                  xcbc-mac/xcbc-mac-spec.pdf
303
304 config CRYPTO_VMAC
305         tristate "VMAC support"
306         depends on EXPERIMENTAL
307         select CRYPTO_HASH
308         select CRYPTO_MANAGER
309         help
310           VMAC is a message authentication algorithm designed for
311           very high speed on 64-bit architectures.
312
313           See also:
314           <http://fastcrypto.org/vmac>
315
316 comment "Digest"
317
318 config CRYPTO_CRC32C
319         tristate "CRC32c CRC algorithm"
320         select CRYPTO_HASH
321         select CRC32
322         help
323           Castagnoli, et al Cyclic Redundancy-Check Algorithm.  Used
324           by iSCSI for header and data digests and by others.
325           See Castagnoli93.  Module will be crc32c.
326
327 config CRYPTO_CRC32C_INTEL
328         tristate "CRC32c INTEL hardware acceleration"
329         depends on X86
330         select CRYPTO_HASH
331         help
332           In Intel processor with SSE4.2 supported, the processor will
333           support CRC32C implementation using hardware accelerated CRC32
334           instruction. This option will create 'crc32c-intel' module,
335           which will enable any routine to use the CRC32 instruction to
336           gain performance compared with software implementation.
337           Module will be crc32c-intel.
338
339 config CRYPTO_GHASH
340         tristate "GHASH digest algorithm"
341         select CRYPTO_GF128MUL
342         help
343           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
344
345 config CRYPTO_MD4
346         tristate "MD4 digest algorithm"
347         select CRYPTO_HASH
348         help
349           MD4 message digest algorithm (RFC1320).
350
351 config CRYPTO_MD5
352         tristate "MD5 digest algorithm"
353         select CRYPTO_HASH
354         help
355           MD5 message digest algorithm (RFC1321).
356
357 config CRYPTO_MD5_SPARC64
358         tristate "MD5 digest algorithm (SPARC64)"
359         depends on SPARC64
360         select CRYPTO_MD5
361         select CRYPTO_HASH
362         help
363           MD5 message digest algorithm (RFC1321) implemented
364           using sparc64 crypto instructions, when available.
365
366 config CRYPTO_MICHAEL_MIC
367         tristate "Michael MIC keyed digest algorithm"
368         select CRYPTO_HASH
369         help
370           Michael MIC is used for message integrity protection in TKIP
371           (IEEE 802.11i). This algorithm is required for TKIP, but it
372           should not be used for other purposes because of the weakness
373           of the algorithm.
374
375 config CRYPTO_RMD128
376         tristate "RIPEMD-128 digest algorithm"
377         select CRYPTO_HASH
378         help
379           RIPEMD-128 (ISO/IEC 10118-3:2004).
380
381           RIPEMD-128 is a 128-bit cryptographic hash function. It should only
382           be used as a secure replacement for RIPEMD. For other use cases,
383           RIPEMD-160 should be used.
384
385           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
386           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
387
388 config CRYPTO_RMD160
389         tristate "RIPEMD-160 digest algorithm"
390         select CRYPTO_HASH
391         help
392           RIPEMD-160 (ISO/IEC 10118-3:2004).
393
394           RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
395           to be used as a secure replacement for the 128-bit hash functions
396           MD4, MD5 and it's predecessor RIPEMD
397           (not to be confused with RIPEMD-128).
398
399           It's speed is comparable to SHA1 and there are no known attacks
400           against RIPEMD-160.
401
402           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
403           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
404
405 config CRYPTO_RMD256
406         tristate "RIPEMD-256 digest algorithm"
407         select CRYPTO_HASH
408         help
409           RIPEMD-256 is an optional extension of RIPEMD-128 with a
410           256 bit hash. It is intended for applications that require
411           longer hash-results, without needing a larger security level
412           (than RIPEMD-128).
413
414           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
415           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
416
417 config CRYPTO_RMD320
418         tristate "RIPEMD-320 digest algorithm"
419         select CRYPTO_HASH
420         help
421           RIPEMD-320 is an optional extension of RIPEMD-160 with a
422           320 bit hash. It is intended for applications that require
423           longer hash-results, without needing a larger security level
424           (than RIPEMD-160).
425
426           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
427           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
428
429 config CRYPTO_SHA1
430         tristate "SHA1 digest algorithm"
431         select CRYPTO_HASH
432         help
433           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
434
435 config CRYPTO_SHA1_SSSE3
436         tristate "SHA1 digest algorithm (SSSE3/AVX)"
437         depends on X86 && 64BIT
438         select CRYPTO_SHA1
439         select CRYPTO_HASH
440         help
441           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
442           using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
443           Extensions (AVX), when available.
444
445 config CRYPTO_SHA1_SPARC64
446         tristate "SHA1 digest algorithm (SPARC64)"
447         depends on SPARC64
448         select CRYPTO_SHA1
449         select CRYPTO_HASH
450         help
451           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
452           using sparc64 crypto instructions, when available.
453
454 config CRYPTO_SHA256
455         tristate "SHA224 and SHA256 digest algorithm"
456         select CRYPTO_HASH
457         help
458           SHA256 secure hash standard (DFIPS 180-2).
459
460           This version of SHA implements a 256 bit hash with 128 bits of
461           security against collision attacks.
462
463           This code also includes SHA-224, a 224 bit hash with 112 bits
464           of security against collision attacks.
465
466 config CRYPTO_SHA256_SPARC64
467         tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
468         depends on SPARC64
469         select CRYPTO_SHA256
470         select CRYPTO_HASH
471         help
472           SHA-256 secure hash standard (DFIPS 180-2) implemented
473           using sparc64 crypto instructions, when available.
474
475 config CRYPTO_SHA512
476         tristate "SHA384 and SHA512 digest algorithms"
477         select CRYPTO_HASH
478         help
479           SHA512 secure hash standard (DFIPS 180-2).
480
481           This version of SHA implements a 512 bit hash with 256 bits of
482           security against collision attacks.
483
484           This code also includes SHA-384, a 384 bit hash with 192 bits
485           of security against collision attacks.
486
487 config CRYPTO_SHA512_SPARC64
488         tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
489         depends on SPARC64
490         select CRYPTO_SHA512
491         select CRYPTO_HASH
492         help
493           SHA-512 secure hash standard (DFIPS 180-2) implemented
494           using sparc64 crypto instructions, when available.
495
496 config CRYPTO_TGR192
497         tristate "Tiger digest algorithms"
498         select CRYPTO_HASH
499         help
500           Tiger hash algorithm 192, 160 and 128-bit hashes
501
502           Tiger is a hash function optimized for 64-bit processors while
503           still having decent performance on 32-bit processors.
504           Tiger was developed by Ross Anderson and Eli Biham.
505
506           See also:
507           <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
508
509 config CRYPTO_WP512
510         tristate "Whirlpool digest algorithms"
511         select CRYPTO_HASH
512         help
513           Whirlpool hash algorithm 512, 384 and 256-bit hashes
514
515           Whirlpool-512 is part of the NESSIE cryptographic primitives.
516           Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
517
518           See also:
519           <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
520
521 config CRYPTO_GHASH_CLMUL_NI_INTEL
522         tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
523         depends on X86 && 64BIT
524         select CRYPTO_CRYPTD
525         help
526           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
527           The implementation is accelerated by CLMUL-NI of Intel.
528
529 comment "Ciphers"
530
531 config CRYPTO_AES
532         tristate "AES cipher algorithms"
533         select CRYPTO_ALGAPI
534         help
535           AES cipher algorithms (FIPS-197). AES uses the Rijndael
536           algorithm.
537
538           Rijndael appears to be consistently a very good performer in
539           both hardware and software across a wide range of computing
540           environments regardless of its use in feedback or non-feedback
541           modes. Its key setup time is excellent, and its key agility is
542           good. Rijndael's very low memory requirements make it very well
543           suited for restricted-space environments, in which it also
544           demonstrates excellent performance. Rijndael's operations are
545           among the easiest to defend against power and timing attacks.
546
547           The AES specifies three key sizes: 128, 192 and 256 bits
548
549           See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
550
551 config CRYPTO_AES_586
552         tristate "AES cipher algorithms (i586)"
553         depends on (X86 || UML_X86) && !64BIT
554         select CRYPTO_ALGAPI
555         select CRYPTO_AES
556         help
557           AES cipher algorithms (FIPS-197). AES uses the Rijndael
558           algorithm.
559
560           Rijndael appears to be consistently a very good performer in
561           both hardware and software across a wide range of computing
562           environments regardless of its use in feedback or non-feedback
563           modes. Its key setup time is excellent, and its key agility is
564           good. Rijndael's very low memory requirements make it very well
565           suited for restricted-space environments, in which it also
566           demonstrates excellent performance. Rijndael's operations are
567           among the easiest to defend against power and timing attacks.
568
569           The AES specifies three key sizes: 128, 192 and 256 bits
570
571           See <http://csrc.nist.gov/encryption/aes/> for more information.
572
573 config CRYPTO_AES_X86_64
574         tristate "AES cipher algorithms (x86_64)"
575         depends on (X86 || UML_X86) && 64BIT
576         select CRYPTO_ALGAPI
577         select CRYPTO_AES
578         help
579           AES cipher algorithms (FIPS-197). AES uses the Rijndael
580           algorithm.
581
582           Rijndael appears to be consistently a very good performer in
583           both hardware and software across a wide range of computing
584           environments regardless of its use in feedback or non-feedback
585           modes. Its key setup time is excellent, and its key agility is
586           good. Rijndael's very low memory requirements make it very well
587           suited for restricted-space environments, in which it also
588           demonstrates excellent performance. Rijndael's operations are
589           among the easiest to defend against power and timing attacks.
590
591           The AES specifies three key sizes: 128, 192 and 256 bits
592
593           See <http://csrc.nist.gov/encryption/aes/> for more information.
594
595 config CRYPTO_AES_NI_INTEL
596         tristate "AES cipher algorithms (AES-NI)"
597         depends on X86
598         select CRYPTO_AES_X86_64 if 64BIT
599         select CRYPTO_AES_586 if !64BIT
600         select CRYPTO_CRYPTD
601         select CRYPTO_ABLK_HELPER_X86
602         select CRYPTO_ALGAPI
603         help
604           Use Intel AES-NI instructions for AES algorithm.
605
606           AES cipher algorithms (FIPS-197). AES uses the Rijndael
607           algorithm.
608
609           Rijndael appears to be consistently a very good performer in
610           both hardware and software across a wide range of computing
611           environments regardless of its use in feedback or non-feedback
612           modes. Its key setup time is excellent, and its key agility is
613           good. Rijndael's very low memory requirements make it very well
614           suited for restricted-space environments, in which it also
615           demonstrates excellent performance. Rijndael's operations are
616           among the easiest to defend against power and timing attacks.
617
618           The AES specifies three key sizes: 128, 192 and 256 bits
619
620           See <http://csrc.nist.gov/encryption/aes/> for more information.
621
622           In addition to AES cipher algorithm support, the acceleration
623           for some popular block cipher mode is supported too, including
624           ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
625           acceleration for CTR.
626
627 config CRYPTO_ANUBIS
628         tristate "Anubis cipher algorithm"
629         select CRYPTO_ALGAPI
630         help
631           Anubis cipher algorithm.
632
633           Anubis is a variable key length cipher which can use keys from
634           128 bits to 320 bits in length.  It was evaluated as a entrant
635           in the NESSIE competition.
636
637           See also:
638           <https://www.cosic.esat.kuleuven.be/nessie/reports/>
639           <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
640
641 config CRYPTO_ARC4
642         tristate "ARC4 cipher algorithm"
643         select CRYPTO_BLKCIPHER
644         help
645           ARC4 cipher algorithm.
646
647           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
648           bits in length.  This algorithm is required for driver-based
649           WEP, but it should not be for other purposes because of the
650           weakness of the algorithm.
651
652 config CRYPTO_BLOWFISH
653         tristate "Blowfish cipher algorithm"
654         select CRYPTO_ALGAPI
655         select CRYPTO_BLOWFISH_COMMON
656         help
657           Blowfish cipher algorithm, by Bruce Schneier.
658
659           This is a variable key length cipher which can use keys from 32
660           bits to 448 bits in length.  It's fast, simple and specifically
661           designed for use on "large microprocessors".
662
663           See also:
664           <http://www.schneier.com/blowfish.html>
665
666 config CRYPTO_BLOWFISH_COMMON
667         tristate
668         help
669           Common parts of the Blowfish cipher algorithm shared by the
670           generic c and the assembler implementations.
671
672           See also:
673           <http://www.schneier.com/blowfish.html>
674
675 config CRYPTO_BLOWFISH_X86_64
676         tristate "Blowfish cipher algorithm (x86_64)"
677         depends on X86 && 64BIT
678         select CRYPTO_ALGAPI
679         select CRYPTO_BLOWFISH_COMMON
680         help
681           Blowfish cipher algorithm (x86_64), by Bruce Schneier.
682
683           This is a variable key length cipher which can use keys from 32
684           bits to 448 bits in length.  It's fast, simple and specifically
685           designed for use on "large microprocessors".
686
687           See also:
688           <http://www.schneier.com/blowfish.html>
689
690 config CRYPTO_CAMELLIA
691         tristate "Camellia cipher algorithms"
692         depends on CRYPTO
693         select CRYPTO_ALGAPI
694         help
695           Camellia cipher algorithms module.
696
697           Camellia is a symmetric key block cipher developed jointly
698           at NTT and Mitsubishi Electric Corporation.
699
700           The Camellia specifies three key sizes: 128, 192 and 256 bits.
701
702           See also:
703           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
704
705 config CRYPTO_CAMELLIA_X86_64
706         tristate "Camellia cipher algorithm (x86_64)"
707         depends on X86 && 64BIT
708         depends on CRYPTO
709         select CRYPTO_ALGAPI
710         select CRYPTO_GLUE_HELPER_X86
711         select CRYPTO_LRW
712         select CRYPTO_XTS
713         help
714           Camellia cipher algorithm module (x86_64).
715
716           Camellia is a symmetric key block cipher developed jointly
717           at NTT and Mitsubishi Electric Corporation.
718
719           The Camellia specifies three key sizes: 128, 192 and 256 bits.
720
721           See also:
722           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
723
724 config CRYPTO_CAST5
725         tristate "CAST5 (CAST-128) cipher algorithm"
726         select CRYPTO_ALGAPI
727         help
728           The CAST5 encryption algorithm (synonymous with CAST-128) is
729           described in RFC2144.
730
731 config CRYPTO_CAST6
732         tristate "CAST6 (CAST-256) cipher algorithm"
733         select CRYPTO_ALGAPI
734         help
735           The CAST6 encryption algorithm (synonymous with CAST-256) is
736           described in RFC2612.
737
738 config CRYPTO_DES
739         tristate "DES and Triple DES EDE cipher algorithms"
740         select CRYPTO_ALGAPI
741         help
742           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
743
744 config CRYPTO_FCRYPT
745         tristate "FCrypt cipher algorithm"
746         select CRYPTO_ALGAPI
747         select CRYPTO_BLKCIPHER
748         help
749           FCrypt algorithm used by RxRPC.
750
751 config CRYPTO_KHAZAD
752         tristate "Khazad cipher algorithm"
753         select CRYPTO_ALGAPI
754         help
755           Khazad cipher algorithm.
756
757           Khazad was a finalist in the initial NESSIE competition.  It is
758           an algorithm optimized for 64-bit processors with good performance
759           on 32-bit processors.  Khazad uses an 128 bit key size.
760
761           See also:
762           <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
763
764 config CRYPTO_SALSA20
765         tristate "Salsa20 stream cipher algorithm (EXPERIMENTAL)"
766         depends on EXPERIMENTAL
767         select CRYPTO_BLKCIPHER
768         help
769           Salsa20 stream cipher algorithm.
770
771           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
772           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
773
774           The Salsa20 stream cipher algorithm is designed by Daniel J.
775           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
776
777 config CRYPTO_SALSA20_586
778         tristate "Salsa20 stream cipher algorithm (i586) (EXPERIMENTAL)"
779         depends on (X86 || UML_X86) && !64BIT
780         depends on EXPERIMENTAL
781         select CRYPTO_BLKCIPHER
782         help
783           Salsa20 stream cipher algorithm.
784
785           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
786           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
787
788           The Salsa20 stream cipher algorithm is designed by Daniel J.
789           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
790
791 config CRYPTO_SALSA20_X86_64
792         tristate "Salsa20 stream cipher algorithm (x86_64) (EXPERIMENTAL)"
793         depends on (X86 || UML_X86) && 64BIT
794         depends on EXPERIMENTAL
795         select CRYPTO_BLKCIPHER
796         help
797           Salsa20 stream cipher algorithm.
798
799           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
800           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
801
802           The Salsa20 stream cipher algorithm is designed by Daniel J.
803           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
804
805 config CRYPTO_SEED
806         tristate "SEED cipher algorithm"
807         select CRYPTO_ALGAPI
808         help
809           SEED cipher algorithm (RFC4269).
810
811           SEED is a 128-bit symmetric key block cipher that has been
812           developed by KISA (Korea Information Security Agency) as a
813           national standard encryption algorithm of the Republic of Korea.
814           It is a 16 round block cipher with the key size of 128 bit.
815
816           See also:
817           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
818
819 config CRYPTO_SERPENT
820         tristate "Serpent cipher algorithm"
821         select CRYPTO_ALGAPI
822         help
823           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
824
825           Keys are allowed to be from 0 to 256 bits in length, in steps
826           of 8 bits.  Also includes the 'Tnepres' algorithm, a reversed
827           variant of Serpent for compatibility with old kerneli.org code.
828
829           See also:
830           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
831
832 config CRYPTO_SERPENT_SSE2_X86_64
833         tristate "Serpent cipher algorithm (x86_64/SSE2)"
834         depends on X86 && 64BIT
835         select CRYPTO_ALGAPI
836         select CRYPTO_CRYPTD
837         select CRYPTO_ABLK_HELPER_X86
838         select CRYPTO_GLUE_HELPER_X86
839         select CRYPTO_SERPENT
840         select CRYPTO_LRW
841         select CRYPTO_XTS
842         help
843           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
844
845           Keys are allowed to be from 0 to 256 bits in length, in steps
846           of 8 bits.
847
848           This module provides Serpent cipher algorithm that processes eigth
849           blocks parallel using SSE2 instruction set.
850
851           See also:
852           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
853
854 config CRYPTO_SERPENT_SSE2_586
855         tristate "Serpent cipher algorithm (i586/SSE2)"
856         depends on X86 && !64BIT
857         select CRYPTO_ALGAPI
858         select CRYPTO_CRYPTD
859         select CRYPTO_ABLK_HELPER_X86
860         select CRYPTO_GLUE_HELPER_X86
861         select CRYPTO_SERPENT
862         select CRYPTO_LRW
863         select CRYPTO_XTS
864         help
865           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
866
867           Keys are allowed to be from 0 to 256 bits in length, in steps
868           of 8 bits.
869
870           This module provides Serpent cipher algorithm that processes four
871           blocks parallel using SSE2 instruction set.
872
873           See also:
874           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
875
876 config CRYPTO_SERPENT_AVX_X86_64
877         tristate "Serpent cipher algorithm (x86_64/AVX)"
878         depends on X86 && 64BIT
879         select CRYPTO_ALGAPI
880         select CRYPTO_CRYPTD
881         select CRYPTO_ABLK_HELPER_X86
882         select CRYPTO_GLUE_HELPER_X86
883         select CRYPTO_SERPENT
884         select CRYPTO_LRW
885         select CRYPTO_XTS
886         help
887           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
888
889           Keys are allowed to be from 0 to 256 bits in length, in steps
890           of 8 bits.
891
892           This module provides the Serpent cipher algorithm that processes
893           eight blocks parallel using the AVX instruction set.
894
895           See also:
896           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
897
898 config CRYPTO_TEA
899         tristate "TEA, XTEA and XETA cipher algorithms"
900         select CRYPTO_ALGAPI
901         help
902           TEA cipher algorithm.
903
904           Tiny Encryption Algorithm is a simple cipher that uses
905           many rounds for security.  It is very fast and uses
906           little memory.
907
908           Xtendend Tiny Encryption Algorithm is a modification to
909           the TEA algorithm to address a potential key weakness
910           in the TEA algorithm.
911
912           Xtendend Encryption Tiny Algorithm is a mis-implementation
913           of the XTEA algorithm for compatibility purposes.
914
915 config CRYPTO_TWOFISH
916         tristate "Twofish cipher algorithm"
917         select CRYPTO_ALGAPI
918         select CRYPTO_TWOFISH_COMMON
919         help
920           Twofish cipher algorithm.
921
922           Twofish was submitted as an AES (Advanced Encryption Standard)
923           candidate cipher by researchers at CounterPane Systems.  It is a
924           16 round block cipher supporting key sizes of 128, 192, and 256
925           bits.
926
927           See also:
928           <http://www.schneier.com/twofish.html>
929
930 config CRYPTO_TWOFISH_COMMON
931         tristate
932         help
933           Common parts of the Twofish cipher algorithm shared by the
934           generic c and the assembler implementations.
935
936 config CRYPTO_TWOFISH_586
937         tristate "Twofish cipher algorithms (i586)"
938         depends on (X86 || UML_X86) && !64BIT
939         select CRYPTO_ALGAPI
940         select CRYPTO_TWOFISH_COMMON
941         help
942           Twofish cipher algorithm.
943
944           Twofish was submitted as an AES (Advanced Encryption Standard)
945           candidate cipher by researchers at CounterPane Systems.  It is a
946           16 round block cipher supporting key sizes of 128, 192, and 256
947           bits.
948
949           See also:
950           <http://www.schneier.com/twofish.html>
951
952 config CRYPTO_TWOFISH_X86_64
953         tristate "Twofish cipher algorithm (x86_64)"
954         depends on (X86 || UML_X86) && 64BIT
955         select CRYPTO_ALGAPI
956         select CRYPTO_TWOFISH_COMMON
957         help
958           Twofish cipher algorithm (x86_64).
959
960           Twofish was submitted as an AES (Advanced Encryption Standard)
961           candidate cipher by researchers at CounterPane Systems.  It is a
962           16 round block cipher supporting key sizes of 128, 192, and 256
963           bits.
964
965           See also:
966           <http://www.schneier.com/twofish.html>
967
968 config CRYPTO_TWOFISH_X86_64_3WAY
969         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
970         depends on X86 && 64BIT
971         select CRYPTO_ALGAPI
972         select CRYPTO_TWOFISH_COMMON
973         select CRYPTO_TWOFISH_X86_64
974         select CRYPTO_GLUE_HELPER_X86
975         select CRYPTO_LRW
976         select CRYPTO_XTS
977         help
978           Twofish cipher algorithm (x86_64, 3-way parallel).
979
980           Twofish was submitted as an AES (Advanced Encryption Standard)
981           candidate cipher by researchers at CounterPane Systems.  It is a
982           16 round block cipher supporting key sizes of 128, 192, and 256
983           bits.
984
985           This module provides Twofish cipher algorithm that processes three
986           blocks parallel, utilizing resources of out-of-order CPUs better.
987
988           See also:
989           <http://www.schneier.com/twofish.html>
990
991 config CRYPTO_TWOFISH_AVX_X86_64
992         tristate "Twofish cipher algorithm (x86_64/AVX)"
993         depends on X86 && 64BIT
994         select CRYPTO_ALGAPI
995         select CRYPTO_CRYPTD
996         select CRYPTO_ABLK_HELPER_X86
997         select CRYPTO_GLUE_HELPER_X86
998         select CRYPTO_TWOFISH_COMMON
999         select CRYPTO_TWOFISH_X86_64
1000         select CRYPTO_TWOFISH_X86_64_3WAY
1001         select CRYPTO_LRW
1002         select CRYPTO_XTS
1003         help
1004           Twofish cipher algorithm (x86_64/AVX).
1005
1006           Twofish was submitted as an AES (Advanced Encryption Standard)
1007           candidate cipher by researchers at CounterPane Systems.  It is a
1008           16 round block cipher supporting key sizes of 128, 192, and 256
1009           bits.
1010
1011           This module provides the Twofish cipher algorithm that processes
1012           eight blocks parallel using the AVX Instruction Set.
1013
1014           See also:
1015           <http://www.schneier.com/twofish.html>
1016
1017 comment "Compression"
1018
1019 config CRYPTO_DEFLATE
1020         tristate "Deflate compression algorithm"
1021         select CRYPTO_ALGAPI
1022         select ZLIB_INFLATE
1023         select ZLIB_DEFLATE
1024         help
1025           This is the Deflate algorithm (RFC1951), specified for use in
1026           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1027
1028           You will most probably want this if using IPSec.
1029
1030 config CRYPTO_ZLIB
1031         tristate "Zlib compression algorithm"
1032         select CRYPTO_PCOMP
1033         select ZLIB_INFLATE
1034         select ZLIB_DEFLATE
1035         select NLATTR
1036         help
1037           This is the zlib algorithm.
1038
1039 config CRYPTO_LZO
1040         tristate "LZO compression algorithm"
1041         select CRYPTO_ALGAPI
1042         select LZO_COMPRESS
1043         select LZO_DECOMPRESS
1044         help
1045           This is the LZO algorithm.
1046
1047 comment "Random Number Generation"
1048
1049 config CRYPTO_ANSI_CPRNG
1050         tristate "Pseudo Random Number Generation for Cryptographic modules"
1051         default m
1052         select CRYPTO_AES
1053         select CRYPTO_RNG
1054         help
1055           This option enables the generic pseudo random number generator
1056           for cryptographic modules.  Uses the Algorithm specified in
1057           ANSI X9.31 A.2.4. Note that this option must be enabled if
1058           CRYPTO_FIPS is selected
1059
1060 config CRYPTO_USER_API
1061         tristate
1062
1063 config CRYPTO_USER_API_HASH
1064         tristate "User-space interface for hash algorithms"
1065         depends on NET
1066         select CRYPTO_HASH
1067         select CRYPTO_USER_API
1068         help
1069           This option enables the user-spaces interface for hash
1070           algorithms.
1071
1072 config CRYPTO_USER_API_SKCIPHER
1073         tristate "User-space interface for symmetric key cipher algorithms"
1074         depends on NET
1075         select CRYPTO_BLKCIPHER
1076         select CRYPTO_USER_API
1077         help
1078           This option enables the user-spaces interface for symmetric
1079           key cipher algorithms.
1080
1081 source "drivers/crypto/Kconfig"
1082
1083 endif   # if CRYPTO