Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 964f3b3bf49eb84b5831121446a28b76de3fb23a

Authored by David Howells
Committed by Rusty Russell
1 parent 9a83b46578
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

KEYS: Implement asymmetric key type 

Create a key type that can be used to represent an asymmetric key type for use
in appropriate cryptographic operations, such as encryption, decryption,
signature generation and signature verification.

The key type is "asymmetric" and can provide access to a variety of
cryptographic algorithms.

Possibly, this would be better as "public_key" - but that has the disadvantage
that "public key" is an overloaded term.

Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

Showing 8 changed files with 273 additions and 0 deletions Inline Diff

1 # 1 #
2 # Generic algorithms support 2 # Generic algorithms support
3 # 3 #
4 config XOR_BLOCKS 4 config XOR_BLOCKS
5 tristate 5 tristate
6 6
7 # 7 #
8 # async_tx api: hardware offloaded memory transfer/transform support 8 # async_tx api: hardware offloaded memory transfer/transform support
9 # 9 #
10 source "crypto/async_tx/Kconfig" 10 source "crypto/async_tx/Kconfig"
11 11
12 # 12 #
13 # Cryptographic API Configuration 13 # Cryptographic API Configuration
14 # 14 #
15 menuconfig CRYPTO 15 menuconfig CRYPTO
16 tristate "Cryptographic API" 16 tristate "Cryptographic API"
17 help 17 help
18 This option provides the core Cryptographic API. 18 This option provides the core Cryptographic API.
19 19
20 if CRYPTO 20 if CRYPTO
21 21
22 comment "Crypto core or helper" 22 comment "Crypto core or helper"
23 23
24 config CRYPTO_FIPS 24 config CRYPTO_FIPS
25 bool "FIPS 200 compliance" 25 bool "FIPS 200 compliance"
26 depends on CRYPTO_ANSI_CPRNG && !CRYPTO_MANAGER_DISABLE_TESTS 26 depends on CRYPTO_ANSI_CPRNG && !CRYPTO_MANAGER_DISABLE_TESTS
27 help 27 help
28 This options enables the fips boot option which is 28 This options enables the fips boot option which is
29 required if you want to system to operate in a FIPS 200 29 required if you want to system to operate in a FIPS 200
30 certification. You should say no unless you know what 30 certification. You should say no unless you know what
31 this is. 31 this is.
32 32
33 config CRYPTO_ALGAPI 33 config CRYPTO_ALGAPI
34 tristate 34 tristate
35 select CRYPTO_ALGAPI2 35 select CRYPTO_ALGAPI2
36 help 36 help
37 This option provides the API for cryptographic algorithms. 37 This option provides the API for cryptographic algorithms.
38 38
39 config CRYPTO_ALGAPI2 39 config CRYPTO_ALGAPI2
40 tristate 40 tristate
41 41
42 config CRYPTO_AEAD 42 config CRYPTO_AEAD
43 tristate 43 tristate
44 select CRYPTO_AEAD2 44 select CRYPTO_AEAD2
45 select CRYPTO_ALGAPI 45 select CRYPTO_ALGAPI
46 46
47 config CRYPTO_AEAD2 47 config CRYPTO_AEAD2
48 tristate 48 tristate
49 select CRYPTO_ALGAPI2 49 select CRYPTO_ALGAPI2
50 50
51 config CRYPTO_BLKCIPHER 51 config CRYPTO_BLKCIPHER
52 tristate 52 tristate
53 select CRYPTO_BLKCIPHER2 53 select CRYPTO_BLKCIPHER2
54 select CRYPTO_ALGAPI 54 select CRYPTO_ALGAPI
55 55
56 config CRYPTO_BLKCIPHER2 56 config CRYPTO_BLKCIPHER2
57 tristate 57 tristate
58 select CRYPTO_ALGAPI2 58 select CRYPTO_ALGAPI2
59 select CRYPTO_RNG2 59 select CRYPTO_RNG2
60 select CRYPTO_WORKQUEUE 60 select CRYPTO_WORKQUEUE
61 61
62 config CRYPTO_HASH 62 config CRYPTO_HASH
63 tristate 63 tristate
64 select CRYPTO_HASH2 64 select CRYPTO_HASH2
65 select CRYPTO_ALGAPI 65 select CRYPTO_ALGAPI
66 66
67 config CRYPTO_HASH2 67 config CRYPTO_HASH2
68 tristate 68 tristate
69 select CRYPTO_ALGAPI2 69 select CRYPTO_ALGAPI2
70 70
71 config CRYPTO_RNG 71 config CRYPTO_RNG
72 tristate 72 tristate
73 select CRYPTO_RNG2 73 select CRYPTO_RNG2
74 select CRYPTO_ALGAPI 74 select CRYPTO_ALGAPI
75 75
76 config CRYPTO_RNG2 76 config CRYPTO_RNG2
77 tristate 77 tristate
78 select CRYPTO_ALGAPI2 78 select CRYPTO_ALGAPI2
79 79
80 config CRYPTO_PCOMP 80 config CRYPTO_PCOMP
81 tristate 81 tristate
82 select CRYPTO_PCOMP2 82 select CRYPTO_PCOMP2
83 select CRYPTO_ALGAPI 83 select CRYPTO_ALGAPI
84 84
85 config CRYPTO_PCOMP2 85 config CRYPTO_PCOMP2
86 tristate 86 tristate
87 select CRYPTO_ALGAPI2 87 select CRYPTO_ALGAPI2
88 88
89 config CRYPTO_MANAGER 89 config CRYPTO_MANAGER
90 tristate "Cryptographic algorithm manager" 90 tristate "Cryptographic algorithm manager"
91 select CRYPTO_MANAGER2 91 select CRYPTO_MANAGER2
92 help 92 help
93 Create default cryptographic template instantiations such as 93 Create default cryptographic template instantiations such as
94 cbc(aes). 94 cbc(aes).
95 95
96 config CRYPTO_MANAGER2 96 config CRYPTO_MANAGER2
97 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y) 97 def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
98 select CRYPTO_AEAD2 98 select CRYPTO_AEAD2
99 select CRYPTO_HASH2 99 select CRYPTO_HASH2
100 select CRYPTO_BLKCIPHER2 100 select CRYPTO_BLKCIPHER2
101 select CRYPTO_PCOMP2 101 select CRYPTO_PCOMP2
102 102
103 config CRYPTO_USER 103 config CRYPTO_USER
104 tristate "Userspace cryptographic algorithm configuration" 104 tristate "Userspace cryptographic algorithm configuration"
105 depends on NET 105 depends on NET
106 select CRYPTO_MANAGER 106 select CRYPTO_MANAGER
107 help 107 help
108 Userspace configuration for cryptographic instantiations such as 108 Userspace configuration for cryptographic instantiations such as
109 cbc(aes). 109 cbc(aes).
110 110
111 config CRYPTO_MANAGER_DISABLE_TESTS 111 config CRYPTO_MANAGER_DISABLE_TESTS
112 bool "Disable run-time self tests" 112 bool "Disable run-time self tests"
113 default y 113 default y
114 depends on CRYPTO_MANAGER2 114 depends on CRYPTO_MANAGER2
115 help 115 help
116 Disable run-time self tests that normally take place at 116 Disable run-time self tests that normally take place at
117 algorithm registration. 117 algorithm registration.
118 118
119 config CRYPTO_GF128MUL 119 config CRYPTO_GF128MUL
120 tristate "GF(2^128) multiplication functions" 120 tristate "GF(2^128) multiplication functions"
121 help 121 help
122 Efficient table driven implementation of multiplications in the 122 Efficient table driven implementation of multiplications in the
123 field GF(2^128). This is needed by some cypher modes. This 123 field GF(2^128). This is needed by some cypher modes. This
124 option will be selected automatically if you select such a 124 option will be selected automatically if you select such a
125 cipher mode. Only select this option by hand if you expect to load 125 cipher mode. Only select this option by hand if you expect to load
126 an external module that requires these functions. 126 an external module that requires these functions.
127 127
128 config CRYPTO_NULL 128 config CRYPTO_NULL
129 tristate "Null algorithms" 129 tristate "Null algorithms"
130 select CRYPTO_ALGAPI 130 select CRYPTO_ALGAPI
131 select CRYPTO_BLKCIPHER 131 select CRYPTO_BLKCIPHER
132 select CRYPTO_HASH 132 select CRYPTO_HASH
133 help 133 help
134 These are 'Null' algorithms, used by IPsec, which do nothing. 134 These are 'Null' algorithms, used by IPsec, which do nothing.
135 135
136 config CRYPTO_PCRYPT 136 config CRYPTO_PCRYPT
137 tristate "Parallel crypto engine (EXPERIMENTAL)" 137 tristate "Parallel crypto engine (EXPERIMENTAL)"
138 depends on SMP && EXPERIMENTAL 138 depends on SMP && EXPERIMENTAL
139 select PADATA 139 select PADATA
140 select CRYPTO_MANAGER 140 select CRYPTO_MANAGER
141 select CRYPTO_AEAD 141 select CRYPTO_AEAD
142 help 142 help
143 This converts an arbitrary crypto algorithm into a parallel 143 This converts an arbitrary crypto algorithm into a parallel
144 algorithm that executes in kernel threads. 144 algorithm that executes in kernel threads.
145 145
146 config CRYPTO_WORKQUEUE 146 config CRYPTO_WORKQUEUE
147 tristate 147 tristate
148 148
149 config CRYPTO_CRYPTD 149 config CRYPTO_CRYPTD
150 tristate "Software async crypto daemon" 150 tristate "Software async crypto daemon"
151 select CRYPTO_BLKCIPHER 151 select CRYPTO_BLKCIPHER
152 select CRYPTO_HASH 152 select CRYPTO_HASH
153 select CRYPTO_MANAGER 153 select CRYPTO_MANAGER
154 select CRYPTO_WORKQUEUE 154 select CRYPTO_WORKQUEUE
155 help 155 help
156 This is a generic software asynchronous crypto daemon that 156 This is a generic software asynchronous crypto daemon that
157 converts an arbitrary synchronous software crypto algorithm 157 converts an arbitrary synchronous software crypto algorithm
158 into an asynchronous algorithm that executes in a kernel thread. 158 into an asynchronous algorithm that executes in a kernel thread.
159 159
160 config CRYPTO_AUTHENC 160 config CRYPTO_AUTHENC
161 tristate "Authenc support" 161 tristate "Authenc support"
162 select CRYPTO_AEAD 162 select CRYPTO_AEAD
163 select CRYPTO_BLKCIPHER 163 select CRYPTO_BLKCIPHER
164 select CRYPTO_MANAGER 164 select CRYPTO_MANAGER
165 select CRYPTO_HASH 165 select CRYPTO_HASH
166 help 166 help
167 Authenc: Combined mode wrapper for IPsec. 167 Authenc: Combined mode wrapper for IPsec.
168 This is required for IPSec. 168 This is required for IPSec.
169 169
170 config CRYPTO_TEST 170 config CRYPTO_TEST
171 tristate "Testing module" 171 tristate "Testing module"
172 depends on m 172 depends on m
173 select CRYPTO_MANAGER 173 select CRYPTO_MANAGER
174 help 174 help
175 Quick & dirty crypto test module. 175 Quick & dirty crypto test module.
176 176
177 config CRYPTO_ABLK_HELPER_X86 177 config CRYPTO_ABLK_HELPER_X86
178 tristate 178 tristate
179 depends on X86 179 depends on X86
180 select CRYPTO_CRYPTD 180 select CRYPTO_CRYPTD
181 181
182 config CRYPTO_GLUE_HELPER_X86 182 config CRYPTO_GLUE_HELPER_X86
183 tristate 183 tristate
184 depends on X86 184 depends on X86
185 select CRYPTO_ALGAPI 185 select CRYPTO_ALGAPI
186 186
187 comment "Authenticated Encryption with Associated Data" 187 comment "Authenticated Encryption with Associated Data"
188 188
189 config CRYPTO_CCM 189 config CRYPTO_CCM
190 tristate "CCM support" 190 tristate "CCM support"
191 select CRYPTO_CTR 191 select CRYPTO_CTR
192 select CRYPTO_AEAD 192 select CRYPTO_AEAD
193 help 193 help
194 Support for Counter with CBC MAC. Required for IPsec. 194 Support for Counter with CBC MAC. Required for IPsec.
195 195
196 config CRYPTO_GCM 196 config CRYPTO_GCM
197 tristate "GCM/GMAC support" 197 tristate "GCM/GMAC support"
198 select CRYPTO_CTR 198 select CRYPTO_CTR
199 select CRYPTO_AEAD 199 select CRYPTO_AEAD
200 select CRYPTO_GHASH 200 select CRYPTO_GHASH
201 help 201 help
202 Support for Galois/Counter Mode (GCM) and Galois Message 202 Support for Galois/Counter Mode (GCM) and Galois Message
203 Authentication Code (GMAC). Required for IPSec. 203 Authentication Code (GMAC). Required for IPSec.
204 204
205 config CRYPTO_SEQIV 205 config CRYPTO_SEQIV
206 tristate "Sequence Number IV Generator" 206 tristate "Sequence Number IV Generator"
207 select CRYPTO_AEAD 207 select CRYPTO_AEAD
208 select CRYPTO_BLKCIPHER 208 select CRYPTO_BLKCIPHER
209 select CRYPTO_RNG 209 select CRYPTO_RNG
210 help 210 help
211 This IV generator generates an IV based on a sequence number by 211 This IV generator generates an IV based on a sequence number by
212 xoring it with a salt. This algorithm is mainly useful for CTR 212 xoring it with a salt. This algorithm is mainly useful for CTR
213 213
214 comment "Block modes" 214 comment "Block modes"
215 215
216 config CRYPTO_CBC 216 config CRYPTO_CBC
217 tristate "CBC support" 217 tristate "CBC support"
218 select CRYPTO_BLKCIPHER 218 select CRYPTO_BLKCIPHER
219 select CRYPTO_MANAGER 219 select CRYPTO_MANAGER
220 help 220 help
221 CBC: Cipher Block Chaining mode 221 CBC: Cipher Block Chaining mode
222 This block cipher algorithm is required for IPSec. 222 This block cipher algorithm is required for IPSec.
223 223
224 config CRYPTO_CTR 224 config CRYPTO_CTR
225 tristate "CTR support" 225 tristate "CTR support"
226 select CRYPTO_BLKCIPHER 226 select CRYPTO_BLKCIPHER
227 select CRYPTO_SEQIV 227 select CRYPTO_SEQIV
228 select CRYPTO_MANAGER 228 select CRYPTO_MANAGER
229 help 229 help
230 CTR: Counter mode 230 CTR: Counter mode
231 This block cipher algorithm is required for IPSec. 231 This block cipher algorithm is required for IPSec.
232 232
233 config CRYPTO_CTS 233 config CRYPTO_CTS
234 tristate "CTS support" 234 tristate "CTS support"
235 select CRYPTO_BLKCIPHER 235 select CRYPTO_BLKCIPHER
236 help 236 help
237 CTS: Cipher Text Stealing 237 CTS: Cipher Text Stealing
238 This is the Cipher Text Stealing mode as described by 238 This is the Cipher Text Stealing mode as described by
239 Section 8 of rfc2040 and referenced by rfc3962. 239 Section 8 of rfc2040 and referenced by rfc3962.
240 (rfc3962 includes errata information in its Appendix A) 240 (rfc3962 includes errata information in its Appendix A)
241 This mode is required for Kerberos gss mechanism support 241 This mode is required for Kerberos gss mechanism support
242 for AES encryption. 242 for AES encryption.
243 243
244 config CRYPTO_ECB 244 config CRYPTO_ECB
245 tristate "ECB support" 245 tristate "ECB support"
246 select CRYPTO_BLKCIPHER 246 select CRYPTO_BLKCIPHER
247 select CRYPTO_MANAGER 247 select CRYPTO_MANAGER
248 help 248 help
249 ECB: Electronic CodeBook mode 249 ECB: Electronic CodeBook mode
250 This is the simplest block cipher algorithm. It simply encrypts 250 This is the simplest block cipher algorithm. It simply encrypts
251 the input block by block. 251 the input block by block.
252 252
253 config CRYPTO_LRW 253 config CRYPTO_LRW
254 tristate "LRW support" 254 tristate "LRW support"
255 select CRYPTO_BLKCIPHER 255 select CRYPTO_BLKCIPHER
256 select CRYPTO_MANAGER 256 select CRYPTO_MANAGER
257 select CRYPTO_GF128MUL 257 select CRYPTO_GF128MUL
258 help 258 help
259 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable 259 LRW: Liskov Rivest Wagner, a tweakable, non malleable, non movable
260 narrow block cipher mode for dm-crypt. Use it with cipher 260 narrow block cipher mode for dm-crypt. Use it with cipher
261 specification string aes-lrw-benbi, the key must be 256, 320 or 384. 261 specification string aes-lrw-benbi, the key must be 256, 320 or 384.
262 The first 128, 192 or 256 bits in the key are used for AES and the 262 The first 128, 192 or 256 bits in the key are used for AES and the
263 rest is used to tie each cipher block to its logical position. 263 rest is used to tie each cipher block to its logical position.
264 264
265 config CRYPTO_PCBC 265 config CRYPTO_PCBC
266 tristate "PCBC support" 266 tristate "PCBC support"
267 select CRYPTO_BLKCIPHER 267 select CRYPTO_BLKCIPHER
268 select CRYPTO_MANAGER 268 select CRYPTO_MANAGER
269 help 269 help
270 PCBC: Propagating Cipher Block Chaining mode 270 PCBC: Propagating Cipher Block Chaining mode
271 This block cipher algorithm is required for RxRPC. 271 This block cipher algorithm is required for RxRPC.
272 272
273 config CRYPTO_XTS 273 config CRYPTO_XTS
274 tristate "XTS support" 274 tristate "XTS support"
275 select CRYPTO_BLKCIPHER 275 select CRYPTO_BLKCIPHER
276 select CRYPTO_MANAGER 276 select CRYPTO_MANAGER
277 select CRYPTO_GF128MUL 277 select CRYPTO_GF128MUL
278 help 278 help
279 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain, 279 XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain,
280 key size 256, 384 or 512 bits. This implementation currently 280 key size 256, 384 or 512 bits. This implementation currently
281 can't handle a sectorsize which is not a multiple of 16 bytes. 281 can't handle a sectorsize which is not a multiple of 16 bytes.
282 282
283 comment "Hash modes" 283 comment "Hash modes"
284 284
285 config CRYPTO_HMAC 285 config CRYPTO_HMAC
286 tristate "HMAC support" 286 tristate "HMAC support"
287 select CRYPTO_HASH 287 select CRYPTO_HASH
288 select CRYPTO_MANAGER 288 select CRYPTO_MANAGER
289 help 289 help
290 HMAC: Keyed-Hashing for Message Authentication (RFC2104). 290 HMAC: Keyed-Hashing for Message Authentication (RFC2104).
291 This is required for IPSec. 291 This is required for IPSec.
292 292
293 config CRYPTO_XCBC 293 config CRYPTO_XCBC
294 tristate "XCBC support" 294 tristate "XCBC support"
295 depends on EXPERIMENTAL 295 depends on EXPERIMENTAL
296 select CRYPTO_HASH 296 select CRYPTO_HASH
297 select CRYPTO_MANAGER 297 select CRYPTO_MANAGER
298 help 298 help
299 XCBC: Keyed-Hashing with encryption algorithm 299 XCBC: Keyed-Hashing with encryption algorithm
300 http://www.ietf.org/rfc/rfc3566.txt 300 http://www.ietf.org/rfc/rfc3566.txt
301 http://csrc.nist.gov/encryption/modes/proposedmodes/ 301 http://csrc.nist.gov/encryption/modes/proposedmodes/
302 xcbc-mac/xcbc-mac-spec.pdf 302 xcbc-mac/xcbc-mac-spec.pdf
303 303
304 config CRYPTO_VMAC 304 config CRYPTO_VMAC
305 tristate "VMAC support" 305 tristate "VMAC support"
306 depends on EXPERIMENTAL 306 depends on EXPERIMENTAL
307 select CRYPTO_HASH 307 select CRYPTO_HASH
308 select CRYPTO_MANAGER 308 select CRYPTO_MANAGER
309 help 309 help
310 VMAC is a message authentication algorithm designed for 310 VMAC is a message authentication algorithm designed for
311 very high speed on 64-bit architectures. 311 very high speed on 64-bit architectures.
312 312
313 See also: 313 See also:
314 <http://fastcrypto.org/vmac> 314 <http://fastcrypto.org/vmac>
315 315
316 comment "Digest" 316 comment "Digest"
317 317
318 config CRYPTO_CRC32C 318 config CRYPTO_CRC32C
319 tristate "CRC32c CRC algorithm" 319 tristate "CRC32c CRC algorithm"
320 select CRYPTO_HASH 320 select CRYPTO_HASH
321 select CRC32 321 select CRC32
322 help 322 help
323 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used 323 Castagnoli, et al Cyclic Redundancy-Check Algorithm. Used
324 by iSCSI for header and data digests and by others. 324 by iSCSI for header and data digests and by others.
325 See Castagnoli93. Module will be crc32c. 325 See Castagnoli93. Module will be crc32c.
326 326
327 config CRYPTO_CRC32C_INTEL 327 config CRYPTO_CRC32C_INTEL
328 tristate "CRC32c INTEL hardware acceleration" 328 tristate "CRC32c INTEL hardware acceleration"
329 depends on X86 329 depends on X86
330 select CRYPTO_HASH 330 select CRYPTO_HASH
331 help 331 help
332 In Intel processor with SSE4.2 supported, the processor will 332 In Intel processor with SSE4.2 supported, the processor will
333 support CRC32C implementation using hardware accelerated CRC32 333 support CRC32C implementation using hardware accelerated CRC32
334 instruction. This option will create 'crc32c-intel' module, 334 instruction. This option will create 'crc32c-intel' module,
335 which will enable any routine to use the CRC32 instruction to 335 which will enable any routine to use the CRC32 instruction to
336 gain performance compared with software implementation. 336 gain performance compared with software implementation.
337 Module will be crc32c-intel. 337 Module will be crc32c-intel.
338 338
339 config CRYPTO_GHASH 339 config CRYPTO_GHASH
340 tristate "GHASH digest algorithm" 340 tristate "GHASH digest algorithm"
341 select CRYPTO_GF128MUL 341 select CRYPTO_GF128MUL
342 help 342 help
343 GHASH is message digest algorithm for GCM (Galois/Counter Mode). 343 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
344 344
345 config CRYPTO_MD4 345 config CRYPTO_MD4
346 tristate "MD4 digest algorithm" 346 tristate "MD4 digest algorithm"
347 select CRYPTO_HASH 347 select CRYPTO_HASH
348 help 348 help
349 MD4 message digest algorithm (RFC1320). 349 MD4 message digest algorithm (RFC1320).
350 350
351 config CRYPTO_MD5 351 config CRYPTO_MD5
352 tristate "MD5 digest algorithm" 352 tristate "MD5 digest algorithm"
353 select CRYPTO_HASH 353 select CRYPTO_HASH
354 help 354 help
355 MD5 message digest algorithm (RFC1321). 355 MD5 message digest algorithm (RFC1321).
356 356
357 config CRYPTO_MICHAEL_MIC 357 config CRYPTO_MICHAEL_MIC
358 tristate "Michael MIC keyed digest algorithm" 358 tristate "Michael MIC keyed digest algorithm"
359 select CRYPTO_HASH 359 select CRYPTO_HASH
360 help 360 help
361 Michael MIC is used for message integrity protection in TKIP 361 Michael MIC is used for message integrity protection in TKIP
362 (IEEE 802.11i). This algorithm is required for TKIP, but it 362 (IEEE 802.11i). This algorithm is required for TKIP, but it
363 should not be used for other purposes because of the weakness 363 should not be used for other purposes because of the weakness
364 of the algorithm. 364 of the algorithm.
365 365
366 config CRYPTO_RMD128 366 config CRYPTO_RMD128
367 tristate "RIPEMD-128 digest algorithm" 367 tristate "RIPEMD-128 digest algorithm"
368 select CRYPTO_HASH 368 select CRYPTO_HASH
369 help 369 help
370 RIPEMD-128 (ISO/IEC 10118-3:2004). 370 RIPEMD-128 (ISO/IEC 10118-3:2004).
371 371
372 RIPEMD-128 is a 128-bit cryptographic hash function. It should only 372 RIPEMD-128 is a 128-bit cryptographic hash function. It should only
373 be used as a secure replacement for RIPEMD. For other use cases, 373 be used as a secure replacement for RIPEMD. For other use cases,
374 RIPEMD-160 should be used. 374 RIPEMD-160 should be used.
375 375
376 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel. 376 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
377 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html> 377 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
378 378
379 config CRYPTO_RMD160 379 config CRYPTO_RMD160
380 tristate "RIPEMD-160 digest algorithm" 380 tristate "RIPEMD-160 digest algorithm"
381 select CRYPTO_HASH 381 select CRYPTO_HASH
382 help 382 help
383 RIPEMD-160 (ISO/IEC 10118-3:2004). 383 RIPEMD-160 (ISO/IEC 10118-3:2004).
384 384
385 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended 385 RIPEMD-160 is a 160-bit cryptographic hash function. It is intended
386 to be used as a secure replacement for the 128-bit hash functions 386 to be used as a secure replacement for the 128-bit hash functions
387 MD4, MD5 and it's predecessor RIPEMD 387 MD4, MD5 and it's predecessor RIPEMD
388 (not to be confused with RIPEMD-128). 388 (not to be confused with RIPEMD-128).
389 389
390 It's speed is comparable to SHA1 and there are no known attacks 390 It's speed is comparable to SHA1 and there are no known attacks
391 against RIPEMD-160. 391 against RIPEMD-160.
392 392
393 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel. 393 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
394 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html> 394 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
395 395
396 config CRYPTO_RMD256 396 config CRYPTO_RMD256
397 tristate "RIPEMD-256 digest algorithm" 397 tristate "RIPEMD-256 digest algorithm"
398 select CRYPTO_HASH 398 select CRYPTO_HASH
399 help 399 help
400 RIPEMD-256 is an optional extension of RIPEMD-128 with a 400 RIPEMD-256 is an optional extension of RIPEMD-128 with a
401 256 bit hash. It is intended for applications that require 401 256 bit hash. It is intended for applications that require
402 longer hash-results, without needing a larger security level 402 longer hash-results, without needing a larger security level
403 (than RIPEMD-128). 403 (than RIPEMD-128).
404 404
405 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel. 405 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
406 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html> 406 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
407 407
408 config CRYPTO_RMD320 408 config CRYPTO_RMD320
409 tristate "RIPEMD-320 digest algorithm" 409 tristate "RIPEMD-320 digest algorithm"
410 select CRYPTO_HASH 410 select CRYPTO_HASH
411 help 411 help
412 RIPEMD-320 is an optional extension of RIPEMD-160 with a 412 RIPEMD-320 is an optional extension of RIPEMD-160 with a
413 320 bit hash. It is intended for applications that require 413 320 bit hash. It is intended for applications that require
414 longer hash-results, without needing a larger security level 414 longer hash-results, without needing a larger security level
415 (than RIPEMD-160). 415 (than RIPEMD-160).
416 416
417 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel. 417 Developed by Hans Dobbertin, Antoon Bosselaers and Bart Preneel.
418 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html> 418 See <http://homes.esat.kuleuven.be/~bosselae/ripemd160.html>
419 419
420 config CRYPTO_SHA1 420 config CRYPTO_SHA1
421 tristate "SHA1 digest algorithm" 421 tristate "SHA1 digest algorithm"
422 select CRYPTO_HASH 422 select CRYPTO_HASH
423 help 423 help
424 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2). 424 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
425 425
426 config CRYPTO_SHA1_SSSE3 426 config CRYPTO_SHA1_SSSE3
427 tristate "SHA1 digest algorithm (SSSE3/AVX)" 427 tristate "SHA1 digest algorithm (SSSE3/AVX)"
428 depends on X86 && 64BIT 428 depends on X86 && 64BIT
429 select CRYPTO_SHA1 429 select CRYPTO_SHA1
430 select CRYPTO_HASH 430 select CRYPTO_HASH
431 help 431 help
432 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented 432 SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2) implemented
433 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector 433 using Supplemental SSE3 (SSSE3) instructions or Advanced Vector
434 Extensions (AVX), when available. 434 Extensions (AVX), when available.
435 435
436 config CRYPTO_SHA256 436 config CRYPTO_SHA256
437 tristate "SHA224 and SHA256 digest algorithm" 437 tristate "SHA224 and SHA256 digest algorithm"
438 select CRYPTO_HASH 438 select CRYPTO_HASH
439 help 439 help
440 SHA256 secure hash standard (DFIPS 180-2). 440 SHA256 secure hash standard (DFIPS 180-2).
441 441
442 This version of SHA implements a 256 bit hash with 128 bits of 442 This version of SHA implements a 256 bit hash with 128 bits of
443 security against collision attacks. 443 security against collision attacks.
444 444
445 This code also includes SHA-224, a 224 bit hash with 112 bits 445 This code also includes SHA-224, a 224 bit hash with 112 bits
446 of security against collision attacks. 446 of security against collision attacks.
447 447
448 config CRYPTO_SHA512 448 config CRYPTO_SHA512
449 tristate "SHA384 and SHA512 digest algorithms" 449 tristate "SHA384 and SHA512 digest algorithms"
450 select CRYPTO_HASH 450 select CRYPTO_HASH
451 help 451 help
452 SHA512 secure hash standard (DFIPS 180-2). 452 SHA512 secure hash standard (DFIPS 180-2).
453 453
454 This version of SHA implements a 512 bit hash with 256 bits of 454 This version of SHA implements a 512 bit hash with 256 bits of
455 security against collision attacks. 455 security against collision attacks.
456 456
457 This code also includes SHA-384, a 384 bit hash with 192 bits 457 This code also includes SHA-384, a 384 bit hash with 192 bits
458 of security against collision attacks. 458 of security against collision attacks.
459 459
460 config CRYPTO_TGR192 460 config CRYPTO_TGR192
461 tristate "Tiger digest algorithms" 461 tristate "Tiger digest algorithms"
462 select CRYPTO_HASH 462 select CRYPTO_HASH
463 help 463 help
464 Tiger hash algorithm 192, 160 and 128-bit hashes 464 Tiger hash algorithm 192, 160 and 128-bit hashes
465 465
466 Tiger is a hash function optimized for 64-bit processors while 466 Tiger is a hash function optimized for 64-bit processors while
467 still having decent performance on 32-bit processors. 467 still having decent performance on 32-bit processors.
468 Tiger was developed by Ross Anderson and Eli Biham. 468 Tiger was developed by Ross Anderson and Eli Biham.
469 469
470 See also: 470 See also:
471 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>. 471 <http://www.cs.technion.ac.il/~biham/Reports/Tiger/>.
472 472
473 config CRYPTO_WP512 473 config CRYPTO_WP512
474 tristate "Whirlpool digest algorithms" 474 tristate "Whirlpool digest algorithms"
475 select CRYPTO_HASH 475 select CRYPTO_HASH
476 help 476 help
477 Whirlpool hash algorithm 512, 384 and 256-bit hashes 477 Whirlpool hash algorithm 512, 384 and 256-bit hashes
478 478
479 Whirlpool-512 is part of the NESSIE cryptographic primitives. 479 Whirlpool-512 is part of the NESSIE cryptographic primitives.
480 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard 480 Whirlpool will be part of the ISO/IEC 10118-3:2003(E) standard
481 481
482 See also: 482 See also:
483 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html> 483 <http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
484 484
485 config CRYPTO_GHASH_CLMUL_NI_INTEL 485 config CRYPTO_GHASH_CLMUL_NI_INTEL
486 tristate "GHASH digest algorithm (CLMUL-NI accelerated)" 486 tristate "GHASH digest algorithm (CLMUL-NI accelerated)"
487 depends on X86 && 64BIT 487 depends on X86 && 64BIT
488 select CRYPTO_CRYPTD 488 select CRYPTO_CRYPTD
489 help 489 help
490 GHASH is message digest algorithm for GCM (Galois/Counter Mode). 490 GHASH is message digest algorithm for GCM (Galois/Counter Mode).
491 The implementation is accelerated by CLMUL-NI of Intel. 491 The implementation is accelerated by CLMUL-NI of Intel.
492 492
493 comment "Ciphers" 493 comment "Ciphers"
494 494
495 config CRYPTO_AES 495 config CRYPTO_AES
496 tristate "AES cipher algorithms" 496 tristate "AES cipher algorithms"
497 select CRYPTO_ALGAPI 497 select CRYPTO_ALGAPI
498 help 498 help
499 AES cipher algorithms (FIPS-197). AES uses the Rijndael 499 AES cipher algorithms (FIPS-197). AES uses the Rijndael
500 algorithm. 500 algorithm.
501 501
502 Rijndael appears to be consistently a very good performer in 502 Rijndael appears to be consistently a very good performer in
503 both hardware and software across a wide range of computing 503 both hardware and software across a wide range of computing
504 environments regardless of its use in feedback or non-feedback 504 environments regardless of its use in feedback or non-feedback
505 modes. Its key setup time is excellent, and its key agility is 505 modes. Its key setup time is excellent, and its key agility is
506 good. Rijndael's very low memory requirements make it very well 506 good. Rijndael's very low memory requirements make it very well
507 suited for restricted-space environments, in which it also 507 suited for restricted-space environments, in which it also
508 demonstrates excellent performance. Rijndael's operations are 508 demonstrates excellent performance. Rijndael's operations are
509 among the easiest to defend against power and timing attacks. 509 among the easiest to defend against power and timing attacks.
510 510
511 The AES specifies three key sizes: 128, 192 and 256 bits 511 The AES specifies three key sizes: 128, 192 and 256 bits
512 512
513 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information. 513 See <http://csrc.nist.gov/CryptoToolkit/aes/> for more information.
514 514
515 config CRYPTO_AES_586 515 config CRYPTO_AES_586
516 tristate "AES cipher algorithms (i586)" 516 tristate "AES cipher algorithms (i586)"
517 depends on (X86 || UML_X86) && !64BIT 517 depends on (X86 || UML_X86) && !64BIT
518 select CRYPTO_ALGAPI 518 select CRYPTO_ALGAPI
519 select CRYPTO_AES 519 select CRYPTO_AES
520 help 520 help
521 AES cipher algorithms (FIPS-197). AES uses the Rijndael 521 AES cipher algorithms (FIPS-197). AES uses the Rijndael
522 algorithm. 522 algorithm.
523 523
524 Rijndael appears to be consistently a very good performer in 524 Rijndael appears to be consistently a very good performer in
525 both hardware and software across a wide range of computing 525 both hardware and software across a wide range of computing
526 environments regardless of its use in feedback or non-feedback 526 environments regardless of its use in feedback or non-feedback
527 modes. Its key setup time is excellent, and its key agility is 527 modes. Its key setup time is excellent, and its key agility is
528 good. Rijndael's very low memory requirements make it very well 528 good. Rijndael's very low memory requirements make it very well
529 suited for restricted-space environments, in which it also 529 suited for restricted-space environments, in which it also
530 demonstrates excellent performance. Rijndael's operations are 530 demonstrates excellent performance. Rijndael's operations are
531 among the easiest to defend against power and timing attacks. 531 among the easiest to defend against power and timing attacks.
532 532
533 The AES specifies three key sizes: 128, 192 and 256 bits 533 The AES specifies three key sizes: 128, 192 and 256 bits
534 534
535 See <http://csrc.nist.gov/encryption/aes/> for more information. 535 See <http://csrc.nist.gov/encryption/aes/> for more information.
536 536
537 config CRYPTO_AES_X86_64 537 config CRYPTO_AES_X86_64
538 tristate "AES cipher algorithms (x86_64)" 538 tristate "AES cipher algorithms (x86_64)"
539 depends on (X86 || UML_X86) && 64BIT 539 depends on (X86 || UML_X86) && 64BIT
540 select CRYPTO_ALGAPI 540 select CRYPTO_ALGAPI
541 select CRYPTO_AES 541 select CRYPTO_AES
542 help 542 help
543 AES cipher algorithms (FIPS-197). AES uses the Rijndael 543 AES cipher algorithms (FIPS-197). AES uses the Rijndael
544 algorithm. 544 algorithm.
545 545
546 Rijndael appears to be consistently a very good performer in 546 Rijndael appears to be consistently a very good performer in
547 both hardware and software across a wide range of computing 547 both hardware and software across a wide range of computing
548 environments regardless of its use in feedback or non-feedback 548 environments regardless of its use in feedback or non-feedback
549 modes. Its key setup time is excellent, and its key agility is 549 modes. Its key setup time is excellent, and its key agility is
550 good. Rijndael's very low memory requirements make it very well 550 good. Rijndael's very low memory requirements make it very well
551 suited for restricted-space environments, in which it also 551 suited for restricted-space environments, in which it also
552 demonstrates excellent performance. Rijndael's operations are 552 demonstrates excellent performance. Rijndael's operations are
553 among the easiest to defend against power and timing attacks. 553 among the easiest to defend against power and timing attacks.
554 554
555 The AES specifies three key sizes: 128, 192 and 256 bits 555 The AES specifies three key sizes: 128, 192 and 256 bits
556 556
557 See <http://csrc.nist.gov/encryption/aes/> for more information. 557 See <http://csrc.nist.gov/encryption/aes/> for more information.
558 558
559 config CRYPTO_AES_NI_INTEL 559 config CRYPTO_AES_NI_INTEL
560 tristate "AES cipher algorithms (AES-NI)" 560 tristate "AES cipher algorithms (AES-NI)"
561 depends on X86 561 depends on X86
562 select CRYPTO_AES_X86_64 if 64BIT 562 select CRYPTO_AES_X86_64 if 64BIT
563 select CRYPTO_AES_586 if !64BIT 563 select CRYPTO_AES_586 if !64BIT
564 select CRYPTO_CRYPTD 564 select CRYPTO_CRYPTD
565 select CRYPTO_ABLK_HELPER_X86 565 select CRYPTO_ABLK_HELPER_X86
566 select CRYPTO_ALGAPI 566 select CRYPTO_ALGAPI
567 help 567 help
568 Use Intel AES-NI instructions for AES algorithm. 568 Use Intel AES-NI instructions for AES algorithm.
569 569
570 AES cipher algorithms (FIPS-197). AES uses the Rijndael 570 AES cipher algorithms (FIPS-197). AES uses the Rijndael
571 algorithm. 571 algorithm.
572 572
573 Rijndael appears to be consistently a very good performer in 573 Rijndael appears to be consistently a very good performer in
574 both hardware and software across a wide range of computing 574 both hardware and software across a wide range of computing
575 environments regardless of its use in feedback or non-feedback 575 environments regardless of its use in feedback or non-feedback
576 modes. Its key setup time is excellent, and its key agility is 576 modes. Its key setup time is excellent, and its key agility is
577 good. Rijndael's very low memory requirements make it very well 577 good. Rijndael's very low memory requirements make it very well
578 suited for restricted-space environments, in which it also 578 suited for restricted-space environments, in which it also
579 demonstrates excellent performance. Rijndael's operations are 579 demonstrates excellent performance. Rijndael's operations are
580 among the easiest to defend against power and timing attacks. 580 among the easiest to defend against power and timing attacks.
581 581
582 The AES specifies three key sizes: 128, 192 and 256 bits 582 The AES specifies three key sizes: 128, 192 and 256 bits
583 583
584 See <http://csrc.nist.gov/encryption/aes/> for more information. 584 See <http://csrc.nist.gov/encryption/aes/> for more information.
585 585
586 In addition to AES cipher algorithm support, the acceleration 586 In addition to AES cipher algorithm support, the acceleration
587 for some popular block cipher mode is supported too, including 587 for some popular block cipher mode is supported too, including
588 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional 588 ECB, CBC, LRW, PCBC, XTS. The 64 bit version has additional
589 acceleration for CTR. 589 acceleration for CTR.
590 590
591 config CRYPTO_ANUBIS 591 config CRYPTO_ANUBIS
592 tristate "Anubis cipher algorithm" 592 tristate "Anubis cipher algorithm"
593 select CRYPTO_ALGAPI 593 select CRYPTO_ALGAPI
594 help 594 help
595 Anubis cipher algorithm. 595 Anubis cipher algorithm.
596 596
597 Anubis is a variable key length cipher which can use keys from 597 Anubis is a variable key length cipher which can use keys from
598 128 bits to 320 bits in length. It was evaluated as a entrant 598 128 bits to 320 bits in length. It was evaluated as a entrant
599 in the NESSIE competition. 599 in the NESSIE competition.
600 600
601 See also: 601 See also:
602 <https://www.cosic.esat.kuleuven.be/nessie/reports/> 602 <https://www.cosic.esat.kuleuven.be/nessie/reports/>
603 <http://www.larc.usp.br/~pbarreto/AnubisPage.html> 603 <http://www.larc.usp.br/~pbarreto/AnubisPage.html>
604 604
605 config CRYPTO_ARC4 605 config CRYPTO_ARC4
606 tristate "ARC4 cipher algorithm" 606 tristate "ARC4 cipher algorithm"
607 select CRYPTO_BLKCIPHER 607 select CRYPTO_BLKCIPHER
608 help 608 help
609 ARC4 cipher algorithm. 609 ARC4 cipher algorithm.
610 610
611 ARC4 is a stream cipher using keys ranging from 8 bits to 2048 611 ARC4 is a stream cipher using keys ranging from 8 bits to 2048
612 bits in length. This algorithm is required for driver-based 612 bits in length. This algorithm is required for driver-based
613 WEP, but it should not be for other purposes because of the 613 WEP, but it should not be for other purposes because of the
614 weakness of the algorithm. 614 weakness of the algorithm.
615 615
616 config CRYPTO_BLOWFISH 616 config CRYPTO_BLOWFISH
617 tristate "Blowfish cipher algorithm" 617 tristate "Blowfish cipher algorithm"
618 select CRYPTO_ALGAPI 618 select CRYPTO_ALGAPI
619 select CRYPTO_BLOWFISH_COMMON 619 select CRYPTO_BLOWFISH_COMMON
620 help 620 help
621 Blowfish cipher algorithm, by Bruce Schneier. 621 Blowfish cipher algorithm, by Bruce Schneier.
622 622
623 This is a variable key length cipher which can use keys from 32 623 This is a variable key length cipher which can use keys from 32
624 bits to 448 bits in length. It's fast, simple and specifically 624 bits to 448 bits in length. It's fast, simple and specifically
625 designed for use on "large microprocessors". 625 designed for use on "large microprocessors".
626 626
627 See also: 627 See also:
628 <http://www.schneier.com/blowfish.html> 628 <http://www.schneier.com/blowfish.html>
629 629
630 config CRYPTO_BLOWFISH_COMMON 630 config CRYPTO_BLOWFISH_COMMON
631 tristate 631 tristate
632 help 632 help
633 Common parts of the Blowfish cipher algorithm shared by the 633 Common parts of the Blowfish cipher algorithm shared by the
634 generic c and the assembler implementations. 634 generic c and the assembler implementations.
635 635
636 See also: 636 See also:
637 <http://www.schneier.com/blowfish.html> 637 <http://www.schneier.com/blowfish.html>
638 638
639 config CRYPTO_BLOWFISH_X86_64 639 config CRYPTO_BLOWFISH_X86_64
640 tristate "Blowfish cipher algorithm (x86_64)" 640 tristate "Blowfish cipher algorithm (x86_64)"
641 depends on X86 && 64BIT 641 depends on X86 && 64BIT
642 select CRYPTO_ALGAPI 642 select CRYPTO_ALGAPI
643 select CRYPTO_BLOWFISH_COMMON 643 select CRYPTO_BLOWFISH_COMMON
644 help 644 help
645 Blowfish cipher algorithm (x86_64), by Bruce Schneier. 645 Blowfish cipher algorithm (x86_64), by Bruce Schneier.
646 646
647 This is a variable key length cipher which can use keys from 32 647 This is a variable key length cipher which can use keys from 32
648 bits to 448 bits in length. It's fast, simple and specifically 648 bits to 448 bits in length. It's fast, simple and specifically
649 designed for use on "large microprocessors". 649 designed for use on "large microprocessors".
650 650
651 See also: 651 See also:
652 <http://www.schneier.com/blowfish.html> 652 <http://www.schneier.com/blowfish.html>
653 653
654 config CRYPTO_CAMELLIA 654 config CRYPTO_CAMELLIA
655 tristate "Camellia cipher algorithms" 655 tristate "Camellia cipher algorithms"
656 depends on CRYPTO 656 depends on CRYPTO
657 select CRYPTO_ALGAPI 657 select CRYPTO_ALGAPI
658 help 658 help
659 Camellia cipher algorithms module. 659 Camellia cipher algorithms module.
660 660
661 Camellia is a symmetric key block cipher developed jointly 661 Camellia is a symmetric key block cipher developed jointly
662 at NTT and Mitsubishi Electric Corporation. 662 at NTT and Mitsubishi Electric Corporation.
663 663
664 The Camellia specifies three key sizes: 128, 192 and 256 bits. 664 The Camellia specifies three key sizes: 128, 192 and 256 bits.
665 665
666 See also: 666 See also:
667 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html> 667 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
668 668
669 config CRYPTO_CAMELLIA_X86_64 669 config CRYPTO_CAMELLIA_X86_64
670 tristate "Camellia cipher algorithm (x86_64)" 670 tristate "Camellia cipher algorithm (x86_64)"
671 depends on X86 && 64BIT 671 depends on X86 && 64BIT
672 depends on CRYPTO 672 depends on CRYPTO
673 select CRYPTO_ALGAPI 673 select CRYPTO_ALGAPI
674 select CRYPTO_GLUE_HELPER_X86 674 select CRYPTO_GLUE_HELPER_X86
675 select CRYPTO_LRW 675 select CRYPTO_LRW
676 select CRYPTO_XTS 676 select CRYPTO_XTS
677 help 677 help
678 Camellia cipher algorithm module (x86_64). 678 Camellia cipher algorithm module (x86_64).
679 679
680 Camellia is a symmetric key block cipher developed jointly 680 Camellia is a symmetric key block cipher developed jointly
681 at NTT and Mitsubishi Electric Corporation. 681 at NTT and Mitsubishi Electric Corporation.
682 682
683 The Camellia specifies three key sizes: 128, 192 and 256 bits. 683 The Camellia specifies three key sizes: 128, 192 and 256 bits.
684 684
685 See also: 685 See also:
686 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html> 686 <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>
687 687
688 config CRYPTO_CAST5 688 config CRYPTO_CAST5
689 tristate "CAST5 (CAST-128) cipher algorithm" 689 tristate "CAST5 (CAST-128) cipher algorithm"
690 select CRYPTO_ALGAPI 690 select CRYPTO_ALGAPI
691 help 691 help
692 The CAST5 encryption algorithm (synonymous with CAST-128) is 692 The CAST5 encryption algorithm (synonymous with CAST-128) is
693 described in RFC2144. 693 described in RFC2144.
694 694
695 config CRYPTO_CAST6 695 config CRYPTO_CAST6
696 tristate "CAST6 (CAST-256) cipher algorithm" 696 tristate "CAST6 (CAST-256) cipher algorithm"
697 select CRYPTO_ALGAPI 697 select CRYPTO_ALGAPI
698 help 698 help
699 The CAST6 encryption algorithm (synonymous with CAST-256) is 699 The CAST6 encryption algorithm (synonymous with CAST-256) is
700 described in RFC2612. 700 described in RFC2612.
701 701
702 config CRYPTO_DES 702 config CRYPTO_DES
703 tristate "DES and Triple DES EDE cipher algorithms" 703 tristate "DES and Triple DES EDE cipher algorithms"
704 select CRYPTO_ALGAPI 704 select CRYPTO_ALGAPI
705 help 705 help
706 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3). 706 DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
707 707
708 config CRYPTO_FCRYPT 708 config CRYPTO_FCRYPT
709 tristate "FCrypt cipher algorithm" 709 tristate "FCrypt cipher algorithm"
710 select CRYPTO_ALGAPI 710 select CRYPTO_ALGAPI
711 select CRYPTO_BLKCIPHER 711 select CRYPTO_BLKCIPHER
712 help 712 help
713 FCrypt algorithm used by RxRPC. 713 FCrypt algorithm used by RxRPC.
714 714
715 config CRYPTO_KHAZAD 715 config CRYPTO_KHAZAD
716 tristate "Khazad cipher algorithm" 716 tristate "Khazad cipher algorithm"
717 select CRYPTO_ALGAPI 717 select CRYPTO_ALGAPI
718 help 718 help
719 Khazad cipher algorithm. 719 Khazad cipher algorithm.
720 720
721 Khazad was a finalist in the initial NESSIE competition. It is 721 Khazad was a finalist in the initial NESSIE competition. It is
722 an algorithm optimized for 64-bit processors with good performance 722 an algorithm optimized for 64-bit processors with good performance
723 on 32-bit processors. Khazad uses an 128 bit key size. 723 on 32-bit processors. Khazad uses an 128 bit key size.
724 724
725 See also: 725 See also:
726 <http://www.larc.usp.br/~pbarreto/KhazadPage.html> 726 <http://www.larc.usp.br/~pbarreto/KhazadPage.html>
727 727
728 config CRYPTO_SALSA20 728 config CRYPTO_SALSA20
729 tristate "Salsa20 stream cipher algorithm (EXPERIMENTAL)" 729 tristate "Salsa20 stream cipher algorithm (EXPERIMENTAL)"
730 depends on EXPERIMENTAL 730 depends on EXPERIMENTAL
731 select CRYPTO_BLKCIPHER 731 select CRYPTO_BLKCIPHER
732 help 732 help
733 Salsa20 stream cipher algorithm. 733 Salsa20 stream cipher algorithm.
734 734
735 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT 735 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
736 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/> 736 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
737 737
738 The Salsa20 stream cipher algorithm is designed by Daniel J. 738 The Salsa20 stream cipher algorithm is designed by Daniel J.
739 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html> 739 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
740 740
741 config CRYPTO_SALSA20_586 741 config CRYPTO_SALSA20_586
742 tristate "Salsa20 stream cipher algorithm (i586) (EXPERIMENTAL)" 742 tristate "Salsa20 stream cipher algorithm (i586) (EXPERIMENTAL)"
743 depends on (X86 || UML_X86) && !64BIT 743 depends on (X86 || UML_X86) && !64BIT
744 depends on EXPERIMENTAL 744 depends on EXPERIMENTAL
745 select CRYPTO_BLKCIPHER 745 select CRYPTO_BLKCIPHER
746 help 746 help
747 Salsa20 stream cipher algorithm. 747 Salsa20 stream cipher algorithm.
748 748
749 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT 749 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
750 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/> 750 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
751 751
752 The Salsa20 stream cipher algorithm is designed by Daniel J. 752 The Salsa20 stream cipher algorithm is designed by Daniel J.
753 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html> 753 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
754 754
755 config CRYPTO_SALSA20_X86_64 755 config CRYPTO_SALSA20_X86_64
756 tristate "Salsa20 stream cipher algorithm (x86_64) (EXPERIMENTAL)" 756 tristate "Salsa20 stream cipher algorithm (x86_64) (EXPERIMENTAL)"
757 depends on (X86 || UML_X86) && 64BIT 757 depends on (X86 || UML_X86) && 64BIT
758 depends on EXPERIMENTAL 758 depends on EXPERIMENTAL
759 select CRYPTO_BLKCIPHER 759 select CRYPTO_BLKCIPHER
760 help 760 help
761 Salsa20 stream cipher algorithm. 761 Salsa20 stream cipher algorithm.
762 762
763 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT 763 Salsa20 is a stream cipher submitted to eSTREAM, the ECRYPT
764 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/> 764 Stream Cipher Project. See <http://www.ecrypt.eu.org/stream/>
765 765
766 The Salsa20 stream cipher algorithm is designed by Daniel J. 766 The Salsa20 stream cipher algorithm is designed by Daniel J.
767 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html> 767 Bernstein <djb@cr.yp.to>. See <http://cr.yp.to/snuffle.html>
768 768
769 config CRYPTO_SEED 769 config CRYPTO_SEED
770 tristate "SEED cipher algorithm" 770 tristate "SEED cipher algorithm"
771 select CRYPTO_ALGAPI 771 select CRYPTO_ALGAPI
772 help 772 help
773 SEED cipher algorithm (RFC4269). 773 SEED cipher algorithm (RFC4269).
774 774
775 SEED is a 128-bit symmetric key block cipher that has been 775 SEED is a 128-bit symmetric key block cipher that has been
776 developed by KISA (Korea Information Security Agency) as a 776 developed by KISA (Korea Information Security Agency) as a
777 national standard encryption algorithm of the Republic of Korea. 777 national standard encryption algorithm of the Republic of Korea.
778 It is a 16 round block cipher with the key size of 128 bit. 778 It is a 16 round block cipher with the key size of 128 bit.
779 779
780 See also: 780 See also:
781 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp> 781 <http://www.kisa.or.kr/kisa/seed/jsp/seed_eng.jsp>
782 782
783 config CRYPTO_SERPENT 783 config CRYPTO_SERPENT
784 tristate "Serpent cipher algorithm" 784 tristate "Serpent cipher algorithm"
785 select CRYPTO_ALGAPI 785 select CRYPTO_ALGAPI
786 help 786 help
787 Serpent cipher algorithm, by Anderson, Biham & Knudsen. 787 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
788 788
789 Keys are allowed to be from 0 to 256 bits in length, in steps 789 Keys are allowed to be from 0 to 256 bits in length, in steps
790 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed 790 of 8 bits. Also includes the 'Tnepres' algorithm, a reversed
791 variant of Serpent for compatibility with old kerneli.org code. 791 variant of Serpent for compatibility with old kerneli.org code.
792 792
793 See also: 793 See also:
794 <http://www.cl.cam.ac.uk/~rja14/serpent.html> 794 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
795 795
796 config CRYPTO_SERPENT_SSE2_X86_64 796 config CRYPTO_SERPENT_SSE2_X86_64
797 tristate "Serpent cipher algorithm (x86_64/SSE2)" 797 tristate "Serpent cipher algorithm (x86_64/SSE2)"
798 depends on X86 && 64BIT 798 depends on X86 && 64BIT
799 select CRYPTO_ALGAPI 799 select CRYPTO_ALGAPI
800 select CRYPTO_CRYPTD 800 select CRYPTO_CRYPTD
801 select CRYPTO_ABLK_HELPER_X86 801 select CRYPTO_ABLK_HELPER_X86
802 select CRYPTO_GLUE_HELPER_X86 802 select CRYPTO_GLUE_HELPER_X86
803 select CRYPTO_SERPENT 803 select CRYPTO_SERPENT
804 select CRYPTO_LRW 804 select CRYPTO_LRW
805 select CRYPTO_XTS 805 select CRYPTO_XTS
806 help 806 help
807 Serpent cipher algorithm, by Anderson, Biham & Knudsen. 807 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
808 808
809 Keys are allowed to be from 0 to 256 bits in length, in steps 809 Keys are allowed to be from 0 to 256 bits in length, in steps
810 of 8 bits. 810 of 8 bits.
811 811
812 This module provides Serpent cipher algorithm that processes eigth 812 This module provides Serpent cipher algorithm that processes eigth
813 blocks parallel using SSE2 instruction set. 813 blocks parallel using SSE2 instruction set.
814 814
815 See also: 815 See also:
816 <http://www.cl.cam.ac.uk/~rja14/serpent.html> 816 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
817 817
818 config CRYPTO_SERPENT_SSE2_586 818 config CRYPTO_SERPENT_SSE2_586
819 tristate "Serpent cipher algorithm (i586/SSE2)" 819 tristate "Serpent cipher algorithm (i586/SSE2)"
820 depends on X86 && !64BIT 820 depends on X86 && !64BIT
821 select CRYPTO_ALGAPI 821 select CRYPTO_ALGAPI
822 select CRYPTO_CRYPTD 822 select CRYPTO_CRYPTD
823 select CRYPTO_ABLK_HELPER_X86 823 select CRYPTO_ABLK_HELPER_X86
824 select CRYPTO_GLUE_HELPER_X86 824 select CRYPTO_GLUE_HELPER_X86
825 select CRYPTO_SERPENT 825 select CRYPTO_SERPENT
826 select CRYPTO_LRW 826 select CRYPTO_LRW
827 select CRYPTO_XTS 827 select CRYPTO_XTS
828 help 828 help
829 Serpent cipher algorithm, by Anderson, Biham & Knudsen. 829 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
830 830
831 Keys are allowed to be from 0 to 256 bits in length, in steps 831 Keys are allowed to be from 0 to 256 bits in length, in steps
832 of 8 bits. 832 of 8 bits.
833 833
834 This module provides Serpent cipher algorithm that processes four 834 This module provides Serpent cipher algorithm that processes four
835 blocks parallel using SSE2 instruction set. 835 blocks parallel using SSE2 instruction set.
836 836
837 See also: 837 See also:
838 <http://www.cl.cam.ac.uk/~rja14/serpent.html> 838 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
839 839
840 config CRYPTO_SERPENT_AVX_X86_64 840 config CRYPTO_SERPENT_AVX_X86_64
841 tristate "Serpent cipher algorithm (x86_64/AVX)" 841 tristate "Serpent cipher algorithm (x86_64/AVX)"
842 depends on X86 && 64BIT 842 depends on X86 && 64BIT
843 select CRYPTO_ALGAPI 843 select CRYPTO_ALGAPI
844 select CRYPTO_CRYPTD 844 select CRYPTO_CRYPTD
845 select CRYPTO_ABLK_HELPER_X86 845 select CRYPTO_ABLK_HELPER_X86
846 select CRYPTO_GLUE_HELPER_X86 846 select CRYPTO_GLUE_HELPER_X86
847 select CRYPTO_SERPENT 847 select CRYPTO_SERPENT
848 select CRYPTO_LRW 848 select CRYPTO_LRW
849 select CRYPTO_XTS 849 select CRYPTO_XTS
850 help 850 help
851 Serpent cipher algorithm, by Anderson, Biham & Knudsen. 851 Serpent cipher algorithm, by Anderson, Biham & Knudsen.
852 852
853 Keys are allowed to be from 0 to 256 bits in length, in steps 853 Keys are allowed to be from 0 to 256 bits in length, in steps
854 of 8 bits. 854 of 8 bits.
855 855
856 This module provides the Serpent cipher algorithm that processes 856 This module provides the Serpent cipher algorithm that processes
857 eight blocks parallel using the AVX instruction set. 857 eight blocks parallel using the AVX instruction set.
858 858
859 See also: 859 See also:
860 <http://www.cl.cam.ac.uk/~rja14/serpent.html> 860 <http://www.cl.cam.ac.uk/~rja14/serpent.html>
861 861
862 config CRYPTO_TEA 862 config CRYPTO_TEA
863 tristate "TEA, XTEA and XETA cipher algorithms" 863 tristate "TEA, XTEA and XETA cipher algorithms"
864 select CRYPTO_ALGAPI 864 select CRYPTO_ALGAPI
865 help 865 help
866 TEA cipher algorithm. 866 TEA cipher algorithm.
867 867
868 Tiny Encryption Algorithm is a simple cipher that uses 868 Tiny Encryption Algorithm is a simple cipher that uses
869 many rounds for security. It is very fast and uses 869 many rounds for security. It is very fast and uses
870 little memory. 870 little memory.
871 871
872 Xtendend Tiny Encryption Algorithm is a modification to 872 Xtendend Tiny Encryption Algorithm is a modification to
873 the TEA algorithm to address a potential key weakness 873 the TEA algorithm to address a potential key weakness
874 in the TEA algorithm. 874 in the TEA algorithm.
875 875
876 Xtendend Encryption Tiny Algorithm is a mis-implementation 876 Xtendend Encryption Tiny Algorithm is a mis-implementation
877 of the XTEA algorithm for compatibility purposes. 877 of the XTEA algorithm for compatibility purposes.
878 878
879 config CRYPTO_TWOFISH 879 config CRYPTO_TWOFISH
880 tristate "Twofish cipher algorithm" 880 tristate "Twofish cipher algorithm"
881 select CRYPTO_ALGAPI 881 select CRYPTO_ALGAPI
882 select CRYPTO_TWOFISH_COMMON 882 select CRYPTO_TWOFISH_COMMON
883 help 883 help
884 Twofish cipher algorithm. 884 Twofish cipher algorithm.
885 885
886 Twofish was submitted as an AES (Advanced Encryption Standard) 886 Twofish was submitted as an AES (Advanced Encryption Standard)
887 candidate cipher by researchers at CounterPane Systems. It is a 887 candidate cipher by researchers at CounterPane Systems. It is a
888 16 round block cipher supporting key sizes of 128, 192, and 256 888 16 round block cipher supporting key sizes of 128, 192, and 256
889 bits. 889 bits.
890 890
891 See also: 891 See also:
892 <http://www.schneier.com/twofish.html> 892 <http://www.schneier.com/twofish.html>
893 893
894 config CRYPTO_TWOFISH_COMMON 894 config CRYPTO_TWOFISH_COMMON
895 tristate 895 tristate
896 help 896 help
897 Common parts of the Twofish cipher algorithm shared by the 897 Common parts of the Twofish cipher algorithm shared by the
898 generic c and the assembler implementations. 898 generic c and the assembler implementations.
899 899
900 config CRYPTO_TWOFISH_586 900 config CRYPTO_TWOFISH_586
901 tristate "Twofish cipher algorithms (i586)" 901 tristate "Twofish cipher algorithms (i586)"
902 depends on (X86 || UML_X86) && !64BIT 902 depends on (X86 || UML_X86) && !64BIT
903 select CRYPTO_ALGAPI 903 select CRYPTO_ALGAPI
904 select CRYPTO_TWOFISH_COMMON 904 select CRYPTO_TWOFISH_COMMON
905 help 905 help
906 Twofish cipher algorithm. 906 Twofish cipher algorithm.
907 907
908 Twofish was submitted as an AES (Advanced Encryption Standard) 908 Twofish was submitted as an AES (Advanced Encryption Standard)
909 candidate cipher by researchers at CounterPane Systems. It is a 909 candidate cipher by researchers at CounterPane Systems. It is a
910 16 round block cipher supporting key sizes of 128, 192, and 256 910 16 round block cipher supporting key sizes of 128, 192, and 256
911 bits. 911 bits.
912 912
913 See also: 913 See also:
914 <http://www.schneier.com/twofish.html> 914 <http://www.schneier.com/twofish.html>
915 915
916 config CRYPTO_TWOFISH_X86_64 916 config CRYPTO_TWOFISH_X86_64
917 tristate "Twofish cipher algorithm (x86_64)" 917 tristate "Twofish cipher algorithm (x86_64)"
918 depends on (X86 || UML_X86) && 64BIT 918 depends on (X86 || UML_X86) && 64BIT
919 select CRYPTO_ALGAPI 919 select CRYPTO_ALGAPI
920 select CRYPTO_TWOFISH_COMMON 920 select CRYPTO_TWOFISH_COMMON
921 help 921 help
922 Twofish cipher algorithm (x86_64). 922 Twofish cipher algorithm (x86_64).
923 923
924 Twofish was submitted as an AES (Advanced Encryption Standard) 924 Twofish was submitted as an AES (Advanced Encryption Standard)
925 candidate cipher by researchers at CounterPane Systems. It is a 925 candidate cipher by researchers at CounterPane Systems. It is a
926 16 round block cipher supporting key sizes of 128, 192, and 256 926 16 round block cipher supporting key sizes of 128, 192, and 256
927 bits. 927 bits.
928 928
929 See also: 929 See also:
930 <http://www.schneier.com/twofish.html> 930 <http://www.schneier.com/twofish.html>
931 931
932 config CRYPTO_TWOFISH_X86_64_3WAY 932 config CRYPTO_TWOFISH_X86_64_3WAY
933 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)" 933 tristate "Twofish cipher algorithm (x86_64, 3-way parallel)"
934 depends on X86 && 64BIT 934 depends on X86 && 64BIT
935 select CRYPTO_ALGAPI 935 select CRYPTO_ALGAPI
936 select CRYPTO_TWOFISH_COMMON 936 select CRYPTO_TWOFISH_COMMON
937 select CRYPTO_TWOFISH_X86_64 937 select CRYPTO_TWOFISH_X86_64
938 select CRYPTO_GLUE_HELPER_X86 938 select CRYPTO_GLUE_HELPER_X86
939 select CRYPTO_LRW 939 select CRYPTO_LRW
940 select CRYPTO_XTS 940 select CRYPTO_XTS
941 help 941 help
942 Twofish cipher algorithm (x86_64, 3-way parallel). 942 Twofish cipher algorithm (x86_64, 3-way parallel).
943 943
944 Twofish was submitted as an AES (Advanced Encryption Standard) 944 Twofish was submitted as an AES (Advanced Encryption Standard)
945 candidate cipher by researchers at CounterPane Systems. It is a 945 candidate cipher by researchers at CounterPane Systems. It is a
946 16 round block cipher supporting key sizes of 128, 192, and 256 946 16 round block cipher supporting key sizes of 128, 192, and 256
947 bits. 947 bits.
948 948
949 This module provides Twofish cipher algorithm that processes three 949 This module provides Twofish cipher algorithm that processes three
950 blocks parallel, utilizing resources of out-of-order CPUs better. 950 blocks parallel, utilizing resources of out-of-order CPUs better.
951 951
952 See also: 952 See also:
953 <http://www.schneier.com/twofish.html> 953 <http://www.schneier.com/twofish.html>
954 954
955 config CRYPTO_TWOFISH_AVX_X86_64 955 config CRYPTO_TWOFISH_AVX_X86_64
956 tristate "Twofish cipher algorithm (x86_64/AVX)" 956 tristate "Twofish cipher algorithm (x86_64/AVX)"
957 depends on X86 && 64BIT 957 depends on X86 && 64BIT
958 select CRYPTO_ALGAPI 958 select CRYPTO_ALGAPI
959 select CRYPTO_CRYPTD 959 select CRYPTO_CRYPTD
960 select CRYPTO_ABLK_HELPER_X86 960 select CRYPTO_ABLK_HELPER_X86
961 select CRYPTO_GLUE_HELPER_X86 961 select CRYPTO_GLUE_HELPER_X86
962 select CRYPTO_TWOFISH_COMMON 962 select CRYPTO_TWOFISH_COMMON
963 select CRYPTO_TWOFISH_X86_64 963 select CRYPTO_TWOFISH_X86_64
964 select CRYPTO_TWOFISH_X86_64_3WAY 964 select CRYPTO_TWOFISH_X86_64_3WAY
965 select CRYPTO_LRW 965 select CRYPTO_LRW
966 select CRYPTO_XTS 966 select CRYPTO_XTS
967 help 967 help
968 Twofish cipher algorithm (x86_64/AVX). 968 Twofish cipher algorithm (x86_64/AVX).
969 969
970 Twofish was submitted as an AES (Advanced Encryption Standard) 970 Twofish was submitted as an AES (Advanced Encryption Standard)
971 candidate cipher by researchers at CounterPane Systems. It is a 971 candidate cipher by researchers at CounterPane Systems. It is a
972 16 round block cipher supporting key sizes of 128, 192, and 256 972 16 round block cipher supporting key sizes of 128, 192, and 256
973 bits. 973 bits.
974 974
975 This module provides the Twofish cipher algorithm that processes 975 This module provides the Twofish cipher algorithm that processes
976 eight blocks parallel using the AVX Instruction Set. 976 eight blocks parallel using the AVX Instruction Set.
977 977
978 See also: 978 See also:
979 <http://www.schneier.com/twofish.html> 979 <http://www.schneier.com/twofish.html>
980 980
981 comment "Compression" 981 comment "Compression"
982 982
983 config CRYPTO_DEFLATE 983 config CRYPTO_DEFLATE
984 tristate "Deflate compression algorithm" 984 tristate "Deflate compression algorithm"
985 select CRYPTO_ALGAPI 985 select CRYPTO_ALGAPI
986 select ZLIB_INFLATE 986 select ZLIB_INFLATE
987 select ZLIB_DEFLATE 987 select ZLIB_DEFLATE
988 help 988 help
989 This is the Deflate algorithm (RFC1951), specified for use in 989 This is the Deflate algorithm (RFC1951), specified for use in
990 IPSec with the IPCOMP protocol (RFC3173, RFC2394). 990 IPSec with the IPCOMP protocol (RFC3173, RFC2394).
991 991
992 You will most probably want this if using IPSec. 992 You will most probably want this if using IPSec.
993 993
994 config CRYPTO_ZLIB 994 config CRYPTO_ZLIB
995 tristate "Zlib compression algorithm" 995 tristate "Zlib compression algorithm"
996 select CRYPTO_PCOMP 996 select CRYPTO_PCOMP
997 select ZLIB_INFLATE 997 select ZLIB_INFLATE
998 select ZLIB_DEFLATE 998 select ZLIB_DEFLATE
999 select NLATTR 999 select NLATTR
1000 help 1000 help
1001 This is the zlib algorithm. 1001 This is the zlib algorithm.
1002 1002
1003 config CRYPTO_LZO 1003 config CRYPTO_LZO
1004 tristate "LZO compression algorithm" 1004 tristate "LZO compression algorithm"
1005 select CRYPTO_ALGAPI 1005 select CRYPTO_ALGAPI
1006 select LZO_COMPRESS 1006 select LZO_COMPRESS
1007 select LZO_DECOMPRESS 1007 select LZO_DECOMPRESS
1008 help 1008 help
1009 This is the LZO algorithm. 1009 This is the LZO algorithm.
1010 1010
1011 comment "Random Number Generation" 1011 comment "Random Number Generation"
1012 1012
1013 config CRYPTO_ANSI_CPRNG 1013 config CRYPTO_ANSI_CPRNG
1014 tristate "Pseudo Random Number Generation for Cryptographic modules" 1014 tristate "Pseudo Random Number Generation for Cryptographic modules"
1015 default m 1015 default m
1016 select CRYPTO_AES 1016 select CRYPTO_AES
1017 select CRYPTO_RNG 1017 select CRYPTO_RNG
1018 help 1018 help
1019 This option enables the generic pseudo random number generator 1019 This option enables the generic pseudo random number generator
1020 for cryptographic modules. Uses the Algorithm specified in 1020 for cryptographic modules. Uses the Algorithm specified in
1021 ANSI X9.31 A.2.4. Note that this option must be enabled if 1021 ANSI X9.31 A.2.4. Note that this option must be enabled if
1022 CRYPTO_FIPS is selected 1022 CRYPTO_FIPS is selected
1023 1023
1024 config CRYPTO_USER_API 1024 config CRYPTO_USER_API
1025 tristate 1025 tristate
1026 1026
1027 config CRYPTO_USER_API_HASH 1027 config CRYPTO_USER_API_HASH
1028 tristate "User-space interface for hash algorithms" 1028 tristate "User-space interface for hash algorithms"
1029 depends on NET 1029 depends on NET
1030 select CRYPTO_HASH 1030 select CRYPTO_HASH
1031 select CRYPTO_USER_API 1031 select CRYPTO_USER_API
1032 help 1032 help
1033 This option enables the user-spaces interface for hash 1033 This option enables the user-spaces interface for hash
1034 algorithms. 1034 algorithms.
1035 1035
1036 config CRYPTO_USER_API_SKCIPHER 1036 config CRYPTO_USER_API_SKCIPHER
1037 tristate "User-space interface for symmetric key cipher algorithms" 1037 tristate "User-space interface for symmetric key cipher algorithms"
1038 depends on NET 1038 depends on NET
1039 select CRYPTO_BLKCIPHER 1039 select CRYPTO_BLKCIPHER
1040 select CRYPTO_USER_API 1040 select CRYPTO_USER_API
1041 help 1041 help
1042 This option enables the user-spaces interface for symmetric 1042 This option enables the user-spaces interface for symmetric
1043 key cipher algorithms. 1043 key cipher algorithms.
1044 1044
1045 source "drivers/crypto/Kconfig" 1045 source "drivers/crypto/Kconfig"
1046 source crypto/asymmetric_keys/Kconfig
1046 1047
1047 endif # if CRYPTO 1048 endif # if CRYPTO
1048 1049
1 # 1 #
2 # Cryptographic API 2 # Cryptographic API
3 # 3 #
4 4
5 obj-$(CONFIG_CRYPTO) += crypto.o 5 obj-$(CONFIG_CRYPTO) += crypto.o
6 crypto-y := api.o cipher.o compress.o 6 crypto-y := api.o cipher.o compress.o
7 7
8 obj-$(CONFIG_CRYPTO_WORKQUEUE) += crypto_wq.o 8 obj-$(CONFIG_CRYPTO_WORKQUEUE) += crypto_wq.o
9 9
10 obj-$(CONFIG_CRYPTO_FIPS) += fips.o 10 obj-$(CONFIG_CRYPTO_FIPS) += fips.o
11 11
12 crypto_algapi-$(CONFIG_PROC_FS) += proc.o 12 crypto_algapi-$(CONFIG_PROC_FS) += proc.o
13 crypto_algapi-y := algapi.o scatterwalk.o $(crypto_algapi-y) 13 crypto_algapi-y := algapi.o scatterwalk.o $(crypto_algapi-y)
14 obj-$(CONFIG_CRYPTO_ALGAPI2) += crypto_algapi.o 14 obj-$(CONFIG_CRYPTO_ALGAPI2) += crypto_algapi.o
15 15
16 obj-$(CONFIG_CRYPTO_AEAD2) += aead.o 16 obj-$(CONFIG_CRYPTO_AEAD2) += aead.o
17 17
18 crypto_blkcipher-y := ablkcipher.o 18 crypto_blkcipher-y := ablkcipher.o
19 crypto_blkcipher-y += blkcipher.o 19 crypto_blkcipher-y += blkcipher.o
20 obj-$(CONFIG_CRYPTO_BLKCIPHER2) += crypto_blkcipher.o 20 obj-$(CONFIG_CRYPTO_BLKCIPHER2) += crypto_blkcipher.o
21 obj-$(CONFIG_CRYPTO_BLKCIPHER2) += chainiv.o 21 obj-$(CONFIG_CRYPTO_BLKCIPHER2) += chainiv.o
22 obj-$(CONFIG_CRYPTO_BLKCIPHER2) += eseqiv.o 22 obj-$(CONFIG_CRYPTO_BLKCIPHER2) += eseqiv.o
23 obj-$(CONFIG_CRYPTO_SEQIV) += seqiv.o 23 obj-$(CONFIG_CRYPTO_SEQIV) += seqiv.o
24 24
25 crypto_hash-y += ahash.o 25 crypto_hash-y += ahash.o
26 crypto_hash-y += shash.o 26 crypto_hash-y += shash.o
27 obj-$(CONFIG_CRYPTO_HASH2) += crypto_hash.o 27 obj-$(CONFIG_CRYPTO_HASH2) += crypto_hash.o
28 28
29 obj-$(CONFIG_CRYPTO_PCOMP2) += pcompress.o 29 obj-$(CONFIG_CRYPTO_PCOMP2) += pcompress.o
30 30
31 cryptomgr-y := algboss.o testmgr.o 31 cryptomgr-y := algboss.o testmgr.o
32 32
33 obj-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o 33 obj-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o
34 obj-$(CONFIG_CRYPTO_USER) += crypto_user.o 34 obj-$(CONFIG_CRYPTO_USER) += crypto_user.o
35 obj-$(CONFIG_CRYPTO_HMAC) += hmac.o 35 obj-$(CONFIG_CRYPTO_HMAC) += hmac.o
36 obj-$(CONFIG_CRYPTO_VMAC) += vmac.o 36 obj-$(CONFIG_CRYPTO_VMAC) += vmac.o
37 obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o 37 obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o
38 obj-$(CONFIG_CRYPTO_NULL) += crypto_null.o 38 obj-$(CONFIG_CRYPTO_NULL) += crypto_null.o
39 obj-$(CONFIG_CRYPTO_MD4) += md4.o 39 obj-$(CONFIG_CRYPTO_MD4) += md4.o
40 obj-$(CONFIG_CRYPTO_MD5) += md5.o 40 obj-$(CONFIG_CRYPTO_MD5) += md5.o
41 obj-$(CONFIG_CRYPTO_RMD128) += rmd128.o 41 obj-$(CONFIG_CRYPTO_RMD128) += rmd128.o
42 obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o 42 obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o
43 obj-$(CONFIG_CRYPTO_RMD256) += rmd256.o 43 obj-$(CONFIG_CRYPTO_RMD256) += rmd256.o
44 obj-$(CONFIG_CRYPTO_RMD320) += rmd320.o 44 obj-$(CONFIG_CRYPTO_RMD320) += rmd320.o
45 obj-$(CONFIG_CRYPTO_SHA1) += sha1_generic.o 45 obj-$(CONFIG_CRYPTO_SHA1) += sha1_generic.o
46 obj-$(CONFIG_CRYPTO_SHA256) += sha256_generic.o 46 obj-$(CONFIG_CRYPTO_SHA256) += sha256_generic.o
47 obj-$(CONFIG_CRYPTO_SHA512) += sha512_generic.o 47 obj-$(CONFIG_CRYPTO_SHA512) += sha512_generic.o
48 obj-$(CONFIG_CRYPTO_WP512) += wp512.o 48 obj-$(CONFIG_CRYPTO_WP512) += wp512.o
49 obj-$(CONFIG_CRYPTO_TGR192) += tgr192.o 49 obj-$(CONFIG_CRYPTO_TGR192) += tgr192.o
50 obj-$(CONFIG_CRYPTO_GF128MUL) += gf128mul.o 50 obj-$(CONFIG_CRYPTO_GF128MUL) += gf128mul.o
51 obj-$(CONFIG_CRYPTO_ECB) += ecb.o 51 obj-$(CONFIG_CRYPTO_ECB) += ecb.o
52 obj-$(CONFIG_CRYPTO_CBC) += cbc.o 52 obj-$(CONFIG_CRYPTO_CBC) += cbc.o
53 obj-$(CONFIG_CRYPTO_PCBC) += pcbc.o 53 obj-$(CONFIG_CRYPTO_PCBC) += pcbc.o
54 obj-$(CONFIG_CRYPTO_CTS) += cts.o 54 obj-$(CONFIG_CRYPTO_CTS) += cts.o
55 obj-$(CONFIG_CRYPTO_LRW) += lrw.o 55 obj-$(CONFIG_CRYPTO_LRW) += lrw.o
56 obj-$(CONFIG_CRYPTO_XTS) += xts.o 56 obj-$(CONFIG_CRYPTO_XTS) += xts.o
57 obj-$(CONFIG_CRYPTO_CTR) += ctr.o 57 obj-$(CONFIG_CRYPTO_CTR) += ctr.o
58 obj-$(CONFIG_CRYPTO_GCM) += gcm.o 58 obj-$(CONFIG_CRYPTO_GCM) += gcm.o
59 obj-$(CONFIG_CRYPTO_CCM) += ccm.o 59 obj-$(CONFIG_CRYPTO_CCM) += ccm.o
60 obj-$(CONFIG_CRYPTO_PCRYPT) += pcrypt.o 60 obj-$(CONFIG_CRYPTO_PCRYPT) += pcrypt.o
61 obj-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o 61 obj-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o
62 obj-$(CONFIG_CRYPTO_DES) += des_generic.o 62 obj-$(CONFIG_CRYPTO_DES) += des_generic.o
63 obj-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o 63 obj-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o
64 obj-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o 64 obj-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o
65 obj-$(CONFIG_CRYPTO_BLOWFISH_COMMON) += blowfish_common.o 65 obj-$(CONFIG_CRYPTO_BLOWFISH_COMMON) += blowfish_common.o
66 obj-$(CONFIG_CRYPTO_TWOFISH) += twofish_generic.o 66 obj-$(CONFIG_CRYPTO_TWOFISH) += twofish_generic.o
67 obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o 67 obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o
68 obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o 68 obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o
69 obj-$(CONFIG_CRYPTO_AES) += aes_generic.o 69 obj-$(CONFIG_CRYPTO_AES) += aes_generic.o
70 obj-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o 70 obj-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o
71 obj-$(CONFIG_CRYPTO_CAST5) += cast5.o 71 obj-$(CONFIG_CRYPTO_CAST5) += cast5.o
72 obj-$(CONFIG_CRYPTO_CAST6) += cast6.o 72 obj-$(CONFIG_CRYPTO_CAST6) += cast6.o
73 obj-$(CONFIG_CRYPTO_ARC4) += arc4.o 73 obj-$(CONFIG_CRYPTO_ARC4) += arc4.o
74 obj-$(CONFIG_CRYPTO_TEA) += tea.o 74 obj-$(CONFIG_CRYPTO_TEA) += tea.o
75 obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o 75 obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o
76 obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o 76 obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o
77 obj-$(CONFIG_CRYPTO_SEED) += seed.o 77 obj-$(CONFIG_CRYPTO_SEED) += seed.o
78 obj-$(CONFIG_CRYPTO_SALSA20) += salsa20_generic.o 78 obj-$(CONFIG_CRYPTO_SALSA20) += salsa20_generic.o
79 obj-$(CONFIG_CRYPTO_DEFLATE) += deflate.o 79 obj-$(CONFIG_CRYPTO_DEFLATE) += deflate.o
80 obj-$(CONFIG_CRYPTO_ZLIB) += zlib.o 80 obj-$(CONFIG_CRYPTO_ZLIB) += zlib.o
81 obj-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o 81 obj-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o
82 obj-$(CONFIG_CRYPTO_CRC32C) += crc32c.o 82 obj-$(CONFIG_CRYPTO_CRC32C) += crc32c.o
83 obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o 83 obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o
84 obj-$(CONFIG_CRYPTO_LZO) += lzo.o 84 obj-$(CONFIG_CRYPTO_LZO) += lzo.o
85 obj-$(CONFIG_CRYPTO_RNG2) += rng.o 85 obj-$(CONFIG_CRYPTO_RNG2) += rng.o
86 obj-$(CONFIG_CRYPTO_RNG2) += krng.o 86 obj-$(CONFIG_CRYPTO_RNG2) += krng.o
87 obj-$(CONFIG_CRYPTO_ANSI_CPRNG) += ansi_cprng.o 87 obj-$(CONFIG_CRYPTO_ANSI_CPRNG) += ansi_cprng.o
88 obj-$(CONFIG_CRYPTO_TEST) += tcrypt.o 88 obj-$(CONFIG_CRYPTO_TEST) += tcrypt.o
89 obj-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o 89 obj-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o
90 obj-$(CONFIG_CRYPTO_USER_API) += af_alg.o 90 obj-$(CONFIG_CRYPTO_USER_API) += af_alg.o
91 obj-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o 91 obj-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o
92 obj-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o 92 obj-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o
93 93
94 # 94 #
95 # generic algorithms and the async_tx api 95 # generic algorithms and the async_tx api
96 # 96 #
97 obj-$(CONFIG_XOR_BLOCKS) += xor.o 97 obj-$(CONFIG_XOR_BLOCKS) += xor.o
98 obj-$(CONFIG_ASYNC_CORE) += async_tx/ 98 obj-$(CONFIG_ASYNC_CORE) += async_tx/
99 obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys/
99 100
crypto/asymmetric_keys/Kconfig
Diff comments   View file @ 964f3b3
File was created 1 menuconfig ASYMMETRIC_KEY_TYPE
2 tristate "Asymmetric (public-key cryptographic) key type"
3 depends on KEYS
4 help
5 This option provides support for a key type that holds the data for
6 the asymmetric keys used for public key cryptographic operations such
7 as encryption, decryption, signature generation and signature
8 verification.
9
10 if ASYMMETRIC_KEY_TYPE
11
12
13 endif # ASYMMETRIC_KEY_TYPE
14
crypto/asymmetric_keys/Makefile
Diff comments   View file @ 964f3b3
File was created 1 #
2 # Makefile for asymmetric cryptographic keys
3 #
4
5 obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o
6
7 asymmetric_keys-y := asymmetric_type.o
8
crypto/asymmetric_keys/asymmetric_keys.h
Diff comments   View file @ 964f3b3
File was created 1 /* Internal definitions for asymmetric key type
2 *
3 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
10 */
11
12 static inline const char *asymmetric_key_id(const struct key *key)
13 {
14 return key->type_data.p[1];
15 }
16
crypto/asymmetric_keys/asymmetric_type.c
Diff comments   View file @ 964f3b3
File was created 1 /* Asymmetric public-key cryptography key type
2 *
3 * See Documentation/security/asymmetric-keys.txt
4 *
5 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
6 * Written by David Howells (dhowells@redhat.com)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public Licence
10 * as published by the Free Software Foundation; either version
11 * 2 of the Licence, or (at your option) any later version.
12 */
13 #include <keys/asymmetric-subtype.h>
14 #include <linux/seq_file.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include "asymmetric_keys.h"
18
19 MODULE_LICENSE("GPL");
20
21 /*
22 * Match asymmetric keys on (part of) their name
23 * We have some shorthand methods for matching keys. We allow:
24 *
25 * "<desc>" - request a key by description
26 * "id:<id>" - request a key matching the ID
27 * "<subtype>:<id>" - request a key of a subtype
28 */
29 static int asymmetric_key_match(const struct key *key, const void *description)
30 {
31 const struct asymmetric_key_subtype *subtype = asymmetric_key_subtype(key);
32 const char *spec = description;
33 const char *id, *kid;
34 ptrdiff_t speclen;
35 size_t idlen, kidlen;
36
37 if (!subtype || !spec || !*spec)
38 return 0;
39
40 /* See if the full key description matches as is */
41 if (key->description && strcmp(key->description, description) == 0)
42 return 1;
43
44 /* All tests from here on break the criterion description into a
45 * specifier, a colon and then an identifier.
46 */
47 id = strchr(spec, ':');
48 if (!id)
49 return 0;
50
51 speclen = id - spec;
52 id++;
53
54 /* Anything after here requires a partial match on the ID string */
55 kid = asymmetric_key_id(key);
56 if (!kid)
57 return 0;
58
59 idlen = strlen(id);
60 kidlen = strlen(kid);
61 if (idlen > kidlen)
62 return 0;
63
64 kid += kidlen - idlen;
65 if (strcasecmp(id, kid) != 0)
66 return 0;
67
68 if (speclen == 2 &&
69 memcmp(spec, "id", 2) == 0)
70 return 1;
71
72 if (speclen == subtype->name_len &&
73 memcmp(spec, subtype->name, speclen) == 0)
74 return 1;
75
76 return 0;
77 }
78
79 /*
80 * Describe the asymmetric key
81 */
82 static void asymmetric_key_describe(const struct key *key, struct seq_file *m)
83 {
84 const struct asymmetric_key_subtype *subtype = asymmetric_key_subtype(key);
85 const char *kid = asymmetric_key_id(key);
86 size_t n;
87
88 seq_puts(m, key->description);
89
90 if (subtype) {
91 seq_puts(m, ": ");
92 subtype->describe(key, m);
93
94 if (kid) {
95 seq_putc(m, ' ');
96 n = strlen(kid);
97 if (n <= 8)
98 seq_puts(m, kid);
99 else
100 seq_puts(m, kid + n - 8);
101 }
102
103 seq_puts(m, " [");
104 /* put something here to indicate the key's capabilities */
105 seq_putc(m, ']');
106 }
107 }
108
109 /*
110 * Instantiate a asymmetric_key defined key. The key was preparsed, so we just
111 * have to transfer the data here.
112 */
113 static int asymmetric_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
114 {
115 return -EOPNOTSUPP;
116 }
117
118 /*
119 * dispose of the data dangling from the corpse of a asymmetric key
120 */
121 static void asymmetric_key_destroy(struct key *key)
122 {
123 struct asymmetric_key_subtype *subtype = asymmetric_key_subtype(key);
124 if (subtype) {
125 subtype->destroy(key->payload.data);
126 module_put(subtype->owner);
127 key->type_data.p[0] = NULL;
128 }
129 kfree(key->type_data.p[1]);
130 key->type_data.p[1] = NULL;
131 }
132
133 struct key_type key_type_asymmetric = {
134 .name = "asymmetric",
135 .instantiate = asymmetric_key_instantiate,
136 .match = asymmetric_key_match,
137 .destroy = asymmetric_key_destroy,
138 .describe = asymmetric_key_describe,
139 };
140 EXPORT_SYMBOL_GPL(key_type_asymmetric);
141
142 /*
143 * Module stuff
144 */
145 static int __init asymmetric_key_init(void)
146 {
147 return register_key_type(&key_type_asymmetric);
148 }
149
150 static void __exit asymmetric_key_cleanup(void)
151 {
152 unregister_key_type(&key_type_asymmetric);
153 }
154
155 module_init(asymmetric_key_init);
156 module_exit(asymmetric_key_cleanup);
157
include/keys/asymmetric-subtype.h
Diff comments   View file @ 964f3b3
File was created 1 /* Asymmetric public-key cryptography key subtype
2 *
3 * See Documentation/security/asymmetric-keys.txt
4 *
5 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
6 * Written by David Howells (dhowells@redhat.com)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public Licence
10 * as published by the Free Software Foundation; either version
11 * 2 of the Licence, or (at your option) any later version.
12 */
13
14 #ifndef _KEYS_ASYMMETRIC_SUBTYPE_H
15 #define _KEYS_ASYMMETRIC_SUBTYPE_H
16
17 #include <linux/seq_file.h>
18 #include <keys/asymmetric-type.h>
19
20 struct public_key_signature;
21
22 /*
23 * Keys of this type declare a subtype that indicates the handlers and
24 * capabilities.
25 */
26 struct asymmetric_key_subtype {
27 struct module *owner;
28 const char *name;
29 unsigned short name_len; /* length of name */
30
31 /* Describe a key of this subtype for /proc/keys */
32 void (*describe)(const struct key *key, struct seq_file *m);
33
34 /* Destroy a key of this subtype */
35 void (*destroy)(void *payload);
36
37 /* Verify the signature on a key of this subtype (optional) */
38 int (*verify_signature)(const struct key *key,
39 const struct public_key_signature *sig);
40 };
41
42 /**
43 * asymmetric_key_subtype - Get the subtype from an asymmetric key
44 * @key: The key of interest.
45 *
46 * Retrieves and returns the subtype pointer of the asymmetric key from the
47 * type-specific data attached to the key.
48 */
49 static inline
50 struct asymmetric_key_subtype *asymmetric_key_subtype(const struct key *key)
51 {
52 return key->type_data.p[0];
53 }
54
55 #endif /* _KEYS_ASYMMETRIC_SUBTYPE_H */
56
include/keys/asymmetric-type.h
Diff comments   View file @ 964f3b3
File was created 1 /* Asymmetric Public-key cryptography key type interface
2 *
3 * See Documentation/security/asymmetric-keys.txt
4 *
5 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
6 * Written by David Howells (dhowells@redhat.com)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public Licence
10 * as published by the Free Software Foundation; either version
11 * 2 of the Licence, or (at your option) any later version.
12 */
13
14 #ifndef _KEYS_ASYMMETRIC_TYPE_H
15 #define _KEYS_ASYMMETRIC_TYPE_H
16
17 #include <linux/key-type.h>
18
19 extern struct key_type key_type_asymmetric;
20
21 /*
22 * The payload is at the discretion of the subtype.
23 */
24
25 #endif /* _KEYS_ASYMMETRIC_TYPE_H */
26