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