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_CHACHA20
1160         tristate "ChaCha20 cipher algorithm"
1161         select CRYPTO_BLKCIPHER
1162         help
1163           ChaCha20 cipher algorithm, RFC7539.
1164
1165           ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1166           Bernstein and further specified in RFC7539 for use in IETF protocols.
1167           This is the portable C implementation of ChaCha20.
1168
1169           See also:
1170           <http://cr.yp.to/chacha/chacha-20080128.pdf>
1171
1172 config CRYPTO_SEED
1173         tristate "SEED cipher algorithm"
1174         select CRYPTO_ALGAPI
1175         help
1176           SEED cipher algorithm (RFC4269).
1177
1178           SEED is a 128-bit symmetric key block cipher that has been
1179           developed by KISA (Korea Information Security Agency) as a
1180           national standard encryption algorithm of the Republic of Korea.
1181           It is a 16 round block cipher with the key size of 128 bit.
1182
1183           See also:
1184           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1185
1186 config CRYPTO_SERPENT
1187         tristate "Serpent cipher algorithm"
1188         select CRYPTO_ALGAPI
1189         help
1190           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1191
1192           Keys are allowed to be from 0 to 256 bits in length, in steps
1193           of 8 bits.  Also includes the 'Tnepres' algorithm, a reversed
1194           variant of Serpent for compatibility with old kerneli.org code.
1195
1196           See also:
1197           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1198
1199 config CRYPTO_SERPENT_SSE2_X86_64
1200         tristate "Serpent cipher algorithm (x86_64/SSE2)"
1201         depends on X86 && 64BIT
1202         select CRYPTO_ALGAPI
1203         select CRYPTO_CRYPTD
1204         select CRYPTO_ABLK_HELPER
1205         select CRYPTO_GLUE_HELPER_X86
1206         select CRYPTO_SERPENT
1207         select CRYPTO_LRW
1208         select CRYPTO_XTS
1209         help
1210           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1211
1212           Keys are allowed to be from 0 to 256 bits in length, in steps
1213           of 8 bits.
1214
1215           This module provides Serpent cipher algorithm that processes eight
1216           blocks parallel using SSE2 instruction set.
1217
1218           See also:
1219           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1220
1221 config CRYPTO_SERPENT_SSE2_586
1222         tristate "Serpent cipher algorithm (i586/SSE2)"
1223         depends on X86 && !64BIT
1224         select CRYPTO_ALGAPI
1225         select CRYPTO_CRYPTD
1226         select CRYPTO_ABLK_HELPER
1227         select CRYPTO_GLUE_HELPER_X86
1228         select CRYPTO_SERPENT
1229         select CRYPTO_LRW
1230         select CRYPTO_XTS
1231         help
1232           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1233
1234           Keys are allowed to be from 0 to 256 bits in length, in steps
1235           of 8 bits.
1236
1237           This module provides Serpent cipher algorithm that processes four
1238           blocks parallel using SSE2 instruction set.
1239
1240           See also:
1241           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1242
1243 config CRYPTO_SERPENT_AVX_X86_64
1244         tristate "Serpent cipher algorithm (x86_64/AVX)"
1245         depends on X86 && 64BIT
1246         select CRYPTO_ALGAPI
1247         select CRYPTO_CRYPTD
1248         select CRYPTO_ABLK_HELPER
1249         select CRYPTO_GLUE_HELPER_X86
1250         select CRYPTO_SERPENT
1251         select CRYPTO_LRW
1252         select CRYPTO_XTS
1253         help
1254           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1255
1256           Keys are allowed to be from 0 to 256 bits in length, in steps
1257           of 8 bits.
1258
1259           This module provides the Serpent cipher algorithm that processes
1260           eight blocks parallel using the AVX instruction set.
1261
1262           See also:
1263           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1264
1265 config CRYPTO_SERPENT_AVX2_X86_64
1266         tristate "Serpent cipher algorithm (x86_64/AVX2)"
1267         depends on X86 && 64BIT
1268         select CRYPTO_ALGAPI
1269         select CRYPTO_CRYPTD
1270         select CRYPTO_ABLK_HELPER
1271         select CRYPTO_GLUE_HELPER_X86
1272         select CRYPTO_SERPENT
1273         select CRYPTO_SERPENT_AVX_X86_64
1274         select CRYPTO_LRW
1275         select CRYPTO_XTS
1276         help
1277           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1278
1279           Keys are allowed to be from 0 to 256 bits in length, in steps
1280           of 8 bits.
1281
1282           This module provides Serpent cipher algorithm that processes 16
1283           blocks parallel using AVX2 instruction set.
1284
1285           See also:
1286           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1287
1288 config CRYPTO_TEA
1289         tristate "TEA, XTEA and XETA cipher algorithms"
1290         select CRYPTO_ALGAPI
1291         help
1292           TEA cipher algorithm.
1293
1294           Tiny Encryption Algorithm is a simple cipher that uses
1295           many rounds for security.  It is very fast and uses
1296           little memory.
1297
1298           Xtendend Tiny Encryption Algorithm is a modification to
1299           the TEA algorithm to address a potential key weakness
1300           in the TEA algorithm.
1301
1302           Xtendend Encryption Tiny Algorithm is a mis-implementation
1303           of the XTEA algorithm for compatibility purposes.
1304
1305 config CRYPTO_TWOFISH
1306         tristate "Twofish cipher algorithm"
1307         select CRYPTO_ALGAPI
1308         select CRYPTO_TWOFISH_COMMON
1309         help
1310           Twofish cipher algorithm.
1311
1312           Twofish was submitted as an AES (Advanced Encryption Standard)
1313           candidate cipher by researchers at CounterPane Systems.  It is a
1314           16 round block cipher supporting key sizes of 128, 192, and 256
1315           bits.
1316
1317           See also:
1318           <http://www.schneier.com/twofish.html>
1319
1320 config CRYPTO_TWOFISH_COMMON
1321         tristate
1322         help
1323           Common parts of the Twofish cipher algorithm shared by the
1324           generic c and the assembler implementations.
1325
1326 config CRYPTO_TWOFISH_586
1327         tristate "Twofish cipher algorithms (i586)"
1328         depends on (X86 || UML_X86) && !64BIT
1329         select CRYPTO_ALGAPI
1330         select CRYPTO_TWOFISH_COMMON
1331         help
1332           Twofish cipher algorithm.
1333
1334           Twofish was submitted as an AES (Advanced Encryption Standard)
1335           candidate cipher by researchers at CounterPane Systems.  It is a
1336           16 round block cipher supporting key sizes of 128, 192, and 256
1337           bits.
1338
1339           See also:
1340           <http://www.schneier.com/twofish.html>
1341
1342 config CRYPTO_TWOFISH_X86_64
1343         tristate "Twofish cipher algorithm (x86_64)"
1344         depends on (X86 || UML_X86) && 64BIT
1345         select CRYPTO_ALGAPI
1346         select CRYPTO_TWOFISH_COMMON
1347         help
1348           Twofish cipher algorithm (x86_64).
1349
1350           Twofish was submitted as an AES (Advanced Encryption Standard)
1351           candidate cipher by researchers at CounterPane Systems.  It is a
1352           16 round block cipher supporting key sizes of 128, 192, and 256
1353           bits.
1354
1355           See also:
1356           <http://www.schneier.com/twofish.html>
1357
1358 config CRYPTO_TWOFISH_X86_64_3WAY
1359         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1360         depends on X86 && 64BIT
1361         select CRYPTO_ALGAPI
1362         select CRYPTO_TWOFISH_COMMON
1363         select CRYPTO_TWOFISH_X86_64
1364         select CRYPTO_GLUE_HELPER_X86
1365         select CRYPTO_LRW
1366         select CRYPTO_XTS
1367         help
1368           Twofish cipher algorithm (x86_64, 3-way parallel).
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           This module provides Twofish cipher algorithm that processes three
1376           blocks parallel, utilizing resources of out-of-order CPUs better.
1377
1378           See also:
1379           <http://www.schneier.com/twofish.html>
1380
1381 config CRYPTO_TWOFISH_AVX_X86_64
1382         tristate "Twofish cipher algorithm (x86_64/AVX)"
1383         depends on X86 && 64BIT
1384         select CRYPTO_ALGAPI
1385         select CRYPTO_CRYPTD
1386         select CRYPTO_ABLK_HELPER
1387         select CRYPTO_GLUE_HELPER_X86
1388         select CRYPTO_TWOFISH_COMMON
1389         select CRYPTO_TWOFISH_X86_64
1390         select CRYPTO_TWOFISH_X86_64_3WAY
1391         select CRYPTO_LRW
1392         select CRYPTO_XTS
1393         help
1394           Twofish cipher algorithm (x86_64/AVX).
1395
1396           Twofish was submitted as an AES (Advanced Encryption Standard)
1397           candidate cipher by researchers at CounterPane Systems.  It is a
1398           16 round block cipher supporting key sizes of 128, 192, and 256
1399           bits.
1400
1401           This module provides the Twofish cipher algorithm that processes
1402           eight blocks parallel using the AVX Instruction Set.
1403
1404           See also:
1405           <http://www.schneier.com/twofish.html>
1406
1407 comment "Compression"
1408
1409 config CRYPTO_DEFLATE
1410         tristate "Deflate compression algorithm"
1411         select CRYPTO_ALGAPI
1412         select ZLIB_INFLATE
1413         select ZLIB_DEFLATE
1414         help
1415           This is the Deflate algorithm (RFC1951), specified for use in
1416           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1417
1418           You will most probably want this if using IPSec.
1419
1420 config CRYPTO_ZLIB
1421         tristate "Zlib compression algorithm"
1422         select CRYPTO_PCOMP
1423         select ZLIB_INFLATE
1424         select ZLIB_DEFLATE
1425         select NLATTR
1426         help
1427           This is the zlib algorithm.
1428
1429 config CRYPTO_LZO
1430         tristate "LZO compression algorithm"
1431         select CRYPTO_ALGAPI
1432         select LZO_COMPRESS
1433         select LZO_DECOMPRESS
1434         help
1435           This is the LZO algorithm.
1436
1437 config CRYPTO_842
1438         tristate "842 compression algorithm"
1439         select CRYPTO_ALGAPI
1440         select 842_COMPRESS
1441         select 842_DECOMPRESS
1442         help
1443           This is the 842 algorithm.
1444
1445 config CRYPTO_LZ4
1446         tristate "LZ4 compression algorithm"
1447         select CRYPTO_ALGAPI
1448         select LZ4_COMPRESS
1449         select LZ4_DECOMPRESS
1450         help
1451           This is the LZ4 algorithm.
1452
1453 config CRYPTO_LZ4HC
1454         tristate "LZ4HC compression algorithm"
1455         select CRYPTO_ALGAPI
1456         select LZ4HC_COMPRESS
1457         select LZ4_DECOMPRESS
1458         help
1459           This is the LZ4 high compression mode algorithm.
1460
1461 comment "Random Number Generation"
1462
1463 config CRYPTO_ANSI_CPRNG
1464         tristate "Pseudo Random Number Generation for Cryptographic modules"
1465         default m
1466         select CRYPTO_AES
1467         select CRYPTO_RNG
1468         help
1469           This option enables the generic pseudo random number generator
1470           for cryptographic modules.  Uses the Algorithm specified in
1471           ANSI X9.31 A.2.4. Note that this option must be enabled if
1472           CRYPTO_FIPS is selected
1473
1474 menuconfig CRYPTO_DRBG_MENU
1475         tristate "NIST SP800-90A DRBG"
1476         help
1477           NIST SP800-90A compliant DRBG. In the following submenu, one or
1478           more of the DRBG types must be selected.
1479
1480 if CRYPTO_DRBG_MENU
1481
1482 config CRYPTO_DRBG_HMAC
1483         bool "Enable HMAC DRBG"
1484         default y
1485         select CRYPTO_HMAC
1486         help
1487           Enable the HMAC DRBG variant as defined in NIST SP800-90A.
1488
1489 config CRYPTO_DRBG_HASH
1490         bool "Enable Hash DRBG"
1491         select CRYPTO_HASH
1492         help
1493           Enable the Hash DRBG variant as defined in NIST SP800-90A.
1494
1495 config CRYPTO_DRBG_CTR
1496         bool "Enable CTR DRBG"
1497         select CRYPTO_AES
1498         help
1499           Enable the CTR DRBG variant as defined in NIST SP800-90A.
1500
1501 config CRYPTO_DRBG
1502         tristate
1503         default CRYPTO_DRBG_MENU if (CRYPTO_DRBG_HMAC || CRYPTO_DRBG_HASH || CRYPTO_DRBG_CTR)
1504         select CRYPTO_RNG
1505         select CRYPTO_JITTERENTROPY
1506
1507 endif   # if CRYPTO_DRBG_MENU
1508
1509 config CRYPTO_JITTERENTROPY
1510         tristate "Jitterentropy Non-Deterministic Random Number Generator"
1511         help
1512           The Jitterentropy RNG is a noise that is intended
1513           to provide seed to another RNG. The RNG does not
1514           perform any cryptographic whitening of the generated
1515           random numbers. This Jitterentropy RNG registers with
1516           the kernel crypto API and can be used by any caller.
1517
1518 config CRYPTO_USER_API
1519         tristate
1520
1521 config CRYPTO_USER_API_HASH
1522         tristate "User-space interface for hash algorithms"
1523         depends on NET
1524         select CRYPTO_HASH
1525         select CRYPTO_USER_API
1526         help
1527           This option enables the user-spaces interface for hash
1528           algorithms.
1529
1530 config CRYPTO_USER_API_SKCIPHER
1531         tristate "User-space interface for symmetric key cipher algorithms"
1532         depends on NET
1533         select CRYPTO_BLKCIPHER
1534         select CRYPTO_USER_API
1535         help
1536           This option enables the user-spaces interface for symmetric
1537           key cipher algorithms.
1538
1539 config CRYPTO_USER_API_RNG
1540         tristate "User-space interface for random number generator algorithms"
1541         depends on NET
1542         select CRYPTO_RNG
1543         select CRYPTO_USER_API
1544         help
1545           This option enables the user-spaces interface for random
1546           number generator algorithms.
1547
1548 config CRYPTO_USER_API_AEAD
1549         tristate "User-space interface for AEAD cipher algorithms"
1550         depends on NET
1551         select CRYPTO_AEAD
1552         select CRYPTO_USER_API
1553         help
1554           This option enables the user-spaces interface for AEAD
1555           cipher algorithms.
1556
1557 config CRYPTO_HASH_INFO
1558         bool
1559
1560 source "drivers/crypto/Kconfig"
1561 source crypto/asymmetric_keys/Kconfig
1562
1563 endif   # if CRYPTO