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