crypto/Kconfig

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