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         select CRYPTO_HASH
 476         help
 477           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
 478
 479 config CRYPTO_POLY1305
 480         tristate "Poly1305 authenticator algorithm"
 481         select CRYPTO_HASH
 482         help
 483           Poly1305 authenticator algorithm, RFC7539.
 484
 485           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
 486           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
 487           in IETF protocols. This is the portable C implementation of Poly1305.
 488
 489 config CRYPTO_POLY1305_X86_64
 490         tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
 491         depends on X86 && 64BIT
 492         select CRYPTO_POLY1305
 493         help
 494           Poly1305 authenticator algorithm, RFC7539.
 495
 496           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
 497           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
 498           in IETF protocols. This is the x86_64 assembler implementation using SIMD
 499           instructions.
 500
 501 config CRYPTO_MD4
 502         tristate "MD4 digest algorithm"
 503         select CRYPTO_HASH
 504         help
 505           MD4 message digest algorithm (RFC1320).
 506
 507 config CRYPTO_MD5
 508         tristate "MD5 digest algorithm"
 509         select CRYPTO_HASH
 510         help
 511           MD5 message digest algorithm (RFC1321).
 512
 513 config CRYPTO_MD5_OCTEON
 514         tristate "MD5 digest algorithm (OCTEON)"
 515         depends on CPU_CAVIUM_OCTEON
 516         select CRYPTO_MD5
 517         select CRYPTO_HASH
 518         help
 519           MD5 message digest algorithm (RFC1321) implemented
 520           using OCTEON crypto instructions, when available.
 521
 522 config CRYPTO_MD5_PPC
 523         tristate "MD5 digest algorithm (PPC)"
 524         depends on PPC
 525         select CRYPTO_HASH
 526         help
 527           MD5 message digest algorithm (RFC1321) implemented
 528           in PPC assembler.
 529
 530 config CRYPTO_MD5_SPARC64
 531         tristate "MD5 digest algorithm (SPARC64)"
 532         depends on SPARC64
 533         select CRYPTO_MD5
 534         select CRYPTO_HASH
 535         help
 536           MD5 message digest algorithm (RFC1321) implemented
 537           using sparc64 crypto instructions, when available.
 538
 539 config CRYPTO_MICHAEL_MIC
 540         tristate "Michael MIC keyed digest algorithm"
 541         select CRYPTO_HASH
 542         help
 543           Michael MIC is used for message integrity protection in TKIP
 544           (IEEE 802.11i). This algorithm is required for TKIP, but it
 545           should not be used for other purposes because of the weakness
 546           of the algorithm.
 547
 548 config CRYPTO_RMD128
 549         tristate "RIPEMD-128 digest algorithm"
 550         select CRYPTO_HASH
 551         help
 552           RIPEMD-128 (ISO/IEC 10118-3:2004).
 553
 554           RIPEMD-128 is a 128-bit cryptographic hash function. It should only
 555           be used as a secure replacement for RIPEMD. For other use cases,
 556           RIPEMD-160 should be used.
 557
 558           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 559           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 560
 561 config CRYPTO_RMD160
 562         tristate "RIPEMD-160 digest algorithm"
 563         select CRYPTO_HASH
 564         help
 565           RIPEMD-160 (ISO/IEC 10118-3:2004).
 566
 567           RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
 568           to be used as a secure replacement for the 128-bit hash functions
 569           MD4, MD5 and it's predecessor RIPEMD
 570           (not to be confused with RIPEMD-128).
 571
 572           It's speed is comparable to SHA1 and there are no known attacks
 573           against RIPEMD-160.
 574
 575           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 576           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 577
 578 config CRYPTO_RMD256
 579         tristate "RIPEMD-256 digest algorithm"
 580         select CRYPTO_HASH
 581         help
 582           RIPEMD-256 is an optional extension of RIPEMD-128 with a
 583           256 bit hash. It is intended for applications that require
 584           longer hash-results, without needing a larger security level
 585           (than RIPEMD-128).
 586
 587           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 588           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 589
 590 config CRYPTO_RMD320
 591         tristate "RIPEMD-320 digest algorithm"
 592         select CRYPTO_HASH
 593         help
 594           RIPEMD-320 is an optional extension of RIPEMD-160 with a
 595           320 bit hash. It is intended for applications that require
 596           longer hash-results, without needing a larger security level
 597           (than RIPEMD-160).
 598
 599           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 600           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 601
 602 config CRYPTO_SHA1
 603         tristate "SHA1 digest algorithm"
 604         select CRYPTO_HASH
 605         help
 606           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 607
 608 config CRYPTO_SHA1_SSSE3
 609         tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
 610         depends on X86 && 64BIT
 611         select CRYPTO_SHA1
 612         select CRYPTO_HASH
 613         help
 614           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 615           using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
 616           Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
 617           when available.
 618
 619 config CRYPTO_SHA256_SSSE3
 620         tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
 621         depends on X86 && 64BIT
 622         select CRYPTO_SHA256
 623         select CRYPTO_HASH
 624         help
 625           SHA-256 secure hash standard (DFIPS 180-2) implemented
 626           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
 627           Extensions version 1 (AVX1), or Advanced Vector Extensions
 628           version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
 629           Instructions) when available.
 630
 631 config CRYPTO_SHA512_SSSE3
 632         tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
 633         depends on X86 && 64BIT
 634         select CRYPTO_SHA512
 635         select CRYPTO_HASH
 636         help
 637           SHA-512 secure hash standard (DFIPS 180-2) implemented
 638           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
 639           Extensions version 1 (AVX1), or Advanced Vector Extensions
 640           version 2 (AVX2) instructions, when available.
 641
 642 config CRYPTO_SHA1_OCTEON
 643         tristate "SHA1 digest algorithm (OCTEON)"
 644         depends on CPU_CAVIUM_OCTEON
 645         select CRYPTO_SHA1
 646         select CRYPTO_HASH
 647         help
 648           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 649           using OCTEON crypto instructions, when available.
 650
 651 config CRYPTO_SHA1_SPARC64
 652         tristate "SHA1 digest algorithm (SPARC64)"
 653         depends on SPARC64
 654         select CRYPTO_SHA1
 655         select CRYPTO_HASH
 656         help
 657           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 658           using sparc64 crypto instructions, when available.
 659
 660 config CRYPTO_SHA1_PPC
 661         tristate "SHA1 digest algorithm (powerpc)"
 662         depends on PPC
 663         help
 664           This is the powerpc hardware accelerated implementation of the
 665           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 666
 667 config CRYPTO_SHA1_PPC_SPE
 668         tristate "SHA1 digest algorithm (PPC SPE)"
 669         depends on PPC && SPE
 670         help
 671           SHA-1 secure hash standard (DFIPS 180-4) implemented
 672           using powerpc SPE SIMD instruction set.
 673
 674 config CRYPTO_SHA1_MB
 675         tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
 676         depends on X86 && 64BIT
 677         select CRYPTO_SHA1
 678         select CRYPTO_HASH
 679         select CRYPTO_MCRYPTD
 680         help
 681           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 682           using multi-buffer technique.  This algorithm computes on
 683           multiple data lanes concurrently with SIMD instructions for
 684           better throughput.  It should not be enabled by default but
 685           used when there is significant amount of work to keep the keep
 686           the data lanes filled to get performance benefit.  If the data
 687           lanes remain unfilled, a flush operation will be initiated to
 688           process the crypto jobs, adding a slight latency.
 689
 690 config CRYPTO_SHA256
 691         tristate "SHA224 and SHA256 digest algorithm"
 692         select CRYPTO_HASH
 693         help
 694           SHA256 secure hash standard (DFIPS 180-2).
 695
 696           This version of SHA implements a 256 bit hash with 128 bits of
 697           security against collision attacks.
 698
 699           This code also includes SHA-224, a 224 bit hash with 112 bits
 700           of security against collision attacks.
 701
 702 config CRYPTO_SHA256_PPC_SPE
 703         tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
 704         depends on PPC && SPE
 705         select CRYPTO_SHA256
 706         select CRYPTO_HASH
 707         help
 708           SHA224 and SHA256 secure hash standard (DFIPS 180-2)
 709           implemented using powerpc SPE SIMD instruction set.
 710
 711 config CRYPTO_SHA256_OCTEON
 712         tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
 713         depends on CPU_CAVIUM_OCTEON
 714         select CRYPTO_SHA256
 715         select CRYPTO_HASH
 716         help
 717           SHA-256 secure hash standard (DFIPS 180-2) implemented
 718           using OCTEON crypto instructions, when available.
 719
 720 config CRYPTO_SHA256_SPARC64
 721         tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
 722         depends on SPARC64
 723         select CRYPTO_SHA256
 724         select CRYPTO_HASH
 725         help
 726           SHA-256 secure hash standard (DFIPS 180-2) implemented
 727           using sparc64 crypto instructions, when available.
 728
 729 config CRYPTO_SHA512
 730         tristate "SHA384 and SHA512 digest algorithms"
 731         select CRYPTO_HASH
 732         help
 733           SHA512 secure hash standard (DFIPS 180-2).
 734
 735           This version of SHA implements a 512 bit hash with 256 bits of
 736           security against collision attacks.
 737
 738           This code also includes SHA-384, a 384 bit hash with 192 bits
 739           of security against collision attacks.
 740
 741 config CRYPTO_SHA512_OCTEON
 742         tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
 743         depends on CPU_CAVIUM_OCTEON
 744         select CRYPTO_SHA512
 745         select CRYPTO_HASH
 746         help
 747           SHA-512 secure hash standard (DFIPS 180-2) implemented
 748           using OCTEON crypto instructions, when available.
 749
 750 config CRYPTO_SHA512_SPARC64
 751         tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
 752         depends on SPARC64
 753         select CRYPTO_SHA512
 754         select CRYPTO_HASH
 755         help
 756           SHA-512 secure hash standard (DFIPS 180-2) implemented
 757           using sparc64 crypto instructions, when available.
 758
 759 config CRYPTO_TGR192
 760         tristate "Tiger digest algorithms"
 761         select CRYPTO_HASH
 762         help
 763           Tiger hash algorithm 192, 160 and 128-bit hashes
 764
 765           Tiger is a hash function optimized for 64-bit processors while
 766           still having decent performance on 32-bit processors.
 767           Tiger was developed by Ross Anderson and Eli Biham.
 768
 769           See also:
 770           <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
 771
 772 config CRYPTO_WP512
 773         tristate "Whirlpool digest algorithms"
 774         select CRYPTO_HASH
 775         help
 776           Whirlpool hash algorithm 512, 384 and 256-bit hashes
 777
 778           Whirlpool-512 is part of the NESSIE cryptographic primitives.
 779           Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
 780
 781           See also:
 782           <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
 783
 784 config CRYPTO_GHASH_CLMUL_NI_INTEL
 785         tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
 786         depends on X86 && 64BIT
 787         select CRYPTO_CRYPTD
 788         help
 789           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
 790           The implementation is accelerated by CLMUL-NI of Intel.
 791
 792 comment "Ciphers"
 793
 794 config CRYPTO_AES
 795         tristate "AES cipher algorithms"
 796         select CRYPTO_ALGAPI
 797         help
 798           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 799           algorithm.
 800
 801           Rijndael appears to be consistently a very good performer in
 802           both hardware and software across a wide range of computing
 803           environments regardless of its use in feedback or non-feedback
 804           modes. Its key setup time is excellent, and its key agility is
 805           good. Rijndael's very low memory requirements make it very well
 806           suited for restricted-space environments, in which it also
 807           demonstrates excellent performance. Rijndael's operations are
 808           among the easiest to defend against power and timing attacks.
 809
 810           The AES specifies three key sizes: 128, 192 and 256 bits
 811
 812           See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
 813
 814 config CRYPTO_AES_586
 815         tristate "AES cipher algorithms (i586)"
 816         depends on (X86 || UML_X86) && !64BIT
 817         select CRYPTO_ALGAPI
 818         select CRYPTO_AES
 819         help
 820           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 821           algorithm.
 822
 823           Rijndael appears to be consistently a very good performer in
 824           both hardware and software across a wide range of computing
 825           environments regardless of its use in feedback or non-feedback
 826           modes. Its key setup time is excellent, and its key agility is
 827           good. Rijndael's very low memory requirements make it very well
 828           suited for restricted-space environments, in which it also
 829           demonstrates excellent performance. Rijndael's operations are
 830           among the easiest to defend against power and timing attacks.
 831
 832           The AES specifies three key sizes: 128, 192 and 256 bits
 833
 834           See <http://csrc.nist.gov/encryption/aes/> for more information.
 835
 836 config CRYPTO_AES_X86_64
 837         tristate "AES cipher algorithms (x86_64)"
 838         depends on (X86 || UML_X86) && 64BIT
 839         select CRYPTO_ALGAPI
 840         select CRYPTO_AES
 841         help
 842           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 843           algorithm.
 844
 845           Rijndael appears to be consistently a very good performer in
 846           both hardware and software across a wide range of computing
 847           environments regardless of its use in feedback or non-feedback
 848           modes. Its key setup time is excellent, and its key agility is
 849           good. Rijndael's very low memory requirements make it very well
 850           suited for restricted-space environments, in which it also
 851           demonstrates excellent performance. Rijndael's operations are
 852           among the easiest to defend against power and timing attacks.
 853
 854           The AES specifies three key sizes: 128, 192 and 256 bits
 855
 856           See <http://csrc.nist.gov/encryption/aes/> for more information.
 857
 858 config CRYPTO_AES_NI_INTEL
 859         tristate "AES cipher algorithms (AES-NI)"
 860         depends on X86
 861         select CRYPTO_AES_X86_64 if 64BIT
 862         select CRYPTO_AES_586 if !64BIT
 863         select CRYPTO_CRYPTD
 864         select CRYPTO_ABLK_HELPER
 865         select CRYPTO_ALGAPI
 866         select CRYPTO_GLUE_HELPER_X86 if 64BIT
 867         select CRYPTO_LRW
 868         select CRYPTO_XTS
 869         help
 870           Use Intel AES-NI instructions for AES algorithm.
 871
 872           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 873           algorithm.
 874
 875           Rijndael appears to be consistently a very good performer in
 876           both hardware and software across a wide range of computing
 877           environments regardless of its use in feedback or non-feedback
 878           modes. Its key setup time is excellent, and its key agility is
 879           good. Rijndael's very low memory requirements make it very well
 880           suited for restricted-space environments, in which it also
 881           demonstrates excellent performance. Rijndael's operations are
 882           among the easiest to defend against power and timing attacks.
 883
 884           The AES specifies three key sizes: 128, 192 and 256 bits
 885
 886           See <http://csrc.nist.gov/encryption/aes/> for more information.
 887
 888           In addition to AES cipher algorithm support, the acceleration
 889           for some popular block cipher mode is supported too, including
 890           ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
 891           acceleration for CTR.
 892
 893 config CRYPTO_AES_SPARC64
 894         tristate "AES cipher algorithms (SPARC64)"
 895         depends on SPARC64
 896         select CRYPTO_CRYPTD
 897         select CRYPTO_ALGAPI
 898         help
 899           Use SPARC64 crypto opcodes for AES algorithm.
 900
 901           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 902           algorithm.
 903
 904           Rijndael appears to be consistently a very good performer in
 905           both hardware and software across a wide range of computing
 906           environments regardless of its use in feedback or non-feedback
 907           modes. Its key setup time is excellent, and its key agility is
 908           good. Rijndael's very low memory requirements make it very well
 909           suited for restricted-space environments, in which it also
 910           demonstrates excellent performance. Rijndael's operations are
 911           among the easiest to defend against power and timing attacks.
 912
 913           The AES specifies three key sizes: 128, 192 and 256 bits
 914
 915           See <http://csrc.nist.gov/encryption/aes/> for more information.
 916
 917           In addition to AES cipher algorithm support, the acceleration
 918           for some popular block cipher mode is supported too, including
 919           ECB and CBC.
 920
 921 config CRYPTO_AES_PPC_SPE
 922         tristate "AES cipher algorithms (PPC SPE)"
 923         depends on PPC && SPE
 924         help
 925           AES cipher algorithms (FIPS-197). Additionally the acceleration
 926           for popular block cipher modes ECB, CBC, CTR and XTS is supported.
 927           This module should only be used for low power (router) devices
 928           without hardware AES acceleration (e.g. caam crypto). It reduces the
 929           size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
 930           timining attacks. Nevertheless it might be not as secure as other
 931           architecture specific assembler implementations that work on 1KB
 932           tables or 256 bytes S-boxes.
 933
 934 config CRYPTO_ANUBIS
 935         tristate "Anubis cipher algorithm"
 936         select CRYPTO_ALGAPI
 937         help
 938           Anubis cipher algorithm.
 939
 940           Anubis is a variable key length cipher which can use keys from
 941           128 bits to 320 bits in length.  It was evaluated as a entrant
 942           in the NESSIE competition.
 943
 944           See also:
 945           <https://www.cosic.esat.kuleuven.be/nessie/reports/>
 946           <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
 947
 948 config CRYPTO_ARC4
 949         tristate "ARC4 cipher algorithm"
 950         select CRYPTO_BLKCIPHER
 951         help
 952           ARC4 cipher algorithm.
 953
 954           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
 955           bits in length.  This algorithm is required for driver-based
 956           WEP, but it should not be for other purposes because of the
 957           weakness of the algorithm.
 958
 959 config CRYPTO_BLOWFISH
 960         tristate "Blowfish cipher algorithm"
 961         select CRYPTO_ALGAPI
 962         select CRYPTO_BLOWFISH_COMMON
 963         help
 964           Blowfish cipher algorithm, by Bruce Schneier.
 965
 966           This is a variable key length cipher which can use keys from 32
 967           bits to 448 bits in length.  It's fast, simple and specifically
 968           designed for use on "large microprocessors".
 969
 970           See also:
 971           <http://www.schneier.com/blowfish.html>
 972
 973 config CRYPTO_BLOWFISH_COMMON
 974         tristate
 975         help
 976           Common parts of the Blowfish cipher algorithm shared by the
 977           generic c and the assembler implementations.
 978
 979           See also:
 980           <http://www.schneier.com/blowfish.html>
 981
 982 config CRYPTO_BLOWFISH_X86_64
 983         tristate "Blowfish cipher algorithm (x86_64)"
 984         depends on X86 && 64BIT
 985         select CRYPTO_ALGAPI
 986         select CRYPTO_BLOWFISH_COMMON
 987         help
 988           Blowfish cipher algorithm (x86_64), by Bruce Schneier.
 989
 990           This is a variable key length cipher which can use keys from 32
 991           bits to 448 bits in length.  It's fast, simple and specifically
 992           designed for use on "large microprocessors".
 993
 994           See also:
 995           <http://www.schneier.com/blowfish.html>
 996
 997 config CRYPTO_CAMELLIA
 998         tristate "Camellia cipher algorithms"
 999         depends on CRYPTO
1000         select CRYPTO_ALGAPI
1001         help
1002           Camellia cipher algorithms module.
1003
1004           Camellia is a symmetric key block cipher developed jointly
1005           at NTT and Mitsubishi Electric Corporation.
1006
1007           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1008
1009           See also:
1010           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1011
1012 config CRYPTO_CAMELLIA_X86_64
1013         tristate "Camellia cipher algorithm (x86_64)"
1014         depends on X86 && 64BIT
1015         depends on CRYPTO
1016         select CRYPTO_ALGAPI
1017         select CRYPTO_GLUE_HELPER_X86
1018         select CRYPTO_LRW
1019         select CRYPTO_XTS
1020         help
1021           Camellia cipher algorithm module (x86_64).
1022
1023           Camellia is a symmetric key block cipher developed jointly
1024           at NTT and Mitsubishi Electric Corporation.
1025
1026           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1027
1028           See also:
1029           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1030
1031 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1032         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1033         depends on X86 && 64BIT
1034         depends on CRYPTO
1035         select CRYPTO_ALGAPI
1036         select CRYPTO_CRYPTD
1037         select CRYPTO_ABLK_HELPER
1038         select CRYPTO_GLUE_HELPER_X86
1039         select CRYPTO_CAMELLIA_X86_64
1040         select CRYPTO_LRW
1041         select CRYPTO_XTS
1042         help
1043           Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1044
1045           Camellia is a symmetric key block cipher developed jointly
1046           at NTT and Mitsubishi Electric Corporation.
1047
1048           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1049
1050           See also:
1051           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1052
1053 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1054         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1055         depends on X86 && 64BIT
1056         depends on CRYPTO
1057         select CRYPTO_ALGAPI
1058         select CRYPTO_CRYPTD
1059         select CRYPTO_ABLK_HELPER
1060         select CRYPTO_GLUE_HELPER_X86
1061         select CRYPTO_CAMELLIA_X86_64
1062         select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1063         select CRYPTO_LRW
1064         select CRYPTO_XTS
1065         help
1066           Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1067
1068           Camellia is a symmetric key block cipher developed jointly
1069           at NTT and Mitsubishi Electric Corporation.
1070
1071           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1072
1073           See also:
1074           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1075
1076 config CRYPTO_CAMELLIA_SPARC64
1077         tristate "Camellia cipher algorithm (SPARC64)"
1078         depends on SPARC64
1079         depends on CRYPTO
1080         select CRYPTO_ALGAPI
1081         help
1082           Camellia cipher algorithm module (SPARC64).
1083
1084           Camellia is a symmetric key block cipher developed jointly
1085           at NTT and Mitsubishi Electric Corporation.
1086
1087           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1088
1089           See also:
1090           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1091
1092 config CRYPTO_CAST_COMMON
1093         tristate
1094         help
1095           Common parts of the CAST cipher algorithms shared by the
1096           generic c and the assembler implementations.
1097
1098 config CRYPTO_CAST5
1099         tristate "CAST5 (CAST-128) cipher algorithm"
1100         select CRYPTO_ALGAPI
1101         select CRYPTO_CAST_COMMON
1102         help
1103           The CAST5 encryption algorithm (synonymous with CAST-128) is
1104           described in RFC2144.
1105
1106 config CRYPTO_CAST5_AVX_X86_64
1107         tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1108         depends on X86 && 64BIT
1109         select CRYPTO_ALGAPI
1110         select CRYPTO_CRYPTD
1111         select CRYPTO_ABLK_HELPER
1112         select CRYPTO_CAST_COMMON
1113         select CRYPTO_CAST5
1114         help
1115           The CAST5 encryption algorithm (synonymous with CAST-128) is
1116           described in RFC2144.
1117
1118           This module provides the Cast5 cipher algorithm that processes
1119           sixteen blocks parallel using the AVX instruction set.
1120
1121 config CRYPTO_CAST6
1122         tristate "CAST6 (CAST-256) cipher algorithm"
1123         select CRYPTO_ALGAPI
1124         select CRYPTO_CAST_COMMON
1125         help
1126           The CAST6 encryption algorithm (synonymous with CAST-256) is
1127           described in RFC2612.
1128
1129 config CRYPTO_CAST6_AVX_X86_64
1130         tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1131         depends on X86 && 64BIT
1132         select CRYPTO_ALGAPI
1133         select CRYPTO_CRYPTD
1134         select CRYPTO_ABLK_HELPER
1135         select CRYPTO_GLUE_HELPER_X86
1136         select CRYPTO_CAST_COMMON
1137         select CRYPTO_CAST6
1138         select CRYPTO_LRW
1139         select CRYPTO_XTS
1140         help
1141           The CAST6 encryption algorithm (synonymous with CAST-256) is
1142           described in RFC2612.
1143
1144           This module provides the Cast6 cipher algorithm that processes
1145           eight blocks parallel using the AVX instruction set.
1146
1147 config CRYPTO_DES
1148         tristate "DES and Triple DES EDE cipher algorithms"
1149         select CRYPTO_ALGAPI
1150         help
1151           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1152
1153 config CRYPTO_DES_SPARC64
1154         tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1155         depends on SPARC64
1156         select CRYPTO_ALGAPI
1157         select CRYPTO_DES
1158         help
1159           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1160           optimized using SPARC64 crypto opcodes.
1161
1162 config CRYPTO_DES3_EDE_X86_64
1163         tristate "Triple DES EDE cipher algorithm (x86-64)"
1164         depends on X86 && 64BIT
1165         select CRYPTO_ALGAPI
1166         select CRYPTO_DES
1167         help
1168           Triple DES EDE (FIPS 46-3) algorithm.
1169
1170           This module provides implementation of the Triple DES EDE cipher
1171           algorithm that is optimized for x86-64 processors. Two versions of
1172           algorithm are provided; regular processing one input block and
1173           one that processes three blocks parallel.
1174
1175 config CRYPTO_FCRYPT
1176         tristate "FCrypt cipher algorithm"
1177         select CRYPTO_ALGAPI
1178         select CRYPTO_BLKCIPHER
1179         help
1180           FCrypt algorithm used by RxRPC.
1181
1182 config CRYPTO_KHAZAD
1183         tristate "Khazad cipher algorithm"
1184         select CRYPTO_ALGAPI
1185         help
1186           Khazad cipher algorithm.
1187
1188           Khazad was a finalist in the initial NESSIE competition.  It is
1189           an algorithm optimized for 64-bit processors with good performance
1190           on 32-bit processors.  Khazad uses an 128 bit key size.
1191
1192           See also:
1193           <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1194
1195 config CRYPTO_SALSA20
1196         tristate "Salsa20 stream cipher algorithm"
1197         select CRYPTO_BLKCIPHER
1198         help
1199           Salsa20 stream cipher algorithm.
1200
1201           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1202           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1203
1204           The Salsa20 stream cipher algorithm is designed by Daniel J.
1205           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1206
1207 config CRYPTO_SALSA20_586
1208         tristate "Salsa20 stream cipher algorithm (i586)"
1209         depends on (X86 || UML_X86) && !64BIT
1210         select CRYPTO_BLKCIPHER
1211         help
1212           Salsa20 stream cipher algorithm.
1213
1214           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1215           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1216
1217           The Salsa20 stream cipher algorithm is designed by Daniel J.
1218           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1219
1220 config CRYPTO_SALSA20_X86_64
1221         tristate "Salsa20 stream cipher algorithm (x86_64)"
1222         depends on (X86 || UML_X86) && 64BIT
1223         select CRYPTO_BLKCIPHER
1224         help
1225           Salsa20 stream cipher algorithm.
1226
1227           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1228           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1229
1230           The Salsa20 stream cipher algorithm is designed by Daniel J.
1231           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1232
1233 config CRYPTO_CHACHA20
1234         tristate "ChaCha20 cipher algorithm"
1235         select CRYPTO_BLKCIPHER
1236         help
1237           ChaCha20 cipher algorithm, RFC7539.
1238
1239           ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1240           Bernstein and further specified in RFC7539 for use in IETF protocols.
1241           This is the portable C implementation of ChaCha20.
1242
1243           See also:
1244           <http://cr.yp.to/chacha/chacha-20080128.pdf>
1245
1246 config CRYPTO_CHACHA20_X86_64
1247         tristate "ChaCha20 cipher algorithm (x86_64/SSSE3/AVX2)"
1248         depends on X86 && 64BIT
1249         select CRYPTO_BLKCIPHER
1250         select CRYPTO_CHACHA20
1251         help
1252           ChaCha20 cipher algorithm, RFC7539.
1253
1254           ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1255           Bernstein and further specified in RFC7539 for use in IETF protocols.
1256           This is the x86_64 assembler implementation using SIMD instructions.
1257
1258           See also:
1259           <http://cr.yp.to/chacha/chacha-20080128.pdf>
1260
1261 config CRYPTO_SEED
1262         tristate "SEED cipher algorithm"
1263         select CRYPTO_ALGAPI
1264         help
1265           SEED cipher algorithm (RFC4269).
1266
1267           SEED is a 128-bit symmetric key block cipher that has been
1268           developed by KISA (Korea Information Security Agency) as a
1269           national standard encryption algorithm of the Republic of Korea.
1270           It is a 16 round block cipher with the key size of 128 bit.
1271
1272           See also:
1273           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1274
1275 config CRYPTO_SERPENT
1276         tristate "Serpent cipher algorithm"
1277         select CRYPTO_ALGAPI
1278         help
1279           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1280
1281           Keys are allowed to be from 0 to 256 bits in length, in steps
1282           of 8 bits.  Also includes the 'Tnepres' algorithm, a reversed
1283           variant of Serpent for compatibility with old kerneli.org code.
1284
1285           See also:
1286           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1287
1288 config CRYPTO_SERPENT_SSE2_X86_64
1289         tristate "Serpent cipher algorithm (x86_64/SSE2)"
1290         depends on X86 && 64BIT
1291         select CRYPTO_ALGAPI
1292         select CRYPTO_CRYPTD
1293         select CRYPTO_ABLK_HELPER
1294         select CRYPTO_GLUE_HELPER_X86
1295         select CRYPTO_SERPENT
1296         select CRYPTO_LRW
1297         select CRYPTO_XTS
1298         help
1299           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1300
1301           Keys are allowed to be from 0 to 256 bits in length, in steps
1302           of 8 bits.
1303
1304           This module provides Serpent cipher algorithm that processes eight
1305           blocks parallel using SSE2 instruction set.
1306
1307           See also:
1308           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1309
1310 config CRYPTO_SERPENT_SSE2_586
1311         tristate "Serpent cipher algorithm (i586/SSE2)"
1312         depends on X86 && !64BIT
1313         select CRYPTO_ALGAPI
1314         select CRYPTO_CRYPTD
1315         select CRYPTO_ABLK_HELPER
1316         select CRYPTO_GLUE_HELPER_X86
1317         select CRYPTO_SERPENT
1318         select CRYPTO_LRW
1319         select CRYPTO_XTS
1320         help
1321           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1322
1323           Keys are allowed to be from 0 to 256 bits in length, in steps
1324           of 8 bits.
1325
1326           This module provides Serpent cipher algorithm that processes four
1327           blocks parallel using SSE2 instruction set.
1328
1329           See also:
1330           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1331
1332 config CRYPTO_SERPENT_AVX_X86_64
1333         tristate "Serpent cipher algorithm (x86_64/AVX)"
1334         depends on X86 && 64BIT
1335         select CRYPTO_ALGAPI
1336         select CRYPTO_CRYPTD
1337         select CRYPTO_ABLK_HELPER
1338         select CRYPTO_GLUE_HELPER_X86
1339         select CRYPTO_SERPENT
1340         select CRYPTO_LRW
1341         select CRYPTO_XTS
1342         help
1343           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1344
1345           Keys are allowed to be from 0 to 256 bits in length, in steps
1346           of 8 bits.
1347
1348           This module provides the Serpent cipher algorithm that processes
1349           eight blocks parallel using the AVX instruction set.
1350
1351           See also:
1352           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1353
1354 config CRYPTO_SERPENT_AVX2_X86_64
1355         tristate "Serpent cipher algorithm (x86_64/AVX2)"
1356         depends on X86 && 64BIT
1357         select CRYPTO_ALGAPI
1358         select CRYPTO_CRYPTD
1359         select CRYPTO_ABLK_HELPER
1360         select CRYPTO_GLUE_HELPER_X86
1361         select CRYPTO_SERPENT
1362         select CRYPTO_SERPENT_AVX_X86_64
1363         select CRYPTO_LRW
1364         select CRYPTO_XTS
1365         help
1366           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1367
1368           Keys are allowed to be from 0 to 256 bits in length, in steps
1369           of 8 bits.
1370
1371           This module provides Serpent cipher algorithm that processes 16
1372           blocks parallel using AVX2 instruction set.
1373
1374           See also:
1375           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1376
1377 config CRYPTO_TEA
1378         tristate "TEA, XTEA and XETA cipher algorithms"
1379         select CRYPTO_ALGAPI
1380         help
1381           TEA cipher algorithm.
1382
1383           Tiny Encryption Algorithm is a simple cipher that uses
1384           many rounds for security.  It is very fast and uses
1385           little memory.
1386
1387           Xtendend Tiny Encryption Algorithm is a modification to
1388           the TEA algorithm to address a potential key weakness
1389           in the TEA algorithm.
1390
1391           Xtendend Encryption Tiny Algorithm is a mis-implementation
1392           of the XTEA algorithm for compatibility purposes.
1393
1394 config CRYPTO_TWOFISH
1395         tristate "Twofish cipher algorithm"
1396         select CRYPTO_ALGAPI
1397         select CRYPTO_TWOFISH_COMMON
1398         help
1399           Twofish cipher algorithm.
1400
1401           Twofish was submitted as an AES (Advanced Encryption Standard)
1402           candidate cipher by researchers at CounterPane Systems.  It is a
1403           16 round block cipher supporting key sizes of 128, 192, and 256
1404           bits.
1405
1406           See also:
1407           <http://www.schneier.com/twofish.html>
1408
1409 config CRYPTO_TWOFISH_COMMON
1410         tristate
1411         help
1412           Common parts of the Twofish cipher algorithm shared by the
1413           generic c and the assembler implementations.
1414
1415 config CRYPTO_TWOFISH_586
1416         tristate "Twofish cipher algorithms (i586)"
1417         depends on (X86 || UML_X86) && !64BIT
1418         select CRYPTO_ALGAPI
1419         select CRYPTO_TWOFISH_COMMON
1420         help
1421           Twofish cipher algorithm.
1422
1423           Twofish was submitted as an AES (Advanced Encryption Standard)
1424           candidate cipher by researchers at CounterPane Systems.  It is a
1425           16 round block cipher supporting key sizes of 128, 192, and 256
1426           bits.
1427
1428           See also:
1429           <http://www.schneier.com/twofish.html>
1430
1431 config CRYPTO_TWOFISH_X86_64
1432         tristate "Twofish cipher algorithm (x86_64)"
1433         depends on (X86 || UML_X86) && 64BIT
1434         select CRYPTO_ALGAPI
1435         select CRYPTO_TWOFISH_COMMON
1436         help
1437           Twofish cipher algorithm (x86_64).
1438
1439           Twofish was submitted as an AES (Advanced Encryption Standard)
1440           candidate cipher by researchers at CounterPane Systems.  It is a
1441           16 round block cipher supporting key sizes of 128, 192, and 256
1442           bits.
1443
1444           See also:
1445           <http://www.schneier.com/twofish.html>
1446
1447 config CRYPTO_TWOFISH_X86_64_3WAY
1448         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1449         depends on X86 && 64BIT
1450         select CRYPTO_ALGAPI
1451         select CRYPTO_TWOFISH_COMMON
1452         select CRYPTO_TWOFISH_X86_64
1453         select CRYPTO_GLUE_HELPER_X86
1454         select CRYPTO_LRW
1455         select CRYPTO_XTS
1456         help
1457           Twofish cipher algorithm (x86_64, 3-way parallel).
1458
1459           Twofish was submitted as an AES (Advanced Encryption Standard)
1460           candidate cipher by researchers at CounterPane Systems.  It is a
1461           16 round block cipher supporting key sizes of 128, 192, and 256
1462           bits.
1463
1464           This module provides Twofish cipher algorithm that processes three
1465           blocks parallel, utilizing resources of out-of-order CPUs better.
1466
1467           See also:
1468           <http://www.schneier.com/twofish.html>
1469
1470 config CRYPTO_TWOFISH_AVX_X86_64
1471         tristate "Twofish cipher algorithm (x86_64/AVX)"
1472         depends on X86 && 64BIT
1473         select CRYPTO_ALGAPI
1474         select CRYPTO_CRYPTD
1475         select CRYPTO_ABLK_HELPER
1476         select CRYPTO_GLUE_HELPER_X86
1477         select CRYPTO_TWOFISH_COMMON
1478         select CRYPTO_TWOFISH_X86_64
1479         select CRYPTO_TWOFISH_X86_64_3WAY
1480         select CRYPTO_LRW
1481         select CRYPTO_XTS
1482         help
1483           Twofish cipher algorithm (x86_64/AVX).
1484
1485           Twofish was submitted as an AES (Advanced Encryption Standard)
1486           candidate cipher by researchers at CounterPane Systems.  It is a
1487           16 round block cipher supporting key sizes of 128, 192, and 256
1488           bits.
1489
1490           This module provides the Twofish cipher algorithm that processes
1491           eight blocks parallel using the AVX Instruction Set.
1492
1493           See also:
1494           <http://www.schneier.com/twofish.html>
1495
1496 comment "Compression"
1497
1498 config CRYPTO_DEFLATE
1499         tristate "Deflate compression algorithm"
1500         select CRYPTO_ALGAPI
1501         select ZLIB_INFLATE
1502         select ZLIB_DEFLATE
1503         help
1504           This is the Deflate algorithm (RFC1951), specified for use in
1505           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1506
1507           You will most probably want this if using IPSec.
1508
1509 config CRYPTO_ZLIB
1510         tristate "Zlib compression algorithm"
1511         select CRYPTO_PCOMP
1512         select ZLIB_INFLATE
1513         select ZLIB_DEFLATE
1514         select NLATTR
1515         help
1516           This is the zlib algorithm.
1517
1518 config CRYPTO_LZO
1519         tristate "LZO compression algorithm"
1520         select CRYPTO_ALGAPI
1521         select LZO_COMPRESS
1522         select LZO_DECOMPRESS
1523         help
1524           This is the LZO algorithm.
1525
1526 config CRYPTO_842
1527         tristate "842 compression algorithm"
1528         select CRYPTO_ALGAPI
1529         select 842_COMPRESS
1530         select 842_DECOMPRESS
1531         help
1532           This is the 842 algorithm.
1533
1534 config CRYPTO_LZ4
1535         tristate "LZ4 compression algorithm"
1536         select CRYPTO_ALGAPI
1537         select LZ4_COMPRESS
1538         select LZ4_DECOMPRESS
1539         help
1540           This is the LZ4 algorithm.
1541
1542 config CRYPTO_LZ4HC
1543         tristate "LZ4HC compression algorithm"
1544         select CRYPTO_ALGAPI
1545         select LZ4HC_COMPRESS
1546         select LZ4_DECOMPRESS
1547         help
1548           This is the LZ4 high compression mode algorithm.
1549
1550 comment "Random Number Generation"
1551
1552 config CRYPTO_ANSI_CPRNG
1553         tristate "Pseudo Random Number Generation for Cryptographic modules"
1554         select CRYPTO_AES
1555         select CRYPTO_RNG
1556         help
1557           This option enables the generic pseudo random number generator
1558           for cryptographic modules.  Uses the Algorithm specified in
1559           ANSI X9.31 A.2.4. Note that this option must be enabled if
1560           CRYPTO_FIPS is selected
1561
1562 menuconfig CRYPTO_DRBG_MENU
1563         tristate "NIST SP800-90A DRBG"
1564         help
1565           NIST SP800-90A compliant DRBG. In the following submenu, one or
1566           more of the DRBG types must be selected.
1567
1568 if CRYPTO_DRBG_MENU
1569
1570 config CRYPTO_DRBG_HMAC
1571         bool
1572         default y
1573         select CRYPTO_HMAC
1574         select CRYPTO_SHA256
1575
1576 config CRYPTO_DRBG_HASH
1577         bool "Enable Hash DRBG"
1578         select CRYPTO_SHA256
1579         help
1580           Enable the Hash DRBG variant as defined in NIST SP800-90A.
1581
1582 config CRYPTO_DRBG_CTR
1583         bool "Enable CTR DRBG"
1584         select CRYPTO_AES
1585         help
1586           Enable the CTR DRBG variant as defined in NIST SP800-90A.
1587
1588 config CRYPTO_DRBG
1589         tristate
1590         default CRYPTO_DRBG_MENU
1591         select CRYPTO_RNG
1592         select CRYPTO_JITTERENTROPY
1593
1594 endif   # if CRYPTO_DRBG_MENU
1595
1596 config CRYPTO_JITTERENTROPY
1597         tristate "Jitterentropy Non-Deterministic Random Number Generator"
1598         help
1599           The Jitterentropy RNG is a noise that is intended
1600           to provide seed to another RNG. The RNG does not
1601           perform any cryptographic whitening of the generated
1602           random numbers. This Jitterentropy RNG registers with
1603           the kernel crypto API and can be used by any caller.
1604
1605 config CRYPTO_USER_API
1606         tristate
1607
1608 config CRYPTO_USER_API_HASH
1609         tristate "User-space interface for hash algorithms"
1610         depends on NET
1611         select CRYPTO_HASH
1612         select CRYPTO_USER_API
1613         help
1614           This option enables the user-spaces interface for hash
1615           algorithms.
1616
1617 config CRYPTO_USER_API_SKCIPHER
1618         tristate "User-space interface for symmetric key cipher algorithms"
1619         depends on NET
1620         select CRYPTO_BLKCIPHER
1621         select CRYPTO_USER_API
1622         help
1623           This option enables the user-spaces interface for symmetric
1624           key cipher algorithms.
1625
1626 config CRYPTO_USER_API_RNG
1627         tristate "User-space interface for random number generator algorithms"
1628         depends on NET
1629         select CRYPTO_RNG
1630         select CRYPTO_USER_API
1631         help
1632           This option enables the user-spaces interface for random
1633           number generator algorithms.
1634
1635 config CRYPTO_USER_API_AEAD
1636         tristate "User-space interface for AEAD cipher algorithms"
1637         depends on NET
1638         select CRYPTO_AEAD
1639         select CRYPTO_USER_API
1640         help
1641           This option enables the user-spaces interface for AEAD
1642           cipher algorithms.
1643
1644 config CRYPTO_HASH_INFO
1645         bool
1646
1647 source "drivers/crypto/Kconfig"
1648 source crypto/asymmetric_keys/Kconfig
1649 source certs/Kconfig
1650
1651 endif   # if CRYPTO