crypto/Kconfig

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