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_SHA1_ARM_NEON
 537         tristate "SHA1 digest algorithm (ARM NEON)"
 538         depends on ARM && KERNEL_MODE_NEON && !CPU_BIG_ENDIAN
 539         select CRYPTO_SHA1_ARM
 540         select CRYPTO_SHA1
 541         select CRYPTO_HASH
 542         help
 543           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 544           using optimized ARM NEON assembly, when NEON instructions are
 545           available.
 546
 547 config CRYPTO_SHA256
 548         tristate "SHA224 and SHA256 digest algorithm"
 549         select CRYPTO_HASH
 550         help
 551           SHA256 secure hash standard (DFIPS 180-2).
 552
 553           This version of SHA implements a 256 bit hash with 128 bits of
 554           security against collision attacks.
 555
 556           This code also includes SHA-224, a 224 bit hash with 112 bits
 557           of security against collision attacks.
 558
 559 config CRYPTO_SHA256_SPARC64
 560         tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
 561         depends on SPARC64
 562         select CRYPTO_SHA256
 563         select CRYPTO_HASH
 564         help
 565           SHA-256 secure hash standard (DFIPS 180-2) implemented
 566           using sparc64 crypto instructions, when available.
 567
 568 config CRYPTO_SHA512
 569         tristate "SHA384 and SHA512 digest algorithms"
 570         select CRYPTO_HASH
 571         help
 572           SHA512 secure hash standard (DFIPS 180-2).
 573
 574           This version of SHA implements a 512 bit hash with 256 bits of
 575           security against collision attacks.
 576
 577           This code also includes SHA-384, a 384 bit hash with 192 bits
 578           of security against collision attacks.
 579
 580 config CRYPTO_SHA512_ARM_NEON
 581         tristate "SHA384 and SHA512 digest algorithm (ARM NEON)"
 582         depends on ARM && KERNEL_MODE_NEON && !CPU_BIG_ENDIAN
 583         select CRYPTO_SHA512
 584         select CRYPTO_HASH
 585         help
 586           SHA-512 secure hash standard (DFIPS 180-2) implemented
 587           using ARM NEON instructions, when available.
 588
 589           This version of SHA implements a 512 bit hash with 256 bits of
 590           security against collision attacks.
 591
 592           This code also includes SHA-384, a 384 bit hash with 192 bits
 593           of security against collision attacks.
 594
 595 config CRYPTO_SHA512_SPARC64
 596         tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
 597         depends on SPARC64
 598         select CRYPTO_SHA512
 599         select CRYPTO_HASH
 600         help
 601           SHA-512 secure hash standard (DFIPS 180-2) implemented
 602           using sparc64 crypto instructions, when available.
 603
 604 config CRYPTO_TGR192
 605         tristate "Tiger digest algorithms"
 606         select CRYPTO_HASH
 607         help
 608           Tiger hash algorithm 192, 160 and 128-bit hashes
 609
 610           Tiger is a hash function optimized for 64-bit processors while
 611           still having decent performance on 32-bit processors.
 612           Tiger was developed by Ross Anderson and Eli Biham.
 613
 614           See also:
 615           <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
 616
 617 config CRYPTO_WP512
 618         tristate "Whirlpool digest algorithms"
 619         select CRYPTO_HASH
 620         help
 621           Whirlpool hash algorithm 512, 384 and 256-bit hashes
 622
 623           Whirlpool-512 is part of the NESSIE cryptographic primitives.
 624           Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
 625
 626           See also:
 627           <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
 628
 629 config CRYPTO_GHASH_CLMUL_NI_INTEL
 630         tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
 631         depends on X86 && 64BIT
 632         select CRYPTO_CRYPTD
 633         help
 634           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
 635           The implementation is accelerated by CLMUL-NI of Intel.
 636
 637 comment "Ciphers"
 638
 639 config CRYPTO_AES
 640         tristate "AES cipher algorithms"
 641         select CRYPTO_ALGAPI
 642         help
 643           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 644           algorithm.
 645
 646           Rijndael appears to be consistently a very good performer in
 647           both hardware and software across a wide range of computing
 648           environments regardless of its use in feedback or non-feedback
 649           modes. Its key setup time is excellent, and its key agility is
 650           good. Rijndael's very low memory requirements make it very well
 651           suited for restricted-space environments, in which it also
 652           demonstrates excellent performance. Rijndael's operations are
 653           among the easiest to defend against power and timing attacks.
 654
 655           The AES specifies three key sizes: 128, 192 and 256 bits
 656
 657           See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
 658
 659 config CRYPTO_AES_586
 660         tristate "AES cipher algorithms (i586)"
 661         depends on (X86 || UML_X86) && !64BIT
 662         select CRYPTO_ALGAPI
 663         select CRYPTO_AES
 664         help
 665           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 666           algorithm.
 667
 668           Rijndael appears to be consistently a very good performer in
 669           both hardware and software across a wide range of computing
 670           environments regardless of its use in feedback or non-feedback
 671           modes. Its key setup time is excellent, and its key agility is
 672           good. Rijndael's very low memory requirements make it very well
 673           suited for restricted-space environments, in which it also
 674           demonstrates excellent performance. Rijndael's operations are
 675           among the easiest to defend against power and timing attacks.
 676
 677           The AES specifies three key sizes: 128, 192 and 256 bits
 678
 679           See <http://csrc.nist.gov/encryption/aes/> for more information.
 680
 681 config CRYPTO_AES_X86_64
 682         tristate "AES cipher algorithms (x86_64)"
 683         depends on (X86 || UML_X86) && 64BIT
 684         select CRYPTO_ALGAPI
 685         select CRYPTO_AES
 686         help
 687           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 688           algorithm.
 689
 690           Rijndael appears to be consistently a very good performer in
 691           both hardware and software across a wide range of computing
 692           environments regardless of its use in feedback or non-feedback
 693           modes. Its key setup time is excellent, and its key agility is
 694           good. Rijndael's very low memory requirements make it very well
 695           suited for restricted-space environments, in which it also
 696           demonstrates excellent performance. Rijndael's operations are
 697           among the easiest to defend against power and timing attacks.
 698
 699           The AES specifies three key sizes: 128, 192 and 256 bits
 700
 701           See <http://csrc.nist.gov/encryption/aes/> for more information.
 702
 703 config CRYPTO_AES_NI_INTEL
 704         tristate "AES cipher algorithms (AES-NI)"
 705         depends on X86
 706         select CRYPTO_AES_X86_64 if 64BIT
 707         select CRYPTO_AES_586 if !64BIT
 708         select CRYPTO_CRYPTD
 709         select CRYPTO_ABLK_HELPER_X86
 710         select CRYPTO_ALGAPI
 711         select CRYPTO_GLUE_HELPER_X86 if 64BIT
 712         select CRYPTO_LRW
 713         select CRYPTO_XTS
 714         help
 715           Use Intel AES-NI instructions for AES algorithm.
 716
 717           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 718           algorithm.
 719
 720           Rijndael appears to be consistently a very good performer in
 721           both hardware and software across a wide range of computing
 722           environments regardless of its use in feedback or non-feedback
 723           modes. Its key setup time is excellent, and its key agility is
 724           good. Rijndael's very low memory requirements make it very well
 725           suited for restricted-space environments, in which it also
 726           demonstrates excellent performance. Rijndael's operations are
 727           among the easiest to defend against power and timing attacks.
 728
 729           The AES specifies three key sizes: 128, 192 and 256 bits
 730
 731           See <http://csrc.nist.gov/encryption/aes/> for more information.
 732
 733           In addition to AES cipher algorithm support, the acceleration
 734           for some popular block cipher mode is supported too, including
 735           ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
 736           acceleration for CTR.
 737
 738 config CRYPTO_AES_SPARC64
 739         tristate "AES cipher algorithms (SPARC64)"
 740         depends on SPARC64
 741         select CRYPTO_CRYPTD
 742         select CRYPTO_ALGAPI
 743         help
 744           Use SPARC64 crypto opcodes for AES algorithm.
 745
 746           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 747           algorithm.
 748
 749           Rijndael appears to be consistently a very good performer in
 750           both hardware and software across a wide range of computing
 751           environments regardless of its use in feedback or non-feedback
 752           modes. Its key setup time is excellent, and its key agility is
 753           good. Rijndael's very low memory requirements make it very well
 754           suited for restricted-space environments, in which it also
 755           demonstrates excellent performance. Rijndael's operations are
 756           among the easiest to defend against power and timing attacks.
 757
 758           The AES specifies three key sizes: 128, 192 and 256 bits
 759
 760           See <http://csrc.nist.gov/encryption/aes/> for more information.
 761
 762           In addition to AES cipher algorithm support, the acceleration
 763           for some popular block cipher mode is supported too, including
 764           ECB and CBC.
 765
 766 config CRYPTO_AES_ARM
 767         tristate "AES cipher algorithms (ARM-asm)"
 768         depends on ARM
 769         select CRYPTO_ALGAPI
 770         select CRYPTO_AES
 771         help
 772           Use optimized AES assembler routines for ARM platforms.
 773
 774           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 775           algorithm.
 776
 777           Rijndael appears to be consistently a very good performer in
 778           both hardware and software across a wide range of computing
 779           environments regardless of its use in feedback or non-feedback
 780           modes. Its key setup time is excellent, and its key agility is
 781           good. Rijndael's very low memory requirements make it very well
 782           suited for restricted-space environments, in which it also
 783           demonstrates excellent performance. Rijndael's operations are
 784           among the easiest to defend against power and timing attacks.
 785
 786           The AES specifies three key sizes: 128, 192 and 256 bits
 787
 788           See <http://csrc.nist.gov/encryption/aes/> for more information.
 789
 790 config CRYPTO_AES_ARM_BS
 791         tristate "Bit sliced AES using NEON instructions"
 792         depends on ARM && KERNEL_MODE_NEON
 793         select CRYPTO_ALGAPI
 794         select CRYPTO_AES_ARM
 795         select CRYPTO_ABLK_HELPER
 796         help
 797           Use a faster and more secure NEON based implementation of AES in CBC,
 798           CTR and XTS modes
 799
 800           Bit sliced AES gives around 45% speedup on Cortex-A15 for CTR mode
 801           and for XTS mode encryption, CBC and XTS mode decryption speedup is
 802           around 25%. (CBC encryption speed is not affected by this driver.)
 803           This implementation does not rely on any lookup tables so it is
 804           believed to be invulnerable to cache timing attacks.
 805
 806 config CRYPTO_ANUBIS
 807         tristate "Anubis cipher algorithm"
 808         select CRYPTO_ALGAPI
 809         help
 810           Anubis cipher algorithm.
 811
 812           Anubis is a variable key length cipher which can use keys from
 813           128 bits to 320 bits in length.  It was evaluated as a entrant
 814           in the NESSIE competition.
 815
 816           See also:
 817           <https://www.cosic.esat.kuleuven.be/nessie/reports/>
 818           <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
 819
 820 config CRYPTO_ARC4
 821         tristate "ARC4 cipher algorithm"
 822         select CRYPTO_BLKCIPHER
 823         help
 824           ARC4 cipher algorithm.
 825
 826           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
 827           bits in length.  This algorithm is required for driver-based
 828           WEP, but it should not be for other purposes because of the
 829           weakness of the algorithm.
 830
 831 config CRYPTO_BLOWFISH
 832         tristate "Blowfish cipher algorithm"
 833         select CRYPTO_ALGAPI
 834         select CRYPTO_BLOWFISH_COMMON
 835         help
 836           Blowfish cipher algorithm, by Bruce Schneier.
 837
 838           This is a variable key length cipher which can use keys from 32
 839           bits to 448 bits in length.  It's fast, simple and specifically
 840           designed for use on "large microprocessors".
 841
 842           See also:
 843           <http://www.schneier.com/blowfish.html>
 844
 845 config CRYPTO_BLOWFISH_COMMON
 846         tristate
 847         help
 848           Common parts of the Blowfish cipher algorithm shared by the
 849           generic c and the assembler implementations.
 850
 851           See also:
 852           <http://www.schneier.com/blowfish.html>
 853
 854 config CRYPTO_BLOWFISH_X86_64
 855         tristate "Blowfish cipher algorithm (x86_64)"
 856         depends on X86 && 64BIT
 857         select CRYPTO_ALGAPI
 858         select CRYPTO_BLOWFISH_COMMON
 859         help
 860           Blowfish cipher algorithm (x86_64), by Bruce Schneier.
 861
 862           This is a variable key length cipher which can use keys from 32
 863           bits to 448 bits in length.  It's fast, simple and specifically
 864           designed for use on "large microprocessors".
 865
 866           See also:
 867           <http://www.schneier.com/blowfish.html>
 868
 869 config CRYPTO_BLOWFISH_AVX2_X86_64
 870         tristate "Blowfish cipher algorithm (x86_64/AVX2)"
 871         depends on X86 && 64BIT
 872         depends on BROKEN
 873         select CRYPTO_ALGAPI
 874         select CRYPTO_CRYPTD
 875         select CRYPTO_ABLK_HELPER_X86
 876         select CRYPTO_BLOWFISH_COMMON
 877         select CRYPTO_BLOWFISH_X86_64
 878         help
 879           Blowfish cipher algorithm (x86_64/AVX2), by Bruce Schneier.
 880
 881           This is a variable key length cipher which can use keys from 32
 882           bits to 448 bits in length.  It's fast, simple and specifically
 883           designed for use on "large microprocessors".
 884
 885           See also:
 886           <http://www.schneier.com/blowfish.html>
 887
 888 config CRYPTO_CAMELLIA
 889         tristate "Camellia cipher algorithms"
 890         depends on CRYPTO
 891         select CRYPTO_ALGAPI
 892         help
 893           Camellia cipher algorithms module.
 894
 895           Camellia is a symmetric key block cipher developed jointly
 896           at NTT and Mitsubishi Electric Corporation.
 897
 898           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 899
 900           See also:
 901           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 902
 903 config CRYPTO_CAMELLIA_X86_64
 904         tristate "Camellia cipher algorithm (x86_64)"
 905         depends on X86 && 64BIT
 906         depends on CRYPTO
 907         select CRYPTO_ALGAPI
 908         select CRYPTO_GLUE_HELPER_X86
 909         select CRYPTO_LRW
 910         select CRYPTO_XTS
 911         help
 912           Camellia cipher algorithm module (x86_64).
 913
 914           Camellia is a symmetric key block cipher developed jointly
 915           at NTT and Mitsubishi Electric Corporation.
 916
 917           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 918
 919           See also:
 920           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 921
 922 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
 923         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
 924         depends on X86 && 64BIT
 925         depends on CRYPTO
 926         select CRYPTO_ALGAPI
 927         select CRYPTO_CRYPTD
 928         select CRYPTO_ABLK_HELPER_X86
 929         select CRYPTO_GLUE_HELPER_X86
 930         select CRYPTO_CAMELLIA_X86_64
 931         select CRYPTO_LRW
 932         select CRYPTO_XTS
 933         help
 934           Camellia cipher algorithm module (x86_64/AES-NI/AVX).
 935
 936           Camellia is a symmetric key block cipher developed jointly
 937           at NTT and Mitsubishi Electric Corporation.
 938
 939           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 940
 941           See also:
 942           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 943
 944 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
 945         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
 946         depends on X86 && 64BIT
 947         depends on CRYPTO
 948         select CRYPTO_ALGAPI
 949         select CRYPTO_CRYPTD
 950         select CRYPTO_ABLK_HELPER_X86
 951         select CRYPTO_GLUE_HELPER_X86
 952         select CRYPTO_CAMELLIA_X86_64
 953         select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
 954         select CRYPTO_LRW
 955         select CRYPTO_XTS
 956         help
 957           Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
 958
 959           Camellia is a symmetric key block cipher developed jointly
 960           at NTT and Mitsubishi Electric Corporation.
 961
 962           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 963
 964           See also:
 965           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 966
 967 config CRYPTO_CAMELLIA_SPARC64
 968         tristate "Camellia cipher algorithm (SPARC64)"
 969         depends on SPARC64
 970         depends on CRYPTO
 971         select CRYPTO_ALGAPI
 972         help
 973           Camellia cipher algorithm module (SPARC64).
 974
 975           Camellia is a symmetric key block cipher developed jointly
 976           at NTT and Mitsubishi Electric Corporation.
 977
 978           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 979
 980           See also:
 981           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 982
 983 config CRYPTO_CAST_COMMON
 984         tristate
 985         help
 986           Common parts of the CAST cipher algorithms shared by the
 987           generic c and the assembler implementations.
 988
 989 config CRYPTO_CAST5
 990         tristate "CAST5 (CAST-128) cipher algorithm"
 991         select CRYPTO_ALGAPI
 992         select CRYPTO_CAST_COMMON
 993         help
 994           The CAST5 encryption algorithm (synonymous with CAST-128) is
 995           described in RFC2144.
 996
 997 config CRYPTO_CAST5_AVX_X86_64
 998         tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
 999         depends on X86 && 64BIT
1000         select CRYPTO_ALGAPI
1001         select CRYPTO_CRYPTD
1002         select CRYPTO_ABLK_HELPER_X86
1003         select CRYPTO_CAST_COMMON
1004         select CRYPTO_CAST5
1005         help
1006           The CAST5 encryption algorithm (synonymous with CAST-128) is
1007           described in RFC2144.
1008
1009           This module provides the Cast5 cipher algorithm that processes
1010           sixteen blocks parallel using the AVX instruction set.
1011
1012 config CRYPTO_CAST6
1013         tristate "CAST6 (CAST-256) cipher algorithm"
1014         select CRYPTO_ALGAPI
1015         select CRYPTO_CAST_COMMON
1016         help
1017           The CAST6 encryption algorithm (synonymous with CAST-256) is
1018           described in RFC2612.
1019
1020 config CRYPTO_CAST6_AVX_X86_64
1021         tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1022         depends on X86 && 64BIT
1023         select CRYPTO_ALGAPI
1024         select CRYPTO_CRYPTD
1025         select CRYPTO_ABLK_HELPER_X86
1026         select CRYPTO_GLUE_HELPER_X86
1027         select CRYPTO_CAST_COMMON
1028         select CRYPTO_CAST6
1029         select CRYPTO_LRW
1030         select CRYPTO_XTS
1031         help
1032           The CAST6 encryption algorithm (synonymous with CAST-256) is
1033           described in RFC2612.
1034
1035           This module provides the Cast6 cipher algorithm that processes
1036           eight blocks parallel using the AVX instruction set.
1037
1038 config CRYPTO_DES
1039         tristate "DES and Triple DES EDE cipher algorithms"
1040         select CRYPTO_ALGAPI
1041         help
1042           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1043
1044 config CRYPTO_DES_SPARC64
1045         tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1046         depends on SPARC64
1047         select CRYPTO_ALGAPI
1048         select CRYPTO_DES
1049         help
1050           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1051           optimized using SPARC64 crypto opcodes.
1052
1053 config CRYPTO_FCRYPT
1054         tristate "FCrypt cipher algorithm"
1055         select CRYPTO_ALGAPI
1056         select CRYPTO_BLKCIPHER
1057         help
1058           FCrypt algorithm used by RxRPC.
1059
1060 config CRYPTO_KHAZAD
1061         tristate "Khazad cipher algorithm"
1062         select CRYPTO_ALGAPI
1063         help
1064           Khazad cipher algorithm.
1065
1066           Khazad was a finalist in the initial NESSIE competition.  It is
1067           an algorithm optimized for 64-bit processors with good performance
1068           on 32-bit processors.  Khazad uses an 128 bit key size.
1069
1070           See also:
1071           <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1072
1073 config CRYPTO_SALSA20
1074         tristate "Salsa20 stream cipher algorithm"
1075         select CRYPTO_BLKCIPHER
1076         help
1077           Salsa20 stream cipher algorithm.
1078
1079           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1080           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1081
1082           The Salsa20 stream cipher algorithm is designed by Daniel J.
1083           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1084
1085 config CRYPTO_SALSA20_586
1086         tristate "Salsa20 stream cipher algorithm (i586)"
1087         depends on (X86 || UML_X86) && !64BIT
1088         select CRYPTO_BLKCIPHER
1089         help
1090           Salsa20 stream cipher algorithm.
1091
1092           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1093           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1094
1095           The Salsa20 stream cipher algorithm is designed by Daniel J.
1096           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1097
1098 config CRYPTO_SALSA20_X86_64
1099         tristate "Salsa20 stream cipher algorithm (x86_64)"
1100         depends on (X86 || UML_X86) && 64BIT
1101         select CRYPTO_BLKCIPHER
1102         help
1103           Salsa20 stream cipher algorithm.
1104
1105           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1106           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1107
1108           The Salsa20 stream cipher algorithm is designed by Daniel J.
1109           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1110
1111 config CRYPTO_SEED
1112         tristate "SEED cipher algorithm"
1113         select CRYPTO_ALGAPI
1114         help
1115           SEED cipher algorithm (RFC4269).
1116
1117           SEED is a 128-bit symmetric key block cipher that has been
1118           developed by KISA (Korea Information Security Agency) as a
1119           national standard encryption algorithm of the Republic of Korea.
1120           It is a 16 round block cipher with the key size of 128 bit.
1121
1122           See also:
1123           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1124
1125 config CRYPTO_SERPENT
1126         tristate "Serpent cipher algorithm"
1127         select CRYPTO_ALGAPI
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.  Also includes the 'Tnepres' algorithm, a reversed
1133           variant of Serpent for compatibility with old kerneli.org code.
1134
1135           See also:
1136           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1137
1138 config CRYPTO_SERPENT_SSE2_X86_64
1139         tristate "Serpent cipher algorithm (x86_64/SSE2)"
1140         depends on X86 && 64BIT
1141         select CRYPTO_ALGAPI
1142         select CRYPTO_CRYPTD
1143         select CRYPTO_ABLK_HELPER_X86
1144         select CRYPTO_GLUE_HELPER_X86
1145         select CRYPTO_SERPENT
1146         select CRYPTO_LRW
1147         select CRYPTO_XTS
1148         help
1149           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1150
1151           Keys are allowed to be from 0 to 256 bits in length, in steps
1152           of 8 bits.
1153
1154           This module provides Serpent cipher algorithm that processes eigth
1155           blocks parallel using SSE2 instruction set.
1156
1157           See also:
1158           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1159
1160 config CRYPTO_SERPENT_SSE2_586
1161         tristate "Serpent cipher algorithm (i586/SSE2)"
1162         depends on X86 && !64BIT
1163         select CRYPTO_ALGAPI
1164         select CRYPTO_CRYPTD
1165         select CRYPTO_ABLK_HELPER_X86
1166         select CRYPTO_GLUE_HELPER_X86
1167         select CRYPTO_SERPENT
1168         select CRYPTO_LRW
1169         select CRYPTO_XTS
1170         help
1171           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1172
1173           Keys are allowed to be from 0 to 256 bits in length, in steps
1174           of 8 bits.
1175
1176           This module provides Serpent cipher algorithm that processes four
1177           blocks parallel using SSE2 instruction set.
1178
1179           See also:
1180           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1181
1182 config CRYPTO_SERPENT_AVX_X86_64
1183         tristate "Serpent cipher algorithm (x86_64/AVX)"
1184         depends on X86 && 64BIT
1185         select CRYPTO_ALGAPI
1186         select CRYPTO_CRYPTD
1187         select CRYPTO_ABLK_HELPER_X86
1188         select CRYPTO_GLUE_HELPER_X86
1189         select CRYPTO_SERPENT
1190         select CRYPTO_LRW
1191         select CRYPTO_XTS
1192         help
1193           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1194
1195           Keys are allowed to be from 0 to 256 bits in length, in steps
1196           of 8 bits.
1197
1198           This module provides the Serpent cipher algorithm that processes
1199           eight blocks parallel using the AVX instruction set.
1200
1201           See also:
1202           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1203
1204 config CRYPTO_SERPENT_AVX2_X86_64
1205         tristate "Serpent cipher algorithm (x86_64/AVX2)"
1206         depends on X86 && 64BIT
1207         select CRYPTO_ALGAPI
1208         select CRYPTO_CRYPTD
1209         select CRYPTO_ABLK_HELPER_X86
1210         select CRYPTO_GLUE_HELPER_X86
1211         select CRYPTO_SERPENT
1212         select CRYPTO_SERPENT_AVX_X86_64
1213         select CRYPTO_LRW
1214         select CRYPTO_XTS
1215         help
1216           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1217
1218           Keys are allowed to be from 0 to 256 bits in length, in steps
1219           of 8 bits.
1220
1221           This module provides Serpent cipher algorithm that processes 16
1222           blocks parallel using AVX2 instruction set.
1223
1224           See also:
1225           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1226
1227 config CRYPTO_TEA
1228         tristate "TEA, XTEA and XETA cipher algorithms"
1229         select CRYPTO_ALGAPI
1230         help
1231           TEA cipher algorithm.
1232
1233           Tiny Encryption Algorithm is a simple cipher that uses
1234           many rounds for security.  It is very fast and uses
1235           little memory.
1236
1237           Xtendend Tiny Encryption Algorithm is a modification to
1238           the TEA algorithm to address a potential key weakness
1239           in the TEA algorithm.
1240
1241           Xtendend Encryption Tiny Algorithm is a mis-implementation
1242           of the XTEA algorithm for compatibility purposes.
1243
1244 config CRYPTO_TWOFISH
1245         tristate "Twofish cipher algorithm"
1246         select CRYPTO_ALGAPI
1247         select CRYPTO_TWOFISH_COMMON
1248         help
1249           Twofish cipher algorithm.
1250
1251           Twofish was submitted as an AES (Advanced Encryption Standard)
1252           candidate cipher by researchers at CounterPane Systems.  It is a
1253           16 round block cipher supporting key sizes of 128, 192, and 256
1254           bits.
1255
1256           See also:
1257           <http://www.schneier.com/twofish.html>
1258
1259 config CRYPTO_TWOFISH_COMMON
1260         tristate
1261         help
1262           Common parts of the Twofish cipher algorithm shared by the
1263           generic c and the assembler implementations.
1264
1265 config CRYPTO_TWOFISH_586
1266         tristate "Twofish cipher algorithms (i586)"
1267         depends on (X86 || UML_X86) && !64BIT
1268         select CRYPTO_ALGAPI
1269         select CRYPTO_TWOFISH_COMMON
1270         help
1271           Twofish cipher algorithm.
1272
1273           Twofish was submitted as an AES (Advanced Encryption Standard)
1274           candidate cipher by researchers at CounterPane Systems.  It is a
1275           16 round block cipher supporting key sizes of 128, 192, and 256
1276           bits.
1277
1278           See also:
1279           <http://www.schneier.com/twofish.html>
1280
1281 config CRYPTO_TWOFISH_X86_64
1282         tristate "Twofish cipher algorithm (x86_64)"
1283         depends on (X86 || UML_X86) && 64BIT
1284         select CRYPTO_ALGAPI
1285         select CRYPTO_TWOFISH_COMMON
1286         help
1287           Twofish cipher algorithm (x86_64).
1288
1289           Twofish was submitted as an AES (Advanced Encryption Standard)
1290           candidate cipher by researchers at CounterPane Systems.  It is a
1291           16 round block cipher supporting key sizes of 128, 192, and 256
1292           bits.
1293
1294           See also:
1295           <http://www.schneier.com/twofish.html>
1296
1297 config CRYPTO_TWOFISH_X86_64_3WAY
1298         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1299         depends on X86 && 64BIT
1300         select CRYPTO_ALGAPI
1301         select CRYPTO_TWOFISH_COMMON
1302         select CRYPTO_TWOFISH_X86_64
1303         select CRYPTO_GLUE_HELPER_X86
1304         select CRYPTO_LRW
1305         select CRYPTO_XTS
1306         help
1307           Twofish cipher algorithm (x86_64, 3-way parallel).
1308
1309           Twofish was submitted as an AES (Advanced Encryption Standard)
1310           candidate cipher by researchers at CounterPane Systems.  It is a
1311           16 round block cipher supporting key sizes of 128, 192, and 256
1312           bits.
1313
1314           This module provides Twofish cipher algorithm that processes three
1315           blocks parallel, utilizing resources of out-of-order CPUs better.
1316
1317           See also:
1318           <http://www.schneier.com/twofish.html>
1319
1320 config CRYPTO_TWOFISH_AVX_X86_64
1321         tristate "Twofish cipher algorithm (x86_64/AVX)"
1322         depends on X86 && 64BIT
1323         select CRYPTO_ALGAPI
1324         select CRYPTO_CRYPTD
1325         select CRYPTO_ABLK_HELPER_X86
1326         select CRYPTO_GLUE_HELPER_X86
1327         select CRYPTO_TWOFISH_COMMON
1328         select CRYPTO_TWOFISH_X86_64
1329         select CRYPTO_TWOFISH_X86_64_3WAY
1330         select CRYPTO_LRW
1331         select CRYPTO_XTS
1332         help
1333           Twofish cipher algorithm (x86_64/AVX).
1334
1335           Twofish was submitted as an AES (Advanced Encryption Standard)
1336           candidate cipher by researchers at CounterPane Systems.  It is a
1337           16 round block cipher supporting key sizes of 128, 192, and 256
1338           bits.
1339
1340           This module provides the Twofish cipher algorithm that processes
1341           eight blocks parallel using the AVX Instruction Set.
1342
1343           See also:
1344           <http://www.schneier.com/twofish.html>
1345
1346 config CRYPTO_TWOFISH_AVX2_X86_64
1347         tristate "Twofish cipher algorithm (x86_64/AVX2)"
1348         depends on X86 && 64BIT
1349         depends on BROKEN
1350         select CRYPTO_ALGAPI
1351         select CRYPTO_CRYPTD
1352         select CRYPTO_ABLK_HELPER_X86
1353         select CRYPTO_GLUE_HELPER_X86
1354         select CRYPTO_TWOFISH_COMMON
1355         select CRYPTO_TWOFISH_X86_64
1356         select CRYPTO_TWOFISH_X86_64_3WAY
1357         select CRYPTO_TWOFISH_AVX_X86_64
1358         select CRYPTO_LRW
1359         select CRYPTO_XTS
1360         help
1361           Twofish cipher algorithm (x86_64/AVX2).
1362
1363           Twofish was submitted as an AES (Advanced Encryption Standard)
1364           candidate cipher by researchers at CounterPane Systems.  It is a
1365           16 round block cipher supporting key sizes of 128, 192, and 256
1366           bits.
1367
1368           See also:
1369           <http://www.schneier.com/twofish.html>
1370
1371 comment "Compression"
1372
1373 config CRYPTO_DEFLATE
1374         tristate "Deflate compression algorithm"
1375         select CRYPTO_ALGAPI
1376         select ZLIB_INFLATE
1377         select ZLIB_DEFLATE
1378         help
1379           This is the Deflate algorithm (RFC1951), specified for use in
1380           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1381
1382           You will most probably want this if using IPSec.
1383
1384 config CRYPTO_ZLIB
1385         tristate "Zlib compression algorithm"
1386         select CRYPTO_PCOMP
1387         select ZLIB_INFLATE
1388         select ZLIB_DEFLATE
1389         select NLATTR
1390         help
1391           This is the zlib algorithm.
1392
1393 config CRYPTO_LZO
1394         tristate "LZO compression algorithm"
1395         select CRYPTO_ALGAPI
1396         select LZO_COMPRESS
1397         select LZO_DECOMPRESS
1398         help
1399           This is the LZO algorithm.
1400
1401 config CRYPTO_842
1402         tristate "842 compression algorithm"
1403         depends on CRYPTO_DEV_NX_COMPRESS
1404         # 842 uses lzo if the hardware becomes unavailable
1405         select LZO_COMPRESS
1406         select LZO_DECOMPRESS
1407         help
1408           This is the 842 algorithm.
1409
1410 comment "Random Number Generation"
1411
1412 config CRYPTO_ANSI_CPRNG
1413         tristate "Pseudo Random Number Generation for Cryptographic modules"
1414         default m
1415         select CRYPTO_AES
1416         select CRYPTO_RNG
1417         help
1418           This option enables the generic pseudo random number generator
1419           for cryptographic modules.  Uses the Algorithm specified in
1420           ANSI X9.31 A.2.4. Note that this option must be enabled if
1421           CRYPTO_FIPS is selected
1422
1423 config CRYPTO_USER_API
1424         tristate
1425
1426 config CRYPTO_USER_API_HASH
1427         tristate "User-space interface for hash algorithms"
1428         depends on NET
1429         select CRYPTO_HASH
1430         select CRYPTO_USER_API
1431         help
1432           This option enables the user-spaces interface for hash
1433           algorithms.
1434
1435 config CRYPTO_USER_API_SKCIPHER
1436         tristate "User-space interface for symmetric key cipher algorithms"
1437         depends on NET
1438         select CRYPTO_BLKCIPHER
1439         select CRYPTO_USER_API
1440         help
1441           This option enables the user-spaces interface for symmetric
1442           key cipher algorithms.
1443
1444 source "drivers/crypto/Kconfig"
1445 source crypto/asymmetric_keys/Kconfig
1446
1447 endif   # if CRYPTO