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