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