crypto/Kconfig

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