xref: /openbmc/linux/net/xfrm/xfrm_algo.c (revision 64c70b1c) 
1 /*
2  * 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
8  * Software Foundation; either version 2 of the License, or (at your option)
9  * any later version.
10  */
11 
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/pfkeyv2.h>
15 #include <linux/crypto.h>
16 #include <net/xfrm.h>
17 #if defined(CONFIG_INET_AH) || defined(CONFIG_INET_AH_MODULE) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
18 #include <net/ah.h>
19 #endif
20 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
21 #include <net/esp.h>
22 #endif
23 #include <asm/scatterlist.h>
24 
25 /*
26  * Algorithms supported by IPsec.  These entries contain properties which
27  * are used in key negotiation and xfrm processing, and are used to verify
28  * that instantiated crypto transforms have correct parameters for IPsec
29  * purposes.
30  */
31 static struct xfrm_algo_desc aalg_list[] = {
32 {
33 	.name = "hmac(digest_null)",
34 	.compat = "digest_null",
35 
36 	.uinfo = {
37 		.auth = {
38 			.icv_truncbits = 0,
39 			.icv_fullbits = 0,
40 		}
41 	},
42 
43 	.desc = {
44 		.sadb_alg_id = SADB_X_AALG_NULL,
45 		.sadb_alg_ivlen = 0,
46 		.sadb_alg_minbits = 0,
47 		.sadb_alg_maxbits = 0
48 	}
49 },
50 {
51 	.name = "hmac(md5)",
52 	.compat = "md5",
53 
54 	.uinfo = {
55 		.auth = {
56 			.icv_truncbits = 96,
57 			.icv_fullbits = 128,
58 		}
59 	},
60 
61 	.desc = {
62 		.sadb_alg_id = SADB_AALG_MD5HMAC,
63 		.sadb_alg_ivlen = 0,
64 		.sadb_alg_minbits = 128,
65 		.sadb_alg_maxbits = 128
66 	}
67 },
68 {
69 	.name = "hmac(sha1)",
70 	.compat = "sha1",
71 
72 	.uinfo = {
73 		.auth = {
74 			.icv_truncbits = 96,
75 			.icv_fullbits = 160,
76 		}
77 	},
78 
79 	.desc = {
80 		.sadb_alg_id = SADB_AALG_SHA1HMAC,
81 		.sadb_alg_ivlen = 0,
82 		.sadb_alg_minbits = 160,
83 		.sadb_alg_maxbits = 160
84 	}
85 },
86 {
87 	.name = "hmac(sha256)",
88 	.compat = "sha256",
89 
90 	.uinfo = {
91 		.auth = {
92 			.icv_truncbits = 96,
93 			.icv_fullbits = 256,
94 		}
95 	},
96 
97 	.desc = {
98 		.sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
99 		.sadb_alg_ivlen = 0,
100 		.sadb_alg_minbits = 256,
101 		.sadb_alg_maxbits = 256
102 	}
103 },
104 {
105 	.name = "hmac(ripemd160)",
106 	.compat = "ripemd160",
107 
108 	.uinfo = {
109 		.auth = {
110 			.icv_truncbits = 96,
111 			.icv_fullbits = 160,
112 		}
113 	},
114 
115 	.desc = {
116 		.sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
117 		.sadb_alg_ivlen = 0,
118 		.sadb_alg_minbits = 160,
119 		.sadb_alg_maxbits = 160
120 	}
121 },
122 {
123 	.name = "xcbc(aes)",
124 
125 	.uinfo = {
126 		.auth = {
127 			.icv_truncbits = 96,
128 			.icv_fullbits = 128,
129 		}
130 	},
131 
132 	.desc = {
133 		.sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
134 		.sadb_alg_ivlen = 0,
135 		.sadb_alg_minbits = 128,
136 		.sadb_alg_maxbits = 128
137 	}
138 },
139 };
140 
141 static struct xfrm_algo_desc ealg_list[] = {
142 {
143 	.name = "ecb(cipher_null)",
144 	.compat = "cipher_null",
145 
146 	.uinfo = {
147 		.encr = {
148 			.blockbits = 8,
149 			.defkeybits = 0,
150 		}
151 	},
152 
153 	.desc = {
154 		.sadb_alg_id =	SADB_EALG_NULL,
155 		.sadb_alg_ivlen = 0,
156 		.sadb_alg_minbits = 0,
157 		.sadb_alg_maxbits = 0
158 	}
159 },
160 {
161 	.name = "cbc(des)",
162 	.compat = "des",
163 
164 	.uinfo = {
165 		.encr = {
166 			.blockbits = 64,
167 			.defkeybits = 64,
168 		}
169 	},
170 
171 	.desc = {
172 		.sadb_alg_id = SADB_EALG_DESCBC,
173 		.sadb_alg_ivlen = 8,
174 		.sadb_alg_minbits = 64,
175 		.sadb_alg_maxbits = 64
176 	}
177 },
178 {
179 	.name = "cbc(des3_ede)",
180 	.compat = "des3_ede",
181 
182 	.uinfo = {
183 		.encr = {
184 			.blockbits = 64,
185 			.defkeybits = 192,
186 		}
187 	},
188 
189 	.desc = {
190 		.sadb_alg_id = SADB_EALG_3DESCBC,
191 		.sadb_alg_ivlen = 8,
192 		.sadb_alg_minbits = 192,
193 		.sadb_alg_maxbits = 192
194 	}
195 },
196 {
197 	.name = "cbc(cast128)",
198 	.compat = "cast128",
199 
200 	.uinfo = {
201 		.encr = {
202 			.blockbits = 64,
203 			.defkeybits = 128,
204 		}
205 	},
206 
207 	.desc = {
208 		.sadb_alg_id = SADB_X_EALG_CASTCBC,
209 		.sadb_alg_ivlen = 8,
210 		.sadb_alg_minbits = 40,
211 		.sadb_alg_maxbits = 128
212 	}
213 },
214 {
215 	.name = "cbc(blowfish)",
216 	.compat = "blowfish",
217 
218 	.uinfo = {
219 		.encr = {
220 			.blockbits = 64,
221 			.defkeybits = 128,
222 		}
223 	},
224 
225 	.desc = {
226 		.sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
227 		.sadb_alg_ivlen = 8,
228 		.sadb_alg_minbits = 40,
229 		.sadb_alg_maxbits = 448
230 	}
231 },
232 {
233 	.name = "cbc(aes)",
234 	.compat = "aes",
235 
236 	.uinfo = {
237 		.encr = {
238 			.blockbits = 128,
239 			.defkeybits = 128,
240 		}
241 	},
242 
243 	.desc = {
244 		.sadb_alg_id = SADB_X_EALG_AESCBC,
245 		.sadb_alg_ivlen = 8,
246 		.sadb_alg_minbits = 128,
247 		.sadb_alg_maxbits = 256
248 	}
249 },
250 {
251 	.name = "cbc(serpent)",
252 	.compat = "serpent",
253 
254 	.uinfo = {
255 		.encr = {
256 			.blockbits = 128,
257 			.defkeybits = 128,
258 		}
259 	},
260 
261 	.desc = {
262 		.sadb_alg_id = SADB_X_EALG_SERPENTCBC,
263 		.sadb_alg_ivlen = 8,
264 		.sadb_alg_minbits = 128,
265 		.sadb_alg_maxbits = 256,
266 	}
267 },
268 {
269 	.name = "cbc(camellia)",
270 
271 	.uinfo = {
272 		.encr = {
273 			.blockbits = 128,
274 			.defkeybits = 128,
275 		}
276 	},
277 
278 	.desc = {
279 		.sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
280 		.sadb_alg_ivlen = 8,
281 		.sadb_alg_minbits = 128,
282 		.sadb_alg_maxbits = 256
283 	}
284 },
285 {
286 	.name = "cbc(twofish)",
287 	.compat = "twofish",
288 
289 	.uinfo = {
290 		.encr = {
291 			.blockbits = 128,
292 			.defkeybits = 128,
293 		}
294 	},
295 
296 	.desc = {
297 		.sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
298 		.sadb_alg_ivlen = 8,
299 		.sadb_alg_minbits = 128,
300 		.sadb_alg_maxbits = 256
301 	}
302 },
303 };
304 
305 static struct xfrm_algo_desc calg_list[] = {
306 {
307 	.name = "deflate",
308 	.uinfo = {
309 		.comp = {
310 			.threshold = 90,
311 		}
312 	},
313 	.desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
314 },
315 {
316 	.name = "lzs",
317 	.uinfo = {
318 		.comp = {
319 			.threshold = 90,
320 		}
321 	},
322 	.desc = { .sadb_alg_id = SADB_X_CALG_LZS }
323 },
324 {
325 	.name = "lzjh",
326 	.uinfo = {
327 		.comp = {
328 			.threshold = 50,
329 		}
330 	},
331 	.desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
332 },
333 };
334 
335 static inline int aalg_entries(void)
336 {
337 	return ARRAY_SIZE(aalg_list);
338 }
339 
340 static inline int ealg_entries(void)
341 {
342 	return ARRAY_SIZE(ealg_list);
343 }
344 
345 static inline int calg_entries(void)
346 {
347 	return ARRAY_SIZE(calg_list);
348 }
349 
350 struct xfrm_algo_list {
351 	struct xfrm_algo_desc *algs;
352 	int entries;
353 	u32 type;
354 	u32 mask;
355 };
356 
357 static const struct xfrm_algo_list xfrm_aalg_list = {
358 	.algs = aalg_list,
359 	.entries = ARRAY_SIZE(aalg_list),
360 	.type = CRYPTO_ALG_TYPE_HASH,
361 	.mask = CRYPTO_ALG_TYPE_HASH_MASK | CRYPTO_ALG_ASYNC,
362 };
363 
364 static const struct xfrm_algo_list xfrm_ealg_list = {
365 	.algs = ealg_list,
366 	.entries = ARRAY_SIZE(ealg_list),
367 	.type = CRYPTO_ALG_TYPE_BLKCIPHER,
368 	.mask = CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC,
369 };
370 
371 static const struct xfrm_algo_list xfrm_calg_list = {
372 	.algs = calg_list,
373 	.entries = ARRAY_SIZE(calg_list),
374 	.type = CRYPTO_ALG_TYPE_COMPRESS,
375 	.mask = CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC,
376 };
377 
378 static struct xfrm_algo_desc *xfrm_find_algo(
379 	const struct xfrm_algo_list *algo_list,
380 	int match(const struct xfrm_algo_desc *entry, const void *data),
381 	const void *data, int probe)
382 {
383 	struct xfrm_algo_desc *list = algo_list->algs;
384 	int i, status;
385 
386 	for (i = 0; i < algo_list->entries; i++) {
387 		if (!match(list + i, data))
388 			continue;
389 
390 		if (list[i].available)
391 			return &list[i];
392 
393 		if (!probe)
394 			break;
395 
396 		status = crypto_has_alg(list[i].name, algo_list->type,
397 					algo_list->mask);
398 		if (!status)
399 			break;
400 
401 		list[i].available = status;
402 		return &list[i];
403 	}
404 	return NULL;
405 }
406 
407 static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
408 			     const void *data)
409 {
410 	return entry->desc.sadb_alg_id == (unsigned long)data;
411 }
412 
413 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
414 {
415 	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
416 			      (void *)(unsigned long)alg_id, 1);
417 }
418 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
419 
420 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
421 {
422 	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
423 			      (void *)(unsigned long)alg_id, 1);
424 }
425 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
426 
427 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
428 {
429 	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
430 			      (void *)(unsigned long)alg_id, 1);
431 }
432 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
433 
434 static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
435 			       const void *data)
436 {
437 	const char *name = data;
438 
439 	return name && (!strcmp(name, entry->name) ||
440 			(entry->compat && !strcmp(name, entry->compat)));
441 }
442 
443 struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe)
444 {
445 	return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
446 			      probe);
447 }
448 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
449 
450 struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe)
451 {
452 	return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
453 			      probe);
454 }
455 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
456 
457 struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe)
458 {
459 	return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
460 			      probe);
461 }
462 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
463 
464 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
465 {
466 	if (idx >= aalg_entries())
467 		return NULL;
468 
469 	return &aalg_list[idx];
470 }
471 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
472 
473 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
474 {
475 	if (idx >= ealg_entries())
476 		return NULL;
477 
478 	return &ealg_list[idx];
479 }
480 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
481 
482 /*
483  * Probe for the availability of crypto algorithms, and set the available
484  * flag for any algorithms found on the system.  This is typically called by
485  * pfkey during userspace SA add, update or register.
486  */
487 void xfrm_probe_algs(void)
488 {
489 #ifdef CONFIG_CRYPTO
490 	int i, status;
491 
492 	BUG_ON(in_softirq());
493 
494 	for (i = 0; i < aalg_entries(); i++) {
495 		status = crypto_has_hash(aalg_list[i].name, 0,
496 					 CRYPTO_ALG_ASYNC);
497 		if (aalg_list[i].available != status)
498 			aalg_list[i].available = status;
499 	}
500 
501 	for (i = 0; i < ealg_entries(); i++) {
502 		status = crypto_has_blkcipher(ealg_list[i].name, 0,
503 					      CRYPTO_ALG_ASYNC);
504 		if (ealg_list[i].available != status)
505 			ealg_list[i].available = status;
506 	}
507 
508 	for (i = 0; i < calg_entries(); i++) {
509 		status = crypto_has_comp(calg_list[i].name, 0,
510 					 CRYPTO_ALG_ASYNC);
511 		if (calg_list[i].available != status)
512 			calg_list[i].available = status;
513 	}
514 #endif
515 }
516 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
517 
518 int xfrm_count_auth_supported(void)
519 {
520 	int i, n;
521 
522 	for (i = 0, n = 0; i < aalg_entries(); i++)
523 		if (aalg_list[i].available)
524 			n++;
525 	return n;
526 }
527 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
528 
529 int xfrm_count_enc_supported(void)
530 {
531 	int i, n;
532 
533 	for (i = 0, n = 0; i < ealg_entries(); i++)
534 		if (ealg_list[i].available)
535 			n++;
536 	return n;
537 }
538 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
539 
540 /* Move to common area: it is shared with AH. */
541 
542 int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
543 		 int offset, int len, icv_update_fn_t icv_update)
544 {
545 	int start = skb_headlen(skb);
546 	int i, copy = start - offset;
547 	int err;
548 	struct scatterlist sg;
549 
550 	/* Checksum header. */
551 	if (copy > 0) {
552 		if (copy > len)
553 			copy = len;
554 
555 		sg.page = virt_to_page(skb->data + offset);
556 		sg.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
557 		sg.length = copy;
558 
559 		err = icv_update(desc, &sg, copy);
560 		if (unlikely(err))
561 			return err;
562 
563 		if ((len -= copy) == 0)
564 			return 0;
565 		offset += copy;
566 	}
567 
568 	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
569 		int end;
570 
571 		BUG_TRAP(start <= offset + len);
572 
573 		end = start + skb_shinfo(skb)->frags[i].size;
574 		if ((copy = end - offset) > 0) {
575 			skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
576 
577 			if (copy > len)
578 				copy = len;
579 
580 			sg.page = frag->page;
581 			sg.offset = frag->page_offset + offset-start;
582 			sg.length = copy;
583 
584 			err = icv_update(desc, &sg, copy);
585 			if (unlikely(err))
586 				return err;
587 
588 			if (!(len -= copy))
589 				return 0;
590 			offset += copy;
591 		}
592 		start = end;
593 	}
594 
595 	if (skb_shinfo(skb)->frag_list) {
596 		struct sk_buff *list = skb_shinfo(skb)->frag_list;
597 
598 		for (; list; list = list->next) {
599 			int end;
600 
601 			BUG_TRAP(start <= offset + len);
602 
603 			end = start + list->len;
604 			if ((copy = end - offset) > 0) {
605 				if (copy > len)
606 					copy = len;
607 				err = skb_icv_walk(list, desc, offset-start,
608 						   copy, icv_update);
609 				if (unlikely(err))
610 					return err;
611 				if ((len -= copy) == 0)
612 					return 0;
613 				offset += copy;
614 			}
615 			start = end;
616 		}
617 	}
618 	BUG_ON(len);
619 	return 0;
620 }
621 EXPORT_SYMBOL_GPL(skb_icv_walk);
622 
623 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
624 
625 void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
626 {
627 	if (tail != skb) {
628 		skb->data_len += len;
629 		skb->len += len;
630 	}
631 	return skb_put(tail, len);
632 }
633 EXPORT_SYMBOL_GPL(pskb_put);
634 #endif
635