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