Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

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

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