xref: /openbmc/linux/net/ipv6/seg6.c (revision e6dec923) 
1 /*
2  *  SR-IPv6 implementation
3  *
4  *  Author:
5  *  David Lebrun <david.lebrun@uclouvain.be>
6  *
7  *
8  *  This program is free software; you can redistribute it and/or
9  *	  modify it under the terms of the GNU General Public License
10  *	  as published by the Free Software Foundation; either version
11  *	  2 of the License, or (at your option) any later version.
12  */
13 
14 #include <linux/errno.h>
15 #include <linux/types.h>
16 #include <linux/socket.h>
17 #include <linux/net.h>
18 #include <linux/in6.h>
19 #include <linux/slab.h>
20 
21 #include <net/ipv6.h>
22 #include <net/protocol.h>
23 
24 #include <net/seg6.h>
25 #include <net/genetlink.h>
26 #include <linux/seg6.h>
27 #include <linux/seg6_genl.h>
28 #ifdef CONFIG_IPV6_SEG6_HMAC
29 #include <net/seg6_hmac.h>
30 #endif
31 
32 bool seg6_validate_srh(struct ipv6_sr_hdr *srh, int len)
33 {
34 	int trailing;
35 	unsigned int tlv_offset;
36 
37 	if (srh->type != IPV6_SRCRT_TYPE_4)
38 		return false;
39 
40 	if (((srh->hdrlen + 1) << 3) != len)
41 		return false;
42 
43 	if (srh->segments_left != srh->first_segment)
44 		return false;
45 
46 	tlv_offset = sizeof(*srh) + ((srh->first_segment + 1) << 4);
47 
48 	trailing = len - tlv_offset;
49 	if (trailing < 0)
50 		return false;
51 
52 	while (trailing) {
53 		struct sr6_tlv *tlv;
54 		unsigned int tlv_len;
55 
56 		if (trailing < sizeof(*tlv))
57 			return false;
58 
59 		tlv = (struct sr6_tlv *)((unsigned char *)srh + tlv_offset);
60 		tlv_len = sizeof(*tlv) + tlv->len;
61 
62 		trailing -= tlv_len;
63 		if (trailing < 0)
64 			return false;
65 
66 		tlv_offset += tlv_len;
67 	}
68 
69 	return true;
70 }
71 
72 static struct genl_family seg6_genl_family;
73 
74 static const struct nla_policy seg6_genl_policy[SEG6_ATTR_MAX + 1] = {
75 	[SEG6_ATTR_DST]				= { .type = NLA_BINARY,
76 		.len = sizeof(struct in6_addr) },
77 	[SEG6_ATTR_DSTLEN]			= { .type = NLA_S32, },
78 	[SEG6_ATTR_HMACKEYID]		= { .type = NLA_U32, },
79 	[SEG6_ATTR_SECRET]			= { .type = NLA_BINARY, },
80 	[SEG6_ATTR_SECRETLEN]		= { .type = NLA_U8, },
81 	[SEG6_ATTR_ALGID]			= { .type = NLA_U8, },
82 	[SEG6_ATTR_HMACINFO]		= { .type = NLA_NESTED, },
83 };
84 
85 #ifdef CONFIG_IPV6_SEG6_HMAC
86 
87 static int seg6_genl_sethmac(struct sk_buff *skb, struct genl_info *info)
88 {
89 	struct net *net = genl_info_net(info);
90 	struct seg6_pernet_data *sdata;
91 	struct seg6_hmac_info *hinfo;
92 	u32 hmackeyid;
93 	char *secret;
94 	int err = 0;
95 	u8 algid;
96 	u8 slen;
97 
98 	sdata = seg6_pernet(net);
99 
100 	if (!info->attrs[SEG6_ATTR_HMACKEYID] ||
101 	    !info->attrs[SEG6_ATTR_SECRETLEN] ||
102 	    !info->attrs[SEG6_ATTR_ALGID])
103 		return -EINVAL;
104 
105 	hmackeyid = nla_get_u32(info->attrs[SEG6_ATTR_HMACKEYID]);
106 	slen = nla_get_u8(info->attrs[SEG6_ATTR_SECRETLEN]);
107 	algid = nla_get_u8(info->attrs[SEG6_ATTR_ALGID]);
108 
109 	if (hmackeyid == 0)
110 		return -EINVAL;
111 
112 	if (slen > SEG6_HMAC_SECRET_LEN)
113 		return -EINVAL;
114 
115 	mutex_lock(&sdata->lock);
116 	hinfo = seg6_hmac_info_lookup(net, hmackeyid);
117 
118 	if (!slen) {
119 		if (!hinfo)
120 			err = -ENOENT;
121 
122 		err = seg6_hmac_info_del(net, hmackeyid);
123 
124 		goto out_unlock;
125 	}
126 
127 	if (!info->attrs[SEG6_ATTR_SECRET]) {
128 		err = -EINVAL;
129 		goto out_unlock;
130 	}
131 
132 	if (hinfo) {
133 		err = seg6_hmac_info_del(net, hmackeyid);
134 		if (err)
135 			goto out_unlock;
136 	}
137 
138 	secret = (char *)nla_data(info->attrs[SEG6_ATTR_SECRET]);
139 
140 	hinfo = kzalloc(sizeof(*hinfo), GFP_KERNEL);
141 	if (!hinfo) {
142 		err = -ENOMEM;
143 		goto out_unlock;
144 	}
145 
146 	memcpy(hinfo->secret, secret, slen);
147 	hinfo->slen = slen;
148 	hinfo->alg_id = algid;
149 	hinfo->hmackeyid = hmackeyid;
150 
151 	err = seg6_hmac_info_add(net, hmackeyid, hinfo);
152 	if (err)
153 		kfree(hinfo);
154 
155 out_unlock:
156 	mutex_unlock(&sdata->lock);
157 	return err;
158 }
159 
160 #else
161 
162 static int seg6_genl_sethmac(struct sk_buff *skb, struct genl_info *info)
163 {
164 	return -ENOTSUPP;
165 }
166 
167 #endif
168 
169 static int seg6_genl_set_tunsrc(struct sk_buff *skb, struct genl_info *info)
170 {
171 	struct net *net = genl_info_net(info);
172 	struct in6_addr *val, *t_old, *t_new;
173 	struct seg6_pernet_data *sdata;
174 
175 	sdata = seg6_pernet(net);
176 
177 	if (!info->attrs[SEG6_ATTR_DST])
178 		return -EINVAL;
179 
180 	val = nla_data(info->attrs[SEG6_ATTR_DST]);
181 	t_new = kmemdup(val, sizeof(*val), GFP_KERNEL);
182 	if (!t_new)
183 		return -ENOMEM;
184 
185 	mutex_lock(&sdata->lock);
186 
187 	t_old = sdata->tun_src;
188 	rcu_assign_pointer(sdata->tun_src, t_new);
189 
190 	mutex_unlock(&sdata->lock);
191 
192 	synchronize_net();
193 	kfree(t_old);
194 
195 	return 0;
196 }
197 
198 static int seg6_genl_get_tunsrc(struct sk_buff *skb, struct genl_info *info)
199 {
200 	struct net *net = genl_info_net(info);
201 	struct in6_addr *tun_src;
202 	struct sk_buff *msg;
203 	void *hdr;
204 
205 	msg = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
206 	if (!msg)
207 		return -ENOMEM;
208 
209 	hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
210 			  &seg6_genl_family, 0, SEG6_CMD_GET_TUNSRC);
211 	if (!hdr)
212 		goto free_msg;
213 
214 	rcu_read_lock();
215 	tun_src = rcu_dereference(seg6_pernet(net)->tun_src);
216 
217 	if (nla_put(msg, SEG6_ATTR_DST, sizeof(struct in6_addr), tun_src))
218 		goto nla_put_failure;
219 
220 	rcu_read_unlock();
221 
222 	genlmsg_end(msg, hdr);
223 	genlmsg_reply(msg, info);
224 
225 	return 0;
226 
227 nla_put_failure:
228 	rcu_read_unlock();
229 	genlmsg_cancel(msg, hdr);
230 free_msg:
231 	nlmsg_free(msg);
232 	return -ENOMEM;
233 }
234 
235 #ifdef CONFIG_IPV6_SEG6_HMAC
236 
237 static int __seg6_hmac_fill_info(struct seg6_hmac_info *hinfo,
238 				 struct sk_buff *msg)
239 {
240 	if (nla_put_u32(msg, SEG6_ATTR_HMACKEYID, hinfo->hmackeyid) ||
241 	    nla_put_u8(msg, SEG6_ATTR_SECRETLEN, hinfo->slen) ||
242 	    nla_put(msg, SEG6_ATTR_SECRET, hinfo->slen, hinfo->secret) ||
243 	    nla_put_u8(msg, SEG6_ATTR_ALGID, hinfo->alg_id))
244 		return -1;
245 
246 	return 0;
247 }
248 
249 static int __seg6_genl_dumphmac_element(struct seg6_hmac_info *hinfo,
250 					u32 portid, u32 seq, u32 flags,
251 					struct sk_buff *skb, u8 cmd)
252 {
253 	void *hdr;
254 
255 	hdr = genlmsg_put(skb, portid, seq, &seg6_genl_family, flags, cmd);
256 	if (!hdr)
257 		return -ENOMEM;
258 
259 	if (__seg6_hmac_fill_info(hinfo, skb) < 0)
260 		goto nla_put_failure;
261 
262 	genlmsg_end(skb, hdr);
263 	return 0;
264 
265 nla_put_failure:
266 	genlmsg_cancel(skb, hdr);
267 	return -EMSGSIZE;
268 }
269 
270 static int seg6_genl_dumphmac_start(struct netlink_callback *cb)
271 {
272 	struct net *net = sock_net(cb->skb->sk);
273 	struct seg6_pernet_data *sdata;
274 	struct rhashtable_iter *iter;
275 
276 	sdata = seg6_pernet(net);
277 	iter = (struct rhashtable_iter *)cb->args[0];
278 
279 	if (!iter) {
280 		iter = kmalloc(sizeof(*iter), GFP_KERNEL);
281 		if (!iter)
282 			return -ENOMEM;
283 
284 		cb->args[0] = (long)iter;
285 	}
286 
287 	rhashtable_walk_enter(&sdata->hmac_infos, iter);
288 
289 	return 0;
290 }
291 
292 static int seg6_genl_dumphmac_done(struct netlink_callback *cb)
293 {
294 	struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];
295 
296 	rhashtable_walk_exit(iter);
297 
298 	kfree(iter);
299 
300 	return 0;
301 }
302 
303 static int seg6_genl_dumphmac(struct sk_buff *skb, struct netlink_callback *cb)
304 {
305 	struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];
306 	struct seg6_hmac_info *hinfo;
307 	int ret;
308 
309 	ret = rhashtable_walk_start(iter);
310 	if (ret && ret != -EAGAIN)
311 		goto done;
312 
313 	for (;;) {
314 		hinfo = rhashtable_walk_next(iter);
315 
316 		if (IS_ERR(hinfo)) {
317 			if (PTR_ERR(hinfo) == -EAGAIN)
318 				continue;
319 			ret = PTR_ERR(hinfo);
320 			goto done;
321 		} else if (!hinfo) {
322 			break;
323 		}
324 
325 		ret = __seg6_genl_dumphmac_element(hinfo,
326 						   NETLINK_CB(cb->skb).portid,
327 						   cb->nlh->nlmsg_seq,
328 						   NLM_F_MULTI,
329 						   skb, SEG6_CMD_DUMPHMAC);
330 		if (ret)
331 			goto done;
332 	}
333 
334 	ret = skb->len;
335 
336 done:
337 	rhashtable_walk_stop(iter);
338 	return ret;
339 }
340 
341 #else
342 
343 static int seg6_genl_dumphmac_start(struct netlink_callback *cb)
344 {
345 	return 0;
346 }
347 
348 static int seg6_genl_dumphmac_done(struct netlink_callback *cb)
349 {
350 	return 0;
351 }
352 
353 static int seg6_genl_dumphmac(struct sk_buff *skb, struct netlink_callback *cb)
354 {
355 	return -ENOTSUPP;
356 }
357 
358 #endif
359 
360 static int __net_init seg6_net_init(struct net *net)
361 {
362 	struct seg6_pernet_data *sdata;
363 
364 	sdata = kzalloc(sizeof(*sdata), GFP_KERNEL);
365 	if (!sdata)
366 		return -ENOMEM;
367 
368 	mutex_init(&sdata->lock);
369 
370 	sdata->tun_src = kzalloc(sizeof(*sdata->tun_src), GFP_KERNEL);
371 	if (!sdata->tun_src) {
372 		kfree(sdata);
373 		return -ENOMEM;
374 	}
375 
376 	net->ipv6.seg6_data = sdata;
377 
378 #ifdef CONFIG_IPV6_SEG6_HMAC
379 	seg6_hmac_net_init(net);
380 #endif
381 
382 	return 0;
383 }
384 
385 static void __net_exit seg6_net_exit(struct net *net)
386 {
387 	struct seg6_pernet_data *sdata = seg6_pernet(net);
388 
389 #ifdef CONFIG_IPV6_SEG6_HMAC
390 	seg6_hmac_net_exit(net);
391 #endif
392 
393 	kfree(sdata->tun_src);
394 	kfree(sdata);
395 }
396 
397 static struct pernet_operations ip6_segments_ops = {
398 	.init = seg6_net_init,
399 	.exit = seg6_net_exit,
400 };
401 
402 static const struct genl_ops seg6_genl_ops[] = {
403 	{
404 		.cmd	= SEG6_CMD_SETHMAC,
405 		.doit	= seg6_genl_sethmac,
406 		.policy	= seg6_genl_policy,
407 		.flags	= GENL_ADMIN_PERM,
408 	},
409 	{
410 		.cmd	= SEG6_CMD_DUMPHMAC,
411 		.start	= seg6_genl_dumphmac_start,
412 		.dumpit	= seg6_genl_dumphmac,
413 		.done	= seg6_genl_dumphmac_done,
414 		.policy	= seg6_genl_policy,
415 		.flags	= GENL_ADMIN_PERM,
416 	},
417 	{
418 		.cmd	= SEG6_CMD_SET_TUNSRC,
419 		.doit	= seg6_genl_set_tunsrc,
420 		.policy	= seg6_genl_policy,
421 		.flags	= GENL_ADMIN_PERM,
422 	},
423 	{
424 		.cmd	= SEG6_CMD_GET_TUNSRC,
425 		.doit	= seg6_genl_get_tunsrc,
426 		.policy = seg6_genl_policy,
427 		.flags	= GENL_ADMIN_PERM,
428 	},
429 };
430 
431 static struct genl_family seg6_genl_family __ro_after_init = {
432 	.hdrsize	= 0,
433 	.name		= SEG6_GENL_NAME,
434 	.version	= SEG6_GENL_VERSION,
435 	.maxattr	= SEG6_ATTR_MAX,
436 	.netnsok	= true,
437 	.parallel_ops	= true,
438 	.ops		= seg6_genl_ops,
439 	.n_ops		= ARRAY_SIZE(seg6_genl_ops),
440 	.module		= THIS_MODULE,
441 };
442 
443 int __init seg6_init(void)
444 {
445 	int err = -ENOMEM;
446 
447 	err = genl_register_family(&seg6_genl_family);
448 	if (err)
449 		goto out;
450 
451 	err = register_pernet_subsys(&ip6_segments_ops);
452 	if (err)
453 		goto out_unregister_genl;
454 
455 #ifdef CONFIG_IPV6_SEG6_LWTUNNEL
456 	err = seg6_iptunnel_init();
457 	if (err)
458 		goto out_unregister_pernet;
459 #endif
460 
461 #ifdef CONFIG_IPV6_SEG6_HMAC
462 	err = seg6_hmac_init();
463 	if (err)
464 		goto out_unregister_iptun;
465 #endif
466 
467 	pr_info("Segment Routing with IPv6\n");
468 
469 out:
470 	return err;
471 #ifdef CONFIG_IPV6_SEG6_HMAC
472 out_unregister_iptun:
473 #ifdef CONFIG_IPV6_SEG6_LWTUNNEL
474 	seg6_iptunnel_exit();
475 #endif
476 #endif
477 #ifdef CONFIG_IPV6_SEG6_LWTUNNEL
478 out_unregister_pernet:
479 	unregister_pernet_subsys(&ip6_segments_ops);
480 #endif
481 out_unregister_genl:
482 	genl_unregister_family(&seg6_genl_family);
483 	goto out;
484 }
485 
486 void seg6_exit(void)
487 {
488 #ifdef CONFIG_IPV6_SEG6_HMAC
489 	seg6_hmac_exit();
490 #endif
491 #ifdef CONFIG_IPV6_SEG6_LWTUNNEL
492 	seg6_iptunnel_exit();
493 #endif
494 	unregister_pernet_subsys(&ip6_segments_ops);
495 	genl_unregister_family(&seg6_genl_family);
496 }
497