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