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