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

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

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