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