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