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