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