crypto/Kconfig

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