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