crypto/Kconfig

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