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