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_XXHASH
 687         tristate "xxHash hash algorithm"
 688         select CRYPTO_HASH
 689         select XXHASH
 690         help
 691           xxHash non-cryptographic hash algorithm. Extremely fast, working at
 692           speeds close to RAM limits.
 693
 694 config CRYPTO_CRCT10DIF
 695         tristate "CRCT10DIF algorithm"
 696         select CRYPTO_HASH
 697         help
 698           CRC T10 Data Integrity Field computation is being cast as
 699           a crypto transform.  This allows for faster crc t10 diff
 700           transforms to be used if they are available.
 701
 702 config CRYPTO_CRCT10DIF_PCLMUL
 703         tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
 704         depends on X86 && 64BIT && CRC_T10DIF
 705         select CRYPTO_HASH
 706         help
 707           For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
 708           CRC T10 DIF PCLMULQDQ computation can be hardware
 709           accelerated PCLMULQDQ instruction. This option will create
 710           'crct10dif-pclmul' module, which is faster when computing the
 711           crct10dif checksum as compared with the generic table implementation.
 712
 713 config CRYPTO_CRCT10DIF_VPMSUM
 714         tristate "CRC32T10DIF powerpc64 hardware acceleration"
 715         depends on PPC64 && ALTIVEC && CRC_T10DIF
 716         select CRYPTO_HASH
 717         help
 718           CRC10T10DIF algorithm implemented using vector polynomial
 719           multiply-sum (vpmsum) instructions, introduced in POWER8. Enable on
 720           POWER8 and newer processors for improved performance.
 721
 722 config CRYPTO_VPMSUM_TESTER
 723         tristate "Powerpc64 vpmsum hardware acceleration tester"
 724         depends on CRYPTO_CRCT10DIF_VPMSUM && CRYPTO_CRC32C_VPMSUM
 725         help
 726           Stress test for CRC32c and CRC-T10DIF algorithms implemented with
 727           POWER8 vpmsum instructions.
 728           Unless you are testing these algorithms, you don't need this.
 729
 730 config CRYPTO_GHASH
 731         tristate "GHASH digest algorithm"
 732         select CRYPTO_GF128MUL
 733         select CRYPTO_HASH
 734         help
 735           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
 736
 737 config CRYPTO_POLY1305
 738         tristate "Poly1305 authenticator algorithm"
 739         select CRYPTO_HASH
 740         help
 741           Poly1305 authenticator algorithm, RFC7539.
 742
 743           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
 744           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
 745           in IETF protocols. This is the portable C implementation of Poly1305.
 746
 747 config CRYPTO_POLY1305_X86_64
 748         tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
 749         depends on X86 && 64BIT
 750         select CRYPTO_POLY1305
 751         help
 752           Poly1305 authenticator algorithm, RFC7539.
 753
 754           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
 755           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
 756           in IETF protocols. This is the x86_64 assembler implementation using SIMD
 757           instructions.
 758
 759 config CRYPTO_MD4
 760         tristate "MD4 digest algorithm"
 761         select CRYPTO_HASH
 762         help
 763           MD4 message digest algorithm (RFC1320).
 764
 765 config CRYPTO_MD5
 766         tristate "MD5 digest algorithm"
 767         select CRYPTO_HASH
 768         help
 769           MD5 message digest algorithm (RFC1321).
 770
 771 config CRYPTO_MD5_OCTEON
 772         tristate "MD5 digest algorithm (OCTEON)"
 773         depends on CPU_CAVIUM_OCTEON
 774         select CRYPTO_MD5
 775         select CRYPTO_HASH
 776         help
 777           MD5 message digest algorithm (RFC1321) implemented
 778           using OCTEON crypto instructions, when available.
 779
 780 config CRYPTO_MD5_PPC
 781         tristate "MD5 digest algorithm (PPC)"
 782         depends on PPC
 783         select CRYPTO_HASH
 784         help
 785           MD5 message digest algorithm (RFC1321) implemented
 786           in PPC assembler.
 787
 788 config CRYPTO_MD5_SPARC64
 789         tristate "MD5 digest algorithm (SPARC64)"
 790         depends on SPARC64
 791         select CRYPTO_MD5
 792         select CRYPTO_HASH
 793         help
 794           MD5 message digest algorithm (RFC1321) implemented
 795           using sparc64 crypto instructions, when available.
 796
 797 config CRYPTO_MICHAEL_MIC
 798         tristate "Michael MIC keyed digest algorithm"
 799         select CRYPTO_HASH
 800         help
 801           Michael MIC is used for message integrity protection in TKIP
 802           (IEEE 802.11i). This algorithm is required for TKIP, but it
 803           should not be used for other purposes because of the weakness
 804           of the algorithm.
 805
 806 config CRYPTO_RMD128
 807         tristate "RIPEMD-128 digest algorithm"
 808         select CRYPTO_HASH
 809         help
 810           RIPEMD-128 (ISO/IEC 10118-3:2004).
 811
 812           RIPEMD-128 is a 128-bit cryptographic hash function. It should only
 813           be used as a secure replacement for RIPEMD. For other use cases,
 814           RIPEMD-160 should be used.
 815
 816           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 817           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 818
 819 config CRYPTO_RMD160
 820         tristate "RIPEMD-160 digest algorithm"
 821         select CRYPTO_HASH
 822         help
 823           RIPEMD-160 (ISO/IEC 10118-3:2004).
 824
 825           RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
 826           to be used as a secure replacement for the 128-bit hash functions
 827           MD4, MD5 and it's predecessor RIPEMD
 828           (not to be confused with RIPEMD-128).
 829
 830           It's speed is comparable to SHA1 and there are no known attacks
 831           against RIPEMD-160.
 832
 833           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 834           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 835
 836 config CRYPTO_RMD256
 837         tristate "RIPEMD-256 digest algorithm"
 838         select CRYPTO_HASH
 839         help
 840           RIPEMD-256 is an optional extension of RIPEMD-128 with a
 841           256 bit hash. It is intended for applications that require
 842           longer hash-results, without needing a larger security level
 843           (than RIPEMD-128).
 844
 845           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 846           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 847
 848 config CRYPTO_RMD320
 849         tristate "RIPEMD-320 digest algorithm"
 850         select CRYPTO_HASH
 851         help
 852           RIPEMD-320 is an optional extension of RIPEMD-160 with a
 853           320 bit hash. It is intended for applications that require
 854           longer hash-results, without needing a larger security level
 855           (than RIPEMD-160).
 856
 857           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 858           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 859
 860 config CRYPTO_SHA1
 861         tristate "SHA1 digest algorithm"
 862         select CRYPTO_HASH
 863         help
 864           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 865
 866 config CRYPTO_SHA1_SSSE3
 867         tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
 868         depends on X86 && 64BIT
 869         select CRYPTO_SHA1
 870         select CRYPTO_HASH
 871         help
 872           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 873           using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
 874           Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
 875           when available.
 876
 877 config CRYPTO_SHA256_SSSE3
 878         tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
 879         depends on X86 && 64BIT
 880         select CRYPTO_SHA256
 881         select CRYPTO_HASH
 882         help
 883           SHA-256 secure hash standard (DFIPS 180-2) implemented
 884           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
 885           Extensions version 1 (AVX1), or Advanced Vector Extensions
 886           version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
 887           Instructions) when available.
 888
 889 config CRYPTO_SHA512_SSSE3
 890         tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
 891         depends on X86 && 64BIT
 892         select CRYPTO_SHA512
 893         select CRYPTO_HASH
 894         help
 895           SHA-512 secure hash standard (DFIPS 180-2) implemented
 896           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
 897           Extensions version 1 (AVX1), or Advanced Vector Extensions
 898           version 2 (AVX2) instructions, when available.
 899
 900 config CRYPTO_SHA1_OCTEON
 901         tristate "SHA1 digest algorithm (OCTEON)"
 902         depends on CPU_CAVIUM_OCTEON
 903         select CRYPTO_SHA1
 904         select CRYPTO_HASH
 905         help
 906           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 907           using OCTEON crypto instructions, when available.
 908
 909 config CRYPTO_SHA1_SPARC64
 910         tristate "SHA1 digest algorithm (SPARC64)"
 911         depends on SPARC64
 912         select CRYPTO_SHA1
 913         select CRYPTO_HASH
 914         help
 915           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 916           using sparc64 crypto instructions, when available.
 917
 918 config CRYPTO_SHA1_PPC
 919         tristate "SHA1 digest algorithm (powerpc)"
 920         depends on PPC
 921         help
 922           This is the powerpc hardware accelerated implementation of the
 923           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 924
 925 config CRYPTO_SHA1_PPC_SPE
 926         tristate "SHA1 digest algorithm (PPC SPE)"
 927         depends on PPC && SPE
 928         help
 929           SHA-1 secure hash standard (DFIPS 180-4) implemented
 930           using powerpc SPE SIMD instruction set.
 931
 932 config CRYPTO_SHA256
 933         tristate "SHA224 and SHA256 digest algorithm"
 934         select CRYPTO_HASH
 935         help
 936           SHA256 secure hash standard (DFIPS 180-2).
 937
 938           This version of SHA implements a 256 bit hash with 128 bits of
 939           security against collision attacks.
 940
 941           This code also includes SHA-224, a 224 bit hash with 112 bits
 942           of security against collision attacks.
 943
 944 config CRYPTO_SHA256_PPC_SPE
 945         tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
 946         depends on PPC && SPE
 947         select CRYPTO_SHA256
 948         select CRYPTO_HASH
 949         help
 950           SHA224 and SHA256 secure hash standard (DFIPS 180-2)
 951           implemented using powerpc SPE SIMD instruction set.
 952
 953 config CRYPTO_SHA256_OCTEON
 954         tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
 955         depends on CPU_CAVIUM_OCTEON
 956         select CRYPTO_SHA256
 957         select CRYPTO_HASH
 958         help
 959           SHA-256 secure hash standard (DFIPS 180-2) implemented
 960           using OCTEON crypto instructions, when available.
 961
 962 config CRYPTO_SHA256_SPARC64
 963         tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
 964         depends on SPARC64
 965         select CRYPTO_SHA256
 966         select CRYPTO_HASH
 967         help
 968           SHA-256 secure hash standard (DFIPS 180-2) implemented
 969           using sparc64 crypto instructions, when available.
 970
 971 config CRYPTO_SHA512
 972         tristate "SHA384 and SHA512 digest algorithms"
 973         select CRYPTO_HASH
 974         help
 975           SHA512 secure hash standard (DFIPS 180-2).
 976
 977           This version of SHA implements a 512 bit hash with 256 bits of
 978           security against collision attacks.
 979
 980           This code also includes SHA-384, a 384 bit hash with 192 bits
 981           of security against collision attacks.
 982
 983 config CRYPTO_SHA512_OCTEON
 984         tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
 985         depends on CPU_CAVIUM_OCTEON
 986         select CRYPTO_SHA512
 987         select CRYPTO_HASH
 988         help
 989           SHA-512 secure hash standard (DFIPS 180-2) implemented
 990           using OCTEON crypto instructions, when available.
 991
 992 config CRYPTO_SHA512_SPARC64
 993         tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
 994         depends on SPARC64
 995         select CRYPTO_SHA512
 996         select CRYPTO_HASH
 997         help
 998           SHA-512 secure hash standard (DFIPS 180-2) implemented
 999           using sparc64 crypto instructions, when available.
1000
1001 config CRYPTO_SHA3
1002         tristate "SHA3 digest algorithm"
1003         select CRYPTO_HASH
1004         help
1005           SHA-3 secure hash standard (DFIPS 202). It's based on
1006           cryptographic sponge function family called Keccak.
1007
1008           References:
1009           http://keccak.noekeon.org/
1010
1011 config CRYPTO_SM3
1012         tristate "SM3 digest algorithm"
1013         select CRYPTO_HASH
1014         help
1015           SM3 secure hash function as defined by OSCCA GM/T 0004-2012 SM3).
1016           It is part of the Chinese Commercial Cryptography suite.
1017
1018           References:
1019           http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
1020           https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
1021
1022 config CRYPTO_STREEBOG
1023         tristate "Streebog Hash Function"
1024         select CRYPTO_HASH
1025         help
1026           Streebog Hash Function (GOST R 34.11-2012, RFC 6986) is one of the Russian
1027           cryptographic standard algorithms (called GOST algorithms).
1028           This setting enables two hash algorithms with 256 and 512 bits output.
1029
1030           References:
1031           https://tc26.ru/upload/iblock/fed/feddbb4d26b685903faa2ba11aea43f6.pdf
1032           https://tools.ietf.org/html/rfc6986
1033
1034 config CRYPTO_TGR192
1035         tristate "Tiger digest algorithms"
1036         select CRYPTO_HASH
1037         help
1038           Tiger hash algorithm 192, 160 and 128-bit hashes
1039
1040           Tiger is a hash function optimized for 64-bit processors while
1041           still having decent performance on 32-bit processors.
1042           Tiger was developed by Ross Anderson and Eli Biham.
1043
1044           See also:
1045           <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
1046
1047 config CRYPTO_WP512
1048         tristate "Whirlpool digest algorithms"
1049         select CRYPTO_HASH
1050         help
1051           Whirlpool hash algorithm 512, 384 and 256-bit hashes
1052
1053           Whirlpool-512 is part of the NESSIE cryptographic primitives.
1054           Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
1055
1056           See also:
1057           <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
1058
1059 config CRYPTO_GHASH_CLMUL_NI_INTEL
1060         tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
1061         depends on X86 && 64BIT
1062         select CRYPTO_CRYPTD
1063         help
1064           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
1065           The implementation is accelerated by CLMUL-NI of Intel.
1066
1067 comment "Ciphers"
1068
1069 config CRYPTO_AES
1070         tristate "AES cipher algorithms"
1071         select CRYPTO_ALGAPI
1072         help
1073           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1074           algorithm.
1075
1076           Rijndael appears to be consistently a very good performer in
1077           both hardware and software across a wide range of computing
1078           environments regardless of its use in feedback or non-feedback
1079           modes. Its key setup time is excellent, and its key agility is
1080           good. Rijndael's very low memory requirements make it very well
1081           suited for restricted-space environments, in which it also
1082           demonstrates excellent performance. Rijndael's operations are
1083           among the easiest to defend against power and timing attacks.
1084
1085           The AES specifies three key sizes: 128, 192 and 256 bits
1086
1087           See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
1088
1089 config CRYPTO_AES_TI
1090         tristate "Fixed time AES cipher"
1091         select CRYPTO_ALGAPI
1092         help
1093           This is a generic implementation of AES that attempts to eliminate
1094           data dependent latencies as much as possible without affecting
1095           performance too much. It is intended for use by the generic CCM
1096           and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
1097           solely on encryption (although decryption is supported as well, but
1098           with a more dramatic performance hit)
1099
1100           Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
1101           8 for decryption), this implementation only uses just two S-boxes of
1102           256 bytes each, and attempts to eliminate data dependent latencies by
1103           prefetching the entire table into the cache at the start of each
1104           block. Interrupts are also disabled to avoid races where cachelines
1105           are evicted when the CPU is interrupted to do something else.
1106
1107 config CRYPTO_AES_586
1108         tristate "AES cipher algorithms (i586)"
1109         depends on (X86 || UML_X86) && !64BIT
1110         select CRYPTO_ALGAPI
1111         select CRYPTO_AES
1112         help
1113           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1114           algorithm.
1115
1116           Rijndael appears to be consistently a very good performer in
1117           both hardware and software across a wide range of computing
1118           environments regardless of its use in feedback or non-feedback
1119           modes. Its key setup time is excellent, and its key agility is
1120           good. Rijndael's very low memory requirements make it very well
1121           suited for restricted-space environments, in which it also
1122           demonstrates excellent performance. Rijndael's operations are
1123           among the easiest to defend against power and timing attacks.
1124
1125           The AES specifies three key sizes: 128, 192 and 256 bits
1126
1127           See <http://csrc.nist.gov/encryption/aes/> for more information.
1128
1129 config CRYPTO_AES_X86_64
1130         tristate "AES cipher algorithms (x86_64)"
1131         depends on (X86 || UML_X86) && 64BIT
1132         select CRYPTO_ALGAPI
1133         select CRYPTO_AES
1134         help
1135           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1136           algorithm.
1137
1138           Rijndael appears to be consistently a very good performer in
1139           both hardware and software across a wide range of computing
1140           environments regardless of its use in feedback or non-feedback
1141           modes. Its key setup time is excellent, and its key agility is
1142           good. Rijndael's very low memory requirements make it very well
1143           suited for restricted-space environments, in which it also
1144           demonstrates excellent performance. Rijndael's operations are
1145           among the easiest to defend against power and timing attacks.
1146
1147           The AES specifies three key sizes: 128, 192 and 256 bits
1148
1149           See <http://csrc.nist.gov/encryption/aes/> for more information.
1150
1151 config CRYPTO_AES_NI_INTEL
1152         tristate "AES cipher algorithms (AES-NI)"
1153         depends on X86
1154         select CRYPTO_AEAD
1155         select CRYPTO_AES_X86_64 if 64BIT
1156         select CRYPTO_AES_586 if !64BIT
1157         select CRYPTO_ALGAPI
1158         select CRYPTO_BLKCIPHER
1159         select CRYPTO_GLUE_HELPER_X86 if 64BIT
1160         select CRYPTO_SIMD
1161         help
1162           Use Intel AES-NI instructions for AES algorithm.
1163
1164           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1165           algorithm.
1166
1167           Rijndael appears to be consistently a very good performer in
1168           both hardware and software across a wide range of computing
1169           environments regardless of its use in feedback or non-feedback
1170           modes. Its key setup time is excellent, and its key agility is
1171           good. Rijndael's very low memory requirements make it very well
1172           suited for restricted-space environments, in which it also
1173           demonstrates excellent performance. Rijndael's operations are
1174           among the easiest to defend against power and timing attacks.
1175
1176           The AES specifies three key sizes: 128, 192 and 256 bits
1177
1178           See <http://csrc.nist.gov/encryption/aes/> for more information.
1179
1180           In addition to AES cipher algorithm support, the acceleration
1181           for some popular block cipher mode is supported too, including
1182           ECB, CBC, LRW, XTS. The 64 bit version has additional
1183           acceleration for CTR.
1184
1185 config CRYPTO_AES_SPARC64
1186         tristate "AES cipher algorithms (SPARC64)"
1187         depends on SPARC64
1188         select CRYPTO_CRYPTD
1189         select CRYPTO_ALGAPI
1190         help
1191           Use SPARC64 crypto opcodes for AES algorithm.
1192
1193           AES cipher algorithms (FIPS-197). AES uses the Rijndael
1194           algorithm.
1195
1196           Rijndael appears to be consistently a very good performer in
1197           both hardware and software across a wide range of computing
1198           environments regardless of its use in feedback or non-feedback
1199           modes. Its key setup time is excellent, and its key agility is
1200           good. Rijndael's very low memory requirements make it very well
1201           suited for restricted-space environments, in which it also
1202           demonstrates excellent performance. Rijndael's operations are
1203           among the easiest to defend against power and timing attacks.
1204
1205           The AES specifies three key sizes: 128, 192 and 256 bits
1206
1207           See <http://csrc.nist.gov/encryption/aes/> for more information.
1208
1209           In addition to AES cipher algorithm support, the acceleration
1210           for some popular block cipher mode is supported too, including
1211           ECB and CBC.
1212
1213 config CRYPTO_AES_PPC_SPE
1214         tristate "AES cipher algorithms (PPC SPE)"
1215         depends on PPC && SPE
1216         help
1217           AES cipher algorithms (FIPS-197). Additionally the acceleration
1218           for popular block cipher modes ECB, CBC, CTR and XTS is supported.
1219           This module should only be used for low power (router) devices
1220           without hardware AES acceleration (e.g. caam crypto). It reduces the
1221           size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
1222           timining attacks. Nevertheless it might be not as secure as other
1223           architecture specific assembler implementations that work on 1KB
1224           tables or 256 bytes S-boxes.
1225
1226 config CRYPTO_ANUBIS
1227         tristate "Anubis cipher algorithm"
1228         select CRYPTO_ALGAPI
1229         help
1230           Anubis cipher algorithm.
1231
1232           Anubis is a variable key length cipher which can use keys from
1233           128 bits to 320 bits in length.  It was evaluated as a entrant
1234           in the NESSIE competition.
1235
1236           See also:
1237           <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1238           <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1239
1240 config CRYPTO_ARC4
1241         tristate "ARC4 cipher algorithm"
1242         select CRYPTO_BLKCIPHER
1243         help
1244           ARC4 cipher algorithm.
1245
1246           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
1247           bits in length.  This algorithm is required for driver-based
1248           WEP, but it should not be for other purposes because of the
1249           weakness of the algorithm.
1250
1251 config CRYPTO_BLOWFISH
1252         tristate "Blowfish cipher algorithm"
1253         select CRYPTO_ALGAPI
1254         select CRYPTO_BLOWFISH_COMMON
1255         help
1256           Blowfish cipher algorithm, by Bruce Schneier.
1257
1258           This is a variable key length cipher which can use keys from 32
1259           bits to 448 bits in length.  It's fast, simple and specifically
1260           designed for use on "large microprocessors".
1261
1262           See also:
1263           <http://www.schneier.com/blowfish.html>
1264
1265 config CRYPTO_BLOWFISH_COMMON
1266         tristate
1267         help
1268           Common parts of the Blowfish cipher algorithm shared by the
1269           generic c and the assembler implementations.
1270
1271           See also:
1272           <http://www.schneier.com/blowfish.html>
1273
1274 config CRYPTO_BLOWFISH_X86_64
1275         tristate "Blowfish cipher algorithm (x86_64)"
1276         depends on X86 && 64BIT
1277         select CRYPTO_BLKCIPHER
1278         select CRYPTO_BLOWFISH_COMMON
1279         help
1280           Blowfish cipher algorithm (x86_64), by Bruce Schneier.
1281
1282           This is a variable key length cipher which can use keys from 32
1283           bits to 448 bits in length.  It's fast, simple and specifically
1284           designed for use on "large microprocessors".
1285
1286           See also:
1287           <http://www.schneier.com/blowfish.html>
1288
1289 config CRYPTO_CAMELLIA
1290         tristate "Camellia cipher algorithms"
1291         depends on CRYPTO
1292         select CRYPTO_ALGAPI
1293         help
1294           Camellia cipher algorithms module.
1295
1296           Camellia is a symmetric key block cipher developed jointly
1297           at NTT and Mitsubishi Electric Corporation.
1298
1299           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1300
1301           See also:
1302           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1303
1304 config CRYPTO_CAMELLIA_X86_64
1305         tristate "Camellia cipher algorithm (x86_64)"
1306         depends on X86 && 64BIT
1307         depends on CRYPTO
1308         select CRYPTO_BLKCIPHER
1309         select CRYPTO_GLUE_HELPER_X86
1310         help
1311           Camellia cipher algorithm module (x86_64).
1312
1313           Camellia is a symmetric key block cipher developed jointly
1314           at NTT and Mitsubishi Electric Corporation.
1315
1316           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1317
1318           See also:
1319           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1320
1321 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1322         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
1323         depends on X86 && 64BIT
1324         depends on CRYPTO
1325         select CRYPTO_BLKCIPHER
1326         select CRYPTO_CAMELLIA_X86_64
1327         select CRYPTO_GLUE_HELPER_X86
1328         select CRYPTO_SIMD
1329         select CRYPTO_XTS
1330         help
1331           Camellia cipher algorithm module (x86_64/AES-NI/AVX).
1332
1333           Camellia is a symmetric key block cipher developed jointly
1334           at NTT and Mitsubishi Electric Corporation.
1335
1336           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1337
1338           See also:
1339           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1340
1341 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
1342         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
1343         depends on X86 && 64BIT
1344         depends on CRYPTO
1345         select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
1346         help
1347           Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1348
1349           Camellia is a symmetric key block cipher developed jointly
1350           at NTT and Mitsubishi Electric Corporation.
1351
1352           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1353
1354           See also:
1355           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1356
1357 config CRYPTO_CAMELLIA_SPARC64
1358         tristate "Camellia cipher algorithm (SPARC64)"
1359         depends on SPARC64
1360         depends on CRYPTO
1361         select CRYPTO_ALGAPI
1362         help
1363           Camellia cipher algorithm module (SPARC64).
1364
1365           Camellia is a symmetric key block cipher developed jointly
1366           at NTT and Mitsubishi Electric Corporation.
1367
1368           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1369
1370           See also:
1371           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1372
1373 config CRYPTO_CAST_COMMON
1374         tristate
1375         help
1376           Common parts of the CAST cipher algorithms shared by the
1377           generic c and the assembler implementations.
1378
1379 config CRYPTO_CAST5
1380         tristate "CAST5 (CAST-128) cipher algorithm"
1381         select CRYPTO_ALGAPI
1382         select CRYPTO_CAST_COMMON
1383         help
1384           The CAST5 encryption algorithm (synonymous with CAST-128) is
1385           described in RFC2144.
1386
1387 config CRYPTO_CAST5_AVX_X86_64
1388         tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1389         depends on X86 && 64BIT
1390         select CRYPTO_BLKCIPHER
1391         select CRYPTO_CAST5
1392         select CRYPTO_CAST_COMMON
1393         select CRYPTO_SIMD
1394         help
1395           The CAST5 encryption algorithm (synonymous with CAST-128) is
1396           described in RFC2144.
1397
1398           This module provides the Cast5 cipher algorithm that processes
1399           sixteen blocks parallel using the AVX instruction set.
1400
1401 config CRYPTO_CAST6
1402         tristate "CAST6 (CAST-256) cipher algorithm"
1403         select CRYPTO_ALGAPI
1404         select CRYPTO_CAST_COMMON
1405         help
1406           The CAST6 encryption algorithm (synonymous with CAST-256) is
1407           described in RFC2612.
1408
1409 config CRYPTO_CAST6_AVX_X86_64
1410         tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1411         depends on X86 && 64BIT
1412         select CRYPTO_BLKCIPHER
1413         select CRYPTO_CAST6
1414         select CRYPTO_CAST_COMMON
1415         select CRYPTO_GLUE_HELPER_X86
1416         select CRYPTO_SIMD
1417         select CRYPTO_XTS
1418         help
1419           The CAST6 encryption algorithm (synonymous with CAST-256) is
1420           described in RFC2612.
1421
1422           This module provides the Cast6 cipher algorithm that processes
1423           eight blocks parallel using the AVX instruction set.
1424
1425 config CRYPTO_DES
1426         tristate "DES and Triple DES EDE cipher algorithms"
1427         select CRYPTO_ALGAPI
1428         help
1429           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1430
1431 config CRYPTO_DES_SPARC64
1432         tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1433         depends on SPARC64
1434         select CRYPTO_ALGAPI
1435         select CRYPTO_DES
1436         help
1437           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1438           optimized using SPARC64 crypto opcodes.
1439
1440 config CRYPTO_DES3_EDE_X86_64
1441         tristate "Triple DES EDE cipher algorithm (x86-64)"
1442         depends on X86 && 64BIT
1443         select CRYPTO_BLKCIPHER
1444         select CRYPTO_DES
1445         help
1446           Triple DES EDE (FIPS 46-3) algorithm.
1447
1448           This module provides implementation of the Triple DES EDE cipher
1449           algorithm that is optimized for x86-64 processors. Two versions of
1450           algorithm are provided; regular processing one input block and
1451           one that processes three blocks parallel.
1452
1453 config CRYPTO_FCRYPT
1454         tristate "FCrypt cipher algorithm"
1455         select CRYPTO_ALGAPI
1456         select CRYPTO_BLKCIPHER
1457         help
1458           FCrypt algorithm used by RxRPC.
1459
1460 config CRYPTO_KHAZAD
1461         tristate "Khazad cipher algorithm"
1462         select CRYPTO_ALGAPI
1463         help
1464           Khazad cipher algorithm.
1465
1466           Khazad was a finalist in the initial NESSIE competition.  It is
1467           an algorithm optimized for 64-bit processors with good performance
1468           on 32-bit processors.  Khazad uses an 128 bit key size.
1469
1470           See also:
1471           <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1472
1473 config CRYPTO_SALSA20
1474         tristate "Salsa20 stream cipher algorithm"
1475         select CRYPTO_BLKCIPHER
1476         help
1477           Salsa20 stream cipher algorithm.
1478
1479           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1480           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1481
1482           The Salsa20 stream cipher algorithm is designed by Daniel J.
1483           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1484
1485 config CRYPTO_CHACHA20
1486         tristate "ChaCha stream cipher algorithms"
1487         select CRYPTO_BLKCIPHER
1488         help
1489           The ChaCha20, XChaCha20, and XChaCha12 stream cipher algorithms.
1490
1491           ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1492           Bernstein and further specified in RFC7539 for use in IETF protocols.
1493           This is the portable C implementation of ChaCha20.  See also:
1494           <http://cr.yp.to/chacha/chacha-20080128.pdf>
1495
1496           XChaCha20 is the application of the XSalsa20 construction to ChaCha20
1497           rather than to Salsa20.  XChaCha20 extends ChaCha20's nonce length
1498           from 64 bits (or 96 bits using the RFC7539 convention) to 192 bits,
1499           while provably retaining ChaCha20's security.  See also:
1500           <https://cr.yp.to/snuffle/xsalsa-20081128.pdf>
1501
1502           XChaCha12 is XChaCha20 reduced to 12 rounds, with correspondingly
1503           reduced security margin but increased performance.  It can be needed
1504           in some performance-sensitive scenarios.
1505
1506 config CRYPTO_CHACHA20_X86_64
1507         tristate "ChaCha stream cipher algorithms (x86_64/SSSE3/AVX2/AVX-512VL)"
1508         depends on X86 && 64BIT
1509         select CRYPTO_BLKCIPHER
1510         select CRYPTO_CHACHA20
1511         help
1512           SSSE3, AVX2, and AVX-512VL optimized implementations of the ChaCha20,
1513           XChaCha20, and XChaCha12 stream ciphers.
1514
1515 config CRYPTO_SEED
1516         tristate "SEED cipher algorithm"
1517         select CRYPTO_ALGAPI
1518         help
1519           SEED cipher algorithm (RFC4269).
1520
1521           SEED is a 128-bit symmetric key block cipher that has been
1522           developed by KISA (Korea Information Security Agency) as a
1523           national standard encryption algorithm of the Republic of Korea.
1524           It is a 16 round block cipher with the key size of 128 bit.
1525
1526           See also:
1527           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1528
1529 config CRYPTO_SERPENT
1530         tristate "Serpent cipher algorithm"
1531         select CRYPTO_ALGAPI
1532         help
1533           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1534
1535           Keys are allowed to be from 0 to 256 bits in length, in steps
1536           of 8 bits.  Also includes the 'Tnepres' algorithm, a reversed
1537           variant of Serpent for compatibility with old kerneli.org code.
1538
1539           See also:
1540           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1541
1542 config CRYPTO_SERPENT_SSE2_X86_64
1543         tristate "Serpent cipher algorithm (x86_64/SSE2)"
1544         depends on X86 && 64BIT
1545         select CRYPTO_BLKCIPHER
1546         select CRYPTO_GLUE_HELPER_X86
1547         select CRYPTO_SERPENT
1548         select CRYPTO_SIMD
1549         help
1550           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1551
1552           Keys are allowed to be from 0 to 256 bits in length, in steps
1553           of 8 bits.
1554
1555           This module provides Serpent cipher algorithm that processes eight
1556           blocks parallel using SSE2 instruction set.
1557
1558           See also:
1559           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1560
1561 config CRYPTO_SERPENT_SSE2_586
1562         tristate "Serpent cipher algorithm (i586/SSE2)"
1563         depends on X86 && !64BIT
1564         select CRYPTO_BLKCIPHER
1565         select CRYPTO_GLUE_HELPER_X86
1566         select CRYPTO_SERPENT
1567         select CRYPTO_SIMD
1568         help
1569           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1570
1571           Keys are allowed to be from 0 to 256 bits in length, in steps
1572           of 8 bits.
1573
1574           This module provides Serpent cipher algorithm that processes four
1575           blocks parallel using SSE2 instruction set.
1576
1577           See also:
1578           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1579
1580 config CRYPTO_SERPENT_AVX_X86_64
1581         tristate "Serpent cipher algorithm (x86_64/AVX)"
1582         depends on X86 && 64BIT
1583         select CRYPTO_BLKCIPHER
1584         select CRYPTO_GLUE_HELPER_X86
1585         select CRYPTO_SERPENT
1586         select CRYPTO_SIMD
1587         select CRYPTO_XTS
1588         help
1589           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1590
1591           Keys are allowed to be from 0 to 256 bits in length, in steps
1592           of 8 bits.
1593
1594           This module provides the Serpent cipher algorithm that processes
1595           eight blocks parallel using the AVX instruction set.
1596
1597           See also:
1598           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1599
1600 config CRYPTO_SERPENT_AVX2_X86_64
1601         tristate "Serpent cipher algorithm (x86_64/AVX2)"
1602         depends on X86 && 64BIT
1603         select CRYPTO_SERPENT_AVX_X86_64
1604         help
1605           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1606
1607           Keys are allowed to be from 0 to 256 bits in length, in steps
1608           of 8 bits.
1609
1610           This module provides Serpent cipher algorithm that processes 16
1611           blocks parallel using AVX2 instruction set.
1612
1613           See also:
1614           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1615
1616 config CRYPTO_SM4
1617         tristate "SM4 cipher algorithm"
1618         select CRYPTO_ALGAPI
1619         help
1620           SM4 cipher algorithms (OSCCA GB/T 32907-2016).
1621
1622           SM4 (GBT.32907-2016) is a cryptographic standard issued by the
1623           Organization of State Commercial Administration of China (OSCCA)
1624           as an authorized cryptographic algorithms for the use within China.
1625
1626           SMS4 was originally created for use in protecting wireless
1627           networks, and is mandated in the Chinese National Standard for
1628           Wireless LAN WAPI (Wired Authentication and Privacy Infrastructure)
1629           (GB.15629.11-2003).
1630
1631           The latest SM4 standard (GBT.32907-2016) was proposed by OSCCA and
1632           standardized through TC 260 of the Standardization Administration
1633           of the People's Republic of China (SAC).
1634
1635           The input, output, and key of SMS4 are each 128 bits.
1636
1637           See also: <https://eprint.iacr.org/2008/329.pdf>
1638
1639           If unsure, say N.
1640
1641 config CRYPTO_TEA
1642         tristate "TEA, XTEA and XETA cipher algorithms"
1643         select CRYPTO_ALGAPI
1644         help
1645           TEA cipher algorithm.
1646
1647           Tiny Encryption Algorithm is a simple cipher that uses
1648           many rounds for security.  It is very fast and uses
1649           little memory.
1650
1651           Xtendend Tiny Encryption Algorithm is a modification to
1652           the TEA algorithm to address a potential key weakness
1653           in the TEA algorithm.
1654
1655           Xtendend Encryption Tiny Algorithm is a mis-implementation
1656           of the XTEA algorithm for compatibility purposes.
1657
1658 config CRYPTO_TWOFISH
1659         tristate "Twofish cipher algorithm"
1660         select CRYPTO_ALGAPI
1661         select CRYPTO_TWOFISH_COMMON
1662         help
1663           Twofish cipher algorithm.
1664
1665           Twofish was submitted as an AES (Advanced Encryption Standard)
1666           candidate cipher by researchers at CounterPane Systems.  It is a
1667           16 round block cipher supporting key sizes of 128, 192, and 256
1668           bits.
1669
1670           See also:
1671           <http://www.schneier.com/twofish.html>
1672
1673 config CRYPTO_TWOFISH_COMMON
1674         tristate
1675         help
1676           Common parts of the Twofish cipher algorithm shared by the
1677           generic c and the assembler implementations.
1678
1679 config CRYPTO_TWOFISH_586
1680         tristate "Twofish cipher algorithms (i586)"
1681         depends on (X86 || UML_X86) && !64BIT
1682         select CRYPTO_ALGAPI
1683         select CRYPTO_TWOFISH_COMMON
1684         help
1685           Twofish cipher algorithm.
1686
1687           Twofish was submitted as an AES (Advanced Encryption Standard)
1688           candidate cipher by researchers at CounterPane Systems.  It is a
1689           16 round block cipher supporting key sizes of 128, 192, and 256
1690           bits.
1691
1692           See also:
1693           <http://www.schneier.com/twofish.html>
1694
1695 config CRYPTO_TWOFISH_X86_64
1696         tristate "Twofish cipher algorithm (x86_64)"
1697         depends on (X86 || UML_X86) && 64BIT
1698         select CRYPTO_ALGAPI
1699         select CRYPTO_TWOFISH_COMMON
1700         help
1701           Twofish cipher algorithm (x86_64).
1702
1703           Twofish was submitted as an AES (Advanced Encryption Standard)
1704           candidate cipher by researchers at CounterPane Systems.  It is a
1705           16 round block cipher supporting key sizes of 128, 192, and 256
1706           bits.
1707
1708           See also:
1709           <http://www.schneier.com/twofish.html>
1710
1711 config CRYPTO_TWOFISH_X86_64_3WAY
1712         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1713         depends on X86 && 64BIT
1714         select CRYPTO_BLKCIPHER
1715         select CRYPTO_TWOFISH_COMMON
1716         select CRYPTO_TWOFISH_X86_64
1717         select CRYPTO_GLUE_HELPER_X86
1718         help
1719           Twofish cipher algorithm (x86_64, 3-way parallel).
1720
1721           Twofish was submitted as an AES (Advanced Encryption Standard)
1722           candidate cipher by researchers at CounterPane Systems.  It is a
1723           16 round block cipher supporting key sizes of 128, 192, and 256
1724           bits.
1725
1726           This module provides Twofish cipher algorithm that processes three
1727           blocks parallel, utilizing resources of out-of-order CPUs better.
1728
1729           See also:
1730           <http://www.schneier.com/twofish.html>
1731
1732 config CRYPTO_TWOFISH_AVX_X86_64
1733         tristate "Twofish cipher algorithm (x86_64/AVX)"
1734         depends on X86 && 64BIT
1735         select CRYPTO_BLKCIPHER
1736         select CRYPTO_GLUE_HELPER_X86
1737         select CRYPTO_SIMD
1738         select CRYPTO_TWOFISH_COMMON
1739         select CRYPTO_TWOFISH_X86_64
1740         select CRYPTO_TWOFISH_X86_64_3WAY
1741         help
1742           Twofish cipher algorithm (x86_64/AVX).
1743
1744           Twofish was submitted as an AES (Advanced Encryption Standard)
1745           candidate cipher by researchers at CounterPane Systems.  It is a
1746           16 round block cipher supporting key sizes of 128, 192, and 256
1747           bits.
1748
1749           This module provides the Twofish cipher algorithm that processes
1750           eight blocks parallel using the AVX Instruction Set.
1751
1752           See also:
1753           <http://www.schneier.com/twofish.html>
1754
1755 comment "Compression"
1756
1757 config CRYPTO_DEFLATE
1758         tristate "Deflate compression algorithm"
1759         select CRYPTO_ALGAPI
1760         select CRYPTO_ACOMP2
1761         select ZLIB_INFLATE
1762         select ZLIB_DEFLATE
1763         help
1764           This is the Deflate algorithm (RFC1951), specified for use in
1765           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1766
1767           You will most probably want this if using IPSec.
1768
1769 config CRYPTO_LZO
1770         tristate "LZO compression algorithm"
1771         select CRYPTO_ALGAPI
1772         select CRYPTO_ACOMP2
1773         select LZO_COMPRESS
1774         select LZO_DECOMPRESS
1775         help
1776           This is the LZO algorithm.
1777
1778 config CRYPTO_842
1779         tristate "842 compression algorithm"
1780         select CRYPTO_ALGAPI
1781         select CRYPTO_ACOMP2
1782         select 842_COMPRESS
1783         select 842_DECOMPRESS
1784         help
1785           This is the 842 algorithm.
1786
1787 config CRYPTO_LZ4
1788         tristate "LZ4 compression algorithm"
1789         select CRYPTO_ALGAPI
1790         select CRYPTO_ACOMP2
1791         select LZ4_COMPRESS
1792         select LZ4_DECOMPRESS
1793         help
1794           This is the LZ4 algorithm.
1795
1796 config CRYPTO_LZ4HC
1797         tristate "LZ4HC compression algorithm"
1798         select CRYPTO_ALGAPI
1799         select CRYPTO_ACOMP2
1800         select LZ4HC_COMPRESS
1801         select LZ4_DECOMPRESS
1802         help
1803           This is the LZ4 high compression mode algorithm.
1804
1805 config CRYPTO_ZSTD
1806         tristate "Zstd compression algorithm"
1807         select CRYPTO_ALGAPI
1808         select CRYPTO_ACOMP2
1809         select ZSTD_COMPRESS
1810         select ZSTD_DECOMPRESS
1811         help
1812           This is the zstd algorithm.
1813
1814 comment "Random Number Generation"
1815
1816 config CRYPTO_ANSI_CPRNG
1817         tristate "Pseudo Random Number Generation for Cryptographic modules"
1818         select CRYPTO_AES
1819         select CRYPTO_RNG
1820         help
1821           This option enables the generic pseudo random number generator
1822           for cryptographic modules.  Uses the Algorithm specified in
1823           ANSI X9.31 A.2.4. Note that this option must be enabled if
1824           CRYPTO_FIPS is selected
1825
1826 menuconfig CRYPTO_DRBG_MENU
1827         tristate "NIST SP800-90A DRBG"
1828         help
1829           NIST SP800-90A compliant DRBG. In the following submenu, one or
1830           more of the DRBG types must be selected.
1831
1832 if CRYPTO_DRBG_MENU
1833
1834 config CRYPTO_DRBG_HMAC
1835         bool
1836         default y
1837         select CRYPTO_HMAC
1838         select CRYPTO_SHA256
1839
1840 config CRYPTO_DRBG_HASH
1841         bool "Enable Hash DRBG"
1842         select CRYPTO_SHA256
1843         help
1844           Enable the Hash DRBG variant as defined in NIST SP800-90A.
1845
1846 config CRYPTO_DRBG_CTR
1847         bool "Enable CTR DRBG"
1848         select CRYPTO_AES
1849         depends on CRYPTO_CTR
1850         help
1851           Enable the CTR DRBG variant as defined in NIST SP800-90A.
1852
1853 config CRYPTO_DRBG
1854         tristate
1855         default CRYPTO_DRBG_MENU
1856         select CRYPTO_RNG
1857         select CRYPTO_JITTERENTROPY
1858
1859 endif   # if CRYPTO_DRBG_MENU
1860
1861 config CRYPTO_JITTERENTROPY
1862         tristate "Jitterentropy Non-Deterministic Random Number Generator"
1863         select CRYPTO_RNG
1864         help
1865           The Jitterentropy RNG is a noise that is intended
1866           to provide seed to another RNG. The RNG does not
1867           perform any cryptographic whitening of the generated
1868           random numbers. This Jitterentropy RNG registers with
1869           the kernel crypto API and can be used by any caller.
1870
1871 config CRYPTO_USER_API
1872         tristate
1873
1874 config CRYPTO_USER_API_HASH
1875         tristate "User-space interface for hash algorithms"
1876         depends on NET
1877         select CRYPTO_HASH
1878         select CRYPTO_USER_API
1879         help
1880           This option enables the user-spaces interface for hash
1881           algorithms.
1882
1883 config CRYPTO_USER_API_SKCIPHER
1884         tristate "User-space interface for symmetric key cipher algorithms"
1885         depends on NET
1886         select CRYPTO_BLKCIPHER
1887         select CRYPTO_USER_API
1888         help
1889           This option enables the user-spaces interface for symmetric
1890           key cipher algorithms.
1891
1892 config CRYPTO_USER_API_RNG
1893         tristate "User-space interface for random number generator algorithms"
1894         depends on NET
1895         select CRYPTO_RNG
1896         select CRYPTO_USER_API
1897         help
1898           This option enables the user-spaces interface for random
1899           number generator algorithms.
1900
1901 config CRYPTO_USER_API_AEAD
1902         tristate "User-space interface for AEAD cipher algorithms"
1903         depends on NET
1904         select CRYPTO_AEAD
1905         select CRYPTO_BLKCIPHER
1906         select CRYPTO_NULL
1907         select CRYPTO_USER_API
1908         help
1909           This option enables the user-spaces interface for AEAD
1910           cipher algorithms.
1911
1912 config CRYPTO_STATS
1913         bool "Crypto usage statistics for User-space"
1914         depends on CRYPTO_USER
1915         help
1916           This option enables the gathering of crypto stats.
1917           This will collect:
1918           - encrypt/decrypt size and numbers of symmeric operations
1919           - compress/decompress size and numbers of compress operations
1920           - size and numbers of hash operations
1921           - encrypt/decrypt/sign/verify numbers for asymmetric operations
1922           - generate/seed numbers for rng operations
1923
1924 config CRYPTO_HASH_INFO
1925         bool
1926
1927 source "drivers/crypto/Kconfig"
1928 source "crypto/asymmetric_keys/Kconfig"
1929 source "certs/Kconfig"
1930
1931 endif   # if CRYPTO