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

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

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