blob: 44ac85fe2bc9bfe72ca1e1e55399428c41a581fa [file] [log] [blame]
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * xfrm algorithm interface
3 *
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +09008 * Software Foundation; either version 2 of the License, or (at your option)
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * any later version.
10 */
11
Herbert Xu17bc1972016-01-24 21:19:11 +080012#include <crypto/hash.h>
13#include <crypto/skcipher.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/pfkeyv2.h>
17#include <linux/crypto.h>
Heiko Carstensb3b724f2007-10-23 09:28:34 +020018#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <net/xfrm.h>
Javier Martinez Canillas65b323e2016-09-09 08:43:20 -040020#if IS_ENABLED(CONFIG_INET_ESP) || IS_ENABLED(CONFIG_INET6_ESP)
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <net/esp.h>
22#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24/*
25 * Algorithms supported by IPsec. These entries contain properties which
26 * are used in key negotiation and xfrm processing, and are used to verify
27 * that instantiated crypto transforms have correct parameters for IPsec
28 * purposes.
29 */
Herbert Xu1a6509d2008-01-28 19:37:29 -080030static struct xfrm_algo_desc aead_list[] = {
31{
32 .name = "rfc4106(gcm(aes))",
33
34 .uinfo = {
35 .aead = {
Herbert Xude0ded72015-08-13 17:28:52 +080036 .geniv = "seqiv",
Herbert Xu1a6509d2008-01-28 19:37:29 -080037 .icv_truncbits = 64,
38 }
39 },
40
Jussi Kivilinna7e50f842013-01-31 12:40:38 +020041 .pfkey_supported = 1,
42
Herbert Xu1a6509d2008-01-28 19:37:29 -080043 .desc = {
44 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
45 .sadb_alg_ivlen = 8,
46 .sadb_alg_minbits = 128,
47 .sadb_alg_maxbits = 256
48 }
49},
50{
51 .name = "rfc4106(gcm(aes))",
52
53 .uinfo = {
54 .aead = {
Herbert Xude0ded72015-08-13 17:28:52 +080055 .geniv = "seqiv",
Herbert Xu1a6509d2008-01-28 19:37:29 -080056 .icv_truncbits = 96,
57 }
58 },
59
Jussi Kivilinna7e50f842013-01-31 12:40:38 +020060 .pfkey_supported = 1,
61
Herbert Xu1a6509d2008-01-28 19:37:29 -080062 .desc = {
63 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
64 .sadb_alg_ivlen = 8,
65 .sadb_alg_minbits = 128,
66 .sadb_alg_maxbits = 256
67 }
68},
69{
70 .name = "rfc4106(gcm(aes))",
71
72 .uinfo = {
73 .aead = {
Herbert Xude0ded72015-08-13 17:28:52 +080074 .geniv = "seqiv",
Herbert Xu1a6509d2008-01-28 19:37:29 -080075 .icv_truncbits = 128,
76 }
77 },
78
Jussi Kivilinna7e50f842013-01-31 12:40:38 +020079 .pfkey_supported = 1,
80
Herbert Xu1a6509d2008-01-28 19:37:29 -080081 .desc = {
82 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
83 .sadb_alg_ivlen = 8,
84 .sadb_alg_minbits = 128,
85 .sadb_alg_maxbits = 256
86 }
87},
88{
89 .name = "rfc4309(ccm(aes))",
90
91 .uinfo = {
92 .aead = {
Herbert Xude0ded72015-08-13 17:28:52 +080093 .geniv = "seqiv",
Herbert Xu1a6509d2008-01-28 19:37:29 -080094 .icv_truncbits = 64,
95 }
96 },
97
Jussi Kivilinna7e50f842013-01-31 12:40:38 +020098 .pfkey_supported = 1,
99
Herbert Xu1a6509d2008-01-28 19:37:29 -0800100 .desc = {
101 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
102 .sadb_alg_ivlen = 8,
103 .sadb_alg_minbits = 128,
104 .sadb_alg_maxbits = 256
105 }
106},
107{
108 .name = "rfc4309(ccm(aes))",
109
110 .uinfo = {
111 .aead = {
Herbert Xude0ded72015-08-13 17:28:52 +0800112 .geniv = "seqiv",
Herbert Xu1a6509d2008-01-28 19:37:29 -0800113 .icv_truncbits = 96,
114 }
115 },
116
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200117 .pfkey_supported = 1,
118
Herbert Xu1a6509d2008-01-28 19:37:29 -0800119 .desc = {
120 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
121 .sadb_alg_ivlen = 8,
122 .sadb_alg_minbits = 128,
123 .sadb_alg_maxbits = 256
124 }
125},
126{
127 .name = "rfc4309(ccm(aes))",
128
129 .uinfo = {
130 .aead = {
Herbert Xude0ded72015-08-13 17:28:52 +0800131 .geniv = "seqiv",
Herbert Xu1a6509d2008-01-28 19:37:29 -0800132 .icv_truncbits = 128,
133 }
134 },
135
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200136 .pfkey_supported = 1,
137
Herbert Xu1a6509d2008-01-28 19:37:29 -0800138 .desc = {
139 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
140 .sadb_alg_ivlen = 8,
141 .sadb_alg_minbits = 128,
142 .sadb_alg_maxbits = 256
143 }
144},
Tobias Brunner73c89c12010-01-17 21:52:11 +1100145{
146 .name = "rfc4543(gcm(aes))",
147
148 .uinfo = {
149 .aead = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800150 .geniv = "seqiv",
Tobias Brunner73c89c12010-01-17 21:52:11 +1100151 .icv_truncbits = 128,
152 }
153 },
154
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200155 .pfkey_supported = 1,
156
Tobias Brunner73c89c12010-01-17 21:52:11 +1100157 .desc = {
158 .sadb_alg_id = SADB_X_EALG_NULL_AES_GMAC,
159 .sadb_alg_ivlen = 8,
160 .sadb_alg_minbits = 128,
161 .sadb_alg_maxbits = 256
162 }
163},
Martin Willib08b6b72015-06-01 13:44:04 +0200164{
165 .name = "rfc7539esp(chacha20,poly1305)",
166
167 .uinfo = {
168 .aead = {
Herbert Xude0ded72015-08-13 17:28:52 +0800169 .geniv = "seqiv",
Martin Willib08b6b72015-06-01 13:44:04 +0200170 .icv_truncbits = 128,
171 }
172 },
173
174 .pfkey_supported = 0,
175},
Herbert Xu1a6509d2008-01-28 19:37:29 -0800176};
177
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178static struct xfrm_algo_desc aalg_list[] = {
179{
Herbert Xu01a22022008-04-27 00:59:59 -0700180 .name = "digest_null",
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 .uinfo = {
183 .auth = {
184 .icv_truncbits = 0,
185 .icv_fullbits = 0,
186 }
187 },
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900188
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200189 .pfkey_supported = 1,
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 .desc = {
192 .sadb_alg_id = SADB_X_AALG_NULL,
193 .sadb_alg_ivlen = 0,
194 .sadb_alg_minbits = 0,
195 .sadb_alg_maxbits = 0
196 }
197},
198{
Herbert Xu07d4ee52006-08-20 14:24:50 +1000199 .name = "hmac(md5)",
200 .compat = "md5",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
202 .uinfo = {
203 .auth = {
204 .icv_truncbits = 96,
205 .icv_fullbits = 128,
206 }
207 },
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900208
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200209 .pfkey_supported = 1,
210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 .desc = {
212 .sadb_alg_id = SADB_AALG_MD5HMAC,
213 .sadb_alg_ivlen = 0,
214 .sadb_alg_minbits = 128,
215 .sadb_alg_maxbits = 128
216 }
217},
218{
Herbert Xu07d4ee52006-08-20 14:24:50 +1000219 .name = "hmac(sha1)",
220 .compat = "sha1",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 .uinfo = {
223 .auth = {
224 .icv_truncbits = 96,
225 .icv_fullbits = 160,
226 }
227 },
228
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200229 .pfkey_supported = 1,
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 .desc = {
232 .sadb_alg_id = SADB_AALG_SHA1HMAC,
233 .sadb_alg_ivlen = 0,
234 .sadb_alg_minbits = 160,
235 .sadb_alg_maxbits = 160
236 }
237},
238{
Herbert Xu07d4ee52006-08-20 14:24:50 +1000239 .name = "hmac(sha256)",
240 .compat = "sha256",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
242 .uinfo = {
243 .auth = {
244 .icv_truncbits = 96,
245 .icv_fullbits = 256,
246 }
247 },
248
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200249 .pfkey_supported = 1,
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 .desc = {
252 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
253 .sadb_alg_ivlen = 0,
254 .sadb_alg_minbits = 256,
255 .sadb_alg_maxbits = 256
256 }
257},
258{
Martin Willibc74b0c2009-11-25 00:58:39 +0000259 .name = "hmac(sha384)",
260
261 .uinfo = {
262 .auth = {
263 .icv_truncbits = 192,
264 .icv_fullbits = 384,
265 }
266 },
267
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200268 .pfkey_supported = 1,
269
Martin Willibc74b0c2009-11-25 00:58:39 +0000270 .desc = {
271 .sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
272 .sadb_alg_ivlen = 0,
273 .sadb_alg_minbits = 384,
274 .sadb_alg_maxbits = 384
275 }
276},
277{
278 .name = "hmac(sha512)",
279
280 .uinfo = {
281 .auth = {
282 .icv_truncbits = 256,
283 .icv_fullbits = 512,
284 }
285 },
286
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200287 .pfkey_supported = 1,
288
Martin Willibc74b0c2009-11-25 00:58:39 +0000289 .desc = {
290 .sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
291 .sadb_alg_ivlen = 0,
292 .sadb_alg_minbits = 512,
293 .sadb_alg_maxbits = 512
294 }
295},
296{
Adrian-Ken Rueegseggera13366c2008-06-04 12:04:55 -0700297 .name = "hmac(rmd160)",
298 .compat = "rmd160",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 .uinfo = {
301 .auth = {
302 .icv_truncbits = 96,
303 .icv_fullbits = 160,
304 }
305 },
306
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200307 .pfkey_supported = 1,
308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 .desc = {
310 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
311 .sadb_alg_ivlen = 0,
312 .sadb_alg_minbits = 160,
313 .sadb_alg_maxbits = 160
314 }
315},
Kazunori MIYAZAWA7cf4c1a2006-10-28 13:21:22 +1000316{
317 .name = "xcbc(aes)",
318
319 .uinfo = {
320 .auth = {
321 .icv_truncbits = 96,
322 .icv_fullbits = 128,
323 }
324 },
325
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200326 .pfkey_supported = 1,
327
Kazunori MIYAZAWA7cf4c1a2006-10-28 13:21:22 +1000328 .desc = {
329 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
330 .sadb_alg_ivlen = 0,
331 .sadb_alg_minbits = 128,
332 .sadb_alg_maxbits = 128
333 }
334},
Jussi Kivilinnad2049d82013-04-08 10:48:49 +0300335{
336 /* rfc4494 */
337 .name = "cmac(aes)",
338
339 .uinfo = {
340 .auth = {
341 .icv_truncbits = 96,
342 .icv_fullbits = 128,
343 }
344 },
345
346 .pfkey_supported = 0,
347},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348};
349
350static struct xfrm_algo_desc ealg_list[] = {
351{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000352 .name = "ecb(cipher_null)",
353 .compat = "cipher_null",
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 .uinfo = {
356 .encr = {
357 .blockbits = 8,
358 .defkeybits = 0,
359 }
360 },
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900361
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200362 .pfkey_supported = 1,
363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 .desc = {
365 .sadb_alg_id = SADB_EALG_NULL,
366 .sadb_alg_ivlen = 0,
367 .sadb_alg_minbits = 0,
368 .sadb_alg_maxbits = 0
369 }
370},
371{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000372 .name = "cbc(des)",
373 .compat = "des",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
375 .uinfo = {
376 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800377 .geniv = "echainiv",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 .blockbits = 64,
379 .defkeybits = 64,
380 }
381 },
382
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200383 .pfkey_supported = 1,
384
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 .desc = {
386 .sadb_alg_id = SADB_EALG_DESCBC,
387 .sadb_alg_ivlen = 8,
388 .sadb_alg_minbits = 64,
389 .sadb_alg_maxbits = 64
390 }
391},
392{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000393 .name = "cbc(des3_ede)",
394 .compat = "des3_ede",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
396 .uinfo = {
397 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800398 .geniv = "echainiv",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 .blockbits = 64,
400 .defkeybits = 192,
401 }
402 },
403
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200404 .pfkey_supported = 1,
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 .desc = {
407 .sadb_alg_id = SADB_EALG_3DESCBC,
408 .sadb_alg_ivlen = 8,
409 .sadb_alg_minbits = 192,
410 .sadb_alg_maxbits = 192
411 }
412},
413{
Herbert Xu245acb82009-06-24 03:55:41 -0700414 .name = "cbc(cast5)",
415 .compat = "cast5",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417 .uinfo = {
418 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800419 .geniv = "echainiv",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 .blockbits = 64,
421 .defkeybits = 128,
422 }
423 },
424
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200425 .pfkey_supported = 1,
426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 .desc = {
428 .sadb_alg_id = SADB_X_EALG_CASTCBC,
429 .sadb_alg_ivlen = 8,
430 .sadb_alg_minbits = 40,
431 .sadb_alg_maxbits = 128
432 }
433},
434{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000435 .name = "cbc(blowfish)",
436 .compat = "blowfish",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
438 .uinfo = {
439 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800440 .geniv = "echainiv",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 .blockbits = 64,
442 .defkeybits = 128,
443 }
444 },
445
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200446 .pfkey_supported = 1,
447
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 .desc = {
449 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
450 .sadb_alg_ivlen = 8,
451 .sadb_alg_minbits = 40,
452 .sadb_alg_maxbits = 448
453 }
454},
455{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000456 .name = "cbc(aes)",
457 .compat = "aes",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
459 .uinfo = {
460 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800461 .geniv = "echainiv",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 .blockbits = 128,
463 .defkeybits = 128,
464 }
465 },
466
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200467 .pfkey_supported = 1,
468
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 .desc = {
470 .sadb_alg_id = SADB_X_EALG_AESCBC,
471 .sadb_alg_ivlen = 8,
472 .sadb_alg_minbits = 128,
473 .sadb_alg_maxbits = 256
474 }
475},
476{
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900477 .name = "cbc(serpent)",
478 .compat = "serpent",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900480 .uinfo = {
481 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800482 .geniv = "echainiv",
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900483 .blockbits = 128,
484 .defkeybits = 128,
485 }
486 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200488 .pfkey_supported = 1,
489
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900490 .desc = {
491 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
492 .sadb_alg_ivlen = 8,
493 .sadb_alg_minbits = 128,
494 .sadb_alg_maxbits = 256,
495 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496},
497{
Noriaki TAKAMIYA6a0dc8d2006-10-22 15:05:57 +1000498 .name = "cbc(camellia)",
Li Yewang138f3c82009-12-01 15:35:05 -0800499 .compat = "camellia",
Noriaki TAKAMIYA6a0dc8d2006-10-22 15:05:57 +1000500
501 .uinfo = {
502 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800503 .geniv = "echainiv",
Noriaki TAKAMIYA6a0dc8d2006-10-22 15:05:57 +1000504 .blockbits = 128,
505 .defkeybits = 128,
506 }
507 },
508
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200509 .pfkey_supported = 1,
510
Noriaki TAKAMIYA6a0dc8d2006-10-22 15:05:57 +1000511 .desc = {
512 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
513 .sadb_alg_ivlen = 8,
514 .sadb_alg_minbits = 128,
515 .sadb_alg_maxbits = 256
516 }
517},
518{
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900519 .name = "cbc(twofish)",
520 .compat = "twofish",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900522 .uinfo = {
523 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800524 .geniv = "echainiv",
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900525 .blockbits = 128,
526 .defkeybits = 128,
527 }
528 },
529
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200530 .pfkey_supported = 1,
531
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900532 .desc = {
533 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
534 .sadb_alg_ivlen = 8,
535 .sadb_alg_minbits = 128,
536 .sadb_alg_maxbits = 256
537 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538},
Joy Latten405137d2008-02-07 23:11:56 -0800539{
540 .name = "rfc3686(ctr(aes))",
541
542 .uinfo = {
543 .encr = {
Herbert Xu165ecc62015-05-27 16:03:44 +0800544 .geniv = "seqiv",
Joy Latten405137d2008-02-07 23:11:56 -0800545 .blockbits = 128,
546 .defkeybits = 160, /* 128-bit key + 32-bit nonce */
547 }
548 },
549
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200550 .pfkey_supported = 1,
551
Joy Latten405137d2008-02-07 23:11:56 -0800552 .desc = {
553 .sadb_alg_id = SADB_X_EALG_AESCTR,
554 .sadb_alg_ivlen = 8,
Tushar Gohad42032232011-07-28 10:36:20 +0000555 .sadb_alg_minbits = 160,
556 .sadb_alg_maxbits = 288
Joy Latten405137d2008-02-07 23:11:56 -0800557 }
558},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559};
560
561static struct xfrm_algo_desc calg_list[] = {
562{
563 .name = "deflate",
564 .uinfo = {
565 .comp = {
566 .threshold = 90,
567 }
568 },
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200569 .pfkey_supported = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
571},
572{
573 .name = "lzs",
574 .uinfo = {
575 .comp = {
576 .threshold = 90,
577 }
578 },
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200579 .pfkey_supported = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
581},
582{
583 .name = "lzjh",
584 .uinfo = {
585 .comp = {
586 .threshold = 50,
587 }
588 },
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200589 .pfkey_supported = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
591},
592};
593
594static inline int aalg_entries(void)
595{
596 return ARRAY_SIZE(aalg_list);
597}
598
599static inline int ealg_entries(void)
600{
601 return ARRAY_SIZE(ealg_list);
602}
603
604static inline int calg_entries(void)
605{
606 return ARRAY_SIZE(calg_list);
607}
608
Herbert Xuc92b3a22007-05-19 14:21:18 -0700609struct xfrm_algo_list {
610 struct xfrm_algo_desc *algs;
611 int entries;
612 u32 type;
613 u32 mask;
614};
615
Herbert Xu1a6509d2008-01-28 19:37:29 -0800616static const struct xfrm_algo_list xfrm_aead_list = {
617 .algs = aead_list,
618 .entries = ARRAY_SIZE(aead_list),
619 .type = CRYPTO_ALG_TYPE_AEAD,
620 .mask = CRYPTO_ALG_TYPE_MASK,
621};
622
Herbert Xuc92b3a22007-05-19 14:21:18 -0700623static const struct xfrm_algo_list xfrm_aalg_list = {
624 .algs = aalg_list,
625 .entries = ARRAY_SIZE(aalg_list),
626 .type = CRYPTO_ALG_TYPE_HASH,
Herbert Xu6fbf2cb2008-01-28 19:35:49 -0800627 .mask = CRYPTO_ALG_TYPE_HASH_MASK,
Herbert Xuc92b3a22007-05-19 14:21:18 -0700628};
629
630static const struct xfrm_algo_list xfrm_ealg_list = {
631 .algs = ealg_list,
632 .entries = ARRAY_SIZE(ealg_list),
633 .type = CRYPTO_ALG_TYPE_BLKCIPHER,
Herbert Xu6fbf2cb2008-01-28 19:35:49 -0800634 .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
Herbert Xuc92b3a22007-05-19 14:21:18 -0700635};
636
637static const struct xfrm_algo_list xfrm_calg_list = {
638 .algs = calg_list,
639 .entries = ARRAY_SIZE(calg_list),
640 .type = CRYPTO_ALG_TYPE_COMPRESS,
Herbert Xu6fbf2cb2008-01-28 19:35:49 -0800641 .mask = CRYPTO_ALG_TYPE_MASK,
Herbert Xuc92b3a22007-05-19 14:21:18 -0700642};
643
644static struct xfrm_algo_desc *xfrm_find_algo(
645 const struct xfrm_algo_list *algo_list,
646 int match(const struct xfrm_algo_desc *entry, const void *data),
647 const void *data, int probe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648{
Herbert Xuc92b3a22007-05-19 14:21:18 -0700649 struct xfrm_algo_desc *list = algo_list->algs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 int i, status;
651
Herbert Xuc92b3a22007-05-19 14:21:18 -0700652 for (i = 0; i < algo_list->entries; i++) {
653 if (!match(list + i, data))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 continue;
655
656 if (list[i].available)
657 return &list[i];
658
659 if (!probe)
660 break;
661
Herbert Xuc92b3a22007-05-19 14:21:18 -0700662 status = crypto_has_alg(list[i].name, algo_list->type,
663 algo_list->mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 if (!status)
665 break;
666
667 list[i].available = status;
668 return &list[i];
669 }
670 return NULL;
671}
672
Herbert Xuc92b3a22007-05-19 14:21:18 -0700673static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
674 const void *data)
675{
Herbert Xu26b8e512007-05-22 16:12:26 -0700676 return entry->desc.sadb_alg_id == (unsigned long)data;
Herbert Xuc92b3a22007-05-19 14:21:18 -0700677}
678
679struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
680{
681 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
Herbert Xu26b8e512007-05-22 16:12:26 -0700682 (void *)(unsigned long)alg_id, 1);
Herbert Xuc92b3a22007-05-19 14:21:18 -0700683}
684EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
685
686struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
687{
688 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
Herbert Xu26b8e512007-05-22 16:12:26 -0700689 (void *)(unsigned long)alg_id, 1);
Herbert Xuc92b3a22007-05-19 14:21:18 -0700690}
691EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
692
693struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
694{
695 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
Herbert Xu26b8e512007-05-22 16:12:26 -0700696 (void *)(unsigned long)alg_id, 1);
Herbert Xuc92b3a22007-05-19 14:21:18 -0700697}
698EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
699
700static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
701 const void *data)
702{
703 const char *name = data;
704
705 return name && (!strcmp(name, entry->name) ||
706 (entry->compat && !strcmp(name, entry->compat)));
707}
708
David S. Miller6f2f19e2011-02-27 23:04:45 -0800709struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710{
Herbert Xuc92b3a22007-05-19 14:21:18 -0700711 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
712 probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713}
714EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
715
David S. Miller6f2f19e2011-02-27 23:04:45 -0800716struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717{
Herbert Xuc92b3a22007-05-19 14:21:18 -0700718 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
719 probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720}
721EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
722
David S. Miller6f2f19e2011-02-27 23:04:45 -0800723struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724{
Herbert Xuc92b3a22007-05-19 14:21:18 -0700725 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
726 probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727}
728EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
729
Herbert Xu1a6509d2008-01-28 19:37:29 -0800730struct xfrm_aead_name {
731 const char *name;
732 int icvbits;
733};
734
735static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
736 const void *data)
737{
738 const struct xfrm_aead_name *aead = data;
739 const char *name = aead->name;
740
741 return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
742 !strcmp(name, entry->name);
743}
744
David S. Miller6f2f19e2011-02-27 23:04:45 -0800745struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len, int probe)
Herbert Xu1a6509d2008-01-28 19:37:29 -0800746{
747 struct xfrm_aead_name data = {
748 .name = name,
749 .icvbits = icv_len,
750 };
751
752 return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
753 probe);
754}
755EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
756
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
758{
759 if (idx >= aalg_entries())
760 return NULL;
761
762 return &aalg_list[idx];
763}
764EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
765
766struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
767{
768 if (idx >= ealg_entries())
769 return NULL;
770
771 return &ealg_list[idx];
772}
773EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
774
775/*
776 * Probe for the availability of crypto algorithms, and set the available
777 * flag for any algorithms found on the system. This is typically called by
778 * pfkey during userspace SA add, update or register.
779 */
780void xfrm_probe_algs(void)
781{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 int i, status;
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900783
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 BUG_ON(in_softirq());
785
786 for (i = 0; i < aalg_entries(); i++) {
Herbert Xu17bc1972016-01-24 21:19:11 +0800787 status = crypto_has_ahash(aalg_list[i].name, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 if (aalg_list[i].available != status)
789 aalg_list[i].available = status;
790 }
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 for (i = 0; i < ealg_entries(); i++) {
Herbert Xu17bc1972016-01-24 21:19:11 +0800793 status = crypto_has_skcipher(ealg_list[i].name, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 if (ealg_list[i].available != status)
795 ealg_list[i].available = status;
796 }
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900797
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 for (i = 0; i < calg_entries(); i++) {
Herbert Xue4d5b792006-08-26 18:12:40 +1000799 status = crypto_has_comp(calg_list[i].name, 0,
800 CRYPTO_ALG_ASYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 if (calg_list[i].available != status)
802 calg_list[i].available = status;
803 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
805EXPORT_SYMBOL_GPL(xfrm_probe_algs);
806
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200807int xfrm_count_pfkey_auth_supported(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808{
809 int i, n;
810
811 for (i = 0, n = 0; i < aalg_entries(); i++)
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200812 if (aalg_list[i].available && aalg_list[i].pfkey_supported)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 n++;
814 return n;
815}
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200816EXPORT_SYMBOL_GPL(xfrm_count_pfkey_auth_supported);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200818int xfrm_count_pfkey_enc_supported(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
820 int i, n;
821
822 for (i = 0, n = 0; i < ealg_entries(); i++)
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200823 if (ealg_list[i].available && ealg_list[i].pfkey_supported)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 n++;
825 return n;
826}
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200827EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
Jan Beulich7e152522012-05-15 01:57:44 +0000829MODULE_LICENSE("GPL");