1 # SPDX-License-Identifier: GPL-2.0 1 # SPDX-License-Identifier: GPL-2.0
2 # 2 #
3 # Generic algorithms support 3 # Generic algorithms support
4 # 4 #
5 config XOR_BLOCKS 5 config XOR_BLOCKS
6 tristate 6 tristate
7 7
8 # 8 #
9 # async_tx api: hardware offloaded memory tran 9 # async_tx api: hardware offloaded memory transfer/transform support
10 # 10 #
11 source "crypto/async_tx/Kconfig" 11 source "crypto/async_tx/Kconfig"
12 12
13 # 13 #
14 # Cryptographic API Configuration 14 # Cryptographic API Configuration
15 # 15 #
16 menuconfig CRYPTO 16 menuconfig CRYPTO
17 tristate "Cryptographic API" 17 tristate "Cryptographic API"
18 select CRYPTO_LIB_UTILS <<
19 help 18 help
20 This option provides the core Crypto 19 This option provides the core Cryptographic API.
21 20
22 if CRYPTO 21 if CRYPTO
23 22
24 menu "Crypto core or helper" !! 23 comment "Crypto core or helper"
25 24
26 config CRYPTO_FIPS 25 config CRYPTO_FIPS
27 bool "FIPS 200 compliance" 26 bool "FIPS 200 compliance"
28 depends on (CRYPTO_ANSI_CPRNG || CRYPT 27 depends on (CRYPTO_ANSI_CPRNG || CRYPTO_DRBG) && !CRYPTO_MANAGER_DISABLE_TESTS
29 depends on (MODULE_SIG || !MODULES) 28 depends on (MODULE_SIG || !MODULES)
30 help 29 help
31 This option enables the fips boot op 30 This option enables the fips boot option which is
32 required if you want the system to o 31 required if you want the system to operate in a FIPS 200
33 certification. You should say no un 32 certification. You should say no unless you know what
34 this is. 33 this is.
35 34
36 config CRYPTO_FIPS_NAME <<
37 string "FIPS Module Name" <<
38 default "Linux Kernel Cryptographic AP <<
39 depends on CRYPTO_FIPS <<
40 help <<
41 This option sets the FIPS Module nam <<
42 the /proc/sys/crypto/fips_name file. <<
43 <<
44 config CRYPTO_FIPS_CUSTOM_VERSION <<
45 bool "Use Custom FIPS Module Version" <<
46 depends on CRYPTO_FIPS <<
47 default n <<
48 <<
49 config CRYPTO_FIPS_VERSION <<
50 string "FIPS Module Version" <<
51 default "(none)" <<
52 depends on CRYPTO_FIPS_CUSTOM_VERSION <<
53 help <<
54 This option provides the ability to <<
55 By default the KERNELRELEASE value i <<
56 <<
57 config CRYPTO_ALGAPI 35 config CRYPTO_ALGAPI
58 tristate 36 tristate
59 select CRYPTO_ALGAPI2 37 select CRYPTO_ALGAPI2
60 help 38 help
61 This option provides the API for cry 39 This option provides the API for cryptographic algorithms.
62 40
63 config CRYPTO_ALGAPI2 41 config CRYPTO_ALGAPI2
64 tristate 42 tristate
65 43
66 config CRYPTO_AEAD 44 config CRYPTO_AEAD
67 tristate 45 tristate
68 select CRYPTO_AEAD2 46 select CRYPTO_AEAD2
69 select CRYPTO_ALGAPI 47 select CRYPTO_ALGAPI
70 48
71 config CRYPTO_AEAD2 49 config CRYPTO_AEAD2
72 tristate 50 tristate
73 select CRYPTO_ALGAPI2 51 select CRYPTO_ALGAPI2
74 !! 52 select CRYPTO_NULL2
75 config CRYPTO_SIG !! 53 select CRYPTO_RNG2
76 tristate <<
77 select CRYPTO_SIG2 <<
78 select CRYPTO_ALGAPI <<
79 <<
80 config CRYPTO_SIG2 <<
81 tristate <<
82 select CRYPTO_ALGAPI2 <<
83 54
84 config CRYPTO_SKCIPHER 55 config CRYPTO_SKCIPHER
85 tristate 56 tristate
86 select CRYPTO_SKCIPHER2 57 select CRYPTO_SKCIPHER2
87 select CRYPTO_ALGAPI 58 select CRYPTO_ALGAPI
88 select CRYPTO_ECB <<
89 59
90 config CRYPTO_SKCIPHER2 60 config CRYPTO_SKCIPHER2
91 tristate 61 tristate
92 select CRYPTO_ALGAPI2 62 select CRYPTO_ALGAPI2
>> 63 select CRYPTO_RNG2
93 64
94 config CRYPTO_HASH 65 config CRYPTO_HASH
95 tristate 66 tristate
96 select CRYPTO_HASH2 67 select CRYPTO_HASH2
97 select CRYPTO_ALGAPI 68 select CRYPTO_ALGAPI
98 69
99 config CRYPTO_HASH2 70 config CRYPTO_HASH2
100 tristate 71 tristate
101 select CRYPTO_ALGAPI2 72 select CRYPTO_ALGAPI2
102 73
103 config CRYPTO_RNG 74 config CRYPTO_RNG
104 tristate 75 tristate
105 select CRYPTO_RNG2 76 select CRYPTO_RNG2
106 select CRYPTO_ALGAPI 77 select CRYPTO_ALGAPI
107 78
108 config CRYPTO_RNG2 79 config CRYPTO_RNG2
109 tristate 80 tristate
110 select CRYPTO_ALGAPI2 81 select CRYPTO_ALGAPI2
111 82
112 config CRYPTO_RNG_DEFAULT 83 config CRYPTO_RNG_DEFAULT
113 tristate 84 tristate
114 select CRYPTO_DRBG_MENU 85 select CRYPTO_DRBG_MENU
115 86
116 config CRYPTO_AKCIPHER2 87 config CRYPTO_AKCIPHER2
117 tristate 88 tristate
118 select CRYPTO_ALGAPI2 89 select CRYPTO_ALGAPI2
119 90
120 config CRYPTO_AKCIPHER 91 config CRYPTO_AKCIPHER
121 tristate 92 tristate
122 select CRYPTO_AKCIPHER2 93 select CRYPTO_AKCIPHER2
123 select CRYPTO_ALGAPI 94 select CRYPTO_ALGAPI
124 95
125 config CRYPTO_KPP2 96 config CRYPTO_KPP2
126 tristate 97 tristate
127 select CRYPTO_ALGAPI2 98 select CRYPTO_ALGAPI2
128 99
129 config CRYPTO_KPP 100 config CRYPTO_KPP
130 tristate 101 tristate
131 select CRYPTO_ALGAPI 102 select CRYPTO_ALGAPI
132 select CRYPTO_KPP2 103 select CRYPTO_KPP2
133 104
134 config CRYPTO_ACOMP2 105 config CRYPTO_ACOMP2
135 tristate 106 tristate
136 select CRYPTO_ALGAPI2 107 select CRYPTO_ALGAPI2
137 select SGL_ALLOC 108 select SGL_ALLOC
138 109
139 config CRYPTO_ACOMP 110 config CRYPTO_ACOMP
140 tristate 111 tristate
141 select CRYPTO_ALGAPI 112 select CRYPTO_ALGAPI
142 select CRYPTO_ACOMP2 113 select CRYPTO_ACOMP2
143 114
144 config CRYPTO_MANAGER 115 config CRYPTO_MANAGER
145 tristate "Cryptographic algorithm mana 116 tristate "Cryptographic algorithm manager"
146 select CRYPTO_MANAGER2 117 select CRYPTO_MANAGER2
147 help 118 help
148 Create default cryptographic templat 119 Create default cryptographic template instantiations such as
149 cbc(aes). 120 cbc(aes).
150 121
151 config CRYPTO_MANAGER2 122 config CRYPTO_MANAGER2
152 def_tristate CRYPTO_MANAGER || (CRYPTO 123 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
153 select CRYPTO_ACOMP2 <<
154 select CRYPTO_AEAD2 124 select CRYPTO_AEAD2
155 select CRYPTO_AKCIPHER2 <<
156 select CRYPTO_SIG2 <<
157 select CRYPTO_HASH2 125 select CRYPTO_HASH2
158 select CRYPTO_KPP2 <<
159 select CRYPTO_RNG2 <<
160 select CRYPTO_SKCIPHER2 126 select CRYPTO_SKCIPHER2
>> 127 select CRYPTO_AKCIPHER2
>> 128 select CRYPTO_KPP2
>> 129 select CRYPTO_ACOMP2
161 130
162 config CRYPTO_USER 131 config CRYPTO_USER
163 tristate "Userspace cryptographic algo 132 tristate "Userspace cryptographic algorithm configuration"
164 depends on NET 133 depends on NET
165 select CRYPTO_MANAGER 134 select CRYPTO_MANAGER
166 help 135 help
167 Userspace configuration for cryptogr 136 Userspace configuration for cryptographic instantiations such as
168 cbc(aes). 137 cbc(aes).
169 138
170 config CRYPTO_MANAGER_DISABLE_TESTS 139 config CRYPTO_MANAGER_DISABLE_TESTS
171 bool "Disable run-time self tests" 140 bool "Disable run-time self tests"
172 default y 141 default y
173 help 142 help
174 Disable run-time self tests that nor 143 Disable run-time self tests that normally take place at
175 algorithm registration. 144 algorithm registration.
176 145
177 config CRYPTO_MANAGER_EXTRA_TESTS 146 config CRYPTO_MANAGER_EXTRA_TESTS
178 bool "Enable extra run-time crypto sel 147 bool "Enable extra run-time crypto self tests"
179 depends on DEBUG_KERNEL && !CRYPTO_MAN 148 depends on DEBUG_KERNEL && !CRYPTO_MANAGER_DISABLE_TESTS && CRYPTO_MANAGER
180 help 149 help
181 Enable extra run-time self tests of 150 Enable extra run-time self tests of registered crypto algorithms,
182 including randomized fuzz tests. 151 including randomized fuzz tests.
183 152
184 This is intended for developer use o 153 This is intended for developer use only, as these tests take much
185 longer to run than the normal self t 154 longer to run than the normal self tests.
186 155
>> 156 config CRYPTO_GF128MUL
>> 157 tristate
>> 158
187 config CRYPTO_NULL 159 config CRYPTO_NULL
188 tristate "Null algorithms" 160 tristate "Null algorithms"
189 select CRYPTO_NULL2 161 select CRYPTO_NULL2
190 help 162 help
191 These are 'Null' algorithms, used by 163 These are 'Null' algorithms, used by IPsec, which do nothing.
192 164
193 config CRYPTO_NULL2 165 config CRYPTO_NULL2
194 tristate 166 tristate
195 select CRYPTO_ALGAPI2 167 select CRYPTO_ALGAPI2
196 select CRYPTO_SKCIPHER2 168 select CRYPTO_SKCIPHER2
197 select CRYPTO_HASH2 169 select CRYPTO_HASH2
198 170
199 config CRYPTO_PCRYPT 171 config CRYPTO_PCRYPT
200 tristate "Parallel crypto engine" 172 tristate "Parallel crypto engine"
201 depends on SMP 173 depends on SMP
202 select PADATA 174 select PADATA
203 select CRYPTO_MANAGER 175 select CRYPTO_MANAGER
204 select CRYPTO_AEAD 176 select CRYPTO_AEAD
205 help 177 help
206 This converts an arbitrary crypto al 178 This converts an arbitrary crypto algorithm into a parallel
207 algorithm that executes in kernel th 179 algorithm that executes in kernel threads.
208 180
209 config CRYPTO_CRYPTD 181 config CRYPTO_CRYPTD
210 tristate "Software async crypto daemon 182 tristate "Software async crypto daemon"
211 select CRYPTO_SKCIPHER 183 select CRYPTO_SKCIPHER
212 select CRYPTO_HASH 184 select CRYPTO_HASH
213 select CRYPTO_MANAGER 185 select CRYPTO_MANAGER
214 help 186 help
215 This is a generic software asynchron 187 This is a generic software asynchronous crypto daemon that
216 converts an arbitrary synchronous so 188 converts an arbitrary synchronous software crypto algorithm
217 into an asynchronous algorithm that 189 into an asynchronous algorithm that executes in a kernel thread.
218 190
219 config CRYPTO_AUTHENC 191 config CRYPTO_AUTHENC
220 tristate "Authenc support" 192 tristate "Authenc support"
221 select CRYPTO_AEAD 193 select CRYPTO_AEAD
222 select CRYPTO_SKCIPHER 194 select CRYPTO_SKCIPHER
223 select CRYPTO_MANAGER 195 select CRYPTO_MANAGER
224 select CRYPTO_HASH 196 select CRYPTO_HASH
225 select CRYPTO_NULL 197 select CRYPTO_NULL
226 help 198 help
227 Authenc: Combined mode wrapper for I 199 Authenc: Combined mode wrapper for IPsec.
228 !! 200 This is required for IPSec.
229 This is required for IPSec ESP (XFRM <<
230 201
231 config CRYPTO_TEST 202 config CRYPTO_TEST
232 tristate "Testing module" 203 tristate "Testing module"
233 depends on m || EXPERT 204 depends on m || EXPERT
234 select CRYPTO_MANAGER 205 select CRYPTO_MANAGER
235 help 206 help
236 Quick & dirty crypto test module. 207 Quick & dirty crypto test module.
237 208
238 config CRYPTO_SIMD 209 config CRYPTO_SIMD
239 tristate 210 tristate
240 select CRYPTO_CRYPTD 211 select CRYPTO_CRYPTD
241 212
242 config CRYPTO_ENGINE 213 config CRYPTO_ENGINE
243 tristate 214 tristate
244 215
245 endmenu !! 216 comment "Public-key cryptography"
246 <<
247 menu "Public-key cryptography" <<
248 217
249 config CRYPTO_RSA 218 config CRYPTO_RSA
250 tristate "RSA (Rivest-Shamir-Adleman)" !! 219 tristate "RSA algorithm"
251 select CRYPTO_AKCIPHER 220 select CRYPTO_AKCIPHER
252 select CRYPTO_MANAGER 221 select CRYPTO_MANAGER
253 select MPILIB 222 select MPILIB
254 select ASN1 223 select ASN1
255 help 224 help
256 RSA (Rivest-Shamir-Adleman) public k !! 225 Generic implementation of the RSA public key algorithm.
257 226
258 config CRYPTO_DH 227 config CRYPTO_DH
259 tristate "DH (Diffie-Hellman)" !! 228 tristate "Diffie-Hellman algorithm"
260 select CRYPTO_KPP 229 select CRYPTO_KPP
261 select MPILIB 230 select MPILIB
262 help 231 help
263 DH (Diffie-Hellman) key exchange alg !! 232 Generic implementation of the Diffie-Hellman algorithm.
264 <<
265 config CRYPTO_DH_RFC7919_GROUPS <<
266 bool "RFC 7919 FFDHE groups" <<
267 depends on CRYPTO_DH <<
268 select CRYPTO_RNG_DEFAULT <<
269 help <<
270 FFDHE (Finite-Field-based Diffie-Hel <<
271 defined in RFC7919. <<
272 <<
273 Support these finite-field groups in <<
274 - ffdhe2048, ffdhe3072, ffdhe4096, f <<
275 <<
276 If unsure, say N. <<
277 233
278 config CRYPTO_ECC 234 config CRYPTO_ECC
279 tristate 235 tristate
280 select CRYPTO_RNG_DEFAULT 236 select CRYPTO_RNG_DEFAULT
281 237
282 config CRYPTO_ECDH 238 config CRYPTO_ECDH
283 tristate "ECDH (Elliptic Curve Diffie- !! 239 tristate "ECDH algorithm"
284 select CRYPTO_ECC 240 select CRYPTO_ECC
285 select CRYPTO_KPP 241 select CRYPTO_KPP
286 help 242 help
287 ECDH (Elliptic Curve Diffie-Hellman) !! 243 Generic implementation of the ECDH algorithm
288 using curves P-192, P-256, and P-384 <<
289 244
290 config CRYPTO_ECDSA 245 config CRYPTO_ECDSA
291 tristate "ECDSA (Elliptic Curve Digita !! 246 tristate "ECDSA (NIST P192, P256 etc.) algorithm"
292 select CRYPTO_ECC 247 select CRYPTO_ECC
293 select CRYPTO_AKCIPHER 248 select CRYPTO_AKCIPHER
294 select ASN1 249 select ASN1
295 help 250 help
296 ECDSA (Elliptic Curve Digital Signat !! 251 Elliptic Curve Digital Signature Algorithm (NIST P192, P256 etc.)
297 ISO/IEC 14888-3) !! 252 is A NIST cryptographic standard algorithm. Only signature verification
298 using curves P-192, P-256, and P-384 !! 253 is implemented.
299 <<
300 Only signature verification is imple <<
301 254
302 config CRYPTO_ECRDSA 255 config CRYPTO_ECRDSA
303 tristate "EC-RDSA (Elliptic Curve Russ !! 256 tristate "EC-RDSA (GOST 34.10) algorithm"
304 select CRYPTO_ECC 257 select CRYPTO_ECC
305 select CRYPTO_AKCIPHER 258 select CRYPTO_AKCIPHER
306 select CRYPTO_STREEBOG 259 select CRYPTO_STREEBOG
307 select OID_REGISTRY 260 select OID_REGISTRY
308 select ASN1 261 select ASN1
309 help 262 help
310 Elliptic Curve Russian Digital Signa 263 Elliptic Curve Russian Digital Signature Algorithm (GOST R 34.10-2012,
311 RFC 7091, ISO/IEC 14888-3) !! 264 RFC 7091, ISO/IEC 14888-3:2018) is one of the Russian cryptographic
>> 265 standard algorithms (called GOST algorithms). Only signature verification
>> 266 is implemented.
>> 267
>> 268 config CRYPTO_SM2
>> 269 tristate "SM2 algorithm"
>> 270 select CRYPTO_SM3
>> 271 select CRYPTO_AKCIPHER
>> 272 select CRYPTO_MANAGER
>> 273 select MPILIB
>> 274 select ASN1
>> 275 help
>> 276 Generic implementation of the SM2 public key algorithm. It was
>> 277 published by State Encryption Management Bureau, China.
>> 278 as specified by OSCCA GM/T 0003.1-2012 -- 0003.5-2012.
312 279
313 One of the Russian cryptographic sta !! 280 References:
314 algorithms). Only signature verifica !! 281 https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02
>> 282 http://www.oscca.gov.cn/sca/xxgk/2010-12/17/content_1002386.shtml
>> 283 http://www.gmbz.org.cn/main/bzlb.html
315 284
316 config CRYPTO_CURVE25519 285 config CRYPTO_CURVE25519
317 tristate "Curve25519" !! 286 tristate "Curve25519 algorithm"
318 select CRYPTO_KPP 287 select CRYPTO_KPP
319 select CRYPTO_LIB_CURVE25519_GENERIC 288 select CRYPTO_LIB_CURVE25519_GENERIC
320 help <<
321 Curve25519 elliptic curve (RFC7748) <<
322 <<
323 endmenu <<
324 <<
325 menu "Block ciphers" <<
326 <<
327 config CRYPTO_AES <<
328 tristate "AES (Advanced Encryption Sta <<
329 select CRYPTO_ALGAPI <<
330 select CRYPTO_LIB_AES <<
331 help <<
332 AES cipher algorithms (Rijndael)(FIP <<
333 <<
334 Rijndael appears to be consistently <<
335 both hardware and software across a <<
336 environments regardless of its use i <<
337 modes. Its key setup time is excelle <<
338 good. Rijndael's very low memory req <<
339 suited for restricted-space environm <<
340 demonstrates excellent performance. <<
341 among the easiest to defend against <<
342 <<
343 The AES specifies three key sizes: 1 <<
344 <<
345 config CRYPTO_AES_TI <<
346 tristate "AES (Advanced Encryption Sta <<
347 select CRYPTO_ALGAPI <<
348 select CRYPTO_LIB_AES <<
349 help <<
350 AES cipher algorithms (Rijndael)(FIP <<
351 289
352 This is a generic implementation of !! 290 config CRYPTO_CURVE25519_X86
353 data dependent latencies as much as !! 291 tristate "x86_64 accelerated Curve25519 scalar multiplication library"
354 performance too much. It is intended !! 292 depends on X86 && 64BIT
355 and GCM drivers, and other CTR or CM !! 293 select CRYPTO_LIB_CURVE25519_GENERIC
356 solely on encryption (although decry !! 294 select CRYPTO_ARCH_HAVE_LIB_CURVE25519
357 with a more dramatic performance hit <<
358 <<
359 Instead of using 16 lookup tables of <<
360 8 for decryption), this implementati <<
361 256 bytes each, and attempts to elim <<
362 prefetching the entire table into th <<
363 block. Interrupts are also disabled <<
364 are evicted when the CPU is interrup <<
365 <<
366 config CRYPTO_ANUBIS <<
367 tristate "Anubis" <<
368 depends on CRYPTO_USER_API_ENABLE_OBSO <<
369 select CRYPTO_ALGAPI <<
370 help <<
371 Anubis cipher algorithm <<
372 <<
373 Anubis is a variable key length ciph <<
374 128 bits to 320 bits in length. It <<
375 in the NESSIE competition. <<
376 <<
377 See https://web.archive.org/web/2016 <<
378 for further information. <<
379 <<
380 config CRYPTO_ARIA <<
381 tristate "ARIA" <<
382 select CRYPTO_ALGAPI <<
383 help <<
384 ARIA cipher algorithm (RFC5794) <<
385 <<
386 ARIA is a standard encryption algori <<
387 The ARIA specifies three key sizes a <<
388 128-bit: 12 rounds. <<
389 192-bit: 14 rounds. <<
390 256-bit: 16 rounds. <<
391 295
392 See: !! 296 comment "Authenticated Encryption with Associated Data"
393 https://seed.kisa.or.kr/kisa/algorit <<
394 297
395 config CRYPTO_BLOWFISH !! 298 config CRYPTO_CCM
396 tristate "Blowfish" !! 299 tristate "CCM support"
397 select CRYPTO_ALGAPI !! 300 select CRYPTO_CTR
398 select CRYPTO_BLOWFISH_COMMON !! 301 select CRYPTO_HASH
>> 302 select CRYPTO_AEAD
>> 303 select CRYPTO_MANAGER
399 help 304 help
400 Blowfish cipher algorithm, by Bruce !! 305 Support for Counter with CBC MAC. Required for IPsec.
401 306
402 This is a variable key length cipher !! 307 config CRYPTO_GCM
403 bits to 448 bits in length. It's fa !! 308 tristate "GCM/GMAC support"
404 designed for use on "large microproc !! 309 select CRYPTO_CTR
405 !! 310 select CRYPTO_AEAD
406 See https://www.schneier.com/blowfis !! 311 select CRYPTO_GHASH
407 !! 312 select CRYPTO_NULL
408 config CRYPTO_BLOWFISH_COMMON !! 313 select CRYPTO_MANAGER
409 tristate <<
410 help 314 help
411 Common parts of the Blowfish cipher !! 315 Support for Galois/Counter Mode (GCM) and Galois Message
412 generic c and the assembler implemen !! 316 Authentication Code (GMAC). Required for IPSec.
413 317
414 config CRYPTO_CAMELLIA !! 318 config CRYPTO_CHACHA20POLY1305
415 tristate "Camellia" !! 319 tristate "ChaCha20-Poly1305 AEAD support"
416 select CRYPTO_ALGAPI !! 320 select CRYPTO_CHACHA20
>> 321 select CRYPTO_POLY1305
>> 322 select CRYPTO_AEAD
>> 323 select CRYPTO_MANAGER
417 help 324 help
418 Camellia cipher algorithms (ISO/IEC !! 325 ChaCha20-Poly1305 AEAD support, RFC7539.
419 <<
420 Camellia is a symmetric key block ci <<
421 at NTT and Mitsubishi Electric Corpo <<
422 326
423 The Camellia specifies three key siz !! 327 Support for the AEAD wrapper using the ChaCha20 stream cipher combined
424 !! 328 with the Poly1305 authenticator. It is defined in RFC7539 for use in
425 See https://info.isl.ntt.co.jp/crypt !! 329 IETF protocols.
426 <<
427 config CRYPTO_CAST_COMMON <<
428 tristate <<
429 help <<
430 Common parts of the CAST cipher algo <<
431 generic c and the assembler implemen <<
432 330
433 config CRYPTO_CAST5 !! 331 config CRYPTO_AEGIS128
434 tristate "CAST5 (CAST-128)" !! 332 tristate "AEGIS-128 AEAD algorithm"
435 select CRYPTO_ALGAPI !! 333 select CRYPTO_AEAD
436 select CRYPTO_CAST_COMMON !! 334 select CRYPTO_AES # for AES S-box tables
437 help 335 help
438 CAST5 (CAST-128) cipher algorithm (R !! 336 Support for the AEGIS-128 dedicated AEAD algorithm.
439 337
440 config CRYPTO_CAST6 !! 338 config CRYPTO_AEGIS128_SIMD
441 tristate "CAST6 (CAST-256)" !! 339 bool "Support SIMD acceleration for AEGIS-128"
442 select CRYPTO_ALGAPI !! 340 depends on CRYPTO_AEGIS128 && ((ARM || ARM64) && KERNEL_MODE_NEON)
443 select CRYPTO_CAST_COMMON !! 341 default y
444 help <<
445 CAST6 (CAST-256) encryption algorith <<
446 342
447 config CRYPTO_DES !! 343 config CRYPTO_AEGIS128_AESNI_SSE2
448 tristate "DES and Triple DES EDE" !! 344 tristate "AEGIS-128 AEAD algorithm (x86_64 AESNI+SSE2 implementation)"
449 select CRYPTO_ALGAPI !! 345 depends on X86 && 64BIT
450 select CRYPTO_LIB_DES !! 346 select CRYPTO_AEAD
>> 347 select CRYPTO_SIMD
451 help 348 help
452 DES (Data Encryption Standard)(FIPS !! 349 AESNI+SSE2 implementation of the AEGIS-128 dedicated AEAD algorithm.
453 Triple DES EDE (Encrypt/Decrypt/Encr <<
454 cipher algorithms <<
455 350
456 config CRYPTO_FCRYPT !! 351 config CRYPTO_SEQIV
457 tristate "FCrypt" !! 352 tristate "Sequence Number IV Generator"
458 select CRYPTO_ALGAPI !! 353 select CRYPTO_AEAD
459 select CRYPTO_SKCIPHER 354 select CRYPTO_SKCIPHER
460 help !! 355 select CRYPTO_NULL
461 FCrypt algorithm used by RxRPC !! 356 select CRYPTO_RNG_DEFAULT
462 <<
463 See https://ota.polyonymo.us/fcrypt- <<
464 <<
465 config CRYPTO_KHAZAD <<
466 tristate "Khazad" <<
467 depends on CRYPTO_USER_API_ENABLE_OBSO <<
468 select CRYPTO_ALGAPI <<
469 help <<
470 Khazad cipher algorithm <<
471 <<
472 Khazad was a finalist in the initial <<
473 an algorithm optimized for 64-bit pr <<
474 on 32-bit processors. Khazad uses a <<
475 <<
476 See https://web.archive.org/web/2017 <<
477 for further information. <<
478 <<
479 config CRYPTO_SEED <<
480 tristate "SEED" <<
481 depends on CRYPTO_USER_API_ENABLE_OBSO <<
482 select CRYPTO_ALGAPI <<
483 help <<
484 SEED cipher algorithm (RFC4269, ISO/ <<
485 <<
486 SEED is a 128-bit symmetric key bloc <<
487 developed by KISA (Korea Information <<
488 national standard encryption algorit <<
489 It is a 16 round block cipher with t <<
490 <<
491 See https://seed.kisa.or.kr/kisa/alg <<
492 for further information. <<
493 <<
494 config CRYPTO_SERPENT <<
495 tristate "Serpent" <<
496 select CRYPTO_ALGAPI <<
497 help <<
498 Serpent cipher algorithm, by Anderso <<
499 <<
500 Keys are allowed to be from 0 to 256 <<
501 of 8 bits. <<
502 <<
503 See https://www.cl.cam.ac.uk/~rja14/ <<
504 <<
505 config CRYPTO_SM4 <<
506 tristate <<
507 <<
508 config CRYPTO_SM4_GENERIC <<
509 tristate "SM4 (ShangMi 4)" <<
510 select CRYPTO_ALGAPI <<
511 select CRYPTO_SM4 <<
512 help <<
513 SM4 cipher algorithms (OSCCA GB/T 32 <<
514 ISO/IEC 18033-3:2010/Amd 1:2021) <<
515 <<
516 SM4 (GBT.32907-2016) is a cryptograp <<
517 Organization of State Commercial Adm <<
518 as an authorized cryptographic algor <<
519 <<
520 SMS4 was originally created for use <<
521 networks, and is mandated in the Chi <<
522 Wireless LAN WAPI (Wired Authenticat <<
523 (GB.15629.11-2003). <<
524 <<
525 The latest SM4 standard (GBT.32907-2 <<
526 standardized through TC 260 of the S <<
527 of the People's Republic of China (S <<
528 <<
529 The input, output, and key of SMS4 a <<
530 <<
531 See https://eprint.iacr.org/2008/329 <<
532 <<
533 If unsure, say N. <<
534 <<
535 config CRYPTO_TEA <<
536 tristate "TEA, XTEA and XETA" <<
537 depends on CRYPTO_USER_API_ENABLE_OBSO <<
538 select CRYPTO_ALGAPI <<
539 help <<
540 TEA (Tiny Encryption Algorithm) ciph <<
541 <<
542 Tiny Encryption Algorithm is a simpl <<
543 many rounds for security. It is ver <<
544 little memory. <<
545 <<
546 Xtendend Tiny Encryption Algorithm i <<
547 the TEA algorithm to address a poten <<
548 in the TEA algorithm. <<
549 <<
550 Xtendend Encryption Tiny Algorithm i <<
551 of the XTEA algorithm for compatibil <<
552 <<
553 config CRYPTO_TWOFISH <<
554 tristate "Twofish" <<
555 select CRYPTO_ALGAPI <<
556 select CRYPTO_TWOFISH_COMMON <<
557 help <<
558 Twofish cipher algorithm <<
559 <<
560 Twofish was submitted as an AES (Adv <<
561 candidate cipher by researchers at C <<
562 16 round block cipher supporting key <<
563 bits. <<
564 <<
565 See https://www.schneier.com/twofish <<
566 <<
567 config CRYPTO_TWOFISH_COMMON <<
568 tristate <<
569 help <<
570 Common parts of the Twofish cipher a <<
571 generic c and the assembler implemen <<
572 <<
573 endmenu <<
574 <<
575 menu "Length-preserving ciphers and modes" <<
576 <<
577 config CRYPTO_ADIANTUM <<
578 tristate "Adiantum" <<
579 select CRYPTO_CHACHA20 <<
580 select CRYPTO_LIB_POLY1305_GENERIC <<
581 select CRYPTO_NHPOLY1305 <<
582 select CRYPTO_MANAGER 357 select CRYPTO_MANAGER
583 help 358 help
584 Adiantum tweakable, length-preservin !! 359 This IV generator generates an IV based on a sequence number by
585 !! 360 xoring it with a salt. This algorithm is mainly useful for CTR
586 Designed for fast and secure disk en <<
587 CPUs without dedicated crypto instru <<
588 each sector using the XChaCha12 stre <<
589 an ε-almost-∆-universal hash func <<
590 the AES-256 block cipher on a single <<
591 without AES instructions, Adiantum i <<
592 AES-XTS. <<
593 <<
594 Adiantum's security is provably redu <<
595 underlying stream and block ciphers, <<
596 bound. Unlike XTS, Adiantum is a tr <<
597 mode, so it actually provides an eve <<
598 security than XTS, subject to the se <<
599 <<
600 If unsure, say N. <<
601 361
602 config CRYPTO_ARC4 !! 362 config CRYPTO_ECHAINIV
603 tristate "ARC4 (Alleged Rivest Cipher !! 363 tristate "Encrypted Chain IV Generator"
604 depends on CRYPTO_USER_API_ENABLE_OBSO !! 364 select CRYPTO_AEAD
605 select CRYPTO_SKCIPHER !! 365 select CRYPTO_NULL
606 select CRYPTO_LIB_ARC4 !! 366 select CRYPTO_RNG_DEFAULT
>> 367 select CRYPTO_MANAGER
607 help 368 help
608 ARC4 cipher algorithm !! 369 This IV generator generates an IV based on the encryption of
>> 370 a sequence number xored with a salt. This is the default
>> 371 algorithm for CBC.
609 372
610 ARC4 is a stream cipher using keys r !! 373 comment "Block modes"
611 bits in length. This algorithm is r <<
612 WEP, but it should not be for other <<
613 weakness of the algorithm. <<
614 374
615 config CRYPTO_CHACHA20 !! 375 config CRYPTO_CBC
616 tristate "ChaCha" !! 376 tristate "CBC support"
617 select CRYPTO_LIB_CHACHA_GENERIC <<
618 select CRYPTO_SKCIPHER 377 select CRYPTO_SKCIPHER
>> 378 select CRYPTO_MANAGER
619 help 379 help
620 The ChaCha20, XChaCha20, and XChaCha !! 380 CBC: Cipher Block Chaining mode
621 !! 381 This block cipher algorithm is required for IPSec.
622 ChaCha20 is a 256-bit high-speed str <<
623 Bernstein and further specified in R <<
624 This is the portable C implementatio <<
625 https://cr.yp.to/chacha/chacha-20080 <<
626 382
627 XChaCha20 is the application of the !! 383 config CRYPTO_CFB
628 rather than to Salsa20. XChaCha20 e !! 384 tristate "CFB support"
629 from 64 bits (or 96 bits using the R <<
630 while provably retaining ChaCha20's <<
631 https://cr.yp.to/snuffle/xsalsa-2008 <<
632 <<
633 XChaCha12 is XChaCha20 reduced to 12 <<
634 reduced security margin but increase <<
635 in some performance-sensitive scenar <<
636 <<
637 config CRYPTO_CBC <<
638 tristate "CBC (Cipher Block Chaining)" <<
639 select CRYPTO_SKCIPHER 385 select CRYPTO_SKCIPHER
640 select CRYPTO_MANAGER 386 select CRYPTO_MANAGER
641 help 387 help
642 CBC (Cipher Block Chaining) mode (NI !! 388 CFB: Cipher FeedBack mode
643 !! 389 This block cipher algorithm is required for TPM2 Cryptography.
644 This block cipher mode is required f <<
645 390
646 config CRYPTO_CTR 391 config CRYPTO_CTR
647 tristate "CTR (Counter)" !! 392 tristate "CTR support"
648 select CRYPTO_SKCIPHER 393 select CRYPTO_SKCIPHER
649 select CRYPTO_MANAGER 394 select CRYPTO_MANAGER
650 help 395 help
651 CTR (Counter) mode (NIST SP800-38A) !! 396 CTR: Counter mode
>> 397 This block cipher algorithm is required for IPSec.
652 398
653 config CRYPTO_CTS 399 config CRYPTO_CTS
654 tristate "CTS (Cipher Text Stealing)" !! 400 tristate "CTS support"
655 select CRYPTO_SKCIPHER 401 select CRYPTO_SKCIPHER
656 select CRYPTO_MANAGER 402 select CRYPTO_MANAGER
657 help 403 help
658 CBC-CS3 variant of CTS (Cipher Text !! 404 CTS: Cipher Text Stealing
659 Addendum to SP800-38A (October 2010) !! 405 This is the Cipher Text Stealing mode as described by
660 !! 406 Section 8 of rfc2040 and referenced by rfc3962
>> 407 (rfc3962 includes errata information in its Appendix A) or
>> 408 CBC-CS3 as defined by NIST in Sp800-38A addendum from Oct 2010.
661 This mode is required for Kerberos g 409 This mode is required for Kerberos gss mechanism support
662 for AES encryption. 410 for AES encryption.
663 411
664 config CRYPTO_ECB !! 412 See: https://csrc.nist.gov/publications/detail/sp/800-38a/addendum/final
665 tristate "ECB (Electronic Codebook)" <<
666 select CRYPTO_SKCIPHER2 <<
667 select CRYPTO_MANAGER <<
668 help <<
669 ECB (Electronic Codebook) mode (NIST <<
670 <<
671 config CRYPTO_HCTR2 <<
672 tristate "HCTR2" <<
673 select CRYPTO_XCTR <<
674 select CRYPTO_POLYVAL <<
675 select CRYPTO_MANAGER <<
676 help <<
677 HCTR2 length-preserving encryption m <<
678 413
679 A mode for storage encryption that i !! 414 config CRYPTO_ECB
680 instructions to accelerate AES and c !! 415 tristate "ECB support"
681 x86 processors with AES-NI and CLMUL <<
682 ARMv8 crypto extensions. <<
683 <<
684 See https://eprint.iacr.org/2021/144 <<
685 <<
686 config CRYPTO_KEYWRAP <<
687 tristate "KW (AES Key Wrap)" <<
688 select CRYPTO_SKCIPHER 416 select CRYPTO_SKCIPHER
689 select CRYPTO_MANAGER 417 select CRYPTO_MANAGER
690 help 418 help
691 KW (AES Key Wrap) authenticated encr !! 419 ECB: Electronic CodeBook mode
692 and RFC3394) without padding. !! 420 This is the simplest block cipher algorithm. It simply encrypts
>> 421 the input block by block.
693 422
694 config CRYPTO_LRW 423 config CRYPTO_LRW
695 tristate "LRW (Liskov Rivest Wagner)" !! 424 tristate "LRW support"
696 select CRYPTO_LIB_GF128MUL <<
697 select CRYPTO_SKCIPHER 425 select CRYPTO_SKCIPHER
698 select CRYPTO_MANAGER 426 select CRYPTO_MANAGER
699 select CRYPTO_ECB !! 427 select CRYPTO_GF128MUL
700 help 428 help
701 LRW (Liskov Rivest Wagner) mode !! 429 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
702 <<
703 A tweakable, non malleable, non mova <<
704 narrow block cipher mode for dm-cryp 430 narrow block cipher mode for dm-crypt. Use it with cipher
705 specification string aes-lrw-benbi, 431 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
706 The first 128, 192 or 256 bits in th 432 The first 128, 192 or 256 bits in the key are used for AES and the
707 rest is used to tie each cipher bloc 433 rest is used to tie each cipher block to its logical position.
708 434
709 See https://people.csail.mit.edu/riv !! 435 config CRYPTO_OFB
710 !! 436 tristate "OFB support"
711 config CRYPTO_PCBC <<
712 tristate "PCBC (Propagating Cipher Blo <<
713 select CRYPTO_SKCIPHER 437 select CRYPTO_SKCIPHER
714 select CRYPTO_MANAGER 438 select CRYPTO_MANAGER
715 help 439 help
716 PCBC (Propagating Cipher Block Chain !! 440 OFB: the Output Feedback mode makes a block cipher into a synchronous
>> 441 stream cipher. It generates keystream blocks, which are then XORed
>> 442 with the plaintext blocks to get the ciphertext. Flipping a bit in the
>> 443 ciphertext produces a flipped bit in the plaintext at the same
>> 444 location. This property allows many error correcting codes to function
>> 445 normally even when applied before encryption.
717 446
718 This block cipher mode is required f !! 447 config CRYPTO_PCBC
719 !! 448 tristate "PCBC support"
720 config CRYPTO_XCTR <<
721 tristate <<
722 select CRYPTO_SKCIPHER 449 select CRYPTO_SKCIPHER
723 select CRYPTO_MANAGER 450 select CRYPTO_MANAGER
724 help 451 help
725 XCTR (XOR Counter) mode for HCTR2 !! 452 PCBC: Propagating Cipher Block Chaining mode
726 !! 453 This block cipher algorithm is required for RxRPC.
727 This blockcipher mode is a variant o <<
728 addition rather than big-endian arit <<
729 <<
730 XCTR mode is used to implement HCTR2 <<
731 454
732 config CRYPTO_XTS 455 config CRYPTO_XTS
733 tristate "XTS (XOR Encrypt XOR with ci !! 456 tristate "XTS support"
734 select CRYPTO_SKCIPHER 457 select CRYPTO_SKCIPHER
735 select CRYPTO_MANAGER 458 select CRYPTO_MANAGER
736 select CRYPTO_ECB 459 select CRYPTO_ECB
737 help 460 help
738 XTS (XOR Encrypt XOR with ciphertext !! 461 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
739 and IEEE 1619) !! 462 key size 256, 384 or 512 bits. This implementation currently
>> 463 can't handle a sectorsize which is not a multiple of 16 bytes.
740 464
741 Use with aes-xts-plain, key size 256 !! 465 config CRYPTO_KEYWRAP
742 implementation currently can't handl !! 466 tristate "Key wrapping support"
743 multiple of 16 bytes. !! 467 select CRYPTO_SKCIPHER
>> 468 select CRYPTO_MANAGER
>> 469 help
>> 470 Support for key wrapping (NIST SP800-38F / RFC3394) without
>> 471 padding.
744 472
745 config CRYPTO_NHPOLY1305 473 config CRYPTO_NHPOLY1305
746 tristate 474 tristate
747 select CRYPTO_HASH 475 select CRYPTO_HASH
748 select CRYPTO_LIB_POLY1305_GENERIC 476 select CRYPTO_LIB_POLY1305_GENERIC
749 477
750 endmenu !! 478 config CRYPTO_NHPOLY1305_SSE2
751 !! 479 tristate "NHPoly1305 hash function (x86_64 SSE2 implementation)"
752 menu "AEAD (authenticated encryption with asso !! 480 depends on X86 && 64BIT
753 !! 481 select CRYPTO_NHPOLY1305
754 config CRYPTO_AEGIS128 <<
755 tristate "AEGIS-128" <<
756 select CRYPTO_AEAD <<
757 select CRYPTO_AES # for AES S-box tab <<
758 help 482 help
759 AEGIS-128 AEAD algorithm !! 483 SSE2 optimized implementation of the hash function used by the
>> 484 Adiantum encryption mode.
760 485
761 config CRYPTO_AEGIS128_SIMD !! 486 config CRYPTO_NHPOLY1305_AVX2
762 bool "AEGIS-128 (arm NEON, arm64 NEON) !! 487 tristate "NHPoly1305 hash function (x86_64 AVX2 implementation)"
763 depends on CRYPTO_AEGIS128 && ((ARM || !! 488 depends on X86 && 64BIT
764 default y !! 489 select CRYPTO_NHPOLY1305
765 help 490 help
766 AEGIS-128 AEAD algorithm !! 491 AVX2 optimized implementation of the hash function used by the
767 !! 492 Adiantum encryption mode.
768 Architecture: arm or arm64 using: <<
769 - NEON (Advanced SIMD) extension <<
770 493
771 config CRYPTO_CHACHA20POLY1305 !! 494 config CRYPTO_ADIANTUM
772 tristate "ChaCha20-Poly1305" !! 495 tristate "Adiantum support"
773 select CRYPTO_CHACHA20 496 select CRYPTO_CHACHA20
774 select CRYPTO_POLY1305 !! 497 select CRYPTO_LIB_POLY1305_GENERIC
775 select CRYPTO_AEAD !! 498 select CRYPTO_NHPOLY1305
776 select CRYPTO_MANAGER <<
777 help <<
778 ChaCha20 stream cipher and Poly1305 <<
779 mode (RFC8439) <<
780 <<
781 config CRYPTO_CCM <<
782 tristate "CCM (Counter with Cipher Blo <<
783 select CRYPTO_CTR <<
784 select CRYPTO_HASH <<
785 select CRYPTO_AEAD <<
786 select CRYPTO_MANAGER <<
787 help <<
788 CCM (Counter with Cipher Block Chain <<
789 authenticated encryption mode (NIST <<
790 <<
791 config CRYPTO_GCM <<
792 tristate "GCM (Galois/Counter Mode) an <<
793 select CRYPTO_CTR <<
794 select CRYPTO_AEAD <<
795 select CRYPTO_GHASH <<
796 select CRYPTO_NULL <<
797 select CRYPTO_MANAGER <<
798 help <<
799 GCM (Galois/Counter Mode) authentica <<
800 (GCM Message Authentication Code) (N <<
801 <<
802 This is required for IPSec ESP (XFRM <<
803 <<
804 config CRYPTO_GENIV <<
805 tristate <<
806 select CRYPTO_AEAD <<
807 select CRYPTO_NULL <<
808 select CRYPTO_MANAGER 499 select CRYPTO_MANAGER
809 select CRYPTO_RNG_DEFAULT <<
810 <<
811 config CRYPTO_SEQIV <<
812 tristate "Sequence Number IV Generator <<
813 select CRYPTO_GENIV <<
814 help 500 help
815 Sequence Number IV generator !! 501 Adiantum is a tweakable, length-preserving encryption mode
816 !! 502 designed for fast and secure disk encryption, especially on
817 This IV generator generates an IV ba !! 503 CPUs without dedicated crypto instructions. It encrypts
818 xoring it with a salt. This algorit !! 504 each sector using the XChaCha12 stream cipher, two passes of
819 !! 505 an ε-almost-∆-universal hash function, and an invocation of
820 This is required for IPsec ESP (XFRM !! 506 the AES-256 block cipher on a single 16-byte block. On CPUs
>> 507 without AES instructions, Adiantum is much faster than
>> 508 AES-XTS.
821 509
822 config CRYPTO_ECHAINIV !! 510 Adiantum's security is provably reducible to that of its
823 tristate "Encrypted Chain IV Generator !! 511 underlying stream and block ciphers, subject to a security
824 select CRYPTO_GENIV !! 512 bound. Unlike XTS, Adiantum is a true wide-block encryption
825 help !! 513 mode, so it actually provides an even stronger notion of
826 Encrypted Chain IV generator !! 514 security than XTS, subject to the security bound.
827 515
828 This IV generator generates an IV ba !! 516 If unsure, say N.
829 a sequence number xored with a salt. <<
830 algorithm for CBC. <<
831 517
832 config CRYPTO_ESSIV 518 config CRYPTO_ESSIV
833 tristate "Encrypted Salt-Sector IV Gen !! 519 tristate "ESSIV support for block encryption"
834 select CRYPTO_AUTHENC 520 select CRYPTO_AUTHENC
835 help 521 help
836 Encrypted Salt-Sector IV generator !! 522 Encrypted salt-sector initialization vector (ESSIV) is an IV
837 !! 523 generation method that is used in some cases by fscrypt and/or
838 This IV generator is used in some ca <<
839 dm-crypt. It uses the hash of the bl 524 dm-crypt. It uses the hash of the block encryption key as the
840 symmetric key for a block encryption 525 symmetric key for a block encryption pass applied to the input
841 IV, making low entropy IV sources mo 526 IV, making low entropy IV sources more suitable for block
842 encryption. 527 encryption.
843 528
844 This driver implements a crypto API 529 This driver implements a crypto API template that can be
845 instantiated either as an skcipher o 530 instantiated either as an skcipher or as an AEAD (depending on the
846 type of the first template argument) 531 type of the first template argument), and which defers encryption
847 and decryption requests to the encap 532 and decryption requests to the encapsulated cipher after applying
848 ESSIV to the input IV. Note that in 533 ESSIV to the input IV. Note that in the AEAD case, it is assumed
849 that the keys are presented in the s 534 that the keys are presented in the same format used by the authenc
850 template, and that the IV appears at 535 template, and that the IV appears at the end of the authenticated
851 associated data (AAD) region (which 536 associated data (AAD) region (which is how dm-crypt uses it.)
852 537
853 Note that the use of ESSIV is not re 538 Note that the use of ESSIV is not recommended for new deployments,
854 and so this only needs to be enabled 539 and so this only needs to be enabled when interoperability with
855 existing encrypted volumes of filesy 540 existing encrypted volumes of filesystems is required, or when
856 building for a particular system tha 541 building for a particular system that requires it (e.g., when
857 the SoC in question has accelerated 542 the SoC in question has accelerated CBC but not XTS, making CBC
858 combined with ESSIV the only feasibl 543 combined with ESSIV the only feasible mode for h/w accelerated
859 block encryption) 544 block encryption)
860 545
861 endmenu !! 546 comment "Hash modes"
862 547
863 menu "Hashes, digests, and MACs" !! 548 config CRYPTO_CMAC
>> 549 tristate "CMAC support"
>> 550 select CRYPTO_HASH
>> 551 select CRYPTO_MANAGER
>> 552 help
>> 553 Cipher-based Message Authentication Code (CMAC) specified by
>> 554 The National Institute of Standards and Technology (NIST).
864 555
865 config CRYPTO_BLAKE2B !! 556 https://tools.ietf.org/html/rfc4493
866 tristate "BLAKE2b" !! 557 http://csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
>> 558
>> 559 config CRYPTO_HMAC
>> 560 tristate "HMAC support"
>> 561 select CRYPTO_HASH
>> 562 select CRYPTO_MANAGER
>> 563 help
>> 564 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
>> 565 This is required for IPSec.
>> 566
>> 567 config CRYPTO_XCBC
>> 568 tristate "XCBC support"
>> 569 select CRYPTO_HASH
>> 570 select CRYPTO_MANAGER
>> 571 help
>> 572 XCBC: Keyed-Hashing with encryption algorithm
>> 573 https://www.ietf.org/rfc/rfc3566.txt
>> 574 http://csrc.nist.gov/encryption/modes/proposedmodes/
>> 575 xcbc-mac/xcbc-mac-spec.pdf
>> 576
>> 577 config CRYPTO_VMAC
>> 578 tristate "VMAC support"
867 select CRYPTO_HASH 579 select CRYPTO_HASH
>> 580 select CRYPTO_MANAGER
868 help 581 help
869 BLAKE2b cryptographic hash function !! 582 VMAC is a message authentication algorithm designed for
>> 583 very high speed on 64-bit architectures.
870 584
871 BLAKE2b is optimized for 64-bit plat !! 585 See also:
872 of any size between 1 and 64 bytes. !! 586 <https://fastcrypto.org/vmac>
>> 587
>> 588 comment "Digest"
>> 589
>> 590 config CRYPTO_CRC32C
>> 591 tristate "CRC32c CRC algorithm"
>> 592 select CRYPTO_HASH
>> 593 select CRC32
>> 594 help
>> 595 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
>> 596 by iSCSI for header and data digests and by others.
>> 597 See Castagnoli93. Module will be crc32c.
>> 598
>> 599 config CRYPTO_CRC32C_INTEL
>> 600 tristate "CRC32c INTEL hardware acceleration"
>> 601 depends on X86
>> 602 select CRYPTO_HASH
>> 603 help
>> 604 In Intel processor with SSE4.2 supported, the processor will
>> 605 support CRC32C implementation using hardware accelerated CRC32
>> 606 instruction. This option will create 'crc32c-intel' module,
>> 607 which will enable any routine to use the CRC32 instruction to
>> 608 gain performance compared with software implementation.
>> 609 Module will be crc32c-intel.
>> 610
>> 611 config CRYPTO_CRC32C_VPMSUM
>> 612 tristate "CRC32c CRC algorithm (powerpc64)"
>> 613 depends on PPC64 && ALTIVEC
>> 614 select CRYPTO_HASH
>> 615 select CRC32
>> 616 help
>> 617 CRC32c algorithm implemented using vector polynomial multiply-sum
>> 618 (vpmsum) instructions, introduced in POWER8. Enable on POWER8
>> 619 and newer processors for improved performance.
>> 620
>> 621
>> 622 config CRYPTO_CRC32C_SPARC64
>> 623 tristate "CRC32c CRC algorithm (SPARC64)"
>> 624 depends on SPARC64
>> 625 select CRYPTO_HASH
>> 626 select CRC32
>> 627 help
>> 628 CRC32c CRC algorithm implemented using sparc64 crypto instructions,
>> 629 when available.
>> 630
>> 631 config CRYPTO_CRC32
>> 632 tristate "CRC32 CRC algorithm"
>> 633 select CRYPTO_HASH
>> 634 select CRC32
>> 635 help
>> 636 CRC-32-IEEE 802.3 cyclic redundancy-check algorithm.
>> 637 Shash crypto api wrappers to crc32_le function.
>> 638
>> 639 config CRYPTO_CRC32_PCLMUL
>> 640 tristate "CRC32 PCLMULQDQ hardware acceleration"
>> 641 depends on X86
>> 642 select CRYPTO_HASH
>> 643 select CRC32
>> 644 help
>> 645 From Intel Westmere and AMD Bulldozer processor with SSE4.2
>> 646 and PCLMULQDQ supported, the processor will support
>> 647 CRC32 PCLMULQDQ implementation using hardware accelerated PCLMULQDQ
>> 648 instruction. This option will create 'crc32-pclmul' module,
>> 649 which will enable any routine to use the CRC-32-IEEE 802.3 checksum
>> 650 and gain better performance as compared with the table implementation.
>> 651
>> 652 config CRYPTO_CRC32_MIPS
>> 653 tristate "CRC32c and CRC32 CRC algorithm (MIPS)"
>> 654 depends on MIPS_CRC_SUPPORT
>> 655 select CRYPTO_HASH
>> 656 help
>> 657 CRC32c and CRC32 CRC algorithms implemented using mips crypto
>> 658 instructions, when available.
>> 659
>> 660
>> 661 config CRYPTO_XXHASH
>> 662 tristate "xxHash hash algorithm"
>> 663 select CRYPTO_HASH
>> 664 select XXHASH
>> 665 help
>> 666 xxHash non-cryptographic hash algorithm. Extremely fast, working at
>> 667 speeds close to RAM limits.
>> 668
>> 669 config CRYPTO_BLAKE2B
>> 670 tristate "BLAKE2b digest algorithm"
>> 671 select CRYPTO_HASH
>> 672 help
>> 673 Implementation of cryptographic hash function BLAKE2b (or just BLAKE2),
>> 674 optimized for 64bit platforms and can produce digests of any size
>> 675 between 1 to 64. The keyed hash is also implemented.
873 676
874 This module provides the following a 677 This module provides the following algorithms:
>> 678
875 - blake2b-160 679 - blake2b-160
876 - blake2b-256 680 - blake2b-256
877 - blake2b-384 681 - blake2b-384
878 - blake2b-512 682 - blake2b-512
879 683
880 Used by the btrfs filesystem. !! 684 See https://blake2.net for further information.
>> 685
>> 686 config CRYPTO_BLAKE2S
>> 687 tristate "BLAKE2s digest algorithm"
>> 688 select CRYPTO_LIB_BLAKE2S_GENERIC
>> 689 select CRYPTO_HASH
>> 690 help
>> 691 Implementation of cryptographic hash function BLAKE2s
>> 692 optimized for 8-32bit platforms and can produce digests of any size
>> 693 between 1 to 32. The keyed hash is also implemented.
>> 694
>> 695 This module provides the following algorithms:
>> 696
>> 697 - blake2s-128
>> 698 - blake2s-160
>> 699 - blake2s-224
>> 700 - blake2s-256
881 701
882 See https://blake2.net for further i 702 See https://blake2.net for further information.
883 703
884 config CRYPTO_CMAC !! 704 config CRYPTO_BLAKE2S_X86
885 tristate "CMAC (Cipher-based MAC)" !! 705 tristate "BLAKE2s digest algorithm (x86 accelerated version)"
>> 706 depends on X86 && 64BIT
>> 707 select CRYPTO_LIB_BLAKE2S_GENERIC
>> 708 select CRYPTO_ARCH_HAVE_LIB_BLAKE2S
>> 709
>> 710 config CRYPTO_CRCT10DIF
>> 711 tristate "CRCT10DIF algorithm"
886 select CRYPTO_HASH 712 select CRYPTO_HASH
887 select CRYPTO_MANAGER <<
888 help 713 help
889 CMAC (Cipher-based Message Authentic !! 714 CRC T10 Data Integrity Field computation is being cast as
890 mode (NIST SP800-38B and IETF RFC449 !! 715 a crypto transform. This allows for faster crc t10 diff
>> 716 transforms to be used if they are available.
>> 717
>> 718 config CRYPTO_CRCT10DIF_PCLMUL
>> 719 tristate "CRCT10DIF PCLMULQDQ hardware acceleration"
>> 720 depends on X86 && 64BIT && CRC_T10DIF
>> 721 select CRYPTO_HASH
>> 722 help
>> 723 For x86_64 processors with SSE4.2 and PCLMULQDQ supported,
>> 724 CRC T10 DIF PCLMULQDQ computation can be hardware
>> 725 accelerated PCLMULQDQ instruction. This option will create
>> 726 'crct10dif-pclmul' module, which is faster when computing the
>> 727 crct10dif checksum as compared with the generic table implementation.
>> 728
>> 729 config CRYPTO_CRCT10DIF_VPMSUM
>> 730 tristate "CRC32T10DIF powerpc64 hardware acceleration"
>> 731 depends on PPC64 && ALTIVEC && CRC_T10DIF
>> 732 select CRYPTO_HASH
>> 733 help
>> 734 CRC10T10DIF algorithm implemented using vector polynomial
>> 735 multiply-sum (vpmsum) instructions, introduced in POWER8. Enable on
>> 736 POWER8 and newer processors for improved performance.
>> 737
>> 738 config CRYPTO_VPMSUM_TESTER
>> 739 tristate "Powerpc64 vpmsum hardware acceleration tester"
>> 740 depends on CRYPTO_CRCT10DIF_VPMSUM && CRYPTO_CRC32C_VPMSUM
>> 741 help
>> 742 Stress test for CRC32c and CRC-T10DIF algorithms implemented with
>> 743 POWER8 vpmsum instructions.
>> 744 Unless you are testing these algorithms, you don't need this.
891 745
892 config CRYPTO_GHASH 746 config CRYPTO_GHASH
893 tristate "GHASH" !! 747 tristate "GHASH hash function"
>> 748 select CRYPTO_GF128MUL
894 select CRYPTO_HASH 749 select CRYPTO_HASH
895 select CRYPTO_LIB_GF128MUL <<
896 help 750 help
897 GCM GHASH function (NIST SP800-38D) !! 751 GHASH is the hash function used in GCM (Galois/Counter Mode).
>> 752 It is not a general-purpose cryptographic hash function.
898 753
899 config CRYPTO_HMAC !! 754 config CRYPTO_POLY1305
900 tristate "HMAC (Keyed-Hash MAC)" !! 755 tristate "Poly1305 authenticator algorithm"
901 select CRYPTO_HASH 756 select CRYPTO_HASH
902 select CRYPTO_MANAGER !! 757 select CRYPTO_LIB_POLY1305_GENERIC
903 help 758 help
904 HMAC (Keyed-Hash Message Authenticat !! 759 Poly1305 authenticator algorithm, RFC7539.
905 RFC2104) !! 760
>> 761 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
>> 762 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
>> 763 in IETF protocols. This is the portable C implementation of Poly1305.
>> 764
>> 765 config CRYPTO_POLY1305_X86_64
>> 766 tristate "Poly1305 authenticator algorithm (x86_64/SSE2/AVX2)"
>> 767 depends on X86 && 64BIT
>> 768 select CRYPTO_LIB_POLY1305_GENERIC
>> 769 select CRYPTO_ARCH_HAVE_LIB_POLY1305
>> 770 help
>> 771 Poly1305 authenticator algorithm, RFC7539.
>> 772
>> 773 Poly1305 is an authenticator algorithm designed by Daniel J. Bernstein.
>> 774 It is used for the ChaCha20-Poly1305 AEAD, specified in RFC7539 for use
>> 775 in IETF protocols. This is the x86_64 assembler implementation using SIMD
>> 776 instructions.
906 777
907 This is required for IPsec AH (XFRM_ !! 778 config CRYPTO_POLY1305_MIPS
>> 779 tristate "Poly1305 authenticator algorithm (MIPS optimized)"
>> 780 depends on MIPS
>> 781 select CRYPTO_ARCH_HAVE_LIB_POLY1305
908 782
909 config CRYPTO_MD4 783 config CRYPTO_MD4
910 tristate "MD4" !! 784 tristate "MD4 digest algorithm"
911 select CRYPTO_HASH 785 select CRYPTO_HASH
912 help 786 help
913 MD4 message digest algorithm (RFC132 !! 787 MD4 message digest algorithm (RFC1320).
914 788
915 config CRYPTO_MD5 789 config CRYPTO_MD5
916 tristate "MD5" !! 790 tristate "MD5 digest algorithm"
917 select CRYPTO_HASH 791 select CRYPTO_HASH
918 help 792 help
919 MD5 message digest algorithm (RFC132 !! 793 MD5 message digest algorithm (RFC1321).
920 794
921 config CRYPTO_MICHAEL_MIC !! 795 config CRYPTO_MD5_OCTEON
922 tristate "Michael MIC" !! 796 tristate "MD5 digest algorithm (OCTEON)"
>> 797 depends on CPU_CAVIUM_OCTEON
>> 798 select CRYPTO_MD5
923 select CRYPTO_HASH 799 select CRYPTO_HASH
924 help 800 help
925 Michael MIC (Message Integrity Code) !! 801 MD5 message digest algorithm (RFC1321) implemented
926 !! 802 using OCTEON crypto instructions, when available.
927 Defined by the IEEE 802.11i TKIP (Te <<
928 known as WPA (Wif-Fi Protected Acces <<
929 803
930 This algorithm is required for TKIP, !! 804 config CRYPTO_MD5_PPC
931 other purposes because of the weakne !! 805 tristate "MD5 digest algorithm (PPC)"
932 !! 806 depends on PPC
933 config CRYPTO_POLYVAL <<
934 tristate <<
935 select CRYPTO_HASH 807 select CRYPTO_HASH
936 select CRYPTO_LIB_GF128MUL <<
937 help 808 help
938 POLYVAL hash function for HCTR2 !! 809 MD5 message digest algorithm (RFC1321) implemented
>> 810 in PPC assembler.
939 811
940 This is used in HCTR2. It is not a !! 812 config CRYPTO_MD5_SPARC64
941 cryptographic hash function. !! 813 tristate "MD5 digest algorithm (SPARC64)"
942 !! 814 depends on SPARC64
943 config CRYPTO_POLY1305 !! 815 select CRYPTO_MD5
944 tristate "Poly1305" <<
945 select CRYPTO_HASH 816 select CRYPTO_HASH
946 select CRYPTO_LIB_POLY1305_GENERIC <<
947 help 817 help
948 Poly1305 authenticator algorithm (RF !! 818 MD5 message digest algorithm (RFC1321) implemented
>> 819 using sparc64 crypto instructions, when available.
949 820
950 Poly1305 is an authenticator algorit !! 821 config CRYPTO_MICHAEL_MIC
951 It is used for the ChaCha20-Poly1305 !! 822 tristate "Michael MIC keyed digest algorithm"
952 in IETF protocols. This is the porta !! 823 select CRYPTO_HASH
>> 824 help
>> 825 Michael MIC is used for message integrity protection in TKIP
>> 826 (IEEE 802.11i). This algorithm is required for TKIP, but it
>> 827 should not be used for other purposes because of the weakness
>> 828 of the algorithm.
953 829
954 config CRYPTO_RMD160 830 config CRYPTO_RMD160
955 tristate "RIPEMD-160" !! 831 tristate "RIPEMD-160 digest algorithm"
956 select CRYPTO_HASH 832 select CRYPTO_HASH
957 help 833 help
958 RIPEMD-160 hash function (ISO/IEC 10 !! 834 RIPEMD-160 (ISO/IEC 10118-3:2004).
959 835
960 RIPEMD-160 is a 160-bit cryptographi 836 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
961 to be used as a secure replacement f 837 to be used as a secure replacement for the 128-bit hash functions
962 MD4, MD5 and its predecessor RIPEMD !! 838 MD4, MD5 and it's predecessor RIPEMD
963 (not to be confused with RIPEMD-128) 839 (not to be confused with RIPEMD-128).
964 840
965 Its speed is comparable to SHA-1 and !! 841 It's speed is comparable to SHA1 and there are no known attacks
966 against RIPEMD-160. 842 against RIPEMD-160.
967 843
968 Developed by Hans Dobbertin, Antoon 844 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
969 See https://homes.esat.kuleuven.be/~ !! 845 See <https://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
970 for further information. <<
971 846
972 config CRYPTO_SHA1 847 config CRYPTO_SHA1
973 tristate "SHA-1" !! 848 tristate "SHA1 digest algorithm"
974 select CRYPTO_HASH 849 select CRYPTO_HASH
975 select CRYPTO_LIB_SHA1 <<
976 help 850 help
977 SHA-1 secure hash algorithm (FIPS 18 !! 851 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
>> 852
>> 853 config CRYPTO_SHA1_SSSE3
>> 854 tristate "SHA1 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
>> 855 depends on X86 && 64BIT
>> 856 select CRYPTO_SHA1
>> 857 select CRYPTO_HASH
>> 858 help
>> 859 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
>> 860 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
>> 861 Extensions (AVX/AVX2) or SHA-NI(SHA Extensions New Instructions),
>> 862 when available.
>> 863
>> 864 config CRYPTO_SHA256_SSSE3
>> 865 tristate "SHA256 digest algorithm (SSSE3/AVX/AVX2/SHA-NI)"
>> 866 depends on X86 && 64BIT
>> 867 select CRYPTO_SHA256
>> 868 select CRYPTO_HASH
>> 869 help
>> 870 SHA-256 secure hash standard (DFIPS 180-2) implemented
>> 871 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
>> 872 Extensions version 1 (AVX1), or Advanced Vector Extensions
>> 873 version 2 (AVX2) instructions, or SHA-NI (SHA Extensions New
>> 874 Instructions) when available.
>> 875
>> 876 config CRYPTO_SHA512_SSSE3
>> 877 tristate "SHA512 digest algorithm (SSSE3/AVX/AVX2)"
>> 878 depends on X86 && 64BIT
>> 879 select CRYPTO_SHA512
>> 880 select CRYPTO_HASH
>> 881 help
>> 882 SHA-512 secure hash standard (DFIPS 180-2) implemented
>> 883 using Supplemental SSE3 (SSSE3) instructions, or Advanced Vector
>> 884 Extensions version 1 (AVX1), or Advanced Vector Extensions
>> 885 version 2 (AVX2) instructions, when available.
>> 886
>> 887 config CRYPTO_SHA1_OCTEON
>> 888 tristate "SHA1 digest algorithm (OCTEON)"
>> 889 depends on CPU_CAVIUM_OCTEON
>> 890 select CRYPTO_SHA1
>> 891 select CRYPTO_HASH
>> 892 help
>> 893 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
>> 894 using OCTEON crypto instructions, when available.
>> 895
>> 896 config CRYPTO_SHA1_SPARC64
>> 897 tristate "SHA1 digest algorithm (SPARC64)"
>> 898 depends on SPARC64
>> 899 select CRYPTO_SHA1
>> 900 select CRYPTO_HASH
>> 901 help
>> 902 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
>> 903 using sparc64 crypto instructions, when available.
>> 904
>> 905 config CRYPTO_SHA1_PPC
>> 906 tristate "SHA1 digest algorithm (powerpc)"
>> 907 depends on PPC
>> 908 help
>> 909 This is the powerpc hardware accelerated implementation of the
>> 910 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
>> 911
>> 912 config CRYPTO_SHA1_PPC_SPE
>> 913 tristate "SHA1 digest algorithm (PPC SPE)"
>> 914 depends on PPC && SPE
>> 915 help
>> 916 SHA-1 secure hash standard (DFIPS 180-4) implemented
>> 917 using powerpc SPE SIMD instruction set.
978 918
979 config CRYPTO_SHA256 919 config CRYPTO_SHA256
980 tristate "SHA-224 and SHA-256" !! 920 tristate "SHA224 and SHA256 digest algorithm"
981 select CRYPTO_HASH 921 select CRYPTO_HASH
982 select CRYPTO_LIB_SHA256 922 select CRYPTO_LIB_SHA256
983 help 923 help
984 SHA-224 and SHA-256 secure hash algo !! 924 SHA256 secure hash standard (DFIPS 180-2).
985 925
986 This is required for IPsec AH (XFRM_ !! 926 This version of SHA implements a 256 bit hash with 128 bits of
987 Used by the btrfs filesystem, Ceph, !! 927 security against collision attacks.
>> 928
>> 929 This code also includes SHA-224, a 224 bit hash with 112 bits
>> 930 of security against collision attacks.
>> 931
>> 932 config CRYPTO_SHA256_PPC_SPE
>> 933 tristate "SHA224 and SHA256 digest algorithm (PPC SPE)"
>> 934 depends on PPC && SPE
>> 935 select CRYPTO_SHA256
>> 936 select CRYPTO_HASH
>> 937 help
>> 938 SHA224 and SHA256 secure hash standard (DFIPS 180-2)
>> 939 implemented using powerpc SPE SIMD instruction set.
>> 940
>> 941 config CRYPTO_SHA256_OCTEON
>> 942 tristate "SHA224 and SHA256 digest algorithm (OCTEON)"
>> 943 depends on CPU_CAVIUM_OCTEON
>> 944 select CRYPTO_SHA256
>> 945 select CRYPTO_HASH
>> 946 help
>> 947 SHA-256 secure hash standard (DFIPS 180-2) implemented
>> 948 using OCTEON crypto instructions, when available.
>> 949
>> 950 config CRYPTO_SHA256_SPARC64
>> 951 tristate "SHA224 and SHA256 digest algorithm (SPARC64)"
>> 952 depends on SPARC64
>> 953 select CRYPTO_SHA256
>> 954 select CRYPTO_HASH
>> 955 help
>> 956 SHA-256 secure hash standard (DFIPS 180-2) implemented
>> 957 using sparc64 crypto instructions, when available.
988 958
989 config CRYPTO_SHA512 959 config CRYPTO_SHA512
990 tristate "SHA-384 and SHA-512" !! 960 tristate "SHA384 and SHA512 digest algorithms"
991 select CRYPTO_HASH 961 select CRYPTO_HASH
992 help 962 help
993 SHA-384 and SHA-512 secure hash algo !! 963 SHA512 secure hash standard (DFIPS 180-2).
994 964
995 config CRYPTO_SHA3 !! 965 This version of SHA implements a 512 bit hash with 256 bits of
996 tristate "SHA-3" !! 966 security against collision attacks.
>> 967
>> 968 This code also includes SHA-384, a 384 bit hash with 192 bits
>> 969 of security against collision attacks.
>> 970
>> 971 config CRYPTO_SHA512_OCTEON
>> 972 tristate "SHA384 and SHA512 digest algorithms (OCTEON)"
>> 973 depends on CPU_CAVIUM_OCTEON
>> 974 select CRYPTO_SHA512
997 select CRYPTO_HASH 975 select CRYPTO_HASH
998 help 976 help
999 SHA-3 secure hash algorithms (FIPS 2 !! 977 SHA-512 secure hash standard (DFIPS 180-2) implemented
>> 978 using OCTEON crypto instructions, when available.
1000 979
1001 config CRYPTO_SM3 !! 980 config CRYPTO_SHA512_SPARC64
1002 tristate !! 981 tristate "SHA384 and SHA512 digest algorithm (SPARC64)"
>> 982 depends on SPARC64
>> 983 select CRYPTO_SHA512
>> 984 select CRYPTO_HASH
>> 985 help
>> 986 SHA-512 secure hash standard (DFIPS 180-2) implemented
>> 987 using sparc64 crypto instructions, when available.
1003 988
1004 config CRYPTO_SM3_GENERIC !! 989 config CRYPTO_SHA3
1005 tristate "SM3 (ShangMi 3)" !! 990 tristate "SHA3 digest algorithm"
1006 select CRYPTO_HASH 991 select CRYPTO_HASH
1007 select CRYPTO_SM3 <<
1008 help 992 help
1009 SM3 (ShangMi 3) secure hash functio !! 993 SHA-3 secure hash standard (DFIPS 202). It's based on
>> 994 cryptographic sponge function family called Keccak.
1010 995
1011 This is part of the Chinese Commerc !! 996 References:
>> 997 http://keccak.noekeon.org/
>> 998
>> 999 config CRYPTO_SM3
>> 1000 tristate "SM3 digest algorithm"
>> 1001 select CRYPTO_HASH
>> 1002 help
>> 1003 SM3 secure hash function as defined by OSCCA GM/T 0004-2012 SM3).
>> 1004 It is part of the Chinese Commercial Cryptography suite.
1012 1005
1013 References: 1006 References:
1014 http://www.oscca.gov.cn/UpFile/2010 1007 http://www.oscca.gov.cn/UpFile/20101222141857786.pdf
1015 https://datatracker.ietf.org/doc/ht 1008 https://datatracker.ietf.org/doc/html/draft-shen-sm3-hash
1016 1009
1017 config CRYPTO_STREEBOG 1010 config CRYPTO_STREEBOG
1018 tristate "Streebog" !! 1011 tristate "Streebog Hash Function"
1019 select CRYPTO_HASH 1012 select CRYPTO_HASH
1020 help 1013 help
1021 Streebog Hash Function (GOST R 34.1 !! 1014 Streebog Hash Function (GOST R 34.11-2012, RFC 6986) is one of the Russian
1022 !! 1015 cryptographic standard algorithms (called GOST algorithms).
1023 This is one of the Russian cryptogr !! 1016 This setting enables two hash algorithms with 256 and 512 bits output.
1024 GOST algorithms). This setting enab <<
1025 256 and 512 bits output. <<
1026 1017
1027 References: 1018 References:
1028 https://tc26.ru/upload/iblock/fed/f 1019 https://tc26.ru/upload/iblock/fed/feddbb4d26b685903faa2ba11aea43f6.pdf
1029 https://tools.ietf.org/html/rfc6986 1020 https://tools.ietf.org/html/rfc6986
1030 1021
1031 config CRYPTO_VMAC !! 1022 config CRYPTO_WP512
1032 tristate "VMAC" !! 1023 tristate "Whirlpool digest algorithms"
1033 select CRYPTO_HASH 1024 select CRYPTO_HASH
1034 select CRYPTO_MANAGER <<
1035 help 1025 help
1036 VMAC is a message authentication al !! 1026 Whirlpool hash algorithm 512, 384 and 256-bit hashes
1037 very high speed on 64-bit architect <<
1038 1027
1039 See https://fastcrypto.org/vmac for !! 1028 Whirlpool-512 is part of the NESSIE cryptographic primitives.
>> 1029 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
1040 1030
1041 config CRYPTO_WP512 !! 1031 See also:
1042 tristate "Whirlpool" !! 1032 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
1043 select CRYPTO_HASH !! 1033
>> 1034 config CRYPTO_GHASH_CLMUL_NI_INTEL
>> 1035 tristate "GHASH hash function (CLMUL-NI accelerated)"
>> 1036 depends on X86 && 64BIT
>> 1037 select CRYPTO_CRYPTD
1044 help 1038 help
1045 Whirlpool hash function (ISO/IEC 10 !! 1039 This is the x86_64 CLMUL-NI accelerated implementation of
>> 1040 GHASH, the hash function used in GCM (Galois/Counter mode).
1046 1041
1047 512, 384 and 256-bit hashes. !! 1042 comment "Ciphers"
1048 1043
1049 Whirlpool-512 is part of the NESSIE !! 1044 config CRYPTO_AES
>> 1045 tristate "AES cipher algorithms"
>> 1046 select CRYPTO_ALGAPI
>> 1047 select CRYPTO_LIB_AES
>> 1048 help
>> 1049 AES cipher algorithms (FIPS-197). AES uses the Rijndael
>> 1050 algorithm.
>> 1051
>> 1052 Rijndael appears to be consistently a very good performer in
>> 1053 both hardware and software across a wide range of computing
>> 1054 environments regardless of its use in feedback or non-feedback
>> 1055 modes. Its key setup time is excellent, and its key agility is
>> 1056 good. Rijndael's very low memory requirements make it very well
>> 1057 suited for restricted-space environments, in which it also
>> 1058 demonstrates excellent performance. Rijndael's operations are
>> 1059 among the easiest to defend against power and timing attacks.
1050 1060
1051 See https://web.archive.org/web/201 !! 1061 The AES specifies three key sizes: 128, 192 and 256 bits
1052 for further information. <<
1053 1062
1054 config CRYPTO_XCBC !! 1063 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
1055 tristate "XCBC-MAC (Extended Cipher B !! 1064
1056 select CRYPTO_HASH !! 1065 config CRYPTO_AES_TI
1057 select CRYPTO_MANAGER !! 1066 tristate "Fixed time AES cipher"
>> 1067 select CRYPTO_ALGAPI
>> 1068 select CRYPTO_LIB_AES
1058 help 1069 help
1059 XCBC-MAC (Extended Cipher Block Cha !! 1070 This is a generic implementation of AES that attempts to eliminate
1060 Code) (RFC3566) !! 1071 data dependent latencies as much as possible without affecting
>> 1072 performance too much. It is intended for use by the generic CCM
>> 1073 and GCM drivers, and other CTR or CMAC/XCBC based modes that rely
>> 1074 solely on encryption (although decryption is supported as well, but
>> 1075 with a more dramatic performance hit)
1061 1076
1062 config CRYPTO_XXHASH !! 1077 Instead of using 16 lookup tables of 1 KB each, (8 for encryption and
1063 tristate "xxHash" !! 1078 8 for decryption), this implementation only uses just two S-boxes of
1064 select CRYPTO_HASH !! 1079 256 bytes each, and attempts to eliminate data dependent latencies by
1065 select XXHASH !! 1080 prefetching the entire table into the cache at the start of each
>> 1081 block. Interrupts are also disabled to avoid races where cachelines
>> 1082 are evicted when the CPU is interrupted to do something else.
>> 1083
>> 1084 config CRYPTO_AES_NI_INTEL
>> 1085 tristate "AES cipher algorithms (AES-NI)"
>> 1086 depends on X86
>> 1087 select CRYPTO_AEAD
>> 1088 select CRYPTO_LIB_AES
>> 1089 select CRYPTO_ALGAPI
>> 1090 select CRYPTO_SKCIPHER
>> 1091 select CRYPTO_SIMD
1066 help 1092 help
1067 xxHash non-cryptographic hash algor !! 1093 Use Intel AES-NI instructions for AES algorithm.
>> 1094
>> 1095 AES cipher algorithms (FIPS-197). AES uses the Rijndael
>> 1096 algorithm.
>> 1097
>> 1098 Rijndael appears to be consistently a very good performer in
>> 1099 both hardware and software across a wide range of computing
>> 1100 environments regardless of its use in feedback or non-feedback
>> 1101 modes. Its key setup time is excellent, and its key agility is
>> 1102 good. Rijndael's very low memory requirements make it very well
>> 1103 suited for restricted-space environments, in which it also
>> 1104 demonstrates excellent performance. Rijndael's operations are
>> 1105 among the easiest to defend against power and timing attacks.
1068 1106
1069 Extremely fast, working at speeds c !! 1107 The AES specifies three key sizes: 128, 192 and 256 bits
1070 1108
1071 Used by the btrfs filesystem. !! 1109 See <http://csrc.nist.gov/encryption/aes/> for more information.
1072 1110
1073 endmenu !! 1111 In addition to AES cipher algorithm support, the acceleration
>> 1112 for some popular block cipher mode is supported too, including
>> 1113 ECB, CBC, LRW, XTS. The 64 bit version has additional
>> 1114 acceleration for CTR.
>> 1115
>> 1116 config CRYPTO_AES_SPARC64
>> 1117 tristate "AES cipher algorithms (SPARC64)"
>> 1118 depends on SPARC64
>> 1119 select CRYPTO_SKCIPHER
>> 1120 help
>> 1121 Use SPARC64 crypto opcodes for AES algorithm.
1074 1122
1075 menu "CRCs (cyclic redundancy checks)" !! 1123 AES cipher algorithms (FIPS-197). AES uses the Rijndael
>> 1124 algorithm.
1076 1125
1077 config CRYPTO_CRC32C !! 1126 Rijndael appears to be consistently a very good performer in
1078 tristate "CRC32c" !! 1127 both hardware and software across a wide range of computing
1079 select CRYPTO_HASH !! 1128 environments regardless of its use in feedback or non-feedback
1080 select CRC32 !! 1129 modes. Its key setup time is excellent, and its key agility is
>> 1130 good. Rijndael's very low memory requirements make it very well
>> 1131 suited for restricted-space environments, in which it also
>> 1132 demonstrates excellent performance. Rijndael's operations are
>> 1133 among the easiest to defend against power and timing attacks.
>> 1134
>> 1135 The AES specifies three key sizes: 128, 192 and 256 bits
>> 1136
>> 1137 See <http://csrc.nist.gov/encryption/aes/> for more information.
>> 1138
>> 1139 In addition to AES cipher algorithm support, the acceleration
>> 1140 for some popular block cipher mode is supported too, including
>> 1141 ECB and CBC.
>> 1142
>> 1143 config CRYPTO_AES_PPC_SPE
>> 1144 tristate "AES cipher algorithms (PPC SPE)"
>> 1145 depends on PPC && SPE
>> 1146 select CRYPTO_SKCIPHER
1081 help 1147 help
1082 CRC32c CRC algorithm with the iSCSI !! 1148 AES cipher algorithms (FIPS-197). Additionally the acceleration
>> 1149 for popular block cipher modes ECB, CBC, CTR and XTS is supported.
>> 1150 This module should only be used for low power (router) devices
>> 1151 without hardware AES acceleration (e.g. caam crypto). It reduces the
>> 1152 size of the AES tables from 16KB to 8KB + 256 bytes and mitigates
>> 1153 timining attacks. Nevertheless it might be not as secure as other
>> 1154 architecture specific assembler implementations that work on 1KB
>> 1155 tables or 256 bytes S-boxes.
1083 1156
1084 A 32-bit CRC (cyclic redundancy che !! 1157 config CRYPTO_ANUBIS
1085 by G. Castagnoli, S. Braeuer and M. !! 1158 tristate "Anubis cipher algorithm"
1086 Redundancy-Check Codes with 24 and !! 1159 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
1087 on Communications, Vol. 41, No. 6, !! 1160 select CRYPTO_ALGAPI
1088 iSCSI. !! 1161 help
>> 1162 Anubis cipher algorithm.
1089 1163
1090 Used by btrfs, ext4, jbd2, NVMeoF/T !! 1164 Anubis is a variable key length cipher which can use keys from
>> 1165 128 bits to 320 bits in length. It was evaluated as a entrant
>> 1166 in the NESSIE competition.
1091 1167
1092 config CRYPTO_CRC32 !! 1168 See also:
1093 tristate "CRC32" !! 1169 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
1094 select CRYPTO_HASH !! 1170 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
1095 select CRC32 !! 1171
>> 1172 config CRYPTO_ARC4
>> 1173 tristate "ARC4 cipher algorithm"
>> 1174 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
>> 1175 select CRYPTO_SKCIPHER
>> 1176 select CRYPTO_LIB_ARC4
1096 help 1177 help
1097 CRC32 CRC algorithm (IEEE 802.3) !! 1178 ARC4 cipher algorithm.
1098 1179
1099 Used by RoCEv2 and f2fs. !! 1180 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
>> 1181 bits in length. This algorithm is required for driver-based
>> 1182 WEP, but it should not be for other purposes because of the
>> 1183 weakness of the algorithm.
1100 1184
1101 config CRYPTO_CRCT10DIF !! 1185 config CRYPTO_BLOWFISH
1102 tristate "CRCT10DIF" !! 1186 tristate "Blowfish cipher algorithm"
1103 select CRYPTO_HASH !! 1187 select CRYPTO_ALGAPI
>> 1188 select CRYPTO_BLOWFISH_COMMON
1104 help 1189 help
1105 CRC16 CRC algorithm used for the T1 !! 1190 Blowfish cipher algorithm, by Bruce Schneier.
>> 1191
>> 1192 This is a variable key length cipher which can use keys from 32
>> 1193 bits to 448 bits in length. It's fast, simple and specifically
>> 1194 designed for use on "large microprocessors".
1106 1195
1107 CRC algorithm used by the SCSI Bloc !! 1196 See also:
>> 1197 <https://www.schneier.com/blowfish.html>
1108 1198
1109 config CRYPTO_CRC64_ROCKSOFT !! 1199 config CRYPTO_BLOWFISH_COMMON
1110 tristate "CRC64 based on Rocksoft Mod !! 1200 tristate
1111 depends on CRC64 !! 1201 help
1112 select CRYPTO_HASH !! 1202 Common parts of the Blowfish cipher algorithm shared by the
>> 1203 generic c and the assembler implementations.
>> 1204
>> 1205 See also:
>> 1206 <https://www.schneier.com/blowfish.html>
>> 1207
>> 1208 config CRYPTO_BLOWFISH_X86_64
>> 1209 tristate "Blowfish cipher algorithm (x86_64)"
>> 1210 depends on X86 && 64BIT
>> 1211 select CRYPTO_SKCIPHER
>> 1212 select CRYPTO_BLOWFISH_COMMON
>> 1213 imply CRYPTO_CTR
>> 1214 help
>> 1215 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
>> 1216
>> 1217 This is a variable key length cipher which can use keys from 32
>> 1218 bits to 448 bits in length. It's fast, simple and specifically
>> 1219 designed for use on "large microprocessors".
>> 1220
>> 1221 See also:
>> 1222 <https://www.schneier.com/blowfish.html>
>> 1223
>> 1224 config CRYPTO_CAMELLIA
>> 1225 tristate "Camellia cipher algorithms"
>> 1226 select CRYPTO_ALGAPI
>> 1227 help
>> 1228 Camellia cipher algorithms module.
>> 1229
>> 1230 Camellia is a symmetric key block cipher developed jointly
>> 1231 at NTT and Mitsubishi Electric Corporation.
>> 1232
>> 1233 The Camellia specifies three key sizes: 128, 192 and 256 bits.
>> 1234
>> 1235 See also:
>> 1236 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
>> 1237
>> 1238 config CRYPTO_CAMELLIA_X86_64
>> 1239 tristate "Camellia cipher algorithm (x86_64)"
>> 1240 depends on X86 && 64BIT
>> 1241 select CRYPTO_SKCIPHER
>> 1242 imply CRYPTO_CTR
>> 1243 help
>> 1244 Camellia cipher algorithm module (x86_64).
>> 1245
>> 1246 Camellia is a symmetric key block cipher developed jointly
>> 1247 at NTT and Mitsubishi Electric Corporation.
>> 1248
>> 1249 The Camellia specifies three key sizes: 128, 192 and 256 bits.
>> 1250
>> 1251 See also:
>> 1252 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
>> 1253
>> 1254 config CRYPTO_CAMELLIA_AESNI_AVX_X86_64
>> 1255 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"
>> 1256 depends on X86 && 64BIT
>> 1257 select CRYPTO_SKCIPHER
>> 1258 select CRYPTO_CAMELLIA_X86_64
>> 1259 select CRYPTO_SIMD
>> 1260 imply CRYPTO_XTS
>> 1261 help
>> 1262 Camellia cipher algorithm module (x86_64/AES-NI/AVX).
>> 1263
>> 1264 Camellia is a symmetric key block cipher developed jointly
>> 1265 at NTT and Mitsubishi Electric Corporation.
>> 1266
>> 1267 The Camellia specifies three key sizes: 128, 192 and 256 bits.
>> 1268
>> 1269 See also:
>> 1270 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
>> 1271
>> 1272 config CRYPTO_CAMELLIA_AESNI_AVX2_X86_64
>> 1273 tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX2)"
>> 1274 depends on X86 && 64BIT
>> 1275 select CRYPTO_CAMELLIA_AESNI_AVX_X86_64
>> 1276 help
>> 1277 Camellia cipher algorithm module (x86_64/AES-NI/AVX2).
>> 1278
>> 1279 Camellia is a symmetric key block cipher developed jointly
>> 1280 at NTT and Mitsubishi Electric Corporation.
>> 1281
>> 1282 The Camellia specifies three key sizes: 128, 192 and 256 bits.
>> 1283
>> 1284 See also:
>> 1285 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
>> 1286
>> 1287 config CRYPTO_CAMELLIA_SPARC64
>> 1288 tristate "Camellia cipher algorithm (SPARC64)"
>> 1289 depends on SPARC64
>> 1290 select CRYPTO_ALGAPI
>> 1291 select CRYPTO_SKCIPHER
>> 1292 help
>> 1293 Camellia cipher algorithm module (SPARC64).
>> 1294
>> 1295 Camellia is a symmetric key block cipher developed jointly
>> 1296 at NTT and Mitsubishi Electric Corporation.
>> 1297
>> 1298 The Camellia specifies three key sizes: 128, 192 and 256 bits.
>> 1299
>> 1300 See also:
>> 1301 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
>> 1302
>> 1303 config CRYPTO_CAST_COMMON
>> 1304 tristate
>> 1305 help
>> 1306 Common parts of the CAST cipher algorithms shared by the
>> 1307 generic c and the assembler implementations.
>> 1308
>> 1309 config CRYPTO_CAST5
>> 1310 tristate "CAST5 (CAST-128) cipher algorithm"
>> 1311 select CRYPTO_ALGAPI
>> 1312 select CRYPTO_CAST_COMMON
>> 1313 help
>> 1314 The CAST5 encryption algorithm (synonymous with CAST-128) is
>> 1315 described in RFC2144.
>> 1316
>> 1317 config CRYPTO_CAST5_AVX_X86_64
>> 1318 tristate "CAST5 (CAST-128) cipher algorithm (x86_64/AVX)"
>> 1319 depends on X86 && 64BIT
>> 1320 select CRYPTO_SKCIPHER
>> 1321 select CRYPTO_CAST5
>> 1322 select CRYPTO_CAST_COMMON
>> 1323 select CRYPTO_SIMD
>> 1324 imply CRYPTO_CTR
>> 1325 help
>> 1326 The CAST5 encryption algorithm (synonymous with CAST-128) is
>> 1327 described in RFC2144.
>> 1328
>> 1329 This module provides the Cast5 cipher algorithm that processes
>> 1330 sixteen blocks parallel using the AVX instruction set.
>> 1331
>> 1332 config CRYPTO_CAST6
>> 1333 tristate "CAST6 (CAST-256) cipher algorithm"
>> 1334 select CRYPTO_ALGAPI
>> 1335 select CRYPTO_CAST_COMMON
>> 1336 help
>> 1337 The CAST6 encryption algorithm (synonymous with CAST-256) is
>> 1338 described in RFC2612.
>> 1339
>> 1340 config CRYPTO_CAST6_AVX_X86_64
>> 1341 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
>> 1342 depends on X86 && 64BIT
>> 1343 select CRYPTO_SKCIPHER
>> 1344 select CRYPTO_CAST6
>> 1345 select CRYPTO_CAST_COMMON
>> 1346 select CRYPTO_SIMD
>> 1347 imply CRYPTO_XTS
>> 1348 imply CRYPTO_CTR
>> 1349 help
>> 1350 The CAST6 encryption algorithm (synonymous with CAST-256) is
>> 1351 described in RFC2612.
>> 1352
>> 1353 This module provides the Cast6 cipher algorithm that processes
>> 1354 eight blocks parallel using the AVX instruction set.
>> 1355
>> 1356 config CRYPTO_DES
>> 1357 tristate "DES and Triple DES EDE cipher algorithms"
>> 1358 select CRYPTO_ALGAPI
>> 1359 select CRYPTO_LIB_DES
>> 1360 help
>> 1361 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
>> 1362
>> 1363 config CRYPTO_DES_SPARC64
>> 1364 tristate "DES and Triple DES EDE cipher algorithms (SPARC64)"
>> 1365 depends on SPARC64
>> 1366 select CRYPTO_ALGAPI
>> 1367 select CRYPTO_LIB_DES
>> 1368 select CRYPTO_SKCIPHER
>> 1369 help
>> 1370 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),
>> 1371 optimized using SPARC64 crypto opcodes.
>> 1372
>> 1373 config CRYPTO_DES3_EDE_X86_64
>> 1374 tristate "Triple DES EDE cipher algorithm (x86-64)"
>> 1375 depends on X86 && 64BIT
>> 1376 select CRYPTO_SKCIPHER
>> 1377 select CRYPTO_LIB_DES
>> 1378 imply CRYPTO_CTR
>> 1379 help
>> 1380 Triple DES EDE (FIPS 46-3) algorithm.
>> 1381
>> 1382 This module provides implementation of the Triple DES EDE cipher
>> 1383 algorithm that is optimized for x86-64 processors. Two versions of
>> 1384 algorithm are provided; regular processing one input block and
>> 1385 one that processes three blocks parallel.
>> 1386
>> 1387 config CRYPTO_FCRYPT
>> 1388 tristate "FCrypt cipher algorithm"
>> 1389 select CRYPTO_ALGAPI
>> 1390 select CRYPTO_SKCIPHER
>> 1391 help
>> 1392 FCrypt algorithm used by RxRPC.
>> 1393
>> 1394 config CRYPTO_KHAZAD
>> 1395 tristate "Khazad cipher algorithm"
>> 1396 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
>> 1397 select CRYPTO_ALGAPI
>> 1398 help
>> 1399 Khazad cipher algorithm.
>> 1400
>> 1401 Khazad was a finalist in the initial NESSIE competition. It is
>> 1402 an algorithm optimized for 64-bit processors with good performance
>> 1403 on 32-bit processors. Khazad uses an 128 bit key size.
>> 1404
>> 1405 See also:
>> 1406 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
>> 1407
>> 1408 config CRYPTO_CHACHA20
>> 1409 tristate "ChaCha stream cipher algorithms"
>> 1410 select CRYPTO_LIB_CHACHA_GENERIC
>> 1411 select CRYPTO_SKCIPHER
>> 1412 help
>> 1413 The ChaCha20, XChaCha20, and XChaCha12 stream cipher algorithms.
>> 1414
>> 1415 ChaCha20 is a 256-bit high-speed stream cipher designed by Daniel J.
>> 1416 Bernstein and further specified in RFC7539 for use in IETF protocols.
>> 1417 This is the portable C implementation of ChaCha20. See also:
>> 1418 <https://cr.yp.to/chacha/chacha-20080128.pdf>
>> 1419
>> 1420 XChaCha20 is the application of the XSalsa20 construction to ChaCha20
>> 1421 rather than to Salsa20. XChaCha20 extends ChaCha20's nonce length
>> 1422 from 64 bits (or 96 bits using the RFC7539 convention) to 192 bits,
>> 1423 while provably retaining ChaCha20's security. See also:
>> 1424 <https://cr.yp.to/snuffle/xsalsa-20081128.pdf>
>> 1425
>> 1426 XChaCha12 is XChaCha20 reduced to 12 rounds, with correspondingly
>> 1427 reduced security margin but increased performance. It can be needed
>> 1428 in some performance-sensitive scenarios.
>> 1429
>> 1430 config CRYPTO_CHACHA20_X86_64
>> 1431 tristate "ChaCha stream cipher algorithms (x86_64/SSSE3/AVX2/AVX-512VL)"
>> 1432 depends on X86 && 64BIT
>> 1433 select CRYPTO_SKCIPHER
>> 1434 select CRYPTO_LIB_CHACHA_GENERIC
>> 1435 select CRYPTO_ARCH_HAVE_LIB_CHACHA
>> 1436 help
>> 1437 SSSE3, AVX2, and AVX-512VL optimized implementations of the ChaCha20,
>> 1438 XChaCha20, and XChaCha12 stream ciphers.
>> 1439
>> 1440 config CRYPTO_CHACHA_MIPS
>> 1441 tristate "ChaCha stream cipher algorithms (MIPS 32r2 optimized)"
>> 1442 depends on CPU_MIPS32_R2
>> 1443 select CRYPTO_SKCIPHER
>> 1444 select CRYPTO_ARCH_HAVE_LIB_CHACHA
>> 1445
>> 1446 config CRYPTO_SEED
>> 1447 tristate "SEED cipher algorithm"
>> 1448 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
>> 1449 select CRYPTO_ALGAPI
>> 1450 help
>> 1451 SEED cipher algorithm (RFC4269).
>> 1452
>> 1453 SEED is a 128-bit symmetric key block cipher that has been
>> 1454 developed by KISA (Korea Information Security Agency) as a
>> 1455 national standard encryption algorithm of the Republic of Korea.
>> 1456 It is a 16 round block cipher with the key size of 128 bit.
>> 1457
>> 1458 See also:
>> 1459 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
>> 1460
>> 1461 config CRYPTO_SERPENT
>> 1462 tristate "Serpent cipher algorithm"
>> 1463 select CRYPTO_ALGAPI
>> 1464 help
>> 1465 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
>> 1466
>> 1467 Keys are allowed to be from 0 to 256 bits in length, in steps
>> 1468 of 8 bits.
>> 1469
>> 1470 See also:
>> 1471 <https://www.cl.cam.ac.uk/~rja14/serpent.html>
>> 1472
>> 1473 config CRYPTO_SERPENT_SSE2_X86_64
>> 1474 tristate "Serpent cipher algorithm (x86_64/SSE2)"
>> 1475 depends on X86 && 64BIT
>> 1476 select CRYPTO_SKCIPHER
>> 1477 select CRYPTO_SERPENT
>> 1478 select CRYPTO_SIMD
>> 1479 imply CRYPTO_CTR
>> 1480 help
>> 1481 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
>> 1482
>> 1483 Keys are allowed to be from 0 to 256 bits in length, in steps
>> 1484 of 8 bits.
>> 1485
>> 1486 This module provides Serpent cipher algorithm that processes eight
>> 1487 blocks parallel using SSE2 instruction set.
>> 1488
>> 1489 See also:
>> 1490 <https://www.cl.cam.ac.uk/~rja14/serpent.html>
>> 1491
>> 1492 config CRYPTO_SERPENT_SSE2_586
>> 1493 tristate "Serpent cipher algorithm (i586/SSE2)"
>> 1494 depends on X86 && !64BIT
>> 1495 select CRYPTO_SKCIPHER
>> 1496 select CRYPTO_SERPENT
>> 1497 select CRYPTO_SIMD
>> 1498 imply CRYPTO_CTR
>> 1499 help
>> 1500 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
>> 1501
>> 1502 Keys are allowed to be from 0 to 256 bits in length, in steps
>> 1503 of 8 bits.
>> 1504
>> 1505 This module provides Serpent cipher algorithm that processes four
>> 1506 blocks parallel using SSE2 instruction set.
>> 1507
>> 1508 See also:
>> 1509 <https://www.cl.cam.ac.uk/~rja14/serpent.html>
>> 1510
>> 1511 config CRYPTO_SERPENT_AVX_X86_64
>> 1512 tristate "Serpent cipher algorithm (x86_64/AVX)"
>> 1513 depends on X86 && 64BIT
>> 1514 select CRYPTO_SKCIPHER
>> 1515 select CRYPTO_SERPENT
>> 1516 select CRYPTO_SIMD
>> 1517 imply CRYPTO_XTS
>> 1518 imply CRYPTO_CTR
>> 1519 help
>> 1520 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
>> 1521
>> 1522 Keys are allowed to be from 0 to 256 bits in length, in steps
>> 1523 of 8 bits.
>> 1524
>> 1525 This module provides the Serpent cipher algorithm that processes
>> 1526 eight blocks parallel using the AVX instruction set.
>> 1527
>> 1528 See also:
>> 1529 <https://www.cl.cam.ac.uk/~rja14/serpent.html>
>> 1530
>> 1531 config CRYPTO_SERPENT_AVX2_X86_64
>> 1532 tristate "Serpent cipher algorithm (x86_64/AVX2)"
>> 1533 depends on X86 && 64BIT
>> 1534 select CRYPTO_SERPENT_AVX_X86_64
>> 1535 help
>> 1536 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
>> 1537
>> 1538 Keys are allowed to be from 0 to 256 bits in length, in steps
>> 1539 of 8 bits.
>> 1540
>> 1541 This module provides Serpent cipher algorithm that processes 16
>> 1542 blocks parallel using AVX2 instruction set.
>> 1543
>> 1544 See also:
>> 1545 <https://www.cl.cam.ac.uk/~rja14/serpent.html>
>> 1546
>> 1547 config CRYPTO_SM4
>> 1548 tristate "SM4 cipher algorithm"
>> 1549 select CRYPTO_ALGAPI
>> 1550 select CRYPTO_LIB_SM4
>> 1551 help
>> 1552 SM4 cipher algorithms (OSCCA GB/T 32907-2016).
>> 1553
>> 1554 SM4 (GBT.32907-2016) is a cryptographic standard issued by the
>> 1555 Organization of State Commercial Administration of China (OSCCA)
>> 1556 as an authorized cryptographic algorithms for the use within China.
>> 1557
>> 1558 SMS4 was originally created for use in protecting wireless
>> 1559 networks, and is mandated in the Chinese National Standard for
>> 1560 Wireless LAN WAPI (Wired Authentication and Privacy Infrastructure)
>> 1561 (GB.15629.11-2003).
>> 1562
>> 1563 The latest SM4 standard (GBT.32907-2016) was proposed by OSCCA and
>> 1564 standardized through TC 260 of the Standardization Administration
>> 1565 of the People's Republic of China (SAC).
>> 1566
>> 1567 The input, output, and key of SMS4 are each 128 bits.
>> 1568
>> 1569 See also: <https://eprint.iacr.org/2008/329.pdf>
>> 1570
>> 1571 If unsure, say N.
>> 1572
>> 1573 config CRYPTO_SM4_AESNI_AVX_X86_64
>> 1574 tristate "SM4 cipher algorithm (x86_64/AES-NI/AVX)"
>> 1575 depends on X86 && 64BIT
>> 1576 select CRYPTO_SKCIPHER
>> 1577 select CRYPTO_SIMD
>> 1578 select CRYPTO_ALGAPI
>> 1579 select CRYPTO_LIB_SM4
>> 1580 help
>> 1581 SM4 cipher algorithms (OSCCA GB/T 32907-2016) (x86_64/AES-NI/AVX).
>> 1582
>> 1583 SM4 (GBT.32907-2016) is a cryptographic standard issued by the
>> 1584 Organization of State Commercial Administration of China (OSCCA)
>> 1585 as an authorized cryptographic algorithms for the use within China.
>> 1586
>> 1587 This is SM4 optimized implementation using AES-NI/AVX/x86_64
>> 1588 instruction set for block cipher. Through two affine transforms,
>> 1589 we can use the AES S-Box to simulate the SM4 S-Box to achieve the
>> 1590 effect of instruction acceleration.
>> 1591
>> 1592 If unsure, say N.
>> 1593
>> 1594 config CRYPTO_SM4_AESNI_AVX2_X86_64
>> 1595 tristate "SM4 cipher algorithm (x86_64/AES-NI/AVX2)"
>> 1596 depends on X86 && 64BIT
>> 1597 select CRYPTO_SKCIPHER
>> 1598 select CRYPTO_SIMD
>> 1599 select CRYPTO_ALGAPI
>> 1600 select CRYPTO_LIB_SM4
>> 1601 select CRYPTO_SM4_AESNI_AVX_X86_64
>> 1602 help
>> 1603 SM4 cipher algorithms (OSCCA GB/T 32907-2016) (x86_64/AES-NI/AVX2).
>> 1604
>> 1605 SM4 (GBT.32907-2016) is a cryptographic standard issued by the
>> 1606 Organization of State Commercial Administration of China (OSCCA)
>> 1607 as an authorized cryptographic algorithms for the use within China.
>> 1608
>> 1609 This is SM4 optimized implementation using AES-NI/AVX2/x86_64
>> 1610 instruction set for block cipher. Through two affine transforms,
>> 1611 we can use the AES S-Box to simulate the SM4 S-Box to achieve the
>> 1612 effect of instruction acceleration.
>> 1613
>> 1614 If unsure, say N.
>> 1615
>> 1616 config CRYPTO_TEA
>> 1617 tristate "TEA, XTEA and XETA cipher algorithms"
>> 1618 depends on CRYPTO_USER_API_ENABLE_OBSOLETE
>> 1619 select CRYPTO_ALGAPI
>> 1620 help
>> 1621 TEA cipher algorithm.
>> 1622
>> 1623 Tiny Encryption Algorithm is a simple cipher that uses
>> 1624 many rounds for security. It is very fast and uses
>> 1625 little memory.
>> 1626
>> 1627 Xtendend Tiny Encryption Algorithm is a modification to
>> 1628 the TEA algorithm to address a potential key weakness
>> 1629 in the TEA algorithm.
>> 1630
>> 1631 Xtendend Encryption Tiny Algorithm is a mis-implementation
>> 1632 of the XTEA algorithm for compatibility purposes.
>> 1633
>> 1634 config CRYPTO_TWOFISH
>> 1635 tristate "Twofish cipher algorithm"
>> 1636 select CRYPTO_ALGAPI
>> 1637 select CRYPTO_TWOFISH_COMMON
1113 help 1638 help
1114 CRC64 CRC algorithm based on the Ro !! 1639 Twofish cipher algorithm.
1115 1640
1116 Used by the NVMe implementation of !! 1641 Twofish was submitted as an AES (Advanced Encryption Standard)
>> 1642 candidate cipher by researchers at CounterPane Systems. It is a
>> 1643 16 round block cipher supporting key sizes of 128, 192, and 256
>> 1644 bits.
>> 1645
>> 1646 See also:
>> 1647 <https://www.schneier.com/twofish.html>
1117 1648
1118 See https://zlib.net/crc_v3.txt !! 1649 config CRYPTO_TWOFISH_COMMON
>> 1650 tristate
>> 1651 help
>> 1652 Common parts of the Twofish cipher algorithm shared by the
>> 1653 generic c and the assembler implementations.
1119 1654
1120 endmenu !! 1655 config CRYPTO_TWOFISH_586
>> 1656 tristate "Twofish cipher algorithms (i586)"
>> 1657 depends on (X86 || UML_X86) && !64BIT
>> 1658 select CRYPTO_ALGAPI
>> 1659 select CRYPTO_TWOFISH_COMMON
>> 1660 imply CRYPTO_CTR
>> 1661 help
>> 1662 Twofish cipher algorithm.
>> 1663
>> 1664 Twofish was submitted as an AES (Advanced Encryption Standard)
>> 1665 candidate cipher by researchers at CounterPane Systems. It is a
>> 1666 16 round block cipher supporting key sizes of 128, 192, and 256
>> 1667 bits.
1121 1668
1122 menu "Compression" !! 1669 See also:
>> 1670 <https://www.schneier.com/twofish.html>
>> 1671
>> 1672 config CRYPTO_TWOFISH_X86_64
>> 1673 tristate "Twofish cipher algorithm (x86_64)"
>> 1674 depends on (X86 || UML_X86) && 64BIT
>> 1675 select CRYPTO_ALGAPI
>> 1676 select CRYPTO_TWOFISH_COMMON
>> 1677 imply CRYPTO_CTR
>> 1678 help
>> 1679 Twofish cipher algorithm (x86_64).
>> 1680
>> 1681 Twofish was submitted as an AES (Advanced Encryption Standard)
>> 1682 candidate cipher by researchers at CounterPane Systems. It is a
>> 1683 16 round block cipher supporting key sizes of 128, 192, and 256
>> 1684 bits.
>> 1685
>> 1686 See also:
>> 1687 <https://www.schneier.com/twofish.html>
>> 1688
>> 1689 config CRYPTO_TWOFISH_X86_64_3WAY
>> 1690 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
>> 1691 depends on X86 && 64BIT
>> 1692 select CRYPTO_SKCIPHER
>> 1693 select CRYPTO_TWOFISH_COMMON
>> 1694 select CRYPTO_TWOFISH_X86_64
>> 1695 help
>> 1696 Twofish cipher algorithm (x86_64, 3-way parallel).
>> 1697
>> 1698 Twofish was submitted as an AES (Advanced Encryption Standard)
>> 1699 candidate cipher by researchers at CounterPane Systems. It is a
>> 1700 16 round block cipher supporting key sizes of 128, 192, and 256
>> 1701 bits.
>> 1702
>> 1703 This module provides Twofish cipher algorithm that processes three
>> 1704 blocks parallel, utilizing resources of out-of-order CPUs better.
>> 1705
>> 1706 See also:
>> 1707 <https://www.schneier.com/twofish.html>
>> 1708
>> 1709 config CRYPTO_TWOFISH_AVX_X86_64
>> 1710 tristate "Twofish cipher algorithm (x86_64/AVX)"
>> 1711 depends on X86 && 64BIT
>> 1712 select CRYPTO_SKCIPHER
>> 1713 select CRYPTO_SIMD
>> 1714 select CRYPTO_TWOFISH_COMMON
>> 1715 select CRYPTO_TWOFISH_X86_64
>> 1716 select CRYPTO_TWOFISH_X86_64_3WAY
>> 1717 imply CRYPTO_XTS
>> 1718 help
>> 1719 Twofish cipher algorithm (x86_64/AVX).
>> 1720
>> 1721 Twofish was submitted as an AES (Advanced Encryption Standard)
>> 1722 candidate cipher by researchers at CounterPane Systems. It is a
>> 1723 16 round block cipher supporting key sizes of 128, 192, and 256
>> 1724 bits.
>> 1725
>> 1726 This module provides the Twofish cipher algorithm that processes
>> 1727 eight blocks parallel using the AVX Instruction Set.
>> 1728
>> 1729 See also:
>> 1730 <https://www.schneier.com/twofish.html>
>> 1731
>> 1732 comment "Compression"
1123 1733
1124 config CRYPTO_DEFLATE 1734 config CRYPTO_DEFLATE
1125 tristate "Deflate" !! 1735 tristate "Deflate compression algorithm"
1126 select CRYPTO_ALGAPI 1736 select CRYPTO_ALGAPI
1127 select CRYPTO_ACOMP2 1737 select CRYPTO_ACOMP2
1128 select ZLIB_INFLATE 1738 select ZLIB_INFLATE
1129 select ZLIB_DEFLATE 1739 select ZLIB_DEFLATE
1130 help 1740 help
1131 Deflate compression algorithm (RFC1 !! 1741 This is the Deflate algorithm (RFC1951), specified for use in
>> 1742 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
1132 1743
1133 Used by IPSec with the IPCOMP proto !! 1744 You will most probably want this if using IPSec.
1134 1745
1135 config CRYPTO_LZO 1746 config CRYPTO_LZO
1136 tristate "LZO" !! 1747 tristate "LZO compression algorithm"
1137 select CRYPTO_ALGAPI 1748 select CRYPTO_ALGAPI
1138 select CRYPTO_ACOMP2 1749 select CRYPTO_ACOMP2
1139 select LZO_COMPRESS 1750 select LZO_COMPRESS
1140 select LZO_DECOMPRESS 1751 select LZO_DECOMPRESS
1141 help 1752 help
1142 LZO compression algorithm !! 1753 This is the LZO algorithm.
1143 <<
1144 See https://www.oberhumer.com/opens <<
1145 1754
1146 config CRYPTO_842 1755 config CRYPTO_842
1147 tristate "842" !! 1756 tristate "842 compression algorithm"
1148 select CRYPTO_ALGAPI 1757 select CRYPTO_ALGAPI
1149 select CRYPTO_ACOMP2 1758 select CRYPTO_ACOMP2
1150 select 842_COMPRESS 1759 select 842_COMPRESS
1151 select 842_DECOMPRESS 1760 select 842_DECOMPRESS
1152 help 1761 help
1153 842 compression algorithm by IBM !! 1762 This is the 842 algorithm.
1154 <<
1155 See https://github.com/plauth/lib84 <<
1156 1763
1157 config CRYPTO_LZ4 1764 config CRYPTO_LZ4
1158 tristate "LZ4" !! 1765 tristate "LZ4 compression algorithm"
1159 select CRYPTO_ALGAPI 1766 select CRYPTO_ALGAPI
1160 select CRYPTO_ACOMP2 1767 select CRYPTO_ACOMP2
1161 select LZ4_COMPRESS 1768 select LZ4_COMPRESS
1162 select LZ4_DECOMPRESS 1769 select LZ4_DECOMPRESS
1163 help 1770 help
1164 LZ4 compression algorithm !! 1771 This is the LZ4 algorithm.
1165 <<
1166 See https://github.com/lz4/lz4 for <<
1167 1772
1168 config CRYPTO_LZ4HC 1773 config CRYPTO_LZ4HC
1169 tristate "LZ4HC" !! 1774 tristate "LZ4HC compression algorithm"
1170 select CRYPTO_ALGAPI 1775 select CRYPTO_ALGAPI
1171 select CRYPTO_ACOMP2 1776 select CRYPTO_ACOMP2
1172 select LZ4HC_COMPRESS 1777 select LZ4HC_COMPRESS
1173 select LZ4_DECOMPRESS 1778 select LZ4_DECOMPRESS
1174 help 1779 help
1175 LZ4 high compression mode algorithm !! 1780 This is the LZ4 high compression mode algorithm.
1176 <<
1177 See https://github.com/lz4/lz4 for <<
1178 1781
1179 config CRYPTO_ZSTD 1782 config CRYPTO_ZSTD
1180 tristate "Zstd" !! 1783 tristate "Zstd compression algorithm"
1181 select CRYPTO_ALGAPI 1784 select CRYPTO_ALGAPI
1182 select CRYPTO_ACOMP2 1785 select CRYPTO_ACOMP2
1183 select ZSTD_COMPRESS 1786 select ZSTD_COMPRESS
1184 select ZSTD_DECOMPRESS 1787 select ZSTD_DECOMPRESS
1185 help 1788 help
1186 zstd compression algorithm !! 1789 This is the zstd algorithm.
1187 <<
1188 See https://github.com/facebook/zst <<
1189 <<
1190 endmenu <<
1191 1790
1192 menu "Random number generation" !! 1791 comment "Random Number Generation"
1193 1792
1194 config CRYPTO_ANSI_CPRNG 1793 config CRYPTO_ANSI_CPRNG
1195 tristate "ANSI PRNG (Pseudo Random Nu !! 1794 tristate "Pseudo Random Number Generation for Cryptographic modules"
1196 select CRYPTO_AES 1795 select CRYPTO_AES
1197 select CRYPTO_RNG 1796 select CRYPTO_RNG
1198 help 1797 help
1199 Pseudo RNG (random number generator !! 1798 This option enables the generic pseudo random number generator
1200 !! 1799 for cryptographic modules. Uses the Algorithm specified in
1201 This uses the AES cipher algorithm. !! 1800 ANSI X9.31 A.2.4. Note that this option must be enabled if
1202 !! 1801 CRYPTO_FIPS is selected
1203 Note that this option must be enabl <<
1204 1802
1205 menuconfig CRYPTO_DRBG_MENU 1803 menuconfig CRYPTO_DRBG_MENU
1206 tristate "NIST SP800-90A DRBG (Determ !! 1804 tristate "NIST SP800-90A DRBG"
1207 help 1805 help
1208 DRBG (Deterministic Random Bit Gene !! 1806 NIST SP800-90A compliant DRBG. In the following submenu, one or
1209 !! 1807 more of the DRBG types must be selected.
1210 In the following submenu, one or mo <<
1211 1808
1212 if CRYPTO_DRBG_MENU 1809 if CRYPTO_DRBG_MENU
1213 1810
1214 config CRYPTO_DRBG_HMAC 1811 config CRYPTO_DRBG_HMAC
1215 bool 1812 bool
1216 default y 1813 default y
1217 select CRYPTO_HMAC 1814 select CRYPTO_HMAC
1218 select CRYPTO_SHA512 1815 select CRYPTO_SHA512
1219 1816
1220 config CRYPTO_DRBG_HASH 1817 config CRYPTO_DRBG_HASH
1221 bool "Hash_DRBG" !! 1818 bool "Enable Hash DRBG"
1222 select CRYPTO_SHA256 1819 select CRYPTO_SHA256
1223 help 1820 help
1224 Hash_DRBG variant as defined in NIS !! 1821 Enable the Hash DRBG variant as defined in NIST SP800-90A.
1225 <<
1226 This uses the SHA-1, SHA-256, SHA-3 <<
1227 1822
1228 config CRYPTO_DRBG_CTR 1823 config CRYPTO_DRBG_CTR
1229 bool "CTR_DRBG" !! 1824 bool "Enable CTR DRBG"
1230 select CRYPTO_AES 1825 select CRYPTO_AES
1231 select CRYPTO_CTR 1826 select CRYPTO_CTR
1232 help 1827 help
1233 CTR_DRBG variant as defined in NIST !! 1828 Enable the CTR DRBG variant as defined in NIST SP800-90A.
1234 <<
1235 This uses the AES cipher algorithm <<
1236 1829
1237 config CRYPTO_DRBG 1830 config CRYPTO_DRBG
1238 tristate 1831 tristate
1239 default CRYPTO_DRBG_MENU 1832 default CRYPTO_DRBG_MENU
1240 select CRYPTO_RNG 1833 select CRYPTO_RNG
1241 select CRYPTO_JITTERENTROPY 1834 select CRYPTO_JITTERENTROPY
1242 1835
1243 endif # if CRYPTO_DRBG_MENU 1836 endif # if CRYPTO_DRBG_MENU
1244 1837
1245 config CRYPTO_JITTERENTROPY 1838 config CRYPTO_JITTERENTROPY
1246 tristate "CPU Jitter Non-Deterministi !! 1839 tristate "Jitterentropy Non-Deterministic Random Number Generator"
1247 select CRYPTO_RNG 1840 select CRYPTO_RNG
1248 select CRYPTO_SHA3 <<
1249 help 1841 help
1250 CPU Jitter RNG (Random Number Gener !! 1842 The Jitterentropy RNG is a noise that is intended
1251 !! 1843 to provide seed to another RNG. The RNG does not
1252 A non-physical non-deterministic (" !! 1844 perform any cryptographic whitening of the generated
1253 compliant with NIST SP800-90B) inte !! 1845 random numbers. This Jitterentropy RNG registers with
1254 deterministic RNG (e.g., per NIST S !! 1846 the kernel crypto API and can be used by any caller.
1255 This RNG does not perform any crypt <<
1256 random numbers. <<
1257 <<
1258 See https://www.chronox.de/jent/ <<
1259 <<
1260 if CRYPTO_JITTERENTROPY <<
1261 if CRYPTO_FIPS && EXPERT <<
1262 <<
1263 choice <<
1264 prompt "CPU Jitter RNG Memory Size" <<
1265 default CRYPTO_JITTERENTROPY_MEMSIZE_ <<
1266 help <<
1267 The Jitter RNG measures the executi <<
1268 Multiple consecutive memory accesse <<
1269 size fits into a cache (e.g. L1), o <<
1270 to that cache is measured. The clos <<
1271 the less variations are measured an <<
1272 obtained. Thus, if the memory size <<
1273 obtained entropy is less than if th <<
1274 L1 + L2, which in turn is less if t <<
1275 L1 + L2 + L3. Thus, by selecting a <<
1276 the entropy rate produced by the Ji <<
1277 <<
1278 config CRYPTO_JITTERENTROPY_MEMSIZE_2 <<
1279 bool "2048 Bytes (default)" <<
1280 <<
1281 config CRYPTO_JITTERENTROPY_MEMSIZE_1 <<
1282 bool "128 kBytes" <<
1283 <<
1284 config CRYPTO_JITTERENTROPY_MEMSIZE_1 <<
1285 bool "1024 kBytes" <<
1286 <<
1287 config CRYPTO_JITTERENTROPY_MEMSIZE_8 <<
1288 bool "8192 kBytes" <<
1289 endchoice <<
1290 <<
1291 config CRYPTO_JITTERENTROPY_MEMORY_BLOCKS <<
1292 int <<
1293 default 64 if CRYPTO_JITTERENTROPY_ME <<
1294 default 512 if CRYPTO_JITTERENTROPY_M <<
1295 default 1024 if CRYPTO_JITTERENTROPY_ <<
1296 default 4096 if CRYPTO_JITTERENTROPY_ <<
1297 <<
1298 config CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE <<
1299 int <<
1300 default 32 if CRYPTO_JITTERENTROPY_ME <<
1301 default 256 if CRYPTO_JITTERENTROPY_M <<
1302 default 1024 if CRYPTO_JITTERENTROPY_ <<
1303 default 2048 if CRYPTO_JITTERENTROPY_ <<
1304 <<
1305 config CRYPTO_JITTERENTROPY_OSR <<
1306 int "CPU Jitter RNG Oversampling Rate <<
1307 range 1 15 <<
1308 default 3 <<
1309 help <<
1310 The Jitter RNG allows the specifica <<
1311 The Jitter RNG operation requires a <<
1312 measurements to produce one output <<
1313 OSR value is multiplied with the am <<
1314 generate one output block. Thus, th <<
1315 by the OSR factor. The oversampling <<
1316 on hardware whose timers deliver li <<
1317 the timer is coarse) by setting the <<
1318 trade-off, however, is that the Jit <<
1319 to generate random numbers. <<
1320 <<
1321 config CRYPTO_JITTERENTROPY_TESTINTERFACE <<
1322 bool "CPU Jitter RNG Test Interface" <<
1323 help <<
1324 The test interface allows a privile <<
1325 the raw unconditioned high resoluti <<
1326 is collected by the Jitter RNG for <<
1327 this data is used at the same time <<
1328 the Jitter RNG operates in an insec <<
1329 recording is enabled. This interfac <<
1330 intended for testing purposes and i <<
1331 production systems. <<
1332 <<
1333 The raw noise data can be obtained <<
1334 debugfs file. Using the option <<
1335 jitterentropy_testing.boot_raw_hire <<
1336 the first 1000 entropy events since <<
1337 <<
1338 If unsure, select N. <<
1339 <<
1340 endif # if CRYPTO_FIPS && EXPERT <<
1341 <<
1342 if !(CRYPTO_FIPS && EXPERT) <<
1343 <<
1344 config CRYPTO_JITTERENTROPY_MEMORY_BLOCKS <<
1345 int <<
1346 default 64 <<
1347 <<
1348 config CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE <<
1349 int <<
1350 default 32 <<
1351 <<
1352 config CRYPTO_JITTERENTROPY_OSR <<
1353 int <<
1354 default 1 <<
1355 <<
1356 config CRYPTO_JITTERENTROPY_TESTINTERFACE <<
1357 bool <<
1358 <<
1359 endif # if !(CRYPTO_FIPS && EXPERT) <<
1360 endif # if CRYPTO_JITTERENTROPY <<
1361 <<
1362 config CRYPTO_KDF800108_CTR <<
1363 tristate <<
1364 select CRYPTO_HMAC <<
1365 select CRYPTO_SHA256 <<
1366 <<
1367 endmenu <<
1368 menu "Userspace interface" <<
1369 1847
1370 config CRYPTO_USER_API 1848 config CRYPTO_USER_API
1371 tristate 1849 tristate
1372 1850
1373 config CRYPTO_USER_API_HASH 1851 config CRYPTO_USER_API_HASH
1374 tristate "Hash algorithms" !! 1852 tristate "User-space interface for hash algorithms"
1375 depends on NET 1853 depends on NET
1376 select CRYPTO_HASH 1854 select CRYPTO_HASH
1377 select CRYPTO_USER_API 1855 select CRYPTO_USER_API
1378 help 1856 help
1379 Enable the userspace interface for !! 1857 This option enables the user-spaces interface for hash
1380 !! 1858 algorithms.
1381 See Documentation/crypto/userspace- <<
1382 https://www.chronox.de/libkcapi/htm <<
1383 1859
1384 config CRYPTO_USER_API_SKCIPHER 1860 config CRYPTO_USER_API_SKCIPHER
1385 tristate "Symmetric key cipher algori !! 1861 tristate "User-space interface for symmetric key cipher algorithms"
1386 depends on NET 1862 depends on NET
1387 select CRYPTO_SKCIPHER 1863 select CRYPTO_SKCIPHER
1388 select CRYPTO_USER_API 1864 select CRYPTO_USER_API
1389 help 1865 help
1390 Enable the userspace interface for !! 1866 This option enables the user-spaces interface for symmetric
1391 !! 1867 key cipher algorithms.
1392 See Documentation/crypto/userspace- <<
1393 https://www.chronox.de/libkcapi/htm <<
1394 1868
1395 config CRYPTO_USER_API_RNG 1869 config CRYPTO_USER_API_RNG
1396 tristate "RNG (random number generato !! 1870 tristate "User-space interface for random number generator algorithms"
1397 depends on NET 1871 depends on NET
1398 select CRYPTO_RNG 1872 select CRYPTO_RNG
1399 select CRYPTO_USER_API 1873 select CRYPTO_USER_API
1400 help 1874 help
1401 Enable the userspace interface for !! 1875 This option enables the user-spaces interface for random
1402 algorithms. !! 1876 number generator algorithms.
1403 <<
1404 See Documentation/crypto/userspace- <<
1405 https://www.chronox.de/libkcapi/htm <<
1406 1877
1407 config CRYPTO_USER_API_RNG_CAVP 1878 config CRYPTO_USER_API_RNG_CAVP
1408 bool "Enable CAVP testing of DRBG" 1879 bool "Enable CAVP testing of DRBG"
1409 depends on CRYPTO_USER_API_RNG && CRY 1880 depends on CRYPTO_USER_API_RNG && CRYPTO_DRBG
1410 help 1881 help
1411 Enable extra APIs in the userspace !! 1882 This option enables extra API for CAVP testing via the user-space
1412 (Cryptographic Algorithm Validation !! 1883 interface: resetting of DRBG entropy, and providing Additional Data.
1413 - resetting DRBG entropy <<
1414 - providing Additional Data <<
1415 <<
1416 This should only be enabled for CAV 1884 This should only be enabled for CAVP testing. You should say
1417 no unless you know what this is. 1885 no unless you know what this is.
1418 1886
1419 config CRYPTO_USER_API_AEAD 1887 config CRYPTO_USER_API_AEAD
1420 tristate "AEAD cipher algorithms" !! 1888 tristate "User-space interface for AEAD cipher algorithms"
1421 depends on NET 1889 depends on NET
1422 select CRYPTO_AEAD 1890 select CRYPTO_AEAD
1423 select CRYPTO_SKCIPHER 1891 select CRYPTO_SKCIPHER
1424 select CRYPTO_NULL 1892 select CRYPTO_NULL
1425 select CRYPTO_USER_API 1893 select CRYPTO_USER_API
1426 help 1894 help
1427 Enable the userspace interface for !! 1895 This option enables the user-spaces interface for AEAD
1428 !! 1896 cipher algorithms.
1429 See Documentation/crypto/userspace- <<
1430 https://www.chronox.de/libkcapi/htm <<
1431 1897
1432 config CRYPTO_USER_API_ENABLE_OBSOLETE 1898 config CRYPTO_USER_API_ENABLE_OBSOLETE
1433 bool "Obsolete cryptographic algorith !! 1899 bool "Enable obsolete cryptographic algorithms for userspace"
1434 depends on CRYPTO_USER_API 1900 depends on CRYPTO_USER_API
1435 default y 1901 default y
1436 help 1902 help
1437 Allow obsolete cryptographic algori 1903 Allow obsolete cryptographic algorithms to be selected that have
1438 already been phased out from intern 1904 already been phased out from internal use by the kernel, and are
1439 only useful for userspace clients t 1905 only useful for userspace clients that still rely on them.
1440 1906
1441 endmenu !! 1907 config CRYPTO_STATS
>> 1908 bool "Crypto usage statistics for User-space"
>> 1909 depends on CRYPTO_USER
>> 1910 help
>> 1911 This option enables the gathering of crypto stats.
>> 1912 This will collect:
>> 1913 - encrypt/decrypt size and numbers of symmeric operations
>> 1914 - compress/decompress size and numbers of compress operations
>> 1915 - size and numbers of hash operations
>> 1916 - encrypt/decrypt/sign/verify numbers for asymmetric operations
>> 1917 - generate/seed numbers for rng operations
1442 1918
1443 config CRYPTO_HASH_INFO 1919 config CRYPTO_HASH_INFO
1444 bool 1920 bool
1445 1921
1446 if !KMSAN # avoid false positives from assemb !! 1922 source "lib/crypto/Kconfig"
1447 if ARM <<
1448 source "arch/arm/crypto/Kconfig" <<
1449 endif <<
1450 if ARM64 <<
1451 source "arch/arm64/crypto/Kconfig" <<
1452 endif <<
1453 if LOONGARCH <<
1454 source "arch/loongarch/crypto/Kconfig" <<
1455 endif <<
1456 if MIPS <<
1457 source "arch/mips/crypto/Kconfig" <<
1458 endif <<
1459 if PPC <<
1460 source "arch/powerpc/crypto/Kconfig" <<
1461 endif <<
1462 if RISCV <<
1463 source "arch/riscv/crypto/Kconfig" <<
1464 endif <<
1465 if S390 <<
1466 source "arch/s390/crypto/Kconfig" <<
1467 endif <<
1468 if SPARC <<
1469 source "arch/sparc/crypto/Kconfig" <<
1470 endif <<
1471 if X86 <<
1472 source "arch/x86/crypto/Kconfig" <<
1473 endif <<
1474 endif <<
1475 <<
1476 source "drivers/crypto/Kconfig" 1923 source "drivers/crypto/Kconfig"
1477 source "crypto/asymmetric_keys/Kconfig" 1924 source "crypto/asymmetric_keys/Kconfig"
1478 source "certs/Kconfig" 1925 source "certs/Kconfig"
1479 1926
1480 endif # if CRYPTO 1927 endif # if CRYPTO
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.