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