crypto/Kconfig

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