Version:  2.0.40 2.2.26 2.4.37 3.5 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

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

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