SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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         help
  27           This options enables the fips boot option which is
  28           required if you want to system to operate in a FIPS 200
  29           certification.  You should say no unless you know what
  30           this is.
  31
  32 config CRYPTO_ALGAPI
  33         tristate
  34         select CRYPTO_ALGAPI2
  35         help
  36           This option provides the API for cryptographic algorithms.
  37
  38 config CRYPTO_ALGAPI2
  39         tristate
  40
  41 config CRYPTO_AEAD
  42         tristate
  43         select CRYPTO_AEAD2
  44         select CRYPTO_ALGAPI
  45
  46 config CRYPTO_AEAD2
  47         tristate
  48         select CRYPTO_ALGAPI2
  49
  50 config CRYPTO_BLKCIPHER
  51         tristate
  52         select CRYPTO_BLKCIPHER2
  53         select CRYPTO_ALGAPI
  54
  55 config CRYPTO_BLKCIPHER2
  56         tristate
  57         select CRYPTO_ALGAPI2
  58         select CRYPTO_RNG2
  59         select CRYPTO_WORKQUEUE
  60
  61 config CRYPTO_HASH
  62         tristate
  63         select CRYPTO_HASH2
  64         select CRYPTO_ALGAPI
  65
  66 config CRYPTO_HASH2
  67         tristate
  68         select CRYPTO_ALGAPI2
  69
  70 config CRYPTO_RNG
  71         tristate
  72         select CRYPTO_RNG2
  73         select CRYPTO_ALGAPI
  74
  75 config CRYPTO_RNG2
  76         tristate
  77         select CRYPTO_ALGAPI2
  78
  79 config CRYPTO_PCOMP
  80         tristate
  81         select CRYPTO_ALGAPI2
  82
  83 config CRYPTO_MANAGER
  84         tristate "Cryptographic algorithm manager"
  85         select CRYPTO_MANAGER2
  86         help
  87           Create default cryptographic template instantiations such as
  88           cbc(aes).
  89
  90 config CRYPTO_MANAGER2
  91         def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
  92         select CRYPTO_AEAD2
  93         select CRYPTO_HASH2
  94         select CRYPTO_BLKCIPHER2
  95         select CRYPTO_PCOMP
  96
  97 config CRYPTO_GF128MUL
  98         tristate "GF(2^128) multiplication functions (EXPERIMENTAL)"
  99         depends on EXPERIMENTAL
 100         help
 101           Efficient table driven implementation of multiplications in the
 102           field GF(2^128).  This is needed by some cypher modes. This
 103           option will be selected automatically if you select such a
 104           cipher mode.  Only select this option by hand if you expect to load
 105           an external module that requires these functions.
 106
 107 config CRYPTO_NULL
 108         tristate "Null algorithms"
 109         select CRYPTO_ALGAPI
 110         select CRYPTO_BLKCIPHER
 111         select CRYPTO_HASH
 112         help
 113           These are 'Null' algorithms, used by IPsec, which do nothing.
 114
 115 config CRYPTO_WORKQUEUE
 116        tristate
 117
 118 config CRYPTO_CRYPTD
 119         tristate "Software async crypto daemon"
 120         select CRYPTO_BLKCIPHER
 121         select CRYPTO_HASH
 122         select CRYPTO_MANAGER
 123         select CRYPTO_WORKQUEUE
 124         help
 125           This is a generic software asynchronous crypto daemon that
 126           converts an arbitrary synchronous software crypto algorithm
 127           into an asynchronous algorithm that executes in a kernel thread.
 128
 129 config CRYPTO_AUTHENC
 130         tristate "Authenc support"
 131         select CRYPTO_AEAD
 132         select CRYPTO_BLKCIPHER
 133         select CRYPTO_MANAGER
 134         select CRYPTO_HASH
 135         help
 136           Authenc: Combined mode wrapper for IPsec.
 137           This is required for IPSec.
 138
 139 config CRYPTO_TEST
 140         tristate "Testing module"
 141         depends on m
 142         select CRYPTO_MANAGER
 143         help
 144           Quick & dirty crypto test module.
 145
 146 comment "Authenticated Encryption with Associated Data"
 147
 148 config CRYPTO_CCM
 149         tristate "CCM support"
 150         select CRYPTO_CTR
 151         select CRYPTO_AEAD
 152         help
 153           Support for Counter with CBC MAC. Required for IPsec.
 154
 155 config CRYPTO_GCM
 156         tristate "GCM/GMAC support"
 157         select CRYPTO_CTR
 158         select CRYPTO_AEAD
 159         select CRYPTO_GHASH
 160         help
 161           Support for Galois/Counter Mode (GCM) and Galois Message
 162           Authentication Code (GMAC). Required for IPSec.
 163
 164 config CRYPTO_SEQIV
 165         tristate "Sequence Number IV Generator"
 166         select CRYPTO_AEAD
 167         select CRYPTO_BLKCIPHER
 168         select CRYPTO_RNG
 169         help
 170           This IV generator generates an IV based on a sequence number by
 171           xoring it with a salt.  This algorithm is mainly useful for CTR
 172
 173 comment "Block modes"
 174
 175 config CRYPTO_CBC
 176         tristate "CBC support"
 177         select CRYPTO_BLKCIPHER
 178         select CRYPTO_MANAGER
 179         help
 180           CBC: Cipher Block Chaining mode
 181           This block cipher algorithm is required for IPSec.
 182
 183 config CRYPTO_CTR
 184         tristate "CTR support"
 185         select CRYPTO_BLKCIPHER
 186         select CRYPTO_SEQIV
 187         select CRYPTO_MANAGER
 188         help
 189           CTR: Counter mode
 190           This block cipher algorithm is required for IPSec.
 191
 192 config CRYPTO_CTS
 193         tristate "CTS support"
 194         select CRYPTO_BLKCIPHER
 195         help
 196           CTS: Cipher Text Stealing
 197           This is the Cipher Text Stealing mode as described by
 198           Section 8 of rfc2040 and referenced by rfc3962.
 199           (rfc3962 includes errata information in its Appendix A)
 200           This mode is required for Kerberos gss mechanism support
 201           for AES encryption.
 202
 203 config CRYPTO_ECB
 204         tristate "ECB support"
 205         select CRYPTO_BLKCIPHER
 206         select CRYPTO_MANAGER
 207         help
 208           ECB: Electronic CodeBook mode
 209           This is the simplest block cipher algorithm.  It simply encrypts
 210           the input block by block.
 211
 212 config CRYPTO_LRW
 213         tristate "LRW support (EXPERIMENTAL)"
 214         depends on EXPERIMENTAL
 215         select CRYPTO_BLKCIPHER
 216         select CRYPTO_MANAGER
 217         select CRYPTO_GF128MUL
 218         help
 219           LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
 220           narrow block cipher mode for dm-crypt.  Use it with cipher
 221           specification string aes-lrw-benbi, the key must be 256, 320 or 384.
 222           The first 128, 192 or 256 bits in the key are used for AES and the
 223           rest is used to tie each cipher block to its logical position.
 224
 225 config CRYPTO_PCBC
 226         tristate "PCBC support"
 227         select CRYPTO_BLKCIPHER
 228         select CRYPTO_MANAGER
 229         help
 230           PCBC: Propagating Cipher Block Chaining mode
 231           This block cipher algorithm is required for RxRPC.
 232
 233 config CRYPTO_XTS
 234         tristate "XTS support (EXPERIMENTAL)"
 235         depends on EXPERIMENTAL
 236         select CRYPTO_BLKCIPHER
 237         select CRYPTO_MANAGER
 238         select CRYPTO_GF128MUL
 239         help
 240           XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
 241           key size 256, 384 or 512 bits. This implementation currently
 242           can't handle a sectorsize which is not a multiple of 16 bytes.
 243
 244 config CRYPTO_FPU
 245         tristate
 246         select CRYPTO_BLKCIPHER
 247         select CRYPTO_MANAGER
 248
 249 comment "Hash modes"
 250
 251 config CRYPTO_HMAC
 252         tristate "HMAC support"
 253         select CRYPTO_HASH
 254         select CRYPTO_MANAGER
 255         help
 256           HMAC: Keyed-Hashing for Message Authentication (RFC2104).
 257           This is required for IPSec.
 258
 259 config CRYPTO_XCBC
 260         tristate "XCBC support"
 261         depends on EXPERIMENTAL
 262         select CRYPTO_HASH
 263         select CRYPTO_MANAGER
 264         help
 265           XCBC: Keyed-Hashing with encryption algorithm
 266                 http://www.ietf.org/rfc/rfc3566.txt
 267                 http://csrc.nist.gov/encryption/modes/proposedmodes/
 268                  xcbc-mac/xcbc-mac-spec.pdf
 269
 270 comment "Digest"
 271
 272 config CRYPTO_CRC32C
 273         tristate "CRC32c CRC algorithm"
 274         select CRYPTO_HASH
 275         help
 276           Castagnoli, et al Cyclic Redundancy-Check Algorithm.  Used
 277           by iSCSI for header and data digests and by others.
 278           See Castagnoli93.  Module will be crc32c.
 279
 280 config CRYPTO_CRC32C_INTEL
 281         tristate "CRC32c INTEL hardware acceleration"
 282         depends on X86
 283         select CRYPTO_HASH
 284         help
 285           In Intel processor with SSE4.2 supported, the processor will
 286           support CRC32C implementation using hardware accelerated CRC32
 287           instruction. This option will create 'crc32c-intel' module,
 288           which will enable any routine to use the CRC32 instruction to
 289           gain performance compared with software implementation.
 290           Module will be crc32c-intel.
 291
 292 config CRYPTO_GHASH
 293         tristate "GHASH digest algorithm"
 294         select CRYPTO_SHASH
 295         select CRYPTO_GF128MUL
 296         help
 297           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
 298
 299 config CRYPTO_MD4
 300         tristate "MD4 digest algorithm"
 301         select CRYPTO_HASH
 302         help
 303           MD4 message digest algorithm (RFC1320).
 304
 305 config CRYPTO_MD5
 306         tristate "MD5 digest algorithm"
 307         select CRYPTO_HASH
 308         help
 309           MD5 message digest algorithm (RFC1321).
 310
 311 config CRYPTO_MICHAEL_MIC
 312         tristate "Michael MIC keyed digest algorithm"
 313         select CRYPTO_HASH
 314         help
 315           Michael MIC is used for message integrity protection in TKIP
 316           (IEEE 802.11i). This algorithm is required for TKIP, but it
 317           should not be used for other purposes because of the weakness
 318           of the algorithm.
 319
 320 config CRYPTO_RMD128
 321         tristate "RIPEMD-128 digest algorithm"
 322         select CRYPTO_HASH
 323         help
 324           RIPEMD-128 (ISO/IEC 10118-3:2004).
 325
 326           RIPEMD-128 is a 128-bit cryptographic hash function. It should only
 327           to be used as a secure replacement for RIPEMD. For other use cases
 328           RIPEMD-160 should be used.
 329
 330           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 331           See <http://home.esat.kuleuven.be/~bosselae/ripemd160.html>
 332
 333 config CRYPTO_RMD160
 334         tristate "RIPEMD-160 digest algorithm"
 335         select CRYPTO_HASH
 336         help
 337           RIPEMD-160 (ISO/IEC 10118-3:2004).
 338
 339           RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
 340           to be used as a secure replacement for the 128-bit hash functions
 341           MD4, MD5 and it's predecessor RIPEMD
 342           (not to be confused with RIPEMD-128).
 343
 344           It's speed is comparable to SHA1 and there are no known attacks
 345           against RIPEMD-160.
 346
 347           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 348           See <http://home.esat.kuleuven.be/~bosselae/ripemd160.html>
 349
 350 config CRYPTO_RMD256
 351         tristate "RIPEMD-256 digest algorithm"
 352         select CRYPTO_HASH
 353         help
 354           RIPEMD-256 is an optional extension of RIPEMD-128 with a
 355           256 bit hash. It is intended for applications that require
 356           longer hash-results, without needing a larger security level
 357           (than RIPEMD-128).
 358
 359           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 360           See <http://home.esat.kuleuven.be/~bosselae/ripemd160.html>
 361
 362 config CRYPTO_RMD320
 363         tristate "RIPEMD-320 digest algorithm"
 364         select CRYPTO_HASH
 365         help
 366           RIPEMD-320 is an optional extension of RIPEMD-160 with a
 367           320 bit hash. It is intended for applications that require
 368           longer hash-results, without needing a larger security level
 369           (than RIPEMD-160).
 370
 371           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 372           See <http://home.esat.kuleuven.be/~bosselae/ripemd160.html>
 373
 374 config CRYPTO_SHA1
 375         tristate "SHA1 digest algorithm"
 376         select CRYPTO_HASH
 377         help
 378           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 379
 380 config CRYPTO_SHA256
 381         tristate "SHA224 and SHA256 digest algorithm"
 382         select CRYPTO_HASH
 383         help
 384           SHA256 secure hash standard (DFIPS 180-2).
 385
 386           This version of SHA implements a 256 bit hash with 128 bits of
 387           security against collision attacks.
 388
 389           This code also includes SHA-224, a 224 bit hash with 112 bits
 390           of security against collision attacks.
 391
 392 config CRYPTO_SHA512
 393         tristate "SHA384 and SHA512 digest algorithms"
 394         select CRYPTO_HASH
 395         help
 396           SHA512 secure hash standard (DFIPS 180-2).
 397
 398           This version of SHA implements a 512 bit hash with 256 bits of
 399           security against collision attacks.
 400
 401           This code also includes SHA-384, a 384 bit hash with 192 bits
 402           of security against collision attacks.
 403
 404 config CRYPTO_TGR192
 405         tristate "Tiger digest algorithms"
 406         select CRYPTO_HASH
 407         help
 408           Tiger hash algorithm 192, 160 and 128-bit hashes
 409
 410           Tiger is a hash function optimized for 64-bit processors while
 411           still having decent performance on 32-bit processors.
 412           Tiger was developed by Ross Anderson and Eli Biham.
 413
 414           See also:
 415           <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
 416
 417 config CRYPTO_WP512
 418         tristate "Whirlpool digest algorithms"
 419         select CRYPTO_HASH
 420         help
 421           Whirlpool hash algorithm 512, 384 and 256-bit hashes
 422
 423           Whirlpool-512 is part of the NESSIE cryptographic primitives.
 424           Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
 425
 426           See also:
 427           <http://planeta.terra.com.br/informatica/paulobarreto/WhirlpoolPage.html>
 428
 429 comment "Ciphers"
 430
 431 config CRYPTO_AES
 432         tristate "AES cipher algorithms"
 433         select CRYPTO_ALGAPI
 434         help
 435           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 436           algorithm.
 437
 438           Rijndael appears to be consistently a very good performer in
 439           both hardware and software across a wide range of computing
 440           environments regardless of its use in feedback or non-feedback
 441           modes. Its key setup time is excellent, and its key agility is
 442           good. Rijndael's very low memory requirements make it very well
 443           suited for restricted-space environments, in which it also
 444           demonstrates excellent performance. Rijndael's operations are
 445           among the easiest to defend against power and timing attacks.
 446
 447           The AES specifies three key sizes: 128, 192 and 256 bits
 448
 449           See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
 450
 451 config CRYPTO_AES_586
 452         tristate "AES cipher algorithms (i586)"
 453         depends on (X86 || UML_X86) && !64BIT
 454         select CRYPTO_ALGAPI
 455         select CRYPTO_AES
 456         help
 457           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 458           algorithm.
 459
 460           Rijndael appears to be consistently a very good performer in
 461           both hardware and software across a wide range of computing
 462           environments regardless of its use in feedback or non-feedback
 463           modes. Its key setup time is excellent, and its key agility is
 464           good. Rijndael's very low memory requirements make it very well
 465           suited for restricted-space environments, in which it also
 466           demonstrates excellent performance. Rijndael's operations are
 467           among the easiest to defend against power and timing attacks.
 468
 469           The AES specifies three key sizes: 128, 192 and 256 bits
 470
 471           See <http://csrc.nist.gov/encryption/aes/> for more information.
 472
 473 config CRYPTO_AES_X86_64
 474         tristate "AES cipher algorithms (x86_64)"
 475         depends on (X86 || UML_X86) && 64BIT
 476         select CRYPTO_ALGAPI
 477         select CRYPTO_AES
 478         help
 479           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 480           algorithm.
 481
 482           Rijndael appears to be consistently a very good performer in
 483           both hardware and software across a wide range of computing
 484           environments regardless of its use in feedback or non-feedback
 485           modes. Its key setup time is excellent, and its key agility is
 486           good. Rijndael's very low memory requirements make it very well
 487           suited for restricted-space environments, in which it also
 488           demonstrates excellent performance. Rijndael's operations are
 489           among the easiest to defend against power and timing attacks.
 490
 491           The AES specifies three key sizes: 128, 192 and 256 bits
 492
 493           See <http://csrc.nist.gov/encryption/aes/> for more information.
 494
 495 config CRYPTO_AES_NI_INTEL
 496         tristate "AES cipher algorithms (AES-NI)"
 497         depends on (X86 || UML_X86) && 64BIT
 498         select CRYPTO_AES_X86_64
 499         select CRYPTO_CRYPTD
 500         select CRYPTO_ALGAPI
 501         select CRYPTO_FPU
 502         help
 503           Use Intel AES-NI instructions for AES algorithm.
 504
 505           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 506           algorithm.
 507
 508           Rijndael appears to be consistently a very good performer in
 509           both hardware and software across a wide range of computing
 510           environments regardless of its use in feedback or non-feedback
 511           modes. Its key setup time is excellent, and its key agility is
 512           good. Rijndael's very low memory requirements make it very well
 513           suited for restricted-space environments, in which it also
 514           demonstrates excellent performance. Rijndael's operations are
 515           among the easiest to defend against power and timing attacks.
 516
 517           The AES specifies three key sizes: 128, 192 and 256 bits
 518
 519           See <http://csrc.nist.gov/encryption/aes/> for more information.
 520
 521           In addition to AES cipher algorithm support, the
 522           acceleration for some popular block cipher mode is supported
 523           too, including ECB, CBC, CTR, LRW, PCBC, XTS.
 524
 525 config CRYPTO_ANUBIS
 526         tristate "Anubis cipher algorithm"
 527         select CRYPTO_ALGAPI
 528         help
 529           Anubis cipher algorithm.
 530
 531           Anubis is a variable key length cipher which can use keys from
 532           128 bits to 320 bits in length.  It was evaluated as a entrant
 533           in the NESSIE competition.
 534
 535           See also:
 536           <https://www.cosic.esat.kuleuven.ac.be/nessie/reports/>
 537           <http://planeta.terra.com.br/informatica/paulobarreto/AnubisPage.html>
 538
 539 config CRYPTO_ARC4
 540         tristate "ARC4 cipher algorithm"
 541         select CRYPTO_ALGAPI
 542         help
 543           ARC4 cipher algorithm.
 544
 545           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
 546           bits in length.  This algorithm is required for driver-based
 547           WEP, but it should not be for other purposes because of the
 548           weakness of the algorithm.
 549
 550 config CRYPTO_BLOWFISH
 551         tristate "Blowfish cipher algorithm"
 552         select CRYPTO_ALGAPI
 553         help
 554           Blowfish cipher algorithm, by Bruce Schneier.
 555
 556           This is a variable key length cipher which can use keys from 32
 557           bits to 448 bits in length.  It's fast, simple and specifically
 558           designed for use on "large microprocessors".
 559
 560           See also:
 561           <http://www.schneier.com/blowfish.html>
 562
 563 config CRYPTO_CAMELLIA
 564         tristate "Camellia cipher algorithms"
 565         depends on CRYPTO
 566         select CRYPTO_ALGAPI
 567         help
 568           Camellia cipher algorithms module.
 569
 570           Camellia is a symmetric key block cipher developed jointly
 571           at NTT and Mitsubishi Electric Corporation.
 572
 573           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 574
 575           See also:
 576           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 577
 578 config CRYPTO_CAST5
 579         tristate "CAST5 (CAST-128) cipher algorithm"
 580         select CRYPTO_ALGAPI
 581         help
 582           The CAST5 encryption algorithm (synonymous with CAST-128) is
 583           described in RFC2144.
 584
 585 config CRYPTO_CAST6
 586         tristate "CAST6 (CAST-256) cipher algorithm"
 587         select CRYPTO_ALGAPI
 588         help
 589           The CAST6 encryption algorithm (synonymous with CAST-256) is
 590           described in RFC2612.
 591
 592 config CRYPTO_DES
 593         tristate "DES and Triple DES EDE cipher algorithms"
 594         select CRYPTO_ALGAPI
 595         help
 596           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
 597
 598 config CRYPTO_FCRYPT
 599         tristate "FCrypt cipher algorithm"
 600         select CRYPTO_ALGAPI
 601         select CRYPTO_BLKCIPHER
 602         help
 603           FCrypt algorithm used by RxRPC.
 604
 605 config CRYPTO_KHAZAD
 606         tristate "Khazad cipher algorithm"
 607         select CRYPTO_ALGAPI
 608         help
 609           Khazad cipher algorithm.
 610
 611           Khazad was a finalist in the initial NESSIE competition.  It is
 612           an algorithm optimized for 64-bit processors with good performance
 613           on 32-bit processors.  Khazad uses an 128 bit key size.
 614
 615           See also:
 616           <http://planeta.terra.com.br/informatica/paulobarreto/KhazadPage.html>
 617
 618 config CRYPTO_SALSA20
 619         tristate "Salsa20 stream cipher algorithm (EXPERIMENTAL)"
 620         depends on EXPERIMENTAL
 621         select CRYPTO_BLKCIPHER
 622         help
 623           Salsa20 stream cipher algorithm.
 624
 625           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
 626           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
 627
 628           The Salsa20 stream cipher algorithm is designed by Daniel J.
 629           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
 630
 631 config CRYPTO_SALSA20_586
 632         tristate "Salsa20 stream cipher algorithm (i586) (EXPERIMENTAL)"
 633         depends on (X86 || UML_X86) && !64BIT
 634         depends on EXPERIMENTAL
 635         select CRYPTO_BLKCIPHER
 636         help
 637           Salsa20 stream cipher algorithm.
 638
 639           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
 640           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
 641
 642           The Salsa20 stream cipher algorithm is designed by Daniel J.
 643           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
 644
 645 config CRYPTO_SALSA20_X86_64
 646         tristate "Salsa20 stream cipher algorithm (x86_64) (EXPERIMENTAL)"
 647         depends on (X86 || UML_X86) && 64BIT
 648         depends on EXPERIMENTAL
 649         select CRYPTO_BLKCIPHER
 650         help
 651           Salsa20 stream cipher algorithm.
 652
 653           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
 654           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
 655
 656           The Salsa20 stream cipher algorithm is designed by Daniel J.
 657           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
 658
 659 config CRYPTO_SEED
 660         tristate "SEED cipher algorithm"
 661         select CRYPTO_ALGAPI
 662         help
 663           SEED cipher algorithm (RFC4269).
 664
 665           SEED is a 128-bit symmetric key block cipher that has been
 666           developed by KISA (Korea Information Security Agency) as a
 667           national standard encryption algorithm of the Republic of Korea.
 668           It is a 16 round block cipher with the key size of 128 bit.
 669
 670           See also:
 671           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
 672
 673 config CRYPTO_SERPENT
 674         tristate "Serpent cipher algorithm"
 675         select CRYPTO_ALGAPI
 676         help
 677           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
 678
 679           Keys are allowed to be from 0 to 256 bits in length, in steps
 680           of 8 bits.  Also includes the 'Tnepres' algorithm, a reversed
 681           variant of Serpent for compatibility with old kerneli.org code.
 682
 683           See also:
 684           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
 685
 686 config CRYPTO_TEA
 687         tristate "TEA, XTEA and XETA cipher algorithms"
 688         select CRYPTO_ALGAPI
 689         help
 690           TEA cipher algorithm.
 691
 692           Tiny Encryption Algorithm is a simple cipher that uses
 693           many rounds for security.  It is very fast and uses
 694           little memory.
 695
 696           Xtendend Tiny Encryption Algorithm is a modification to
 697           the TEA algorithm to address a potential key weakness
 698           in the TEA algorithm.
 699
 700           Xtendend Encryption Tiny Algorithm is a mis-implementation
 701           of the XTEA algorithm for compatibility purposes.
 702
 703 config CRYPTO_TWOFISH
 704         tristate "Twofish cipher algorithm"
 705         select CRYPTO_ALGAPI
 706         select CRYPTO_TWOFISH_COMMON
 707         help
 708           Twofish cipher algorithm.
 709
 710           Twofish was submitted as an AES (Advanced Encryption Standard)
 711           candidate cipher by researchers at CounterPane Systems.  It is a
 712           16 round block cipher supporting key sizes of 128, 192, and 256
 713           bits.
 714
 715           See also:
 716           <http://www.schneier.com/twofish.html>
 717
 718 config CRYPTO_TWOFISH_COMMON
 719         tristate
 720         help
 721           Common parts of the Twofish cipher algorithm shared by the
 722           generic c and the assembler implementations.
 723
 724 config CRYPTO_TWOFISH_586
 725         tristate "Twofish cipher algorithms (i586)"
 726         depends on (X86 || UML_X86) && !64BIT
 727         select CRYPTO_ALGAPI
 728         select CRYPTO_TWOFISH_COMMON
 729         help
 730           Twofish cipher algorithm.
 731
 732           Twofish was submitted as an AES (Advanced Encryption Standard)
 733           candidate cipher by researchers at CounterPane Systems.  It is a
 734           16 round block cipher supporting key sizes of 128, 192, and 256
 735           bits.
 736
 737           See also:
 738           <http://www.schneier.com/twofish.html>
 739
 740 config CRYPTO_TWOFISH_X86_64
 741         tristate "Twofish cipher algorithm (x86_64)"
 742         depends on (X86 || UML_X86) && 64BIT
 743         select CRYPTO_ALGAPI
 744         select CRYPTO_TWOFISH_COMMON
 745         help
 746           Twofish cipher algorithm (x86_64).
 747
 748           Twofish was submitted as an AES (Advanced Encryption Standard)
 749           candidate cipher by researchers at CounterPane Systems.  It is a
 750           16 round block cipher supporting key sizes of 128, 192, and 256
 751           bits.
 752
 753           See also:
 754           <http://www.schneier.com/twofish.html>
 755
 756 comment "Compression"
 757
 758 config CRYPTO_DEFLATE
 759         tristate "Deflate compression algorithm"
 760         select CRYPTO_ALGAPI
 761         select ZLIB_INFLATE
 762         select ZLIB_DEFLATE
 763         help
 764           This is the Deflate algorithm (RFC1951), specified for use in
 765           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
 766
 767           You will most probably want this if using IPSec.
 768
 769 config CRYPTO_ZLIB
 770         tristate "Zlib compression algorithm"
 771         select CRYPTO_PCOMP
 772         select ZLIB_INFLATE
 773         select ZLIB_DEFLATE
 774         select NLATTR
 775         help
 776           This is the zlib algorithm.
 777
 778 config CRYPTO_LZO
 779         tristate "LZO compression algorithm"
 780         select CRYPTO_ALGAPI
 781         select LZO_COMPRESS
 782         select LZO_DECOMPRESS
 783         help
 784           This is the LZO algorithm.
 785
 786 comment "Random Number Generation"
 787
 788 config CRYPTO_ANSI_CPRNG
 789         tristate "Pseudo Random Number Generation for Cryptographic modules"
 790         select CRYPTO_AES
 791         select CRYPTO_RNG
 792         help
 793           This option enables the generic pseudo random number generator
 794           for cryptographic modules.  Uses the Algorithm specified in
 795           ANSI X9.31 A.2.4
 796
 797 source "drivers/crypto/Kconfig"
 798
 799 endif   # if CRYPTO