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