blob: ab4ef72f0b1daefd4b46765d9009975cd9330676 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/module.h>
13#include <linux/kernel.h>
14#include <linux/pfkeyv2.h>
15#include <linux/crypto.h>
Heiko Carstensb3b724f2007-10-23 09:28:34 +020016#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
19#include <net/esp.h>
20#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22/*
23 * Algorithms supported by IPsec. These entries contain properties which
24 * are used in key negotiation and xfrm processing, and are used to verify
25 * that instantiated crypto transforms have correct parameters for IPsec
26 * purposes.
27 */
Herbert Xu1a6509d2008-01-28 19:37:29 -080028static struct xfrm_algo_desc aead_list[] = {
29{
30 .name = "rfc4106(gcm(aes))",
31
32 .uinfo = {
33 .aead = {
34 .icv_truncbits = 64,
35 }
36 },
37
Jussi Kivilinna7e50f842013-01-31 12:40:38 +020038 .pfkey_supported = 1,
39
Herbert Xu1a6509d2008-01-28 19:37:29 -080040 .desc = {
41 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
42 .sadb_alg_ivlen = 8,
43 .sadb_alg_minbits = 128,
44 .sadb_alg_maxbits = 256
45 }
46},
47{
48 .name = "rfc4106(gcm(aes))",
49
50 .uinfo = {
51 .aead = {
52 .icv_truncbits = 96,
53 }
54 },
55
Jussi Kivilinna7e50f842013-01-31 12:40:38 +020056 .pfkey_supported = 1,
57
Herbert Xu1a6509d2008-01-28 19:37:29 -080058 .desc = {
59 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
60 .sadb_alg_ivlen = 8,
61 .sadb_alg_minbits = 128,
62 .sadb_alg_maxbits = 256
63 }
64},
65{
66 .name = "rfc4106(gcm(aes))",
67
68 .uinfo = {
69 .aead = {
70 .icv_truncbits = 128,
71 }
72 },
73
Jussi Kivilinna7e50f842013-01-31 12:40:38 +020074 .pfkey_supported = 1,
75
Herbert Xu1a6509d2008-01-28 19:37:29 -080076 .desc = {
77 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
78 .sadb_alg_ivlen = 8,
79 .sadb_alg_minbits = 128,
80 .sadb_alg_maxbits = 256
81 }
82},
83{
84 .name = "rfc4309(ccm(aes))",
85
86 .uinfo = {
87 .aead = {
88 .icv_truncbits = 64,
89 }
90 },
91
Jussi Kivilinna7e50f842013-01-31 12:40:38 +020092 .pfkey_supported = 1,
93
Herbert Xu1a6509d2008-01-28 19:37:29 -080094 .desc = {
95 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
96 .sadb_alg_ivlen = 8,
97 .sadb_alg_minbits = 128,
98 .sadb_alg_maxbits = 256
99 }
100},
101{
102 .name = "rfc4309(ccm(aes))",
103
104 .uinfo = {
105 .aead = {
106 .icv_truncbits = 96,
107 }
108 },
109
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200110 .pfkey_supported = 1,
111
Herbert Xu1a6509d2008-01-28 19:37:29 -0800112 .desc = {
113 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
114 .sadb_alg_ivlen = 8,
115 .sadb_alg_minbits = 128,
116 .sadb_alg_maxbits = 256
117 }
118},
119{
120 .name = "rfc4309(ccm(aes))",
121
122 .uinfo = {
123 .aead = {
124 .icv_truncbits = 128,
125 }
126 },
127
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200128 .pfkey_supported = 1,
129
Herbert Xu1a6509d2008-01-28 19:37:29 -0800130 .desc = {
131 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
132 .sadb_alg_ivlen = 8,
133 .sadb_alg_minbits = 128,
134 .sadb_alg_maxbits = 256
135 }
136},
Tobias Brunner73c89c12010-01-17 21:52:11 +1100137{
138 .name = "rfc4543(gcm(aes))",
139
140 .uinfo = {
141 .aead = {
142 .icv_truncbits = 128,
143 }
144 },
145
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200146 .pfkey_supported = 1,
147
Tobias Brunner73c89c12010-01-17 21:52:11 +1100148 .desc = {
149 .sadb_alg_id = SADB_X_EALG_NULL_AES_GMAC,
150 .sadb_alg_ivlen = 8,
151 .sadb_alg_minbits = 128,
152 .sadb_alg_maxbits = 256
153 }
154},
Herbert Xu1a6509d2008-01-28 19:37:29 -0800155};
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157static struct xfrm_algo_desc aalg_list[] = {
158{
Herbert Xu01a22022008-04-27 00:59:59 -0700159 .name = "digest_null",
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 .uinfo = {
162 .auth = {
163 .icv_truncbits = 0,
164 .icv_fullbits = 0,
165 }
166 },
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900167
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200168 .pfkey_supported = 1,
169
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 .desc = {
171 .sadb_alg_id = SADB_X_AALG_NULL,
172 .sadb_alg_ivlen = 0,
173 .sadb_alg_minbits = 0,
174 .sadb_alg_maxbits = 0
175 }
176},
177{
Herbert Xu07d4ee52006-08-20 14:24:50 +1000178 .name = "hmac(md5)",
179 .compat = "md5",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
181 .uinfo = {
182 .auth = {
183 .icv_truncbits = 96,
184 .icv_fullbits = 128,
185 }
186 },
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900187
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200188 .pfkey_supported = 1,
189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 .desc = {
191 .sadb_alg_id = SADB_AALG_MD5HMAC,
192 .sadb_alg_ivlen = 0,
193 .sadb_alg_minbits = 128,
194 .sadb_alg_maxbits = 128
195 }
196},
197{
Herbert Xu07d4ee52006-08-20 14:24:50 +1000198 .name = "hmac(sha1)",
199 .compat = "sha1",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
201 .uinfo = {
202 .auth = {
203 .icv_truncbits = 96,
204 .icv_fullbits = 160,
205 }
206 },
207
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200208 .pfkey_supported = 1,
209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 .desc = {
211 .sadb_alg_id = SADB_AALG_SHA1HMAC,
212 .sadb_alg_ivlen = 0,
213 .sadb_alg_minbits = 160,
214 .sadb_alg_maxbits = 160
215 }
216},
217{
Herbert Xu07d4ee52006-08-20 14:24:50 +1000218 .name = "hmac(sha256)",
219 .compat = "sha256",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221 .uinfo = {
222 .auth = {
223 .icv_truncbits = 96,
224 .icv_fullbits = 256,
225 }
226 },
227
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200228 .pfkey_supported = 1,
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 .desc = {
231 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
232 .sadb_alg_ivlen = 0,
233 .sadb_alg_minbits = 256,
234 .sadb_alg_maxbits = 256
235 }
236},
237{
Martin Willibc74b0c2009-11-25 00:58:39 +0000238 .name = "hmac(sha384)",
239
240 .uinfo = {
241 .auth = {
242 .icv_truncbits = 192,
243 .icv_fullbits = 384,
244 }
245 },
246
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200247 .pfkey_supported = 1,
248
Martin Willibc74b0c2009-11-25 00:58:39 +0000249 .desc = {
250 .sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
251 .sadb_alg_ivlen = 0,
252 .sadb_alg_minbits = 384,
253 .sadb_alg_maxbits = 384
254 }
255},
256{
257 .name = "hmac(sha512)",
258
259 .uinfo = {
260 .auth = {
261 .icv_truncbits = 256,
262 .icv_fullbits = 512,
263 }
264 },
265
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200266 .pfkey_supported = 1,
267
Martin Willibc74b0c2009-11-25 00:58:39 +0000268 .desc = {
269 .sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
270 .sadb_alg_ivlen = 0,
271 .sadb_alg_minbits = 512,
272 .sadb_alg_maxbits = 512
273 }
274},
275{
Adrian-Ken Rueegseggera13366c2008-06-04 12:04:55 -0700276 .name = "hmac(rmd160)",
277 .compat = "rmd160",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
279 .uinfo = {
280 .auth = {
281 .icv_truncbits = 96,
282 .icv_fullbits = 160,
283 }
284 },
285
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200286 .pfkey_supported = 1,
287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 .desc = {
289 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
290 .sadb_alg_ivlen = 0,
291 .sadb_alg_minbits = 160,
292 .sadb_alg_maxbits = 160
293 }
294},
Kazunori MIYAZAWA7cf4c1a2006-10-28 13:21:22 +1000295{
296 .name = "xcbc(aes)",
297
298 .uinfo = {
299 .auth = {
300 .icv_truncbits = 96,
301 .icv_fullbits = 128,
302 }
303 },
304
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200305 .pfkey_supported = 1,
306
Kazunori MIYAZAWA7cf4c1a2006-10-28 13:21:22 +1000307 .desc = {
308 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
309 .sadb_alg_ivlen = 0,
310 .sadb_alg_minbits = 128,
311 .sadb_alg_maxbits = 128
312 }
313},
Jussi Kivilinnad2049d82013-04-08 10:48:49 +0300314{
315 /* rfc4494 */
316 .name = "cmac(aes)",
317
318 .uinfo = {
319 .auth = {
320 .icv_truncbits = 96,
321 .icv_fullbits = 128,
322 }
323 },
324
325 .pfkey_supported = 0,
326},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327};
328
329static struct xfrm_algo_desc ealg_list[] = {
330{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000331 .name = "ecb(cipher_null)",
332 .compat = "cipher_null",
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 .uinfo = {
335 .encr = {
336 .blockbits = 8,
337 .defkeybits = 0,
338 }
339 },
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900340
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200341 .pfkey_supported = 1,
342
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 .desc = {
344 .sadb_alg_id = SADB_EALG_NULL,
345 .sadb_alg_ivlen = 0,
346 .sadb_alg_minbits = 0,
347 .sadb_alg_maxbits = 0
348 }
349},
350{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000351 .name = "cbc(des)",
352 .compat = "des",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 .uinfo = {
355 .encr = {
356 .blockbits = 64,
357 .defkeybits = 64,
358 }
359 },
360
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200361 .pfkey_supported = 1,
362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 .desc = {
364 .sadb_alg_id = SADB_EALG_DESCBC,
365 .sadb_alg_ivlen = 8,
366 .sadb_alg_minbits = 64,
367 .sadb_alg_maxbits = 64
368 }
369},
370{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000371 .name = "cbc(des3_ede)",
372 .compat = "des3_ede",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
374 .uinfo = {
375 .encr = {
376 .blockbits = 64,
377 .defkeybits = 192,
378 }
379 },
380
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200381 .pfkey_supported = 1,
382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 .desc = {
384 .sadb_alg_id = SADB_EALG_3DESCBC,
385 .sadb_alg_ivlen = 8,
386 .sadb_alg_minbits = 192,
387 .sadb_alg_maxbits = 192
388 }
389},
390{
Herbert Xu245acb82009-06-24 03:55:41 -0700391 .name = "cbc(cast5)",
392 .compat = "cast5",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394 .uinfo = {
395 .encr = {
396 .blockbits = 64,
397 .defkeybits = 128,
398 }
399 },
400
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200401 .pfkey_supported = 1,
402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 .desc = {
404 .sadb_alg_id = SADB_X_EALG_CASTCBC,
405 .sadb_alg_ivlen = 8,
406 .sadb_alg_minbits = 40,
407 .sadb_alg_maxbits = 128
408 }
409},
410{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000411 .name = "cbc(blowfish)",
412 .compat = "blowfish",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 .uinfo = {
415 .encr = {
416 .blockbits = 64,
417 .defkeybits = 128,
418 }
419 },
420
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200421 .pfkey_supported = 1,
422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 .desc = {
424 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
425 .sadb_alg_ivlen = 8,
426 .sadb_alg_minbits = 40,
427 .sadb_alg_maxbits = 448
428 }
429},
430{
Herbert Xu6b7326c2006-07-30 15:41:01 +1000431 .name = "cbc(aes)",
432 .compat = "aes",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 .uinfo = {
435 .encr = {
436 .blockbits = 128,
437 .defkeybits = 128,
438 }
439 },
440
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200441 .pfkey_supported = 1,
442
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 .desc = {
444 .sadb_alg_id = SADB_X_EALG_AESCBC,
445 .sadb_alg_ivlen = 8,
446 .sadb_alg_minbits = 128,
447 .sadb_alg_maxbits = 256
448 }
449},
450{
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900451 .name = "cbc(serpent)",
452 .compat = "serpent",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900454 .uinfo = {
455 .encr = {
456 .blockbits = 128,
457 .defkeybits = 128,
458 }
459 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200461 .pfkey_supported = 1,
462
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900463 .desc = {
464 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
465 .sadb_alg_ivlen = 8,
466 .sadb_alg_minbits = 128,
467 .sadb_alg_maxbits = 256,
468 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469},
470{
Noriaki TAKAMIYA6a0dc8d2006-10-22 15:05:57 +1000471 .name = "cbc(camellia)",
Li Yewang138f3c82009-12-01 15:35:05 -0800472 .compat = "camellia",
Noriaki TAKAMIYA6a0dc8d2006-10-22 15:05:57 +1000473
474 .uinfo = {
475 .encr = {
476 .blockbits = 128,
477 .defkeybits = 128,
478 }
479 },
480
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200481 .pfkey_supported = 1,
482
Noriaki TAKAMIYA6a0dc8d2006-10-22 15:05:57 +1000483 .desc = {
484 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
485 .sadb_alg_ivlen = 8,
486 .sadb_alg_minbits = 128,
487 .sadb_alg_maxbits = 256
488 }
489},
490{
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900491 .name = "cbc(twofish)",
492 .compat = "twofish",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900494 .uinfo = {
495 .encr = {
496 .blockbits = 128,
497 .defkeybits = 128,
498 }
499 },
500
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200501 .pfkey_supported = 1,
502
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900503 .desc = {
504 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
505 .sadb_alg_ivlen = 8,
506 .sadb_alg_minbits = 128,
507 .sadb_alg_maxbits = 256
508 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509},
Joy Latten405137d2008-02-07 23:11:56 -0800510{
511 .name = "rfc3686(ctr(aes))",
512
513 .uinfo = {
514 .encr = {
515 .blockbits = 128,
516 .defkeybits = 160, /* 128-bit key + 32-bit nonce */
517 }
518 },
519
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200520 .pfkey_supported = 1,
521
Joy Latten405137d2008-02-07 23:11:56 -0800522 .desc = {
523 .sadb_alg_id = SADB_X_EALG_AESCTR,
524 .sadb_alg_ivlen = 8,
Tushar Gohad42032232011-07-28 10:36:20 +0000525 .sadb_alg_minbits = 160,
526 .sadb_alg_maxbits = 288
Joy Latten405137d2008-02-07 23:11:56 -0800527 }
528},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529};
530
531static struct xfrm_algo_desc calg_list[] = {
532{
533 .name = "deflate",
534 .uinfo = {
535 .comp = {
536 .threshold = 90,
537 }
538 },
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200539 .pfkey_supported = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
541},
542{
543 .name = "lzs",
544 .uinfo = {
545 .comp = {
546 .threshold = 90,
547 }
548 },
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200549 .pfkey_supported = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
551},
552{
553 .name = "lzjh",
554 .uinfo = {
555 .comp = {
556 .threshold = 50,
557 }
558 },
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200559 .pfkey_supported = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
561},
562};
563
Herbert Xu1a6509d2008-01-28 19:37:29 -0800564static inline int aead_entries(void)
565{
566 return ARRAY_SIZE(aead_list);
567}
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569static inline int aalg_entries(void)
570{
571 return ARRAY_SIZE(aalg_list);
572}
573
574static inline int ealg_entries(void)
575{
576 return ARRAY_SIZE(ealg_list);
577}
578
579static inline int calg_entries(void)
580{
581 return ARRAY_SIZE(calg_list);
582}
583
Herbert Xuc92b3a22007-05-19 14:21:18 -0700584struct xfrm_algo_list {
585 struct xfrm_algo_desc *algs;
586 int entries;
587 u32 type;
588 u32 mask;
589};
590
Herbert Xu1a6509d2008-01-28 19:37:29 -0800591static const struct xfrm_algo_list xfrm_aead_list = {
592 .algs = aead_list,
593 .entries = ARRAY_SIZE(aead_list),
594 .type = CRYPTO_ALG_TYPE_AEAD,
595 .mask = CRYPTO_ALG_TYPE_MASK,
596};
597
Herbert Xuc92b3a22007-05-19 14:21:18 -0700598static const struct xfrm_algo_list xfrm_aalg_list = {
599 .algs = aalg_list,
600 .entries = ARRAY_SIZE(aalg_list),
601 .type = CRYPTO_ALG_TYPE_HASH,
Herbert Xu6fbf2cb2008-01-28 19:35:49 -0800602 .mask = CRYPTO_ALG_TYPE_HASH_MASK,
Herbert Xuc92b3a22007-05-19 14:21:18 -0700603};
604
605static const struct xfrm_algo_list xfrm_ealg_list = {
606 .algs = ealg_list,
607 .entries = ARRAY_SIZE(ealg_list),
608 .type = CRYPTO_ALG_TYPE_BLKCIPHER,
Herbert Xu6fbf2cb2008-01-28 19:35:49 -0800609 .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
Herbert Xuc92b3a22007-05-19 14:21:18 -0700610};
611
612static const struct xfrm_algo_list xfrm_calg_list = {
613 .algs = calg_list,
614 .entries = ARRAY_SIZE(calg_list),
615 .type = CRYPTO_ALG_TYPE_COMPRESS,
Herbert Xu6fbf2cb2008-01-28 19:35:49 -0800616 .mask = CRYPTO_ALG_TYPE_MASK,
Herbert Xuc92b3a22007-05-19 14:21:18 -0700617};
618
619static struct xfrm_algo_desc *xfrm_find_algo(
620 const struct xfrm_algo_list *algo_list,
621 int match(const struct xfrm_algo_desc *entry, const void *data),
622 const void *data, int probe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623{
Herbert Xuc92b3a22007-05-19 14:21:18 -0700624 struct xfrm_algo_desc *list = algo_list->algs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 int i, status;
626
Herbert Xuc92b3a22007-05-19 14:21:18 -0700627 for (i = 0; i < algo_list->entries; i++) {
628 if (!match(list + i, data))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 continue;
630
631 if (list[i].available)
632 return &list[i];
633
634 if (!probe)
635 break;
636
Herbert Xuc92b3a22007-05-19 14:21:18 -0700637 status = crypto_has_alg(list[i].name, algo_list->type,
638 algo_list->mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 if (!status)
640 break;
641
642 list[i].available = status;
643 return &list[i];
644 }
645 return NULL;
646}
647
Herbert Xuc92b3a22007-05-19 14:21:18 -0700648static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
649 const void *data)
650{
Herbert Xu26b8e512007-05-22 16:12:26 -0700651 return entry->desc.sadb_alg_id == (unsigned long)data;
Herbert Xuc92b3a22007-05-19 14:21:18 -0700652}
653
654struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
655{
656 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
Herbert Xu26b8e512007-05-22 16:12:26 -0700657 (void *)(unsigned long)alg_id, 1);
Herbert Xuc92b3a22007-05-19 14:21:18 -0700658}
659EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
660
661struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
662{
663 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
Herbert Xu26b8e512007-05-22 16:12:26 -0700664 (void *)(unsigned long)alg_id, 1);
Herbert Xuc92b3a22007-05-19 14:21:18 -0700665}
666EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
667
668struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
669{
670 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
Herbert Xu26b8e512007-05-22 16:12:26 -0700671 (void *)(unsigned long)alg_id, 1);
Herbert Xuc92b3a22007-05-19 14:21:18 -0700672}
673EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
674
675static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
676 const void *data)
677{
678 const char *name = data;
679
680 return name && (!strcmp(name, entry->name) ||
681 (entry->compat && !strcmp(name, entry->compat)));
682}
683
David S. Miller6f2f19e2011-02-27 23:04:45 -0800684struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
Herbert Xuc92b3a22007-05-19 14:21:18 -0700686 return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
687 probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688}
689EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
690
David S. Miller6f2f19e2011-02-27 23:04:45 -0800691struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
Herbert Xuc92b3a22007-05-19 14:21:18 -0700693 return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
694 probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695}
696EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
697
David S. Miller6f2f19e2011-02-27 23:04:45 -0800698struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699{
Herbert Xuc92b3a22007-05-19 14:21:18 -0700700 return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
701 probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
703EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
704
Herbert Xu1a6509d2008-01-28 19:37:29 -0800705struct xfrm_aead_name {
706 const char *name;
707 int icvbits;
708};
709
710static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
711 const void *data)
712{
713 const struct xfrm_aead_name *aead = data;
714 const char *name = aead->name;
715
716 return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
717 !strcmp(name, entry->name);
718}
719
David S. Miller6f2f19e2011-02-27 23:04:45 -0800720struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len, int probe)
Herbert Xu1a6509d2008-01-28 19:37:29 -0800721{
722 struct xfrm_aead_name data = {
723 .name = name,
724 .icvbits = icv_len,
725 };
726
727 return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
728 probe);
729}
730EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
733{
734 if (idx >= aalg_entries())
735 return NULL;
736
737 return &aalg_list[idx];
738}
739EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
740
741struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
742{
743 if (idx >= ealg_entries())
744 return NULL;
745
746 return &ealg_list[idx];
747}
748EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
749
750/*
751 * Probe for the availability of crypto algorithms, and set the available
752 * flag for any algorithms found on the system. This is typically called by
753 * pfkey during userspace SA add, update or register.
754 */
755void xfrm_probe_algs(void)
756{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 int i, status;
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 BUG_ON(in_softirq());
760
761 for (i = 0; i < aalg_entries(); i++) {
Herbert Xue4d5b792006-08-26 18:12:40 +1000762 status = crypto_has_hash(aalg_list[i].name, 0,
763 CRYPTO_ALG_ASYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 if (aalg_list[i].available != status)
765 aalg_list[i].available = status;
766 }
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 for (i = 0; i < ealg_entries(); i++) {
Jussi Kivilinna71331da2012-12-28 12:04:53 +0200769 status = crypto_has_ablkcipher(ealg_list[i].name, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 if (ealg_list[i].available != status)
771 ealg_list[i].available = status;
772 }
YOSHIFUJI Hideakia716c112007-02-09 23:25:29 +0900773
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 for (i = 0; i < calg_entries(); i++) {
Herbert Xue4d5b792006-08-26 18:12:40 +1000775 status = crypto_has_comp(calg_list[i].name, 0,
776 CRYPTO_ALG_ASYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 if (calg_list[i].available != status)
778 calg_list[i].available = status;
779 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780}
781EXPORT_SYMBOL_GPL(xfrm_probe_algs);
782
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200783int xfrm_count_pfkey_auth_supported(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784{
785 int i, n;
786
787 for (i = 0, n = 0; i < aalg_entries(); i++)
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200788 if (aalg_list[i].available && aalg_list[i].pfkey_supported)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 n++;
790 return n;
791}
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200792EXPORT_SYMBOL_GPL(xfrm_count_pfkey_auth_supported);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200794int xfrm_count_pfkey_enc_supported(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
796 int i, n;
797
798 for (i = 0, n = 0; i < ealg_entries(); i++)
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200799 if (ealg_list[i].available && ealg_list[i].pfkey_supported)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 n++;
801 return n;
802}
Jussi Kivilinna7e50f842013-01-31 12:40:38 +0200803EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805#if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
808{
809 if (tail != skb) {
810 skb->data_len += len;
811 skb->len += len;
812 }
813 return skb_put(tail, len);
814}
815EXPORT_SYMBOL_GPL(pskb_put);
816#endif
Jan Beulich7e152522012-05-15 01:57:44 +0000817
818MODULE_LICENSE("GPL");