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