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         select CRYPTO_AES_ARM32_CE if (ARCH_MT6752)
 746         help
 747           Use optimized AES assembler routines for ARM platforms.
 748
 749           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 750           algorithm.
 751
 752           Rijndael appears to be consistently a very good performer in
 753           both hardware and software across a wide range of computing
 754           environments regardless of its use in feedback or non-feedback
 755           modes. Its key setup time is excellent, and its key agility is
 756           good. Rijndael's very low memory requirements make it very well
 757           suited for restricted-space environments, in which it also
 758           demonstrates excellent performance. Rijndael's operations are
 759           among the easiest to defend against power and timing attacks.
 760
 761           The AES specifies three key sizes: 128, 192 and 256 bits
 762
 763           See <http://csrc.nist.gov/encryption/aes/> for more information.
 764
 765 config CRYPTO_AES_ARM32_CE
 766         tristate "AES cipher using ARMv8 32bits Crypto Extensions"
 767         select CRYPTO_ABLK_HELPER
 768         help
 769           AES cipher using ARMv8 32bits Crypto Extensions (HW) to
 770           accelerate.
 771
 772 config CRYPTO_ANUBIS
 773         tristate "Anubis cipher algorithm"
 774         select CRYPTO_ALGAPI
 775         help
 776           Anubis cipher algorithm.
 777
 778           Anubis is a variable key length cipher which can use keys from
 779           128 bits to 320 bits in length.  It was evaluated as a entrant
 780           in the NESSIE competition.
 781
 782           See also:
 783           <https://www.cosic.esat.kuleuven.be/nessie/reports/>
 784           <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
 785
 786 config CRYPTO_ARC4
 787         tristate "ARC4 cipher algorithm"
 788         select CRYPTO_BLKCIPHER
 789         help
 790           ARC4 cipher algorithm.
 791
 792           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
 793           bits in length.  This algorithm is required for driver-based
 794           WEP, but it should not be for other purposes because of the
 795           weakness of the algorithm.
 796
 797 config CRYPTO_BLOWFISH
 798         tristate "Blowfish cipher algorithm"
 799         select CRYPTO_ALGAPI
 800         select CRYPTO_BLOWFISH_COMMON
 801         help
 802           Blowfish cipher algorithm, by Bruce Schneier.
 803
 804           This is a variable key length cipher which can use keys from 32
 805           bits to 448 bits in length.  It's fast, simple and specifically
 806           designed for use on "large microprocessors".
 807
 808           See also:
 809           <http://www.schneier.com/blowfish.html>
 810
 811 config CRYPTO_BLOWFISH_COMMON
 812         tristate
 813         help
 814           Common parts of the Blowfish cipher algorithm shared by the
 815           generic c and the assembler implementations.
 816
 817           See also:
 818           <http://www.schneier.com/blowfish.html>
 819
 820 config CRYPTO_BLOWFISH_X86_64
 821         tristate "Blowfish cipher algorithm (x86_64)"
 822         depends on X86 && 64BIT
 823         select CRYPTO_ALGAPI
 824         select CRYPTO_BLOWFISH_COMMON
 825         help
 826           Blowfish cipher algorithm (x86_64), by Bruce Schneier.
 827
 828           This is a variable key length cipher which can use keys from 32
 829           bits to 448 bits in length.  It's fast, simple and specifically
 830           designed for use on "large microprocessors".
 831
 832           See also:
 833           <http://www.schneier.com/blowfish.html>
 834
 835 config CRYPTO_BLOWFISH_AVX2_X86_64
 836         tristate "Blowfish cipher algorithm (x86_64/AVX2)"
 837         depends on X86 && 64BIT
 838         depends on BROKEN
 839         select CRYPTO_ALGAPI
 840         select CRYPTO_CRYPTD
 841         select CRYPTO_ABLK_HELPER_X86
 842         select CRYPTO_BLOWFISH_COMMON
 843         select CRYPTO_BLOWFISH_X86_64
 844         help
 845           Blowfish cipher algorithm (x86_64/AVX2), by Bruce Schneier.
 846
 847           This is a variable key length cipher which can use keys from 32
 848           bits to 448 bits in length.  It's fast, simple and specifically
 849           designed for use on "large microprocessors".
 850
 851           See also:
 852           <http://www.schneier.com/blowfish.html>
 853
 854 config CRYPTO_CAMELLIA
 855         tristate "Camellia cipher algorithms"
 856         depends on CRYPTO
 857         select CRYPTO_ALGAPI
 858         help
 859           Camellia cipher algorithms module.
 860
 861           Camellia is a symmetric key block cipher developed jointly
 862           at NTT and Mitsubishi Electric Corporation.
 863
 864           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 865
 866           See also:
 867           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 868
 869 config CRYPTO_CAMELLIA_X86_64
 870         tristate "Camellia cipher algorithm (x86_64)"
 871         depends on X86 && 64BIT
 872         depends on CRYPTO
 873         select CRYPTO_ALGAPI
 874         select CRYPTO_GLUE_HELPER_X86
 875         select CRYPTO_LRW
 876         select CRYPTO_XTS
 877         help
 878           Camellia cipher algorithm module (x86_64).
 879
 880           Camellia is a symmetric key block cipher developed jointly
 881           at NTT and Mitsubishi Electric Corporation.
 882
 883           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 884
 885           See also:
 886           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 887
 888 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
 889         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
 890         depends on X86 && 64BIT
 891         depends on CRYPTO
 892         select CRYPTO_ALGAPI
 893         select CRYPTO_CRYPTD
 894         select CRYPTO_ABLK_HELPER_X86
 895         select CRYPTO_GLUE_HELPER_X86
 896         select CRYPTO_CAMELLIA_X86_64
 897         select CRYPTO_LRW
 898         select CRYPTO_XTS
 899         help
 900           Camellia cipher algorithm module (x86_64/AES-NI/AVX).
 901
 902           Camellia is a symmetric key block cipher developed jointly
 903           at NTT and Mitsubishi Electric Corporation.
 904
 905           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 906
 907           See also:
 908           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 909
 910 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
 911         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
 912         depends on X86 && 64BIT
 913         depends on CRYPTO
 914         select CRYPTO_ALGAPI
 915         select CRYPTO_CRYPTD
 916         select CRYPTO_ABLK_HELPER_X86
 917         select CRYPTO_GLUE_HELPER_X86
 918         select CRYPTO_CAMELLIA_X86_64
 919         select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
 920         select CRYPTO_LRW
 921         select CRYPTO_XTS
 922         help
 923           Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
 924
 925           Camellia is a symmetric key block cipher developed jointly
 926           at NTT and Mitsubishi Electric Corporation.
 927
 928           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 929
 930           See also:
 931           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 932
 933 config CRYPTO_CAMELLIA_SPARC64
 934         tristate "Camellia cipher algorithm (SPARC64)"
 935         depends on SPARC64
 936         depends on CRYPTO
 937         select CRYPTO_ALGAPI
 938         help
 939           Camellia cipher algorithm module (SPARC64).
 940
 941           Camellia is a symmetric key block cipher developed jointly
 942           at NTT and Mitsubishi Electric Corporation.
 943
 944           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 945
 946           See also:
 947           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 948
 949 config CRYPTO_CAST_COMMON
 950         tristate
 951         help
 952           Common parts of the CAST cipher algorithms shared by the
 953           generic c and the assembler implementations.
 954
 955 config CRYPTO_CAST5
 956         tristate "CAST5 (CAST-128) cipher algorithm"
 957         select CRYPTO_ALGAPI
 958         select CRYPTO_CAST_COMMON
 959         help
 960           The CAST5 encryption algorithm (synonymous with CAST-128) is
 961           described in RFC2144.
 962
 963 config CRYPTO_CAST5_AVX_X86_64
 964         tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
 965         depends on X86 && 64BIT
 966         select CRYPTO_ALGAPI
 967         select CRYPTO_CRYPTD
 968         select CRYPTO_ABLK_HELPER_X86
 969         select CRYPTO_CAST_COMMON
 970         select CRYPTO_CAST5
 971         help
 972           The CAST5 encryption algorithm (synonymous with CAST-128) is
 973           described in RFC2144.
 974
 975           This module provides the Cast5 cipher algorithm that processes
 976           sixteen blocks parallel using the AVX instruction set.
 977
 978 config CRYPTO_CAST6
 979         tristate "CAST6 (CAST-256) cipher algorithm"
 980         select CRYPTO_ALGAPI
 981         select CRYPTO_CAST_COMMON
 982         help
 983           The CAST6 encryption algorithm (synonymous with CAST-256) is
 984           described in RFC2612.
 985
 986 config CRYPTO_CAST6_AVX_X86_64
 987         tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
 988         depends on X86 && 64BIT
 989         select CRYPTO_ALGAPI
 990         select CRYPTO_CRYPTD
 991         select CRYPTO_ABLK_HELPER_X86
 992         select CRYPTO_GLUE_HELPER_X86
 993         select CRYPTO_CAST_COMMON
 994         select CRYPTO_CAST6
 995         select CRYPTO_LRW
 996         select CRYPTO_XTS
 997         help
 998           The CAST6 encryption algorithm (synonymous with CAST-256) is
 999           described in RFC2612.
1000
1001           This module provides the Cast6 cipher algorithm that processes
1002           eight blocks parallel using the AVX instruction set.
1003
1004 config CRYPTO_DES
1005         tristate "DES and Triple DES EDE cipher algorithms"
1006         select CRYPTO_ALGAPI
1007         help
1008           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1009
1010 config CRYPTO_DES_SPARC64
1011         tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1012         depends on SPARC64
1013         select CRYPTO_ALGAPI
1014         select CRYPTO_DES
1015         help
1016           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1017           optimized using SPARC64 crypto opcodes.
1018
1019 config CRYPTO_FCRYPT
1020         tristate "FCrypt cipher algorithm"
1021         select CRYPTO_ALGAPI
1022         select CRYPTO_BLKCIPHER
1023         help
1024           FCrypt algorithm used by RxRPC.
1025
1026 config CRYPTO_KHAZAD
1027         tristate "Khazad cipher algorithm"
1028         select CRYPTO_ALGAPI
1029         help
1030           Khazad cipher algorithm.
1031
1032           Khazad was a finalist in the initial NESSIE competition.  It is
1033           an algorithm optimized for 64-bit processors with good performance
1034           on 32-bit processors.  Khazad uses an 128 bit key size.
1035
1036           See also:
1037           <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1038
1039 config CRYPTO_SALSA20
1040         tristate "Salsa20 stream cipher algorithm"
1041         select CRYPTO_BLKCIPHER
1042         help
1043           Salsa20 stream cipher algorithm.
1044
1045           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1046           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1047
1048           The Salsa20 stream cipher algorithm is designed by Daniel J.
1049           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1050
1051 config CRYPTO_SALSA20_586
1052         tristate "Salsa20 stream cipher algorithm (i586)"
1053         depends on (X86 || UML_X86) && !64BIT
1054         select CRYPTO_BLKCIPHER
1055         help
1056           Salsa20 stream cipher algorithm.
1057
1058           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1059           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1060
1061           The Salsa20 stream cipher algorithm is designed by Daniel J.
1062           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1063
1064 config CRYPTO_SALSA20_X86_64
1065         tristate "Salsa20 stream cipher algorithm (x86_64)"
1066         depends on (X86 || UML_X86) && 64BIT
1067         select CRYPTO_BLKCIPHER
1068         help
1069           Salsa20 stream cipher algorithm.
1070
1071           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1072           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1073
1074           The Salsa20 stream cipher algorithm is designed by Daniel J.
1075           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1076
1077 config CRYPTO_SEED
1078         tristate "SEED cipher algorithm"
1079         select CRYPTO_ALGAPI
1080         help
1081           SEED cipher algorithm (RFC4269).
1082
1083           SEED is a 128-bit symmetric key block cipher that has been
1084           developed by KISA (Korea Information Security Agency) as a
1085           national standard encryption algorithm of the Republic of Korea.
1086           It is a 16 round block cipher with the key size of 128 bit.
1087
1088           See also:
1089           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1090
1091 config CRYPTO_SERPENT
1092         tristate "Serpent cipher algorithm"
1093         select CRYPTO_ALGAPI
1094         help
1095           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1096
1097           Keys are allowed to be from 0 to 256 bits in length, in steps
1098           of 8 bits.  Also includes the 'Tnepres' algorithm, a reversed
1099           variant of Serpent for compatibility with old kerneli.org code.
1100
1101           See also:
1102           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1103
1104 config CRYPTO_SERPENT_SSE2_X86_64
1105         tristate "Serpent cipher algorithm (x86_64/SSE2)"
1106         depends on X86 && 64BIT
1107         select CRYPTO_ALGAPI
1108         select CRYPTO_CRYPTD
1109         select CRYPTO_ABLK_HELPER_X86
1110         select CRYPTO_GLUE_HELPER_X86
1111         select CRYPTO_SERPENT
1112         select CRYPTO_LRW
1113         select CRYPTO_XTS
1114         help
1115           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1116
1117           Keys are allowed to be from 0 to 256 bits in length, in steps
1118           of 8 bits.
1119
1120           This module provides Serpent cipher algorithm that processes eigth
1121           blocks parallel using SSE2 instruction set.
1122
1123           See also:
1124           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1125
1126 config CRYPTO_SERPENT_SSE2_586
1127         tristate "Serpent cipher algorithm (i586/SSE2)"
1128         depends on X86 && !64BIT
1129         select CRYPTO_ALGAPI
1130         select CRYPTO_CRYPTD
1131         select CRYPTO_ABLK_HELPER_X86
1132         select CRYPTO_GLUE_HELPER_X86
1133         select CRYPTO_SERPENT
1134         select CRYPTO_LRW
1135         select CRYPTO_XTS
1136         help
1137           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1138
1139           Keys are allowed to be from 0 to 256 bits in length, in steps
1140           of 8 bits.
1141
1142           This module provides Serpent cipher algorithm that processes four
1143           blocks parallel using SSE2 instruction set.
1144
1145           See also:
1146           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1147
1148 config CRYPTO_SERPENT_AVX_X86_64
1149         tristate "Serpent cipher algorithm (x86_64/AVX)"
1150         depends on X86 && 64BIT
1151         select CRYPTO_ALGAPI
1152         select CRYPTO_CRYPTD
1153         select CRYPTO_ABLK_HELPER_X86
1154         select CRYPTO_GLUE_HELPER_X86
1155         select CRYPTO_SERPENT
1156         select CRYPTO_LRW
1157         select CRYPTO_XTS
1158         help
1159           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1160
1161           Keys are allowed to be from 0 to 256 bits in length, in steps
1162           of 8 bits.
1163
1164           This module provides the Serpent cipher algorithm that processes
1165           eight blocks parallel using the AVX instruction set.
1166
1167           See also:
1168           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1169
1170 config CRYPTO_SERPENT_AVX2_X86_64
1171         tristate "Serpent cipher algorithm (x86_64/AVX2)"
1172         depends on X86 && 64BIT
1173         select CRYPTO_ALGAPI
1174         select CRYPTO_CRYPTD
1175         select CRYPTO_ABLK_HELPER_X86
1176         select CRYPTO_GLUE_HELPER_X86
1177         select CRYPTO_SERPENT
1178         select CRYPTO_SERPENT_AVX_X86_64
1179         select CRYPTO_LRW
1180         select CRYPTO_XTS
1181         help
1182           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1183
1184           Keys are allowed to be from 0 to 256 bits in length, in steps
1185           of 8 bits.
1186
1187           This module provides Serpent cipher algorithm that processes 16
1188           blocks parallel using AVX2 instruction set.
1189
1190           See also:
1191           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1192
1193 config CRYPTO_TEA
1194         tristate "TEA, XTEA and XETA cipher algorithms"
1195         select CRYPTO_ALGAPI
1196         help
1197           TEA cipher algorithm.
1198
1199           Tiny Encryption Algorithm is a simple cipher that uses
1200           many rounds for security.  It is very fast and uses
1201           little memory.
1202
1203           Xtendend Tiny Encryption Algorithm is a modification to
1204           the TEA algorithm to address a potential key weakness
1205           in the TEA algorithm.
1206
1207           Xtendend Encryption Tiny Algorithm is a mis-implementation
1208           of the XTEA algorithm for compatibility purposes.
1209
1210 config CRYPTO_TWOFISH
1211         tristate "Twofish cipher algorithm"
1212         select CRYPTO_ALGAPI
1213         select CRYPTO_TWOFISH_COMMON
1214         help
1215           Twofish cipher algorithm.
1216
1217           Twofish was submitted as an AES (Advanced Encryption Standard)
1218           candidate cipher by researchers at CounterPane Systems.  It is a
1219           16 round block cipher supporting key sizes of 128, 192, and 256
1220           bits.
1221
1222           See also:
1223           <http://www.schneier.com/twofish.html>
1224
1225 config CRYPTO_TWOFISH_COMMON
1226         tristate
1227         help
1228           Common parts of the Twofish cipher algorithm shared by the
1229           generic c and the assembler implementations.
1230
1231 config CRYPTO_TWOFISH_586
1232         tristate "Twofish cipher algorithms (i586)"
1233         depends on (X86 || UML_X86) && !64BIT
1234         select CRYPTO_ALGAPI
1235         select CRYPTO_TWOFISH_COMMON
1236         help
1237           Twofish cipher algorithm.
1238
1239           Twofish was submitted as an AES (Advanced Encryption Standard)
1240           candidate cipher by researchers at CounterPane Systems.  It is a
1241           16 round block cipher supporting key sizes of 128, 192, and 256
1242           bits.
1243
1244           See also:
1245           <http://www.schneier.com/twofish.html>
1246
1247 config CRYPTO_TWOFISH_X86_64
1248         tristate "Twofish cipher algorithm (x86_64)"
1249         depends on (X86 || UML_X86) && 64BIT
1250         select CRYPTO_ALGAPI
1251         select CRYPTO_TWOFISH_COMMON
1252         help
1253           Twofish cipher algorithm (x86_64).
1254
1255           Twofish was submitted as an AES (Advanced Encryption Standard)
1256           candidate cipher by researchers at CounterPane Systems.  It is a
1257           16 round block cipher supporting key sizes of 128, 192, and 256
1258           bits.
1259
1260           See also:
1261           <http://www.schneier.com/twofish.html>
1262
1263 config CRYPTO_TWOFISH_X86_64_3WAY
1264         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1265         depends on X86 && 64BIT
1266         select CRYPTO_ALGAPI
1267         select CRYPTO_TWOFISH_COMMON
1268         select CRYPTO_TWOFISH_X86_64
1269         select CRYPTO_GLUE_HELPER_X86
1270         select CRYPTO_LRW
1271         select CRYPTO_XTS
1272         help
1273           Twofish cipher algorithm (x86_64, 3-way parallel).
1274
1275           Twofish was submitted as an AES (Advanced Encryption Standard)
1276           candidate cipher by researchers at CounterPane Systems.  It is a
1277           16 round block cipher supporting key sizes of 128, 192, and 256
1278           bits.
1279
1280           This module provides Twofish cipher algorithm that processes three
1281           blocks parallel, utilizing resources of out-of-order CPUs better.
1282
1283           See also:
1284           <http://www.schneier.com/twofish.html>
1285
1286 config CRYPTO_TWOFISH_AVX_X86_64
1287         tristate "Twofish cipher algorithm (x86_64/AVX)"
1288         depends on X86 && 64BIT
1289         select CRYPTO_ALGAPI
1290         select CRYPTO_CRYPTD
1291         select CRYPTO_ABLK_HELPER_X86
1292         select CRYPTO_GLUE_HELPER_X86
1293         select CRYPTO_TWOFISH_COMMON
1294         select CRYPTO_TWOFISH_X86_64
1295         select CRYPTO_TWOFISH_X86_64_3WAY
1296         select CRYPTO_LRW
1297         select CRYPTO_XTS
1298         help
1299           Twofish cipher algorithm (x86_64/AVX).
1300
1301           Twofish was submitted as an AES (Advanced Encryption Standard)
1302           candidate cipher by researchers at CounterPane Systems.  It is a
1303           16 round block cipher supporting key sizes of 128, 192, and 256
1304           bits.
1305
1306           This module provides the Twofish cipher algorithm that processes
1307           eight blocks parallel using the AVX Instruction Set.
1308
1309           See also:
1310           <http://www.schneier.com/twofish.html>
1311
1312 config CRYPTO_TWOFISH_AVX2_X86_64
1313         tristate "Twofish cipher algorithm (x86_64/AVX2)"
1314         depends on X86 && 64BIT
1315         depends on BROKEN
1316         select CRYPTO_ALGAPI
1317         select CRYPTO_CRYPTD
1318         select CRYPTO_ABLK_HELPER_X86
1319         select CRYPTO_GLUE_HELPER_X86
1320         select CRYPTO_TWOFISH_COMMON
1321         select CRYPTO_TWOFISH_X86_64
1322         select CRYPTO_TWOFISH_X86_64_3WAY
1323         select CRYPTO_TWOFISH_AVX_X86_64
1324         select CRYPTO_LRW
1325         select CRYPTO_XTS
1326         help
1327           Twofish cipher algorithm (x86_64/AVX2).
1328
1329           Twofish was submitted as an AES (Advanced Encryption Standard)
1330           candidate cipher by researchers at CounterPane Systems.  It is a
1331           16 round block cipher supporting key sizes of 128, 192, and 256
1332           bits.
1333
1334           See also:
1335           <http://www.schneier.com/twofish.html>
1336
1337 comment "Compression"
1338
1339 config CRYPTO_DEFLATE
1340         tristate "Deflate compression algorithm"
1341         select CRYPTO_ALGAPI
1342         select ZLIB_INFLATE
1343         select ZLIB_DEFLATE
1344         help
1345           This is the Deflate algorithm (RFC1951), specified for use in
1346           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1347
1348           You will most probably want this if using IPSec.
1349
1350 config CRYPTO_ZLIB
1351         tristate "Zlib compression algorithm"
1352         select CRYPTO_PCOMP
1353         select ZLIB_INFLATE
1354         select ZLIB_DEFLATE
1355         select NLATTR
1356         help
1357           This is the zlib algorithm.
1358
1359 config CRYPTO_LZO
1360         tristate "LZO compression algorithm"
1361         select CRYPTO_ALGAPI
1362         select LZO_COMPRESS
1363         select LZO_DECOMPRESS
1364         help
1365           This is the LZO algorithm.
1366
1367 config CRYPTO_LZ4K
1368         tristate "LZ4K compression algorithm"
1369         select CRYPTO_ALGAPI
1370         help
1371           This is the LZ4K algorithm.
1372
1373 config CRYPTO_842
1374         tristate "842 compression algorithm"
1375         depends on CRYPTO_DEV_NX_COMPRESS
1376         # 842 uses lzo if the hardware becomes unavailable
1377         select LZO_COMPRESS
1378         select LZO_DECOMPRESS
1379         help
1380           This is the 842 algorithm.
1381
1382 comment "Random Number Generation"
1383
1384 config CRYPTO_ANSI_CPRNG
1385         tristate "Pseudo Random Number Generation for Cryptographic modules"
1386         default m
1387         select CRYPTO_AES
1388         select CRYPTO_RNG
1389         help
1390           This option enables the generic pseudo random number generator
1391           for cryptographic modules.  Uses the Algorithm specified in
1392           ANSI X9.31 A.2.4. Note that this option must be enabled if
1393           CRYPTO_FIPS is selected
1394
1395 config CRYPTO_USER_API
1396         tristate
1397
1398 config CRYPTO_USER_API_HASH
1399         tristate "User-space interface for hash algorithms"
1400         depends on NET
1401         select CRYPTO_HASH
1402         select CRYPTO_USER_API
1403         help
1404           This option enables the user-spaces interface for hash
1405           algorithms.
1406
1407 config CRYPTO_USER_API_SKCIPHER
1408         tristate "User-space interface for symmetric key cipher algorithms"
1409         depends on NET
1410         select CRYPTO_BLKCIPHER
1411         select CRYPTO_USER_API
1412         help
1413           This option enables the user-spaces interface for symmetric
1414           key cipher algorithms.
1415
1416 source "drivers/crypto/Kconfig"
1417 source crypto/asymmetric_keys/Kconfig
1418
1419 endif   # if CRYPTO