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_POLY1305
 430         tristate "Poly1305 authenticator algorithm"
 431         help
 432           Poly1305 authenticator algorithm, RFC7539.
 433
 434           Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
 435           It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
 436           in IETF protocols. This is the portable C implementation of Poly1305.
 437
 438 config CRYPTO_MD4
 439         tristate "MD4 digest algorithm"
 440         select CRYPTO_HASH
 441         help
 442           MD4 message digest algorithm (RFC1320).
 443
 444 config CRYPTO_MD5
 445         tristate "MD5 digest algorithm"
 446         select CRYPTO_HASH
 447         help
 448           MD5 message digest algorithm (RFC1321).
 449
 450 config CRYPTO_MD5_OCTEON
 451         tristate "MD5 digest algorithm (OCTEON)"
 452         depends on CPU_CAVIUM_OCTEON
 453         select CRYPTO_MD5
 454         select CRYPTO_HASH
 455         help
 456           MD5 message digest algorithm (RFC1321) implemented
 457           using OCTEON crypto instructions, when available.
 458
 459 config CRYPTO_MD5_PPC
 460         tristate "MD5 digest algorithm (PPC)"
 461         depends on PPC
 462         select CRYPTO_HASH
 463         help
 464           MD5 message digest algorithm (RFC1321) implemented
 465           in PPC assembler.
 466
 467 config CRYPTO_MD5_SPARC64
 468         tristate "MD5 digest algorithm (SPARC64)"
 469         depends on SPARC64
 470         select CRYPTO_MD5
 471         select CRYPTO_HASH
 472         help
 473           MD5 message digest algorithm (RFC1321) implemented
 474           using sparc64 crypto instructions, when available.
 475
 476 config CRYPTO_MICHAEL_MIC
 477         tristate "Michael MIC keyed digest algorithm"
 478         select CRYPTO_HASH
 479         help
 480           Michael MIC is used for message integrity protection in TKIP
 481           (IEEE 802.11i). This algorithm is required for TKIP, but it
 482           should not be used for other purposes because of the weakness
 483           of the algorithm.
 484
 485 config CRYPTO_RMD128
 486         tristate "RIPEMD-128 digest algorithm"
 487         select CRYPTO_HASH
 488         help
 489           RIPEMD-128 (ISO/IEC 10118-3:2004).
 490
 491           RIPEMD-128 is a 128-bit cryptographic hash function. It should only
 492           be used as a secure replacement for RIPEMD. For other use cases,
 493           RIPEMD-160 should be used.
 494
 495           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 496           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 497
 498 config CRYPTO_RMD160
 499         tristate "RIPEMD-160 digest algorithm"
 500         select CRYPTO_HASH
 501         help
 502           RIPEMD-160 (ISO/IEC 10118-3:2004).
 503
 504           RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
 505           to be used as a secure replacement for the 128-bit hash functions
 506           MD4, MD5 and it's predecessor RIPEMD
 507           (not to be confused with RIPEMD-128).
 508
 509           It's speed is comparable to SHA1 and there are no known attacks
 510           against RIPEMD-160.
 511
 512           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 513           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 514
 515 config CRYPTO_RMD256
 516         tristate "RIPEMD-256 digest algorithm"
 517         select CRYPTO_HASH
 518         help
 519           RIPEMD-256 is an optional extension of RIPEMD-128 with a
 520           256 bit hash. It is intended for applications that require
 521           longer hash-results, without needing a larger security level
 522           (than RIPEMD-128).
 523
 524           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 525           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 526
 527 config CRYPTO_RMD320
 528         tristate "RIPEMD-320 digest algorithm"
 529         select CRYPTO_HASH
 530         help
 531           RIPEMD-320 is an optional extension of RIPEMD-160 with a
 532           320 bit hash. It is intended for applications that require
 533           longer hash-results, without needing a larger security level
 534           (than RIPEMD-160).
 535
 536           Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
 537           See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
 538
 539 config CRYPTO_SHA1
 540         tristate "SHA1 digest algorithm"
 541         select CRYPTO_HASH
 542         help
 543           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 544
 545 config CRYPTO_SHA1_SSSE3
 546         tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2)"
 547         depends on X86 && 64BIT
 548         select CRYPTO_SHA1
 549         select CRYPTO_HASH
 550         help
 551           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 552           using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
 553           Extensions (AVX/AVX2), when available.
 554
 555 config CRYPTO_SHA256_SSSE3
 556         tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2)"
 557         depends on X86 && 64BIT
 558         select CRYPTO_SHA256
 559         select CRYPTO_HASH
 560         help
 561           SHA-256 secure hash standard (DFIPS 180-2) implemented
 562           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
 563           Extensions version 1 (AVX1), or Advanced Vector Extensions
 564           version 2 (AVX2) instructions, when available.
 565
 566 config CRYPTO_SHA512_SSSE3
 567         tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
 568         depends on X86 && 64BIT
 569         select CRYPTO_SHA512
 570         select CRYPTO_HASH
 571         help
 572           SHA-512 secure hash standard (DFIPS 180-2) implemented
 573           using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
 574           Extensions version 1 (AVX1), or Advanced Vector Extensions
 575           version 2 (AVX2) instructions, when available.
 576
 577 config CRYPTO_SHA1_OCTEON
 578         tristate "SHA1 digest algorithm (OCTEON)"
 579         depends on CPU_CAVIUM_OCTEON
 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 OCTEON crypto instructions, when available.
 585
 586 config CRYPTO_SHA1_SPARC64
 587         tristate "SHA1 digest algorithm (SPARC64)"
 588         depends on SPARC64
 589         select CRYPTO_SHA1
 590         select CRYPTO_HASH
 591         help
 592           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 593           using sparc64 crypto instructions, when available.
 594
 595 config CRYPTO_SHA1_PPC
 596         tristate "SHA1 digest algorithm (powerpc)"
 597         depends on PPC
 598         help
 599           This is the powerpc hardware accelerated implementation of the
 600           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 601
 602 config CRYPTO_SHA1_PPC_SPE
 603         tristate "SHA1 digest algorithm (PPC SPE)"
 604         depends on PPC && SPE
 605         help
 606           SHA-1 secure hash standard (DFIPS 180-4) implemented
 607           using powerpc SPE SIMD instruction set.
 608
 609 config CRYPTO_SHA1_MB
 610         tristate "SHA1 digest algorithm (x86_64 Multi-Buffer, Experimental)"
 611         depends on X86 && 64BIT
 612         select CRYPTO_SHA1
 613         select CRYPTO_HASH
 614         select CRYPTO_MCRYPTD
 615         help
 616           SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
 617           using multi-buffer technique.  This algorithm computes on
 618           multiple data lanes concurrently with SIMD instructions for
 619           better throughput.  It should not be enabled by default but
 620           used when there is significant amount of work to keep the keep
 621           the data lanes filled to get performance benefit.  If the data
 622           lanes remain unfilled, a flush operation will be initiated to
 623           process the crypto jobs, adding a slight latency.
 624
 625 config CRYPTO_SHA256
 626         tristate "SHA224 and SHA256 digest algorithm"
 627         select CRYPTO_HASH
 628         help
 629           SHA256 secure hash standard (DFIPS 180-2).
 630
 631           This version of SHA implements a 256 bit hash with 128 bits of
 632           security against collision attacks.
 633
 634           This code also includes SHA-224, a 224 bit hash with 112 bits
 635           of security against collision attacks.
 636
 637 config CRYPTO_SHA256_PPC_SPE
 638         tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
 639         depends on PPC && SPE
 640         select CRYPTO_SHA256
 641         select CRYPTO_HASH
 642         help
 643           SHA224 and SHA256 secure hash standard (DFIPS 180-2)
 644           implemented using powerpc SPE SIMD instruction set.
 645
 646 config CRYPTO_SHA256_OCTEON
 647         tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
 648         depends on CPU_CAVIUM_OCTEON
 649         select CRYPTO_SHA256
 650         select CRYPTO_HASH
 651         help
 652           SHA-256 secure hash standard (DFIPS 180-2) implemented
 653           using OCTEON crypto instructions, when available.
 654
 655 config CRYPTO_SHA256_SPARC64
 656         tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
 657         depends on SPARC64
 658         select CRYPTO_SHA256
 659         select CRYPTO_HASH
 660         help
 661           SHA-256 secure hash standard (DFIPS 180-2) implemented
 662           using sparc64 crypto instructions, when available.
 663
 664 config CRYPTO_SHA512
 665         tristate "SHA384 and SHA512 digest algorithms"
 666         select CRYPTO_HASH
 667         help
 668           SHA512 secure hash standard (DFIPS 180-2).
 669
 670           This version of SHA implements a 512 bit hash with 256 bits of
 671           security against collision attacks.
 672
 673           This code also includes SHA-384, a 384 bit hash with 192 bits
 674           of security against collision attacks.
 675
 676 config CRYPTO_SHA512_OCTEON
 677         tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
 678         depends on CPU_CAVIUM_OCTEON
 679         select CRYPTO_SHA512
 680         select CRYPTO_HASH
 681         help
 682           SHA-512 secure hash standard (DFIPS 180-2) implemented
 683           using OCTEON crypto instructions, when available.
 684
 685 config CRYPTO_SHA512_SPARC64
 686         tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
 687         depends on SPARC64
 688         select CRYPTO_SHA512
 689         select CRYPTO_HASH
 690         help
 691           SHA-512 secure hash standard (DFIPS 180-2) implemented
 692           using sparc64 crypto instructions, when available.
 693
 694 config CRYPTO_TGR192
 695         tristate "Tiger digest algorithms"
 696         select CRYPTO_HASH
 697         help
 698           Tiger hash algorithm 192, 160 and 128-bit hashes
 699
 700           Tiger is a hash function optimized for 64-bit processors while
 701           still having decent performance on 32-bit processors.
 702           Tiger was developed by Ross Anderson and Eli Biham.
 703
 704           See also:
 705           <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
 706
 707 config CRYPTO_WP512
 708         tristate "Whirlpool digest algorithms"
 709         select CRYPTO_HASH
 710         help
 711           Whirlpool hash algorithm 512, 384 and 256-bit hashes
 712
 713           Whirlpool-512 is part of the NESSIE cryptographic primitives.
 714           Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
 715
 716           See also:
 717           <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
 718
 719 config CRYPTO_GHASH_CLMUL_NI_INTEL
 720         tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
 721         depends on X86 && 64BIT
 722         select CRYPTO_CRYPTD
 723         help
 724           GHASH is message digest algorithm for GCM (Galois/Counter Mode).
 725           The implementation is accelerated by CLMUL-NI of Intel.
 726
 727 comment "Ciphers"
 728
 729 config CRYPTO_AES
 730         tristate "AES cipher algorithms"
 731         select CRYPTO_ALGAPI
 732         help
 733           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 734           algorithm.
 735
 736           Rijndael appears to be consistently a very good performer in
 737           both hardware and software across a wide range of computing
 738           environments regardless of its use in feedback or non-feedback
 739           modes. Its key setup time is excellent, and its key agility is
 740           good. Rijndael's very low memory requirements make it very well
 741           suited for restricted-space environments, in which it also
 742           demonstrates excellent performance. Rijndael's operations are
 743           among the easiest to defend against power and timing attacks.
 744
 745           The AES specifies three key sizes: 128, 192 and 256 bits
 746
 747           See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
 748
 749 config CRYPTO_AES_586
 750         tristate "AES cipher algorithms (i586)"
 751         depends on (X86 || UML_X86) && !64BIT
 752         select CRYPTO_ALGAPI
 753         select CRYPTO_AES
 754         help
 755           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 756           algorithm.
 757
 758           Rijndael appears to be consistently a very good performer in
 759           both hardware and software across a wide range of computing
 760           environments regardless of its use in feedback or non-feedback
 761           modes. Its key setup time is excellent, and its key agility is
 762           good. Rijndael's very low memory requirements make it very well
 763           suited for restricted-space environments, in which it also
 764           demonstrates excellent performance. Rijndael's operations are
 765           among the easiest to defend against power and timing attacks.
 766
 767           The AES specifies three key sizes: 128, 192 and 256 bits
 768
 769           See <http://csrc.nist.gov/encryption/aes/> for more information.
 770
 771 config CRYPTO_AES_X86_64
 772         tristate "AES cipher algorithms (x86_64)"
 773         depends on (X86 || UML_X86) && 64BIT
 774         select CRYPTO_ALGAPI
 775         select CRYPTO_AES
 776         help
 777           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 778           algorithm.
 779
 780           Rijndael appears to be consistently a very good performer in
 781           both hardware and software across a wide range of computing
 782           environments regardless of its use in feedback or non-feedback
 783           modes. Its key setup time is excellent, and its key agility is
 784           good. Rijndael's very low memory requirements make it very well
 785           suited for restricted-space environments, in which it also
 786           demonstrates excellent performance. Rijndael's operations are
 787           among the easiest to defend against power and timing attacks.
 788
 789           The AES specifies three key sizes: 128, 192 and 256 bits
 790
 791           See <http://csrc.nist.gov/encryption/aes/> for more information.
 792
 793 config CRYPTO_AES_NI_INTEL
 794         tristate "AES cipher algorithms (AES-NI)"
 795         depends on X86
 796         select CRYPTO_AES_X86_64 if 64BIT
 797         select CRYPTO_AES_586 if !64BIT
 798         select CRYPTO_CRYPTD
 799         select CRYPTO_ABLK_HELPER
 800         select CRYPTO_ALGAPI
 801         select CRYPTO_GLUE_HELPER_X86 if 64BIT
 802         select CRYPTO_LRW
 803         select CRYPTO_XTS
 804         help
 805           Use Intel AES-NI instructions for AES algorithm.
 806
 807           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 808           algorithm.
 809
 810           Rijndael appears to be consistently a very good performer in
 811           both hardware and software across a wide range of computing
 812           environments regardless of its use in feedback or non-feedback
 813           modes. Its key setup time is excellent, and its key agility is
 814           good. Rijndael's very low memory requirements make it very well
 815           suited for restricted-space environments, in which it also
 816           demonstrates excellent performance. Rijndael's operations are
 817           among the easiest to defend against power and timing attacks.
 818
 819           The AES specifies three key sizes: 128, 192 and 256 bits
 820
 821           See <http://csrc.nist.gov/encryption/aes/> for more information.
 822
 823           In addition to AES cipher algorithm support, the acceleration
 824           for some popular block cipher mode is supported too, including
 825           ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
 826           acceleration for CTR.
 827
 828 config CRYPTO_AES_SPARC64
 829         tristate "AES cipher algorithms (SPARC64)"
 830         depends on SPARC64
 831         select CRYPTO_CRYPTD
 832         select CRYPTO_ALGAPI
 833         help
 834           Use SPARC64 crypto opcodes for AES algorithm.
 835
 836           AES cipher algorithms (FIPS-197). AES uses the Rijndael
 837           algorithm.
 838
 839           Rijndael appears to be consistently a very good performer in
 840           both hardware and software across a wide range of computing
 841           environments regardless of its use in feedback or non-feedback
 842           modes. Its key setup time is excellent, and its key agility is
 843           good. Rijndael's very low memory requirements make it very well
 844           suited for restricted-space environments, in which it also
 845           demonstrates excellent performance. Rijndael's operations are
 846           among the easiest to defend against power and timing attacks.
 847
 848           The AES specifies three key sizes: 128, 192 and 256 bits
 849
 850           See <http://csrc.nist.gov/encryption/aes/> for more information.
 851
 852           In addition to AES cipher algorithm support, the acceleration
 853           for some popular block cipher mode is supported too, including
 854           ECB and CBC.
 855
 856 config CRYPTO_AES_PPC_SPE
 857         tristate "AES cipher algorithms (PPC SPE)"
 858         depends on PPC && SPE
 859         help
 860           AES cipher algorithms (FIPS-197). Additionally the acceleration
 861           for popular block cipher modes ECB, CBC, CTR and XTS is supported.
 862           This module should only be used for low power (router) devices
 863           without hardware AES acceleration (e.g. caam crypto). It reduces the
 864           size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
 865           timining attacks. Nevertheless it might be not as secure as other
 866           architecture specific assembler implementations that work on 1KB
 867           tables or 256 bytes S-boxes.
 868
 869 config CRYPTO_ANUBIS
 870         tristate "Anubis cipher algorithm"
 871         select CRYPTO_ALGAPI
 872         help
 873           Anubis cipher algorithm.
 874
 875           Anubis is a variable key length cipher which can use keys from
 876           128 bits to 320 bits in length.  It was evaluated as a entrant
 877           in the NESSIE competition.
 878
 879           See also:
 880           <https://www.cosic.esat.kuleuven.be/nessie/reports/>
 881           <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
 882
 883 config CRYPTO_ARC4
 884         tristate "ARC4 cipher algorithm"
 885         select CRYPTO_BLKCIPHER
 886         help
 887           ARC4 cipher algorithm.
 888
 889           ARC4 is a stream cipher using keys ranging from 8 bits to 2048
 890           bits in length.  This algorithm is required for driver-based
 891           WEP, but it should not be for other purposes because of the
 892           weakness of the algorithm.
 893
 894 config CRYPTO_BLOWFISH
 895         tristate "Blowfish cipher algorithm"
 896         select CRYPTO_ALGAPI
 897         select CRYPTO_BLOWFISH_COMMON
 898         help
 899           Blowfish cipher algorithm, by Bruce Schneier.
 900
 901           This is a variable key length cipher which can use keys from 32
 902           bits to 448 bits in length.  It's fast, simple and specifically
 903           designed for use on "large microprocessors".
 904
 905           See also:
 906           <http://www.schneier.com/blowfish.html>
 907
 908 config CRYPTO_BLOWFISH_COMMON
 909         tristate
 910         help
 911           Common parts of the Blowfish cipher algorithm shared by the
 912           generic c and the assembler implementations.
 913
 914           See also:
 915           <http://www.schneier.com/blowfish.html>
 916
 917 config CRYPTO_BLOWFISH_X86_64
 918         tristate "Blowfish cipher algorithm (x86_64)"
 919         depends on X86 && 64BIT
 920         select CRYPTO_ALGAPI
 921         select CRYPTO_BLOWFISH_COMMON
 922         help
 923           Blowfish cipher algorithm (x86_64), by Bruce Schneier.
 924
 925           This is a variable key length cipher which can use keys from 32
 926           bits to 448 bits in length.  It's fast, simple and specifically
 927           designed for use on "large microprocessors".
 928
 929           See also:
 930           <http://www.schneier.com/blowfish.html>
 931
 932 config CRYPTO_CAMELLIA
 933         tristate "Camellia cipher algorithms"
 934         depends on CRYPTO
 935         select CRYPTO_ALGAPI
 936         help
 937           Camellia cipher algorithms module.
 938
 939           Camellia is a symmetric key block cipher developed jointly
 940           at NTT and Mitsubishi Electric Corporation.
 941
 942           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 943
 944           See also:
 945           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 946
 947 config CRYPTO_CAMELLIA_X86_64
 948         tristate "Camellia cipher algorithm (x86_64)"
 949         depends on X86 && 64BIT
 950         depends on CRYPTO
 951         select CRYPTO_ALGAPI
 952         select CRYPTO_GLUE_HELPER_X86
 953         select CRYPTO_LRW
 954         select CRYPTO_XTS
 955         help
 956           Camellia cipher algorithm module (x86_64).
 957
 958           Camellia is a symmetric key block cipher developed jointly
 959           at NTT and Mitsubishi Electric Corporation.
 960
 961           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 962
 963           See also:
 964           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 965
 966 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
 967         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
 968         depends on X86 && 64BIT
 969         depends on CRYPTO
 970         select CRYPTO_ALGAPI
 971         select CRYPTO_CRYPTD
 972         select CRYPTO_ABLK_HELPER
 973         select CRYPTO_GLUE_HELPER_X86
 974         select CRYPTO_CAMELLIA_X86_64
 975         select CRYPTO_LRW
 976         select CRYPTO_XTS
 977         help
 978           Camellia cipher algorithm module (x86_64/AES-NI/AVX).
 979
 980           Camellia is a symmetric key block cipher developed jointly
 981           at NTT and Mitsubishi Electric Corporation.
 982
 983           The Camellia specifies three key sizes: 128, 192 and 256 bits.
 984
 985           See also:
 986           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
 987
 988 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
 989         tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
 990         depends on X86 && 64BIT
 991         depends on CRYPTO
 992         select CRYPTO_ALGAPI
 993         select CRYPTO_CRYPTD
 994         select CRYPTO_ABLK_HELPER
 995         select CRYPTO_GLUE_HELPER_X86
 996         select CRYPTO_CAMELLIA_X86_64
 997         select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
 998         select CRYPTO_LRW
 999         select CRYPTO_XTS
1000         help
1001           Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
1002
1003           Camellia is a symmetric key block cipher developed jointly
1004           at NTT and Mitsubishi Electric Corporation.
1005
1006           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1007
1008           See also:
1009           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1010
1011 config CRYPTO_CAMELLIA_SPARC64
1012         tristate "Camellia cipher algorithm (SPARC64)"
1013         depends on SPARC64
1014         depends on CRYPTO
1015         select CRYPTO_ALGAPI
1016         help
1017           Camellia cipher algorithm module (SPARC64).
1018
1019           Camellia is a symmetric key block cipher developed jointly
1020           at NTT and Mitsubishi Electric Corporation.
1021
1022           The Camellia specifies three key sizes: 128, 192 and 256 bits.
1023
1024           See also:
1025           <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
1026
1027 config CRYPTO_CAST_COMMON
1028         tristate
1029         help
1030           Common parts of the CAST cipher algorithms shared by the
1031           generic c and the assembler implementations.
1032
1033 config CRYPTO_CAST5
1034         tristate "CAST5 (CAST-128) cipher algorithm"
1035         select CRYPTO_ALGAPI
1036         select CRYPTO_CAST_COMMON
1037         help
1038           The CAST5 encryption algorithm (synonymous with CAST-128) is
1039           described in RFC2144.
1040
1041 config CRYPTO_CAST5_AVX_X86_64
1042         tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
1043         depends on X86 && 64BIT
1044         select CRYPTO_ALGAPI
1045         select CRYPTO_CRYPTD
1046         select CRYPTO_ABLK_HELPER
1047         select CRYPTO_CAST_COMMON
1048         select CRYPTO_CAST5
1049         help
1050           The CAST5 encryption algorithm (synonymous with CAST-128) is
1051           described in RFC2144.
1052
1053           This module provides the Cast5 cipher algorithm that processes
1054           sixteen blocks parallel using the AVX instruction set.
1055
1056 config CRYPTO_CAST6
1057         tristate "CAST6 (CAST-256) cipher algorithm"
1058         select CRYPTO_ALGAPI
1059         select CRYPTO_CAST_COMMON
1060         help
1061           The CAST6 encryption algorithm (synonymous with CAST-256) is
1062           described in RFC2612.
1063
1064 config CRYPTO_CAST6_AVX_X86_64
1065         tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1066         depends on X86 && 64BIT
1067         select CRYPTO_ALGAPI
1068         select CRYPTO_CRYPTD
1069         select CRYPTO_ABLK_HELPER
1070         select CRYPTO_GLUE_HELPER_X86
1071         select CRYPTO_CAST_COMMON
1072         select CRYPTO_CAST6
1073         select CRYPTO_LRW
1074         select CRYPTO_XTS
1075         help
1076           The CAST6 encryption algorithm (synonymous with CAST-256) is
1077           described in RFC2612.
1078
1079           This module provides the Cast6 cipher algorithm that processes
1080           eight blocks parallel using the AVX instruction set.
1081
1082 config CRYPTO_DES
1083         tristate "DES and Triple DES EDE cipher algorithms"
1084         select CRYPTO_ALGAPI
1085         help
1086           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
1087
1088 config CRYPTO_DES_SPARC64
1089         tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
1090         depends on SPARC64
1091         select CRYPTO_ALGAPI
1092         select CRYPTO_DES
1093         help
1094           DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
1095           optimized using SPARC64 crypto opcodes.
1096
1097 config CRYPTO_DES3_EDE_X86_64
1098         tristate "Triple DES EDE cipher algorithm (x86-64)"
1099         depends on X86 && 64BIT
1100         select CRYPTO_ALGAPI
1101         select CRYPTO_DES
1102         help
1103           Triple DES EDE (FIPS 46-3) algorithm.
1104
1105           This module provides implementation of the Triple DES EDE cipher
1106           algorithm that is optimized for x86-64 processors. Two versions of
1107           algorithm are provided; regular processing one input block and
1108           one that processes three blocks parallel.
1109
1110 config CRYPTO_FCRYPT
1111         tristate "FCrypt cipher algorithm"
1112         select CRYPTO_ALGAPI
1113         select CRYPTO_BLKCIPHER
1114         help
1115           FCrypt algorithm used by RxRPC.
1116
1117 config CRYPTO_KHAZAD
1118         tristate "Khazad cipher algorithm"
1119         select CRYPTO_ALGAPI
1120         help
1121           Khazad cipher algorithm.
1122
1123           Khazad was a finalist in the initial NESSIE competition.  It is
1124           an algorithm optimized for 64-bit processors with good performance
1125           on 32-bit processors.  Khazad uses an 128 bit key size.
1126
1127           See also:
1128           <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
1129
1130 config CRYPTO_SALSA20
1131         tristate "Salsa20 stream cipher algorithm"
1132         select CRYPTO_BLKCIPHER
1133         help
1134           Salsa20 stream cipher algorithm.
1135
1136           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1137           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1138
1139           The Salsa20 stream cipher algorithm is designed by Daniel J.
1140           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1141
1142 config CRYPTO_SALSA20_586
1143         tristate "Salsa20 stream cipher algorithm (i586)"
1144         depends on (X86 || UML_X86) && !64BIT
1145         select CRYPTO_BLKCIPHER
1146         help
1147           Salsa20 stream cipher algorithm.
1148
1149           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1150           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1151
1152           The Salsa20 stream cipher algorithm is designed by Daniel J.
1153           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1154
1155 config CRYPTO_SALSA20_X86_64
1156         tristate "Salsa20 stream cipher algorithm (x86_64)"
1157         depends on (X86 || UML_X86) && 64BIT
1158         select CRYPTO_BLKCIPHER
1159         help
1160           Salsa20 stream cipher algorithm.
1161
1162           Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
1163           Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
1164
1165           The Salsa20 stream cipher algorithm is designed by Daniel J.
1166           Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
1167
1168 config CRYPTO_CHACHA20
1169         tristate "ChaCha20 cipher algorithm"
1170         select CRYPTO_BLKCIPHER
1171         help
1172           ChaCha20 cipher algorithm, RFC7539.
1173
1174           ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
1175           Bernstein and further specified in RFC7539 for use in IETF protocols.
1176           This is the portable C implementation of ChaCha20.
1177
1178           See also:
1179           <http://cr.yp.to/chacha/chacha-20080128.pdf>
1180
1181 config CRYPTO_SEED
1182         tristate "SEED cipher algorithm"
1183         select CRYPTO_ALGAPI
1184         help
1185           SEED cipher algorithm (RFC4269).
1186
1187           SEED is a 128-bit symmetric key block cipher that has been
1188           developed by KISA (Korea Information Security Agency) as a
1189           national standard encryption algorithm of the Republic of Korea.
1190           It is a 16 round block cipher with the key size of 128 bit.
1191
1192           See also:
1193           <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
1194
1195 config CRYPTO_SERPENT
1196         tristate "Serpent cipher algorithm"
1197         select CRYPTO_ALGAPI
1198         help
1199           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1200
1201           Keys are allowed to be from 0 to 256 bits in length, in steps
1202           of 8 bits.  Also includes the 'Tnepres' algorithm, a reversed
1203           variant of Serpent for compatibility with old kerneli.org code.
1204
1205           See also:
1206           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1207
1208 config CRYPTO_SERPENT_SSE2_X86_64
1209         tristate "Serpent cipher algorithm (x86_64/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 eight
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_SSE2_586
1231         tristate "Serpent cipher algorithm (i586/SSE2)"
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 Serpent cipher algorithm that processes four
1247           blocks parallel using SSE2 instruction set.
1248
1249           See also:
1250           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1251
1252 config CRYPTO_SERPENT_AVX_X86_64
1253         tristate "Serpent cipher algorithm (x86_64/AVX)"
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_LRW
1261         select CRYPTO_XTS
1262         help
1263           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1264
1265           Keys are allowed to be from 0 to 256 bits in length, in steps
1266           of 8 bits.
1267
1268           This module provides the Serpent cipher algorithm that processes
1269           eight blocks parallel using the AVX instruction set.
1270
1271           See also:
1272           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1273
1274 config CRYPTO_SERPENT_AVX2_X86_64
1275         tristate "Serpent cipher algorithm (x86_64/AVX2)"
1276         depends on X86 && 64BIT
1277         select CRYPTO_ALGAPI
1278         select CRYPTO_CRYPTD
1279         select CRYPTO_ABLK_HELPER
1280         select CRYPTO_GLUE_HELPER_X86
1281         select CRYPTO_SERPENT
1282         select CRYPTO_SERPENT_AVX_X86_64
1283         select CRYPTO_LRW
1284         select CRYPTO_XTS
1285         help
1286           Serpent cipher algorithm, by Anderson, Biham & Knudsen.
1287
1288           Keys are allowed to be from 0 to 256 bits in length, in steps
1289           of 8 bits.
1290
1291           This module provides Serpent cipher algorithm that processes 16
1292           blocks parallel using AVX2 instruction set.
1293
1294           See also:
1295           <http://www.cl.cam.ac.uk/~rja14/serpent.html>
1296
1297 config CRYPTO_TEA
1298         tristate "TEA, XTEA and XETA cipher algorithms"
1299         select CRYPTO_ALGAPI
1300         help
1301           TEA cipher algorithm.
1302
1303           Tiny Encryption Algorithm is a simple cipher that uses
1304           many rounds for security.  It is very fast and uses
1305           little memory.
1306
1307           Xtendend Tiny Encryption Algorithm is a modification to
1308           the TEA algorithm to address a potential key weakness
1309           in the TEA algorithm.
1310
1311           Xtendend Encryption Tiny Algorithm is a mis-implementation
1312           of the XTEA algorithm for compatibility purposes.
1313
1314 config CRYPTO_TWOFISH
1315         tristate "Twofish cipher algorithm"
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_COMMON
1330         tristate
1331         help
1332           Common parts of the Twofish cipher algorithm shared by the
1333           generic c and the assembler implementations.
1334
1335 config CRYPTO_TWOFISH_586
1336         tristate "Twofish cipher algorithms (i586)"
1337         depends on (X86 || UML_X86) && !64BIT
1338         select CRYPTO_ALGAPI
1339         select CRYPTO_TWOFISH_COMMON
1340         help
1341           Twofish cipher algorithm.
1342
1343           Twofish was submitted as an AES (Advanced Encryption Standard)
1344           candidate cipher by researchers at CounterPane Systems.  It is a
1345           16 round block cipher supporting key sizes of 128, 192, and 256
1346           bits.
1347
1348           See also:
1349           <http://www.schneier.com/twofish.html>
1350
1351 config CRYPTO_TWOFISH_X86_64
1352         tristate "Twofish cipher algorithm (x86_64)"
1353         depends on (X86 || UML_X86) && 64BIT
1354         select CRYPTO_ALGAPI
1355         select CRYPTO_TWOFISH_COMMON
1356         help
1357           Twofish cipher algorithm (x86_64).
1358
1359           Twofish was submitted as an AES (Advanced Encryption Standard)
1360           candidate cipher by researchers at CounterPane Systems.  It is a
1361           16 round block cipher supporting key sizes of 128, 192, and 256
1362           bits.
1363
1364           See also:
1365           <http://www.schneier.com/twofish.html>
1366
1367 config CRYPTO_TWOFISH_X86_64_3WAY
1368         tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
1369         depends on X86 && 64BIT
1370         select CRYPTO_ALGAPI
1371         select CRYPTO_TWOFISH_COMMON
1372         select CRYPTO_TWOFISH_X86_64
1373         select CRYPTO_GLUE_HELPER_X86
1374         select CRYPTO_LRW
1375         select CRYPTO_XTS
1376         help
1377           Twofish cipher algorithm (x86_64, 3-way parallel).
1378
1379           Twofish was submitted as an AES (Advanced Encryption Standard)
1380           candidate cipher by researchers at CounterPane Systems.  It is a
1381           16 round block cipher supporting key sizes of 128, 192, and 256
1382           bits.
1383
1384           This module provides Twofish cipher algorithm that processes three
1385           blocks parallel, utilizing resources of out-of-order CPUs better.
1386
1387           See also:
1388           <http://www.schneier.com/twofish.html>
1389
1390 config CRYPTO_TWOFISH_AVX_X86_64
1391         tristate "Twofish cipher algorithm (x86_64/AVX)"
1392         depends on X86 && 64BIT
1393         select CRYPTO_ALGAPI
1394         select CRYPTO_CRYPTD
1395         select CRYPTO_ABLK_HELPER
1396         select CRYPTO_GLUE_HELPER_X86
1397         select CRYPTO_TWOFISH_COMMON
1398         select CRYPTO_TWOFISH_X86_64
1399         select CRYPTO_TWOFISH_X86_64_3WAY
1400         select CRYPTO_LRW
1401         select CRYPTO_XTS
1402         help
1403           Twofish cipher algorithm (x86_64/AVX).
1404
1405           Twofish was submitted as an AES (Advanced Encryption Standard)
1406           candidate cipher by researchers at CounterPane Systems.  It is a
1407           16 round block cipher supporting key sizes of 128, 192, and 256
1408           bits.
1409
1410           This module provides the Twofish cipher algorithm that processes
1411           eight blocks parallel using the AVX Instruction Set.
1412
1413           See also:
1414           <http://www.schneier.com/twofish.html>
1415
1416 comment "Compression"
1417
1418 config CRYPTO_DEFLATE
1419         tristate "Deflate compression algorithm"
1420         select CRYPTO_ALGAPI
1421         select ZLIB_INFLATE
1422         select ZLIB_DEFLATE
1423         help
1424           This is the Deflate algorithm (RFC1951), specified for use in
1425           IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1426
1427           You will most probably want this if using IPSec.
1428
1429 config CRYPTO_ZLIB
1430         tristate "Zlib compression algorithm"
1431         select CRYPTO_PCOMP
1432         select ZLIB_INFLATE
1433         select ZLIB_DEFLATE
1434         select NLATTR
1435         help
1436           This is the zlib algorithm.
1437
1438 config CRYPTO_LZO
1439         tristate "LZO compression algorithm"
1440         select CRYPTO_ALGAPI
1441         select LZO_COMPRESS
1442         select LZO_DECOMPRESS
1443         help
1444           This is the LZO algorithm.
1445
1446 config CRYPTO_842
1447         tristate "842 compression algorithm"
1448         select CRYPTO_ALGAPI
1449         select 842_COMPRESS
1450         select 842_DECOMPRESS
1451         help
1452           This is the 842 algorithm.
1453
1454 config CRYPTO_LZ4
1455         tristate "LZ4 compression algorithm"
1456         select CRYPTO_ALGAPI
1457         select LZ4_COMPRESS
1458         select LZ4_DECOMPRESS
1459         help
1460           This is the LZ4 algorithm.
1461
1462 config CRYPTO_LZ4HC
1463         tristate "LZ4HC compression algorithm"
1464         select CRYPTO_ALGAPI
1465         select LZ4HC_COMPRESS
1466         select LZ4_DECOMPRESS
1467         help
1468           This is the LZ4 high compression mode algorithm.
1469
1470 comment "Random Number Generation"
1471
1472 config CRYPTO_ANSI_CPRNG
1473         tristate "Pseudo Random Number Generation for Cryptographic modules"
1474         default m
1475         select CRYPTO_AES
1476         select CRYPTO_RNG
1477         help
1478           This option enables the generic pseudo random number generator
1479           for cryptographic modules.  Uses the Algorithm specified in
1480           ANSI X9.31 A.2.4. Note that this option must be enabled if
1481           CRYPTO_FIPS is selected
1482
1483 menuconfig CRYPTO_DRBG_MENU
1484         tristate "NIST SP800-90A DRBG"
1485         help
1486           NIST SP800-90A compliant DRBG. In the following submenu, one or
1487           more of the DRBG types must be selected.
1488
1489 if CRYPTO_DRBG_MENU
1490
1491 config CRYPTO_DRBG_HMAC
1492         bool "Enable HMAC DRBG"
1493         default y
1494         select CRYPTO_HMAC
1495         help
1496           Enable the HMAC DRBG variant as defined in NIST SP800-90A.
1497
1498 config CRYPTO_DRBG_HASH
1499         bool "Enable Hash DRBG"
1500         select CRYPTO_HASH
1501         help
1502           Enable the Hash DRBG variant as defined in NIST SP800-90A.
1503
1504 config CRYPTO_DRBG_CTR
1505         bool "Enable CTR DRBG"
1506         select CRYPTO_AES
1507         help
1508           Enable the CTR DRBG variant as defined in NIST SP800-90A.
1509
1510 config CRYPTO_DRBG
1511         tristate
1512         default CRYPTO_DRBG_MENU if (CRYPTO_DRBG_HMAC || CRYPTO_DRBG_HASH || CRYPTO_DRBG_CTR)
1513         select CRYPTO_RNG
1514         select CRYPTO_JITTERENTROPY
1515
1516 endif   # if CRYPTO_DRBG_MENU
1517
1518 config CRYPTO_JITTERENTROPY
1519         tristate "Jitterentropy Non-Deterministic Random Number Generator"
1520         help
1521           The Jitterentropy RNG is a noise that is intended
1522           to provide seed to another RNG. The RNG does not
1523           perform any cryptographic whitening of the generated
1524           random numbers. This Jitterentropy RNG registers with
1525           the kernel crypto API and can be used by any caller.
1526
1527 config CRYPTO_USER_API
1528         tristate
1529
1530 config CRYPTO_USER_API_HASH
1531         tristate "User-space interface for hash algorithms"
1532         depends on NET
1533         select CRYPTO_HASH
1534         select CRYPTO_USER_API
1535         help
1536           This option enables the user-spaces interface for hash
1537           algorithms.
1538
1539 config CRYPTO_USER_API_SKCIPHER
1540         tristate "User-space interface for symmetric key cipher algorithms"
1541         depends on NET
1542         select CRYPTO_BLKCIPHER
1543         select CRYPTO_USER_API
1544         help
1545           This option enables the user-spaces interface for symmetric
1546           key cipher algorithms.
1547
1548 config CRYPTO_USER_API_RNG
1549         tristate "User-space interface for random number generator algorithms"
1550         depends on NET
1551         select CRYPTO_RNG
1552         select CRYPTO_USER_API
1553         help
1554           This option enables the user-spaces interface for random
1555           number generator algorithms.
1556
1557 config CRYPTO_USER_API_AEAD
1558         tristate "User-space interface for AEAD cipher algorithms"
1559         depends on NET
1560         select CRYPTO_AEAD
1561         select CRYPTO_USER_API
1562         help
1563           This option enables the user-spaces interface for AEAD
1564           cipher algorithms.
1565
1566 config CRYPTO_HASH_INFO
1567         bool
1568
1569 source "drivers/crypto/Kconfig"
1570 source crypto/asymmetric_keys/Kconfig
1571
1572 endif   # if CRYPTO