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