crypto/Kconfig

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