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