Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/crypto/Kconfig

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us