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