1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * ipsec.c - Check xfrm on veth inside a net-ns.
4 * Copyright (c) 2018 Dmitry Safonov
5 */
6
7 #define _GNU_SOURCE
8
9 #include <arpa/inet.h>
10 #include <asm/types.h>
11 #include <errno.h>
12 #include <fcntl.h>
13 #include <limits.h>
14 #include <linux/limits.h>
15 #include <linux/netlink.h>
16 #include <linux/random.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/veth.h>
19 #include <linux/xfrm.h>
20 #include <netinet/in.h>
21 #include <net/if.h>
22 #include <sched.h>
23 #include <stdbool.h>
24 #include <stdint.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/mman.h>
29 #include <sys/socket.h>
30 #include <sys/stat.h>
31 #include <sys/syscall.h>
32 #include <sys/types.h>
33 #include <sys/wait.h>
34 #include <time.h>
35 #include <unistd.h>
36
37 #include "../kselftest.h"
38
39 #define printk(fmt, ...) \
40 ksft_print_msg("%d[%u] " fmt "\n", getpid(), __LINE__, ##__VA_ARGS__)
41
42 #define pr_err(fmt, ...) printk(fmt ": %m", ##__VA_ARGS__)
43
44 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
45
46 #define IPV4_STR_SZ 16 /* xxx.xxx.xxx.xxx is longest + \0 */
47 #define MAX_PAYLOAD 2048
48 #define XFRM_ALGO_KEY_BUF_SIZE 512
49 #define MAX_PROCESSES (1 << 14) /* /16 mask divided by /30 subnets */
50 #define INADDR_A ((in_addr_t) 0x0a000000) /* 10.0.0.0 */
51 #define INADDR_B ((in_addr_t) 0xc0a80000) /* 192.168.0.0 */
52
53 /* /30 mask for one veth connection */
54 #define PREFIX_LEN 30
55 #define child_ip(nr) (4*nr + 1)
56 #define grchild_ip(nr) (4*nr + 2)
57
58 #define VETH_FMT "ktst-%d"
59 #define VETH_LEN 12
60
61 #define XFRM_ALGO_NR_KEYS 29
62
63 static int nsfd_parent = -1;
64 static int nsfd_childa = -1;
65 static int nsfd_childb = -1;
66 static long page_size;
67
68 /*
69 * ksft_cnt is static in kselftest, so isn't shared with children.
70 * We have to send a test result back to parent and count there.
71 * results_fd is a pipe with test feedback from children.
72 */
73 static int results_fd[2];
74
75 const unsigned int ping_delay_nsec = 50 * 1000 * 1000;
76 const unsigned int ping_timeout = 300;
77 const unsigned int ping_count = 100;
78 const unsigned int ping_success = 80;
79
80 struct xfrm_key_entry {
81 char algo_name[35];
82 int key_len;
83 };
84
85 struct xfrm_key_entry xfrm_key_entries[] = {
86 {"digest_null", 0},
87 {"ecb(cipher_null)", 0},
88 {"cbc(des)", 64},
89 {"hmac(md5)", 128},
90 {"cmac(aes)", 128},
91 {"xcbc(aes)", 128},
92 {"cbc(cast5)", 128},
93 {"cbc(serpent)", 128},
94 {"hmac(sha1)", 160},
95 {"hmac(rmd160)", 160},
96 {"cbc(des3_ede)", 192},
97 {"hmac(sha256)", 256},
98 {"cbc(aes)", 256},
99 {"cbc(camellia)", 256},
100 {"cbc(twofish)", 256},
101 {"rfc3686(ctr(aes))", 288},
102 {"hmac(sha384)", 384},
103 {"cbc(blowfish)", 448},
104 {"hmac(sha512)", 512},
105 {"rfc4106(gcm(aes))-128", 160},
106 {"rfc4543(gcm(aes))-128", 160},
107 {"rfc4309(ccm(aes))-128", 152},
108 {"rfc4106(gcm(aes))-192", 224},
109 {"rfc4543(gcm(aes))-192", 224},
110 {"rfc4309(ccm(aes))-192", 216},
111 {"rfc4106(gcm(aes))-256", 288},
112 {"rfc4543(gcm(aes))-256", 288},
113 {"rfc4309(ccm(aes))-256", 280},
114 {"rfc7539(chacha20,poly1305)-128", 0}
115 };
116
117 static void randomize_buffer(void *buf, size_t buflen)
118 {
119 int *p = (int *)buf;
120 size_t words = buflen / sizeof(int);
121 size_t leftover = buflen % sizeof(int);
122
123 if (!buflen)
124 return;
125
126 while (words--)
127 *p++ = rand();
128
129 if (leftover) {
130 int tmp = rand();
131
132 memcpy(buf + buflen - leftover, &tmp, leftover);
133 }
134
135 return;
136 }
137
138 static int unshare_open(void)
139 {
140 const char *netns_path = "/proc/self/ns/net";
141 int fd;
142
143 if (unshare(CLONE_NEWNET) != 0) {
144 pr_err("unshare()");
145 return -1;
146 }
147
148 fd = open(netns_path, O_RDONLY);
149 if (fd <= 0) {
150 pr_err("open(%s)", netns_path);
151 return -1;
152 }
153
154 return fd;
155 }
156
157 static int switch_ns(int fd)
158 {
159 if (setns(fd, CLONE_NEWNET)) {
160 pr_err("setns()");
161 return -1;
162 }
163 return 0;
164 }
165
166 /*
167 * Running the test inside a new parent net namespace to bother less
168 * about cleanup on error-path.
169 */
170 static int init_namespaces(void)
171 {
172 nsfd_parent = unshare_open();
173 if (nsfd_parent <= 0)
174 return -1;
175
176 nsfd_childa = unshare_open();
177 if (nsfd_childa <= 0)
178 return -1;
179
180 if (switch_ns(nsfd_parent))
181 return -1;
182
183 nsfd_childb = unshare_open();
184 if (nsfd_childb <= 0)
185 return -1;
186
187 if (switch_ns(nsfd_parent))
188 return -1;
189 return 0;
190 }
191
192 static int netlink_sock(int *sock, uint32_t *seq_nr, int proto)
193 {
194 if (*sock > 0) {
195 seq_nr++;
196 return 0;
197 }
198
199 *sock = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, proto);
200 if (*sock <= 0) {
201 pr_err("socket(AF_NETLINK)");
202 return -1;
203 }
204
205 randomize_buffer(seq_nr, sizeof(*seq_nr));
206
207 return 0;
208 }
209
210 static inline struct rtattr *rtattr_hdr(struct nlmsghdr *nh)
211 {
212 return (struct rtattr *)((char *)(nh) + RTA_ALIGN((nh)->nlmsg_len));
213 }
214
215 static int rtattr_pack(struct nlmsghdr *nh, size_t req_sz,
216 unsigned short rta_type, const void *payload, size_t size)
217 {
218 /* NLMSG_ALIGNTO == RTA_ALIGNTO, nlmsg_len already aligned */
219 struct rtattr *attr = rtattr_hdr(nh);
220 size_t nl_size = RTA_ALIGN(nh->nlmsg_len) + RTA_LENGTH(size);
221
222 if (req_sz < nl_size) {
223 printk("req buf is too small: %zu < %zu", req_sz, nl_size);
224 return -1;
225 }
226 nh->nlmsg_len = nl_size;
227
228 attr->rta_len = RTA_LENGTH(size);
229 attr->rta_type = rta_type;
230 memcpy(RTA_DATA(attr), payload, size);
231
232 return 0;
233 }
234
235 static struct rtattr *_rtattr_begin(struct nlmsghdr *nh, size_t req_sz,
236 unsigned short rta_type, const void *payload, size_t size)
237 {
238 struct rtattr *ret = rtattr_hdr(nh);
239
240 if (rtattr_pack(nh, req_sz, rta_type, payload, size))
241 return 0;
242
243 return ret;
244 }
245
246 static inline struct rtattr *rtattr_begin(struct nlmsghdr *nh, size_t req_sz,
247 unsigned short rta_type)
248 {
249 return _rtattr_begin(nh, req_sz, rta_type, 0, 0);
250 }
251
252 static inline void rtattr_end(struct nlmsghdr *nh, struct rtattr *attr)
253 {
254 char *nlmsg_end = (char *)nh + nh->nlmsg_len;
255
256 attr->rta_len = nlmsg_end - (char *)attr;
257 }
258
259 static int veth_pack_peerb(struct nlmsghdr *nh, size_t req_sz,
260 const char *peer, int ns)
261 {
262 struct ifinfomsg pi;
263 struct rtattr *peer_attr;
264
265 memset(&pi, 0, sizeof(pi));
266 pi.ifi_family = AF_UNSPEC;
267 pi.ifi_change = 0xFFFFFFFF;
268
269 peer_attr = _rtattr_begin(nh, req_sz, VETH_INFO_PEER, &pi, sizeof(pi));
270 if (!peer_attr)
271 return -1;
272
273 if (rtattr_pack(nh, req_sz, IFLA_IFNAME, peer, strlen(peer)))
274 return -1;
275
276 if (rtattr_pack(nh, req_sz, IFLA_NET_NS_FD, &ns, sizeof(ns)))
277 return -1;
278
279 rtattr_end(nh, peer_attr);
280
281 return 0;
282 }
283
284 static int netlink_check_answer(int sock)
285 {
286 struct nlmsgerror {
287 struct nlmsghdr hdr;
288 int error;
289 struct nlmsghdr orig_msg;
290 } answer;
291
292 if (recv(sock, &answer, sizeof(answer), 0) < 0) {
293 pr_err("recv()");
294 return -1;
295 } else if (answer.hdr.nlmsg_type != NLMSG_ERROR) {
296 printk("expected NLMSG_ERROR, got %d", (int)answer.hdr.nlmsg_type);
297 return -1;
298 } else if (answer.error) {
299 printk("NLMSG_ERROR: %d: %s",
300 answer.error, strerror(-answer.error));
301 return answer.error;
302 }
303
304 return 0;
305 }
306
307 static int veth_add(int sock, uint32_t seq, const char *peera, int ns_a,
308 const char *peerb, int ns_b)
309 {
310 uint16_t flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
311 struct {
312 struct nlmsghdr nh;
313 struct ifinfomsg info;
314 char attrbuf[MAX_PAYLOAD];
315 } req;
316 const char veth_type[] = "veth";
317 struct rtattr *link_info, *info_data;
318
319 memset(&req, 0, sizeof(req));
320 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.info));
321 req.nh.nlmsg_type = RTM_NEWLINK;
322 req.nh.nlmsg_flags = flags;
323 req.nh.nlmsg_seq = seq;
324 req.info.ifi_family = AF_UNSPEC;
325 req.info.ifi_change = 0xFFFFFFFF;
326
327 if (rtattr_pack(&req.nh, sizeof(req), IFLA_IFNAME, peera, strlen(peera)))
328 return -1;
329
330 if (rtattr_pack(&req.nh, sizeof(req), IFLA_NET_NS_FD, &ns_a, sizeof(ns_a)))
331 return -1;
332
333 link_info = rtattr_begin(&req.nh, sizeof(req), IFLA_LINKINFO);
334 if (!link_info)
335 return -1;
336
337 if (rtattr_pack(&req.nh, sizeof(req), IFLA_INFO_KIND, veth_type, sizeof(veth_type)))
338 return -1;
339
340 info_data = rtattr_begin(&req.nh, sizeof(req), IFLA_INFO_DATA);
341 if (!info_data)
342 return -1;
343
344 if (veth_pack_peerb(&req.nh, sizeof(req), peerb, ns_b))
345 return -1;
346
347 rtattr_end(&req.nh, info_data);
348 rtattr_end(&req.nh, link_info);
349
350 if (send(sock, &req, req.nh.nlmsg_len, 0) < 0) {
351 pr_err("send()");
352 return -1;
353 }
354 return netlink_check_answer(sock);
355 }
356
357 static int ip4_addr_set(int sock, uint32_t seq, const char *intf,
358 struct in_addr addr, uint8_t prefix)
359 {
360 uint16_t flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
361 struct {
362 struct nlmsghdr nh;
363 struct ifaddrmsg info;
364 char attrbuf[MAX_PAYLOAD];
365 } req;
366
367 memset(&req, 0, sizeof(req));
368 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.info));
369 req.nh.nlmsg_type = RTM_NEWADDR;
370 req.nh.nlmsg_flags = flags;
371 req.nh.nlmsg_seq = seq;
372 req.info.ifa_family = AF_INET;
373 req.info.ifa_prefixlen = prefix;
374 req.info.ifa_index = if_nametoindex(intf);
375
376 #ifdef DEBUG
377 {
378 char addr_str[IPV4_STR_SZ] = {};
379
380 strncpy(addr_str, inet_ntoa(addr), IPV4_STR_SZ - 1);
381
382 printk("ip addr set %s", addr_str);
383 }
384 #endif
385
386 if (rtattr_pack(&req.nh, sizeof(req), IFA_LOCAL, &addr, sizeof(addr)))
387 return -1;
388
389 if (rtattr_pack(&req.nh, sizeof(req), IFA_ADDRESS, &addr, sizeof(addr)))
390 return -1;
391
392 if (send(sock, &req, req.nh.nlmsg_len, 0) < 0) {
393 pr_err("send()");
394 return -1;
395 }
396 return netlink_check_answer(sock);
397 }
398
399 static int link_set_up(int sock, uint32_t seq, const char *intf)
400 {
401 struct {
402 struct nlmsghdr nh;
403 struct ifinfomsg info;
404 char attrbuf[MAX_PAYLOAD];
405 } req;
406
407 memset(&req, 0, sizeof(req));
408 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.info));
409 req.nh.nlmsg_type = RTM_NEWLINK;
410 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
411 req.nh.nlmsg_seq = seq;
412 req.info.ifi_family = AF_UNSPEC;
413 req.info.ifi_change = 0xFFFFFFFF;
414 req.info.ifi_index = if_nametoindex(intf);
415 req.info.ifi_flags = IFF_UP;
416 req.info.ifi_change = IFF_UP;
417
418 if (send(sock, &req, req.nh.nlmsg_len, 0) < 0) {
419 pr_err("send()");
420 return -1;
421 }
422 return netlink_check_answer(sock);
423 }
424
425 static int ip4_route_set(int sock, uint32_t seq, const char *intf,
426 struct in_addr src, struct in_addr dst)
427 {
428 struct {
429 struct nlmsghdr nh;
430 struct rtmsg rt;
431 char attrbuf[MAX_PAYLOAD];
432 } req;
433 unsigned int index = if_nametoindex(intf);
434
435 memset(&req, 0, sizeof(req));
436 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.rt));
437 req.nh.nlmsg_type = RTM_NEWROUTE;
438 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_CREATE;
439 req.nh.nlmsg_seq = seq;
440 req.rt.rtm_family = AF_INET;
441 req.rt.rtm_dst_len = 32;
442 req.rt.rtm_table = RT_TABLE_MAIN;
443 req.rt.rtm_protocol = RTPROT_BOOT;
444 req.rt.rtm_scope = RT_SCOPE_LINK;
445 req.rt.rtm_type = RTN_UNICAST;
446
447 if (rtattr_pack(&req.nh, sizeof(req), RTA_DST, &dst, sizeof(dst)))
448 return -1;
449
450 if (rtattr_pack(&req.nh, sizeof(req), RTA_PREFSRC, &src, sizeof(src)))
451 return -1;
452
453 if (rtattr_pack(&req.nh, sizeof(req), RTA_OIF, &index, sizeof(index)))
454 return -1;
455
456 if (send(sock, &req, req.nh.nlmsg_len, 0) < 0) {
457 pr_err("send()");
458 return -1;
459 }
460
461 return netlink_check_answer(sock);
462 }
463
464 static int tunnel_set_route(int route_sock, uint32_t *route_seq, char *veth,
465 struct in_addr tunsrc, struct in_addr tundst)
466 {
467 if (ip4_addr_set(route_sock, (*route_seq)++, "lo",
468 tunsrc, PREFIX_LEN)) {
469 printk("Failed to set ipv4 addr");
470 return -1;
471 }
472
473 if (ip4_route_set(route_sock, (*route_seq)++, veth, tunsrc, tundst)) {
474 printk("Failed to set ipv4 route");
475 return -1;
476 }
477
478 return 0;
479 }
480
481 static int init_child(int nsfd, char *veth, unsigned int src, unsigned int dst)
482 {
483 struct in_addr intsrc = inet_makeaddr(INADDR_B, src);
484 struct in_addr tunsrc = inet_makeaddr(INADDR_A, src);
485 struct in_addr tundst = inet_makeaddr(INADDR_A, dst);
486 int route_sock = -1, ret = -1;
487 uint32_t route_seq;
488
489 if (switch_ns(nsfd))
490 return -1;
491
492 if (netlink_sock(&route_sock, &route_seq, NETLINK_ROUTE)) {
493 printk("Failed to open netlink route socket in child");
494 return -1;
495 }
496
497 if (ip4_addr_set(route_sock, route_seq++, veth, intsrc, PREFIX_LEN)) {
498 printk("Failed to set ipv4 addr");
499 goto err;
500 }
501
502 if (link_set_up(route_sock, route_seq++, veth)) {
503 printk("Failed to bring up %s", veth);
504 goto err;
505 }
506
507 if (tunnel_set_route(route_sock, &route_seq, veth, tunsrc, tundst)) {
508 printk("Failed to add tunnel route on %s", veth);
509 goto err;
510 }
511 ret = 0;
512
513 err:
514 close(route_sock);
515 return ret;
516 }
517
518 #define ALGO_LEN 64
519 enum desc_type {
520 CREATE_TUNNEL = 0,
521 ALLOCATE_SPI,
522 MONITOR_ACQUIRE,
523 EXPIRE_STATE,
524 EXPIRE_POLICY,
525 SPDINFO_ATTRS,
526 };
527 const char *desc_name[] = {
528 "create tunnel",
529 "alloc spi",
530 "monitor acquire",
531 "expire state",
532 "expire policy",
533 "spdinfo attributes",
534 ""
535 };
536 struct xfrm_desc {
537 enum desc_type type;
538 uint8_t proto;
539 char a_algo[ALGO_LEN];
540 char e_algo[ALGO_LEN];
541 char c_algo[ALGO_LEN];
542 char ae_algo[ALGO_LEN];
543 unsigned int icv_len;
544 /* unsigned key_len; */
545 };
546
547 enum msg_type {
548 MSG_ACK = 0,
549 MSG_EXIT,
550 MSG_PING,
551 MSG_XFRM_PREPARE,
552 MSG_XFRM_ADD,
553 MSG_XFRM_DEL,
554 MSG_XFRM_CLEANUP,
555 };
556
557 struct test_desc {
558 enum msg_type type;
559 union {
560 struct {
561 in_addr_t reply_ip;
562 unsigned int port;
563 } ping;
564 struct xfrm_desc xfrm_desc;
565 } body;
566 };
567
568 struct test_result {
569 struct xfrm_desc desc;
570 unsigned int res;
571 };
572
573 static void write_test_result(unsigned int res, struct xfrm_desc *d)
574 {
575 struct test_result tr = {};
576 ssize_t ret;
577
578 tr.desc = *d;
579 tr.res = res;
580
581 ret = write(results_fd[1], &tr, sizeof(tr));
582 if (ret != sizeof(tr))
583 pr_err("Failed to write the result in pipe %zd", ret);
584 }
585
586 static void write_msg(int fd, struct test_desc *msg, bool exit_of_fail)
587 {
588 ssize_t bytes = write(fd, msg, sizeof(*msg));
589
590 /* Make sure that write/read is atomic to a pipe */
591 BUILD_BUG_ON(sizeof(struct test_desc) > PIPE_BUF);
592
593 if (bytes < 0) {
594 pr_err("write()");
595 if (exit_of_fail)
596 exit(KSFT_FAIL);
597 }
598 if (bytes != sizeof(*msg)) {
599 pr_err("sent part of the message %zd/%zu", bytes, sizeof(*msg));
600 if (exit_of_fail)
601 exit(KSFT_FAIL);
602 }
603 }
604
605 static void read_msg(int fd, struct test_desc *msg, bool exit_of_fail)
606 {
607 ssize_t bytes = read(fd, msg, sizeof(*msg));
608
609 if (bytes < 0) {
610 pr_err("read()");
611 if (exit_of_fail)
612 exit(KSFT_FAIL);
613 }
614 if (bytes != sizeof(*msg)) {
615 pr_err("got incomplete message %zd/%zu", bytes, sizeof(*msg));
616 if (exit_of_fail)
617 exit(KSFT_FAIL);
618 }
619 }
620
621 static int udp_ping_init(struct in_addr listen_ip, unsigned int u_timeout,
622 unsigned int *server_port, int sock[2])
623 {
624 struct sockaddr_in server;
625 struct timeval t = { .tv_sec = 0, .tv_usec = u_timeout };
626 socklen_t s_len = sizeof(server);
627
628 sock[0] = socket(AF_INET, SOCK_DGRAM, 0);
629 if (sock[0] < 0) {
630 pr_err("socket()");
631 return -1;
632 }
633
634 server.sin_family = AF_INET;
635 server.sin_port = 0;
636 memcpy(&server.sin_addr.s_addr, &listen_ip, sizeof(struct in_addr));
637
638 if (bind(sock[0], (struct sockaddr *)&server, s_len)) {
639 pr_err("bind()");
640 goto err_close_server;
641 }
642
643 if (getsockname(sock[0], (struct sockaddr *)&server, &s_len)) {
644 pr_err("getsockname()");
645 goto err_close_server;
646 }
647
648 *server_port = ntohs(server.sin_port);
649
650 if (setsockopt(sock[0], SOL_SOCKET, SO_RCVTIMEO, (const char *)&t, sizeof t)) {
651 pr_err("setsockopt()");
652 goto err_close_server;
653 }
654
655 sock[1] = socket(AF_INET, SOCK_DGRAM, 0);
656 if (sock[1] < 0) {
657 pr_err("socket()");
658 goto err_close_server;
659 }
660
661 return 0;
662
663 err_close_server:
664 close(sock[0]);
665 return -1;
666 }
667
668 static int udp_ping_send(int sock[2], in_addr_t dest_ip, unsigned int port,
669 char *buf, size_t buf_len)
670 {
671 struct sockaddr_in server;
672 const struct sockaddr *dest_addr = (struct sockaddr *)&server;
673 char *sock_buf[buf_len];
674 ssize_t r_bytes, s_bytes;
675
676 server.sin_family = AF_INET;
677 server.sin_port = htons(port);
678 server.sin_addr.s_addr = dest_ip;
679
680 s_bytes = sendto(sock[1], buf, buf_len, 0, dest_addr, sizeof(server));
681 if (s_bytes < 0) {
682 pr_err("sendto()");
683 return -1;
684 } else if (s_bytes != buf_len) {
685 printk("send part of the message: %zd/%zu", s_bytes, sizeof(server));
686 return -1;
687 }
688
689 r_bytes = recv(sock[0], sock_buf, buf_len, 0);
690 if (r_bytes < 0) {
691 if (errno != EAGAIN)
692 pr_err("recv()");
693 return -1;
694 } else if (r_bytes == 0) { /* EOF */
695 printk("EOF on reply to ping");
696 return -1;
697 } else if (r_bytes != buf_len || memcmp(buf, sock_buf, buf_len)) {
698 printk("ping reply packet is corrupted %zd/%zu", r_bytes, buf_len);
699 return -1;
700 }
701
702 return 0;
703 }
704
705 static int udp_ping_reply(int sock[2], in_addr_t dest_ip, unsigned int port,
706 char *buf, size_t buf_len)
707 {
708 struct sockaddr_in server;
709 const struct sockaddr *dest_addr = (struct sockaddr *)&server;
710 char *sock_buf[buf_len];
711 ssize_t r_bytes, s_bytes;
712
713 server.sin_family = AF_INET;
714 server.sin_port = htons(port);
715 server.sin_addr.s_addr = dest_ip;
716
717 r_bytes = recv(sock[0], sock_buf, buf_len, 0);
718 if (r_bytes < 0) {
719 if (errno != EAGAIN)
720 pr_err("recv()");
721 return -1;
722 }
723 if (r_bytes == 0) { /* EOF */
724 printk("EOF on reply to ping");
725 return -1;
726 }
727 if (r_bytes != buf_len || memcmp(buf, sock_buf, buf_len)) {
728 printk("ping reply packet is corrupted %zd/%zu", r_bytes, buf_len);
729 return -1;
730 }
731
732 s_bytes = sendto(sock[1], buf, buf_len, 0, dest_addr, sizeof(server));
733 if (s_bytes < 0) {
734 pr_err("sendto()");
735 return -1;
736 } else if (s_bytes != buf_len) {
737 printk("send part of the message: %zd/%zu", s_bytes, sizeof(server));
738 return -1;
739 }
740
741 return 0;
742 }
743
744 typedef int (*ping_f)(int sock[2], in_addr_t dest_ip, unsigned int port,
745 char *buf, size_t buf_len);
746 static int do_ping(int cmd_fd, char *buf, size_t buf_len, struct in_addr from,
747 bool init_side, int d_port, in_addr_t to, ping_f func)
748 {
749 struct test_desc msg;
750 unsigned int s_port, i, ping_succeeded = 0;
751 int ping_sock[2];
752 char to_str[IPV4_STR_SZ] = {}, from_str[IPV4_STR_SZ] = {};
753
754 if (udp_ping_init(from, ping_timeout, &s_port, ping_sock)) {
755 printk("Failed to init ping");
756 return -1;
757 }
758
759 memset(&msg, 0, sizeof(msg));
760 msg.type = MSG_PING;
761 msg.body.ping.port = s_port;
762 memcpy(&msg.body.ping.reply_ip, &from, sizeof(from));
763
764 write_msg(cmd_fd, &msg, 0);
765 if (init_side) {
766 /* The other end sends ip to ping */
767 read_msg(cmd_fd, &msg, 0);
768 if (msg.type != MSG_PING)
769 return -1;
770 to = msg.body.ping.reply_ip;
771 d_port = msg.body.ping.port;
772 }
773
774 for (i = 0; i < ping_count ; i++) {
775 struct timespec sleep_time = {
776 .tv_sec = 0,
777 .tv_nsec = ping_delay_nsec,
778 };
779
780 ping_succeeded += !func(ping_sock, to, d_port, buf, page_size);
781 nanosleep(&sleep_time, 0);
782 }
783
784 close(ping_sock[0]);
785 close(ping_sock[1]);
786
787 strncpy(to_str, inet_ntoa(*(struct in_addr *)&to), IPV4_STR_SZ - 1);
788 strncpy(from_str, inet_ntoa(from), IPV4_STR_SZ - 1);
789
790 if (ping_succeeded < ping_success) {
791 printk("ping (%s) %s->%s failed %u/%u times",
792 init_side ? "send" : "reply", from_str, to_str,
793 ping_count - ping_succeeded, ping_count);
794 return -1;
795 }
796
797 #ifdef DEBUG
798 printk("ping (%s) %s->%s succeeded %u/%u times",
799 init_side ? "send" : "reply", from_str, to_str,
800 ping_succeeded, ping_count);
801 #endif
802
803 return 0;
804 }
805
806 static int xfrm_fill_key(char *name, char *buf,
807 size_t buf_len, unsigned int *key_len)
808 {
809 int i;
810
811 for (i = 0; i < XFRM_ALGO_NR_KEYS; i++) {
812 if (strncmp(name, xfrm_key_entries[i].algo_name, ALGO_LEN) == 0)
813 *key_len = xfrm_key_entries[i].key_len;
814 }
815
816 if (*key_len > buf_len) {
817 printk("Can't pack a key - too big for buffer");
818 return -1;
819 }
820
821 randomize_buffer(buf, *key_len);
822
823 return 0;
824 }
825
826 static int xfrm_state_pack_algo(struct nlmsghdr *nh, size_t req_sz,
827 struct xfrm_desc *desc)
828 {
829 struct {
830 union {
831 struct xfrm_algo alg;
832 struct xfrm_algo_aead aead;
833 struct xfrm_algo_auth auth;
834 } u;
835 char buf[XFRM_ALGO_KEY_BUF_SIZE];
836 } alg = {};
837 size_t alen, elen, clen, aelen;
838 unsigned short type;
839
840 alen = strlen(desc->a_algo);
841 elen = strlen(desc->e_algo);
842 clen = strlen(desc->c_algo);
843 aelen = strlen(desc->ae_algo);
844
845 /* Verify desc */
846 switch (desc->proto) {
847 case IPPROTO_AH:
848 if (!alen || elen || clen || aelen) {
849 printk("BUG: buggy ah desc");
850 return -1;
851 }
852 strncpy(alg.u.alg.alg_name, desc->a_algo, ALGO_LEN - 1);
853 if (xfrm_fill_key(desc->a_algo, alg.u.alg.alg_key,
854 sizeof(alg.buf), &alg.u.alg.alg_key_len))
855 return -1;
856 type = XFRMA_ALG_AUTH;
857 break;
858 case IPPROTO_COMP:
859 if (!clen || elen || alen || aelen) {
860 printk("BUG: buggy comp desc");
861 return -1;
862 }
863 strncpy(alg.u.alg.alg_name, desc->c_algo, ALGO_LEN - 1);
864 if (xfrm_fill_key(desc->c_algo, alg.u.alg.alg_key,
865 sizeof(alg.buf), &alg.u.alg.alg_key_len))
866 return -1;
867 type = XFRMA_ALG_COMP;
868 break;
869 case IPPROTO_ESP:
870 if (!((alen && elen) ^ aelen) || clen) {
871 printk("BUG: buggy esp desc");
872 return -1;
873 }
874 if (aelen) {
875 alg.u.aead.alg_icv_len = desc->icv_len;
876 strncpy(alg.u.aead.alg_name, desc->ae_algo, ALGO_LEN - 1);
877 if (xfrm_fill_key(desc->ae_algo, alg.u.aead.alg_key,
878 sizeof(alg.buf), &alg.u.aead.alg_key_len))
879 return -1;
880 type = XFRMA_ALG_AEAD;
881 } else {
882
883 strncpy(alg.u.alg.alg_name, desc->e_algo, ALGO_LEN - 1);
884 type = XFRMA_ALG_CRYPT;
885 if (xfrm_fill_key(desc->e_algo, alg.u.alg.alg_key,
886 sizeof(alg.buf), &alg.u.alg.alg_key_len))
887 return -1;
888 if (rtattr_pack(nh, req_sz, type, &alg, sizeof(alg)))
889 return -1;
890
891 strncpy(alg.u.alg.alg_name, desc->a_algo, ALGO_LEN);
892 type = XFRMA_ALG_AUTH;
893 if (xfrm_fill_key(desc->a_algo, alg.u.alg.alg_key,
894 sizeof(alg.buf), &alg.u.alg.alg_key_len))
895 return -1;
896 }
897 break;
898 default:
899 printk("BUG: unknown proto in desc");
900 return -1;
901 }
902
903 if (rtattr_pack(nh, req_sz, type, &alg, sizeof(alg)))
904 return -1;
905
906 return 0;
907 }
908
909 static inline uint32_t gen_spi(struct in_addr src)
910 {
911 return htonl(inet_lnaof(src));
912 }
913
914 static int xfrm_state_add(int xfrm_sock, uint32_t seq, uint32_t spi,
915 struct in_addr src, struct in_addr dst,
916 struct xfrm_desc *desc)
917 {
918 struct {
919 struct nlmsghdr nh;
920 struct xfrm_usersa_info info;
921 char attrbuf[MAX_PAYLOAD];
922 } req;
923
924 memset(&req, 0, sizeof(req));
925 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.info));
926 req.nh.nlmsg_type = XFRM_MSG_NEWSA;
927 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
928 req.nh.nlmsg_seq = seq;
929
930 /* Fill selector. */
931 memcpy(&req.info.sel.daddr, &dst, sizeof(dst));
932 memcpy(&req.info.sel.saddr, &src, sizeof(src));
933 req.info.sel.family = AF_INET;
934 req.info.sel.prefixlen_d = PREFIX_LEN;
935 req.info.sel.prefixlen_s = PREFIX_LEN;
936
937 /* Fill id */
938 memcpy(&req.info.id.daddr, &dst, sizeof(dst));
939 /* Note: zero-spi cannot be deleted */
940 req.info.id.spi = spi;
941 req.info.id.proto = desc->proto;
942
943 memcpy(&req.info.saddr, &src, sizeof(src));
944
945 /* Fill lifteme_cfg */
946 req.info.lft.soft_byte_limit = XFRM_INF;
947 req.info.lft.hard_byte_limit = XFRM_INF;
948 req.info.lft.soft_packet_limit = XFRM_INF;
949 req.info.lft.hard_packet_limit = XFRM_INF;
950
951 req.info.family = AF_INET;
952 req.info.mode = XFRM_MODE_TUNNEL;
953
954 if (xfrm_state_pack_algo(&req.nh, sizeof(req), desc))
955 return -1;
956
957 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
958 pr_err("send()");
959 return -1;
960 }
961
962 return netlink_check_answer(xfrm_sock);
963 }
964
965 static bool xfrm_usersa_found(struct xfrm_usersa_info *info, uint32_t spi,
966 struct in_addr src, struct in_addr dst,
967 struct xfrm_desc *desc)
968 {
969 if (memcmp(&info->sel.daddr, &dst, sizeof(dst)))
970 return false;
971
972 if (memcmp(&info->sel.saddr, &src, sizeof(src)))
973 return false;
974
975 if (info->sel.family != AF_INET ||
976 info->sel.prefixlen_d != PREFIX_LEN ||
977 info->sel.prefixlen_s != PREFIX_LEN)
978 return false;
979
980 if (info->id.spi != spi || info->id.proto != desc->proto)
981 return false;
982
983 if (memcmp(&info->id.daddr, &dst, sizeof(dst)))
984 return false;
985
986 if (memcmp(&info->saddr, &src, sizeof(src)))
987 return false;
988
989 if (info->lft.soft_byte_limit != XFRM_INF ||
990 info->lft.hard_byte_limit != XFRM_INF ||
991 info->lft.soft_packet_limit != XFRM_INF ||
992 info->lft.hard_packet_limit != XFRM_INF)
993 return false;
994
995 if (info->family != AF_INET || info->mode != XFRM_MODE_TUNNEL)
996 return false;
997
998 /* XXX: check xfrm algo, see xfrm_state_pack_algo(). */
999
1000 return true;
1001 }
1002
1003 static int xfrm_state_check(int xfrm_sock, uint32_t seq, uint32_t spi,
1004 struct in_addr src, struct in_addr dst,
1005 struct xfrm_desc *desc)
1006 {
1007 struct {
1008 struct nlmsghdr nh;
1009 char attrbuf[MAX_PAYLOAD];
1010 } req;
1011 struct {
1012 struct nlmsghdr nh;
1013 union {
1014 struct xfrm_usersa_info info;
1015 int error;
1016 };
1017 char attrbuf[MAX_PAYLOAD];
1018 } answer;
1019 struct xfrm_address_filter filter = {};
1020 bool found = false;
1021
1022
1023 memset(&req, 0, sizeof(req));
1024 req.nh.nlmsg_len = NLMSG_LENGTH(0);
1025 req.nh.nlmsg_type = XFRM_MSG_GETSA;
1026 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
1027 req.nh.nlmsg_seq = seq;
1028
1029 /*
1030 * Add dump filter by source address as there may be other tunnels
1031 * in this netns (if tests run in parallel).
1032 */
1033 filter.family = AF_INET;
1034 filter.splen = 0x1f; /* 0xffffffff mask see addr_match() */
1035 memcpy(&filter.saddr, &src, sizeof(src));
1036 if (rtattr_pack(&req.nh, sizeof(req), XFRMA_ADDRESS_FILTER,
1037 &filter, sizeof(filter)))
1038 return -1;
1039
1040 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1041 pr_err("send()");
1042 return -1;
1043 }
1044
1045 while (1) {
1046 if (recv(xfrm_sock, &answer, sizeof(answer), 0) < 0) {
1047 pr_err("recv()");
1048 return -1;
1049 }
1050 if (answer.nh.nlmsg_type == NLMSG_ERROR) {
1051 printk("NLMSG_ERROR: %d: %s",
1052 answer.error, strerror(-answer.error));
1053 return -1;
1054 } else if (answer.nh.nlmsg_type == NLMSG_DONE) {
1055 if (found)
1056 return 0;
1057 printk("didn't find allocated xfrm state in dump");
1058 return -1;
1059 } else if (answer.nh.nlmsg_type == XFRM_MSG_NEWSA) {
1060 if (xfrm_usersa_found(&answer.info, spi, src, dst, desc))
1061 found = true;
1062 }
1063 }
1064 }
1065
1066 static int xfrm_set(int xfrm_sock, uint32_t *seq,
1067 struct in_addr src, struct in_addr dst,
1068 struct in_addr tunsrc, struct in_addr tundst,
1069 struct xfrm_desc *desc)
1070 {
1071 int err;
1072
1073 err = xfrm_state_add(xfrm_sock, (*seq)++, gen_spi(src), src, dst, desc);
1074 if (err) {
1075 printk("Failed to add xfrm state");
1076 return -1;
1077 }
1078
1079 err = xfrm_state_add(xfrm_sock, (*seq)++, gen_spi(src), dst, src, desc);
1080 if (err) {
1081 printk("Failed to add xfrm state");
1082 return -1;
1083 }
1084
1085 /* Check dumps for XFRM_MSG_GETSA */
1086 err = xfrm_state_check(xfrm_sock, (*seq)++, gen_spi(src), src, dst, desc);
1087 err |= xfrm_state_check(xfrm_sock, (*seq)++, gen_spi(src), dst, src, desc);
1088 if (err) {
1089 printk("Failed to check xfrm state");
1090 return -1;
1091 }
1092
1093 return 0;
1094 }
1095
1096 static int xfrm_policy_add(int xfrm_sock, uint32_t seq, uint32_t spi,
1097 struct in_addr src, struct in_addr dst, uint8_t dir,
1098 struct in_addr tunsrc, struct in_addr tundst, uint8_t proto)
1099 {
1100 struct {
1101 struct nlmsghdr nh;
1102 struct xfrm_userpolicy_info info;
1103 char attrbuf[MAX_PAYLOAD];
1104 } req;
1105 struct xfrm_user_tmpl tmpl;
1106
1107 memset(&req, 0, sizeof(req));
1108 memset(&tmpl, 0, sizeof(tmpl));
1109 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.info));
1110 req.nh.nlmsg_type = XFRM_MSG_NEWPOLICY;
1111 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1112 req.nh.nlmsg_seq = seq;
1113
1114 /* Fill selector. */
1115 memcpy(&req.info.sel.daddr, &dst, sizeof(tundst));
1116 memcpy(&req.info.sel.saddr, &src, sizeof(tunsrc));
1117 req.info.sel.family = AF_INET;
1118 req.info.sel.prefixlen_d = PREFIX_LEN;
1119 req.info.sel.prefixlen_s = PREFIX_LEN;
1120
1121 /* Fill lifteme_cfg */
1122 req.info.lft.soft_byte_limit = XFRM_INF;
1123 req.info.lft.hard_byte_limit = XFRM_INF;
1124 req.info.lft.soft_packet_limit = XFRM_INF;
1125 req.info.lft.hard_packet_limit = XFRM_INF;
1126
1127 req.info.dir = dir;
1128
1129 /* Fill tmpl */
1130 memcpy(&tmpl.id.daddr, &dst, sizeof(dst));
1131 /* Note: zero-spi cannot be deleted */
1132 tmpl.id.spi = spi;
1133 tmpl.id.proto = proto;
1134 tmpl.family = AF_INET;
1135 memcpy(&tmpl.saddr, &src, sizeof(src));
1136 tmpl.mode = XFRM_MODE_TUNNEL;
1137 tmpl.aalgos = (~(uint32_t)0);
1138 tmpl.ealgos = (~(uint32_t)0);
1139 tmpl.calgos = (~(uint32_t)0);
1140
1141 if (rtattr_pack(&req.nh, sizeof(req), XFRMA_TMPL, &tmpl, sizeof(tmpl)))
1142 return -1;
1143
1144 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1145 pr_err("send()");
1146 return -1;
1147 }
1148
1149 return netlink_check_answer(xfrm_sock);
1150 }
1151
1152 static int xfrm_prepare(int xfrm_sock, uint32_t *seq,
1153 struct in_addr src, struct in_addr dst,
1154 struct in_addr tunsrc, struct in_addr tundst, uint8_t proto)
1155 {
1156 if (xfrm_policy_add(xfrm_sock, (*seq)++, gen_spi(src), src, dst,
1157 XFRM_POLICY_OUT, tunsrc, tundst, proto)) {
1158 printk("Failed to add xfrm policy");
1159 return -1;
1160 }
1161
1162 if (xfrm_policy_add(xfrm_sock, (*seq)++, gen_spi(src), dst, src,
1163 XFRM_POLICY_IN, tunsrc, tundst, proto)) {
1164 printk("Failed to add xfrm policy");
1165 return -1;
1166 }
1167
1168 return 0;
1169 }
1170
1171 static int xfrm_policy_del(int xfrm_sock, uint32_t seq,
1172 struct in_addr src, struct in_addr dst, uint8_t dir,
1173 struct in_addr tunsrc, struct in_addr tundst)
1174 {
1175 struct {
1176 struct nlmsghdr nh;
1177 struct xfrm_userpolicy_id id;
1178 char attrbuf[MAX_PAYLOAD];
1179 } req;
1180
1181 memset(&req, 0, sizeof(req));
1182 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.id));
1183 req.nh.nlmsg_type = XFRM_MSG_DELPOLICY;
1184 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1185 req.nh.nlmsg_seq = seq;
1186
1187 /* Fill id */
1188 memcpy(&req.id.sel.daddr, &dst, sizeof(tundst));
1189 memcpy(&req.id.sel.saddr, &src, sizeof(tunsrc));
1190 req.id.sel.family = AF_INET;
1191 req.id.sel.prefixlen_d = PREFIX_LEN;
1192 req.id.sel.prefixlen_s = PREFIX_LEN;
1193 req.id.dir = dir;
1194
1195 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1196 pr_err("send()");
1197 return -1;
1198 }
1199
1200 return netlink_check_answer(xfrm_sock);
1201 }
1202
1203 static int xfrm_cleanup(int xfrm_sock, uint32_t *seq,
1204 struct in_addr src, struct in_addr dst,
1205 struct in_addr tunsrc, struct in_addr tundst)
1206 {
1207 if (xfrm_policy_del(xfrm_sock, (*seq)++, src, dst,
1208 XFRM_POLICY_OUT, tunsrc, tundst)) {
1209 printk("Failed to add xfrm policy");
1210 return -1;
1211 }
1212
1213 if (xfrm_policy_del(xfrm_sock, (*seq)++, dst, src,
1214 XFRM_POLICY_IN, tunsrc, tundst)) {
1215 printk("Failed to add xfrm policy");
1216 return -1;
1217 }
1218
1219 return 0;
1220 }
1221
1222 static int xfrm_state_del(int xfrm_sock, uint32_t seq, uint32_t spi,
1223 struct in_addr src, struct in_addr dst, uint8_t proto)
1224 {
1225 struct {
1226 struct nlmsghdr nh;
1227 struct xfrm_usersa_id id;
1228 char attrbuf[MAX_PAYLOAD];
1229 } req;
1230 xfrm_address_t saddr = {};
1231
1232 memset(&req, 0, sizeof(req));
1233 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.id));
1234 req.nh.nlmsg_type = XFRM_MSG_DELSA;
1235 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1236 req.nh.nlmsg_seq = seq;
1237
1238 memcpy(&req.id.daddr, &dst, sizeof(dst));
1239 req.id.family = AF_INET;
1240 req.id.proto = proto;
1241 /* Note: zero-spi cannot be deleted */
1242 req.id.spi = spi;
1243
1244 memcpy(&saddr, &src, sizeof(src));
1245 if (rtattr_pack(&req.nh, sizeof(req), XFRMA_SRCADDR, &saddr, sizeof(saddr)))
1246 return -1;
1247
1248 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1249 pr_err("send()");
1250 return -1;
1251 }
1252
1253 return netlink_check_answer(xfrm_sock);
1254 }
1255
1256 static int xfrm_delete(int xfrm_sock, uint32_t *seq,
1257 struct in_addr src, struct in_addr dst,
1258 struct in_addr tunsrc, struct in_addr tundst, uint8_t proto)
1259 {
1260 if (xfrm_state_del(xfrm_sock, (*seq)++, gen_spi(src), src, dst, proto)) {
1261 printk("Failed to remove xfrm state");
1262 return -1;
1263 }
1264
1265 if (xfrm_state_del(xfrm_sock, (*seq)++, gen_spi(src), dst, src, proto)) {
1266 printk("Failed to remove xfrm state");
1267 return -1;
1268 }
1269
1270 return 0;
1271 }
1272
1273 static int xfrm_state_allocspi(int xfrm_sock, uint32_t *seq,
1274 uint32_t spi, uint8_t proto)
1275 {
1276 struct {
1277 struct nlmsghdr nh;
1278 struct xfrm_userspi_info spi;
1279 } req;
1280 struct {
1281 struct nlmsghdr nh;
1282 union {
1283 struct xfrm_usersa_info info;
1284 int error;
1285 };
1286 } answer;
1287
1288 memset(&req, 0, sizeof(req));
1289 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.spi));
1290 req.nh.nlmsg_type = XFRM_MSG_ALLOCSPI;
1291 req.nh.nlmsg_flags = NLM_F_REQUEST;
1292 req.nh.nlmsg_seq = (*seq)++;
1293
1294 req.spi.info.family = AF_INET;
1295 req.spi.min = spi;
1296 req.spi.max = spi;
1297 req.spi.info.id.proto = proto;
1298
1299 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1300 pr_err("send()");
1301 return KSFT_FAIL;
1302 }
1303
1304 if (recv(xfrm_sock, &answer, sizeof(answer), 0) < 0) {
1305 pr_err("recv()");
1306 return KSFT_FAIL;
1307 } else if (answer.nh.nlmsg_type == XFRM_MSG_NEWSA) {
1308 uint32_t new_spi = htonl(answer.info.id.spi);
1309
1310 if (new_spi != spi) {
1311 printk("allocated spi is different from requested: %#x != %#x",
1312 new_spi, spi);
1313 return KSFT_FAIL;
1314 }
1315 return KSFT_PASS;
1316 } else if (answer.nh.nlmsg_type != NLMSG_ERROR) {
1317 printk("expected NLMSG_ERROR, got %d", (int)answer.nh.nlmsg_type);
1318 return KSFT_FAIL;
1319 }
1320
1321 printk("NLMSG_ERROR: %d: %s", answer.error, strerror(-answer.error));
1322 return (answer.error) ? KSFT_FAIL : KSFT_PASS;
1323 }
1324
1325 static int netlink_sock_bind(int *sock, uint32_t *seq, int proto, uint32_t groups)
1326 {
1327 struct sockaddr_nl snl = {};
1328 socklen_t addr_len;
1329 int ret = -1;
1330
1331 snl.nl_family = AF_NETLINK;
1332 snl.nl_groups = groups;
1333
1334 if (netlink_sock(sock, seq, proto)) {
1335 printk("Failed to open xfrm netlink socket");
1336 return -1;
1337 }
1338
1339 if (bind(*sock, (struct sockaddr *)&snl, sizeof(snl)) < 0) {
1340 pr_err("bind()");
1341 goto out_close;
1342 }
1343
1344 addr_len = sizeof(snl);
1345 if (getsockname(*sock, (struct sockaddr *)&snl, &addr_len) < 0) {
1346 pr_err("getsockname()");
1347 goto out_close;
1348 }
1349 if (addr_len != sizeof(snl)) {
1350 printk("Wrong address length %d", addr_len);
1351 goto out_close;
1352 }
1353 if (snl.nl_family != AF_NETLINK) {
1354 printk("Wrong address family %d", snl.nl_family);
1355 goto out_close;
1356 }
1357 return 0;
1358
1359 out_close:
1360 close(*sock);
1361 return ret;
1362 }
1363
1364 static int xfrm_monitor_acquire(int xfrm_sock, uint32_t *seq, unsigned int nr)
1365 {
1366 struct {
1367 struct nlmsghdr nh;
1368 union {
1369 struct xfrm_user_acquire acq;
1370 int error;
1371 };
1372 char attrbuf[MAX_PAYLOAD];
1373 } req;
1374 struct xfrm_user_tmpl xfrm_tmpl = {};
1375 int xfrm_listen = -1, ret = KSFT_FAIL;
1376 uint32_t seq_listen;
1377
1378 if (netlink_sock_bind(&xfrm_listen, &seq_listen, NETLINK_XFRM, XFRMNLGRP_ACQUIRE))
1379 return KSFT_FAIL;
1380
1381 memset(&req, 0, sizeof(req));
1382 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.acq));
1383 req.nh.nlmsg_type = XFRM_MSG_ACQUIRE;
1384 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1385 req.nh.nlmsg_seq = (*seq)++;
1386
1387 req.acq.policy.sel.family = AF_INET;
1388 req.acq.aalgos = 0xfeed;
1389 req.acq.ealgos = 0xbaad;
1390 req.acq.calgos = 0xbabe;
1391
1392 xfrm_tmpl.family = AF_INET;
1393 xfrm_tmpl.id.proto = IPPROTO_ESP;
1394 if (rtattr_pack(&req.nh, sizeof(req), XFRMA_TMPL, &xfrm_tmpl, sizeof(xfrm_tmpl)))
1395 goto out_close;
1396
1397 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1398 pr_err("send()");
1399 goto out_close;
1400 }
1401
1402 if (recv(xfrm_sock, &req, sizeof(req), 0) < 0) {
1403 pr_err("recv()");
1404 goto out_close;
1405 } else if (req.nh.nlmsg_type != NLMSG_ERROR) {
1406 printk("expected NLMSG_ERROR, got %d", (int)req.nh.nlmsg_type);
1407 goto out_close;
1408 }
1409
1410 if (req.error) {
1411 printk("NLMSG_ERROR: %d: %s", req.error, strerror(-req.error));
1412 ret = req.error;
1413 goto out_close;
1414 }
1415
1416 if (recv(xfrm_listen, &req, sizeof(req), 0) < 0) {
1417 pr_err("recv()");
1418 goto out_close;
1419 }
1420
1421 if (req.acq.aalgos != 0xfeed || req.acq.ealgos != 0xbaad
1422 || req.acq.calgos != 0xbabe) {
1423 printk("xfrm_user_acquire has changed %x %x %x",
1424 req.acq.aalgos, req.acq.ealgos, req.acq.calgos);
1425 goto out_close;
1426 }
1427
1428 ret = KSFT_PASS;
1429 out_close:
1430 close(xfrm_listen);
1431 return ret;
1432 }
1433
1434 static int xfrm_expire_state(int xfrm_sock, uint32_t *seq,
1435 unsigned int nr, struct xfrm_desc *desc)
1436 {
1437 struct {
1438 struct nlmsghdr nh;
1439 union {
1440 struct xfrm_user_expire expire;
1441 int error;
1442 };
1443 } req;
1444 struct in_addr src, dst;
1445 int xfrm_listen = -1, ret = KSFT_FAIL;
1446 uint32_t seq_listen;
1447
1448 src = inet_makeaddr(INADDR_B, child_ip(nr));
1449 dst = inet_makeaddr(INADDR_B, grchild_ip(nr));
1450
1451 if (xfrm_state_add(xfrm_sock, (*seq)++, gen_spi(src), src, dst, desc)) {
1452 printk("Failed to add xfrm state");
1453 return KSFT_FAIL;
1454 }
1455
1456 if (netlink_sock_bind(&xfrm_listen, &seq_listen, NETLINK_XFRM, XFRMNLGRP_EXPIRE))
1457 return KSFT_FAIL;
1458
1459 memset(&req, 0, sizeof(req));
1460 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.expire));
1461 req.nh.nlmsg_type = XFRM_MSG_EXPIRE;
1462 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1463 req.nh.nlmsg_seq = (*seq)++;
1464
1465 memcpy(&req.expire.state.id.daddr, &dst, sizeof(dst));
1466 req.expire.state.id.spi = gen_spi(src);
1467 req.expire.state.id.proto = desc->proto;
1468 req.expire.state.family = AF_INET;
1469 req.expire.hard = 0xff;
1470
1471 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1472 pr_err("send()");
1473 goto out_close;
1474 }
1475
1476 if (recv(xfrm_sock, &req, sizeof(req), 0) < 0) {
1477 pr_err("recv()");
1478 goto out_close;
1479 } else if (req.nh.nlmsg_type != NLMSG_ERROR) {
1480 printk("expected NLMSG_ERROR, got %d", (int)req.nh.nlmsg_type);
1481 goto out_close;
1482 }
1483
1484 if (req.error) {
1485 printk("NLMSG_ERROR: %d: %s", req.error, strerror(-req.error));
1486 ret = req.error;
1487 goto out_close;
1488 }
1489
1490 if (recv(xfrm_listen, &req, sizeof(req), 0) < 0) {
1491 pr_err("recv()");
1492 goto out_close;
1493 }
1494
1495 if (req.expire.hard != 0x1) {
1496 printk("expire.hard is not set: %x", req.expire.hard);
1497 goto out_close;
1498 }
1499
1500 ret = KSFT_PASS;
1501 out_close:
1502 close(xfrm_listen);
1503 return ret;
1504 }
1505
1506 static int xfrm_expire_policy(int xfrm_sock, uint32_t *seq,
1507 unsigned int nr, struct xfrm_desc *desc)
1508 {
1509 struct {
1510 struct nlmsghdr nh;
1511 union {
1512 struct xfrm_user_polexpire expire;
1513 int error;
1514 };
1515 } req;
1516 struct in_addr src, dst, tunsrc, tundst;
1517 int xfrm_listen = -1, ret = KSFT_FAIL;
1518 uint32_t seq_listen;
1519
1520 src = inet_makeaddr(INADDR_B, child_ip(nr));
1521 dst = inet_makeaddr(INADDR_B, grchild_ip(nr));
1522 tunsrc = inet_makeaddr(INADDR_A, child_ip(nr));
1523 tundst = inet_makeaddr(INADDR_A, grchild_ip(nr));
1524
1525 if (xfrm_policy_add(xfrm_sock, (*seq)++, gen_spi(src), src, dst,
1526 XFRM_POLICY_OUT, tunsrc, tundst, desc->proto)) {
1527 printk("Failed to add xfrm policy");
1528 return KSFT_FAIL;
1529 }
1530
1531 if (netlink_sock_bind(&xfrm_listen, &seq_listen, NETLINK_XFRM, XFRMNLGRP_EXPIRE))
1532 return KSFT_FAIL;
1533
1534 memset(&req, 0, sizeof(req));
1535 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.expire));
1536 req.nh.nlmsg_type = XFRM_MSG_POLEXPIRE;
1537 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1538 req.nh.nlmsg_seq = (*seq)++;
1539
1540 /* Fill selector. */
1541 memcpy(&req.expire.pol.sel.daddr, &dst, sizeof(tundst));
1542 memcpy(&req.expire.pol.sel.saddr, &src, sizeof(tunsrc));
1543 req.expire.pol.sel.family = AF_INET;
1544 req.expire.pol.sel.prefixlen_d = PREFIX_LEN;
1545 req.expire.pol.sel.prefixlen_s = PREFIX_LEN;
1546 req.expire.pol.dir = XFRM_POLICY_OUT;
1547 req.expire.hard = 0xff;
1548
1549 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1550 pr_err("send()");
1551 goto out_close;
1552 }
1553
1554 if (recv(xfrm_sock, &req, sizeof(req), 0) < 0) {
1555 pr_err("recv()");
1556 goto out_close;
1557 } else if (req.nh.nlmsg_type != NLMSG_ERROR) {
1558 printk("expected NLMSG_ERROR, got %d", (int)req.nh.nlmsg_type);
1559 goto out_close;
1560 }
1561
1562 if (req.error) {
1563 printk("NLMSG_ERROR: %d: %s", req.error, strerror(-req.error));
1564 ret = req.error;
1565 goto out_close;
1566 }
1567
1568 if (recv(xfrm_listen, &req, sizeof(req), 0) < 0) {
1569 pr_err("recv()");
1570 goto out_close;
1571 }
1572
1573 if (req.expire.hard != 0x1) {
1574 printk("expire.hard is not set: %x", req.expire.hard);
1575 goto out_close;
1576 }
1577
1578 ret = KSFT_PASS;
1579 out_close:
1580 close(xfrm_listen);
1581 return ret;
1582 }
1583
1584 static int xfrm_spdinfo_set_thresh(int xfrm_sock, uint32_t *seq,
1585 unsigned thresh4_l, unsigned thresh4_r,
1586 unsigned thresh6_l, unsigned thresh6_r,
1587 bool add_bad_attr)
1588
1589 {
1590 struct {
1591 struct nlmsghdr nh;
1592 union {
1593 uint32_t unused;
1594 int error;
1595 };
1596 char attrbuf[MAX_PAYLOAD];
1597 } req;
1598 struct xfrmu_spdhthresh thresh;
1599
1600 memset(&req, 0, sizeof(req));
1601 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.unused));
1602 req.nh.nlmsg_type = XFRM_MSG_NEWSPDINFO;
1603 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1604 req.nh.nlmsg_seq = (*seq)++;
1605
1606 thresh.lbits = thresh4_l;
1607 thresh.rbits = thresh4_r;
1608 if (rtattr_pack(&req.nh, sizeof(req), XFRMA_SPD_IPV4_HTHRESH, &thresh, sizeof(thresh)))
1609 return -1;
1610
1611 thresh.lbits = thresh6_l;
1612 thresh.rbits = thresh6_r;
1613 if (rtattr_pack(&req.nh, sizeof(req), XFRMA_SPD_IPV6_HTHRESH, &thresh, sizeof(thresh)))
1614 return -1;
1615
1616 if (add_bad_attr) {
1617 BUILD_BUG_ON(XFRMA_IF_ID <= XFRMA_SPD_MAX + 1);
1618 if (rtattr_pack(&req.nh, sizeof(req), XFRMA_IF_ID, NULL, 0)) {
1619 pr_err("adding attribute failed: no space");
1620 return -1;
1621 }
1622 }
1623
1624 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1625 pr_err("send()");
1626 return -1;
1627 }
1628
1629 if (recv(xfrm_sock, &req, sizeof(req), 0) < 0) {
1630 pr_err("recv()");
1631 return -1;
1632 } else if (req.nh.nlmsg_type != NLMSG_ERROR) {
1633 printk("expected NLMSG_ERROR, got %d", (int)req.nh.nlmsg_type);
1634 return -1;
1635 }
1636
1637 if (req.error) {
1638 printk("NLMSG_ERROR: %d: %s", req.error, strerror(-req.error));
1639 return -1;
1640 }
1641
1642 return 0;
1643 }
1644
1645 static int xfrm_spdinfo_attrs(int xfrm_sock, uint32_t *seq)
1646 {
1647 struct {
1648 struct nlmsghdr nh;
1649 union {
1650 uint32_t unused;
1651 int error;
1652 };
1653 char attrbuf[MAX_PAYLOAD];
1654 } req;
1655
1656 if (xfrm_spdinfo_set_thresh(xfrm_sock, seq, 32, 31, 120, 16, false)) {
1657 pr_err("Can't set SPD HTHRESH");
1658 return KSFT_FAIL;
1659 }
1660
1661 memset(&req, 0, sizeof(req));
1662
1663 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.unused));
1664 req.nh.nlmsg_type = XFRM_MSG_GETSPDINFO;
1665 req.nh.nlmsg_flags = NLM_F_REQUEST;
1666 req.nh.nlmsg_seq = (*seq)++;
1667 if (send(xfrm_sock, &req, req.nh.nlmsg_len, 0) < 0) {
1668 pr_err("send()");
1669 return KSFT_FAIL;
1670 }
1671
1672 if (recv(xfrm_sock, &req, sizeof(req), 0) < 0) {
1673 pr_err("recv()");
1674 return KSFT_FAIL;
1675 } else if (req.nh.nlmsg_type == XFRM_MSG_NEWSPDINFO) {
1676 size_t len = NLMSG_PAYLOAD(&req.nh, sizeof(req.unused));
1677 struct rtattr *attr = (void *)req.attrbuf;
1678 int got_thresh = 0;
1679
1680 for (; RTA_OK(attr, len); attr = RTA_NEXT(attr, len)) {
1681 if (attr->rta_type == XFRMA_SPD_IPV4_HTHRESH) {
1682 struct xfrmu_spdhthresh *t = RTA_DATA(attr);
1683
1684 got_thresh++;
1685 if (t->lbits != 32 || t->rbits != 31) {
1686 pr_err("thresh differ: %u, %u",
1687 t->lbits, t->rbits);
1688 return KSFT_FAIL;
1689 }
1690 }
1691 if (attr->rta_type == XFRMA_SPD_IPV6_HTHRESH) {
1692 struct xfrmu_spdhthresh *t = RTA_DATA(attr);
1693
1694 got_thresh++;
1695 if (t->lbits != 120 || t->rbits != 16) {
1696 pr_err("thresh differ: %u, %u",
1697 t->lbits, t->rbits);
1698 return KSFT_FAIL;
1699 }
1700 }
1701 }
1702 if (got_thresh != 2) {
1703 pr_err("only %d thresh returned by XFRM_MSG_GETSPDINFO", got_thresh);
1704 return KSFT_FAIL;
1705 }
1706 } else if (req.nh.nlmsg_type != NLMSG_ERROR) {
1707 printk("expected NLMSG_ERROR, got %d", (int)req.nh.nlmsg_type);
1708 return KSFT_FAIL;
1709 } else {
1710 printk("NLMSG_ERROR: %d: %s", req.error, strerror(-req.error));
1711 return -1;
1712 }
1713
1714 /* Restore the default */
1715 if (xfrm_spdinfo_set_thresh(xfrm_sock, seq, 32, 32, 128, 128, false)) {
1716 pr_err("Can't restore SPD HTHRESH");
1717 return KSFT_FAIL;
1718 }
1719
1720 /*
1721 * At this moment xfrm uses nlmsg_parse_deprecated(), which
1722 * implies NL_VALIDATE_LIBERAL - ignoring attributes with
1723 * (type > maxtype). nla_parse_depricated_strict() would enforce
1724 * it. Or even stricter nla_parse().
1725 * Right now it's not expected to fail, but to be ignored.
1726 */
1727 if (xfrm_spdinfo_set_thresh(xfrm_sock, seq, 32, 32, 128, 128, true))
1728 return KSFT_PASS;
1729
1730 return KSFT_PASS;
1731 }
1732
1733 static int child_serv(int xfrm_sock, uint32_t *seq,
1734 unsigned int nr, int cmd_fd, void *buf, struct xfrm_desc *desc)
1735 {
1736 struct in_addr src, dst, tunsrc, tundst;
1737 struct test_desc msg;
1738 int ret = KSFT_FAIL;
1739
1740 src = inet_makeaddr(INADDR_B, child_ip(nr));
1741 dst = inet_makeaddr(INADDR_B, grchild_ip(nr));
1742 tunsrc = inet_makeaddr(INADDR_A, child_ip(nr));
1743 tundst = inet_makeaddr(INADDR_A, grchild_ip(nr));
1744
1745 /* UDP pinging without xfrm */
1746 if (do_ping(cmd_fd, buf, page_size, src, true, 0, 0, udp_ping_send)) {
1747 printk("ping failed before setting xfrm");
1748 return KSFT_FAIL;
1749 }
1750
1751 memset(&msg, 0, sizeof(msg));
1752 msg.type = MSG_XFRM_PREPARE;
1753 memcpy(&msg.body.xfrm_desc, desc, sizeof(*desc));
1754 write_msg(cmd_fd, &msg, 1);
1755
1756 if (xfrm_prepare(xfrm_sock, seq, src, dst, tunsrc, tundst, desc->proto)) {
1757 printk("failed to prepare xfrm");
1758 goto cleanup;
1759 }
1760
1761 memset(&msg, 0, sizeof(msg));
1762 msg.type = MSG_XFRM_ADD;
1763 memcpy(&msg.body.xfrm_desc, desc, sizeof(*desc));
1764 write_msg(cmd_fd, &msg, 1);
1765 if (xfrm_set(xfrm_sock, seq, src, dst, tunsrc, tundst, desc)) {
1766 printk("failed to set xfrm");
1767 goto delete;
1768 }
1769
1770 /* UDP pinging with xfrm tunnel */
1771 if (do_ping(cmd_fd, buf, page_size, tunsrc,
1772 true, 0, 0, udp_ping_send)) {
1773 printk("ping failed for xfrm");
1774 goto delete;
1775 }
1776
1777 ret = KSFT_PASS;
1778 delete:
1779 /* xfrm delete */
1780 memset(&msg, 0, sizeof(msg));
1781 msg.type = MSG_XFRM_DEL;
1782 memcpy(&msg.body.xfrm_desc, desc, sizeof(*desc));
1783 write_msg(cmd_fd, &msg, 1);
1784
1785 if (xfrm_delete(xfrm_sock, seq, src, dst, tunsrc, tundst, desc->proto)) {
1786 printk("failed ping to remove xfrm");
1787 ret = KSFT_FAIL;
1788 }
1789
1790 cleanup:
1791 memset(&msg, 0, sizeof(msg));
1792 msg.type = MSG_XFRM_CLEANUP;
1793 memcpy(&msg.body.xfrm_desc, desc, sizeof(*desc));
1794 write_msg(cmd_fd, &msg, 1);
1795 if (xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst)) {
1796 printk("failed ping to cleanup xfrm");
1797 ret = KSFT_FAIL;
1798 }
1799 return ret;
1800 }
1801
1802 static int child_f(unsigned int nr, int test_desc_fd, int cmd_fd, void *buf)
1803 {
1804 struct xfrm_desc desc;
1805 struct test_desc msg;
1806 int xfrm_sock = -1;
1807 uint32_t seq;
1808
1809 if (switch_ns(nsfd_childa))
1810 exit(KSFT_FAIL);
1811
1812 if (netlink_sock(&xfrm_sock, &seq, NETLINK_XFRM)) {
1813 printk("Failed to open xfrm netlink socket");
1814 exit(KSFT_FAIL);
1815 }
1816
1817 /* Check that seq sock is ready, just for sure. */
1818 memset(&msg, 0, sizeof(msg));
1819 msg.type = MSG_ACK;
1820 write_msg(cmd_fd, &msg, 1);
1821 read_msg(cmd_fd, &msg, 1);
1822 if (msg.type != MSG_ACK) {
1823 printk("Ack failed");
1824 exit(KSFT_FAIL);
1825 }
1826
1827 for (;;) {
1828 ssize_t received = read(test_desc_fd, &desc, sizeof(desc));
1829 int ret;
1830
1831 if (received == 0) /* EOF */
1832 break;
1833
1834 if (received != sizeof(desc)) {
1835 pr_err("read() returned %zd", received);
1836 exit(KSFT_FAIL);
1837 }
1838
1839 switch (desc.type) {
1840 case CREATE_TUNNEL:
1841 ret = child_serv(xfrm_sock, &seq, nr,
1842 cmd_fd, buf, &desc);
1843 break;
1844 case ALLOCATE_SPI:
1845 ret = xfrm_state_allocspi(xfrm_sock, &seq,
1846 -1, desc.proto);
1847 break;
1848 case MONITOR_ACQUIRE:
1849 ret = xfrm_monitor_acquire(xfrm_sock, &seq, nr);
1850 break;
1851 case EXPIRE_STATE:
1852 ret = xfrm_expire_state(xfrm_sock, &seq, nr, &desc);
1853 break;
1854 case EXPIRE_POLICY:
1855 ret = xfrm_expire_policy(xfrm_sock, &seq, nr, &desc);
1856 break;
1857 case SPDINFO_ATTRS:
1858 ret = xfrm_spdinfo_attrs(xfrm_sock, &seq);
1859 break;
1860 default:
1861 printk("Unknown desc type %d", desc.type);
1862 exit(KSFT_FAIL);
1863 }
1864 write_test_result(ret, &desc);
1865 }
1866
1867 close(xfrm_sock);
1868
1869 msg.type = MSG_EXIT;
1870 write_msg(cmd_fd, &msg, 1);
1871 exit(KSFT_PASS);
1872 }
1873
1874 static void grand_child_serv(unsigned int nr, int cmd_fd, void *buf,
1875 struct test_desc *msg, int xfrm_sock, uint32_t *seq)
1876 {
1877 struct in_addr src, dst, tunsrc, tundst;
1878 bool tun_reply;
1879 struct xfrm_desc *desc = &msg->body.xfrm_desc;
1880
1881 src = inet_makeaddr(INADDR_B, grchild_ip(nr));
1882 dst = inet_makeaddr(INADDR_B, child_ip(nr));
1883 tunsrc = inet_makeaddr(INADDR_A, grchild_ip(nr));
1884 tundst = inet_makeaddr(INADDR_A, child_ip(nr));
1885
1886 switch (msg->type) {
1887 case MSG_EXIT:
1888 exit(KSFT_PASS);
1889 case MSG_ACK:
1890 write_msg(cmd_fd, msg, 1);
1891 break;
1892 case MSG_PING:
1893 tun_reply = memcmp(&dst, &msg->body.ping.reply_ip, sizeof(in_addr_t));
1894 /* UDP pinging without xfrm */
1895 if (do_ping(cmd_fd, buf, page_size, tun_reply ? tunsrc : src,
1896 false, msg->body.ping.port,
1897 msg->body.ping.reply_ip, udp_ping_reply)) {
1898 printk("ping failed before setting xfrm");
1899 }
1900 break;
1901 case MSG_XFRM_PREPARE:
1902 if (xfrm_prepare(xfrm_sock, seq, src, dst, tunsrc, tundst,
1903 desc->proto)) {
1904 xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst);
1905 printk("failed to prepare xfrm");
1906 }
1907 break;
1908 case MSG_XFRM_ADD:
1909 if (xfrm_set(xfrm_sock, seq, src, dst, tunsrc, tundst, desc)) {
1910 xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst);
1911 printk("failed to set xfrm");
1912 }
1913 break;
1914 case MSG_XFRM_DEL:
1915 if (xfrm_delete(xfrm_sock, seq, src, dst, tunsrc, tundst,
1916 desc->proto)) {
1917 xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst);
1918 printk("failed to remove xfrm");
1919 }
1920 break;
1921 case MSG_XFRM_CLEANUP:
1922 if (xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst)) {
1923 printk("failed to cleanup xfrm");
1924 }
1925 break;
1926 default:
1927 printk("got unknown msg type %d", msg->type);
1928 }
1929 }
1930
1931 static int grand_child_f(unsigned int nr, int cmd_fd, void *buf)
1932 {
1933 struct test_desc msg;
1934 int xfrm_sock = -1;
1935 uint32_t seq;
1936
1937 if (switch_ns(nsfd_childb))
1938 exit(KSFT_FAIL);
1939
1940 if (netlink_sock(&xfrm_sock, &seq, NETLINK_XFRM)) {
1941 printk("Failed to open xfrm netlink socket");
1942 exit(KSFT_FAIL);
1943 }
1944
1945 do {
1946 read_msg(cmd_fd, &msg, 1);
1947 grand_child_serv(nr, cmd_fd, buf, &msg, xfrm_sock, &seq);
1948 } while (1);
1949
1950 close(xfrm_sock);
1951 exit(KSFT_FAIL);
1952 }
1953
1954 static int start_child(unsigned int nr, char *veth, int test_desc_fd[2])
1955 {
1956 int cmd_sock[2];
1957 void *data_map;
1958 pid_t child;
1959
1960 if (init_child(nsfd_childa, veth, child_ip(nr), grchild_ip(nr)))
1961 return -1;
1962
1963 if (init_child(nsfd_childb, veth, grchild_ip(nr), child_ip(nr)))
1964 return -1;
1965
1966 child = fork();
1967 if (child < 0) {
1968 pr_err("fork()");
1969 return -1;
1970 } else if (child) {
1971 /* in parent - selftest */
1972 return switch_ns(nsfd_parent);
1973 }
1974
1975 if (close(test_desc_fd[1])) {
1976 pr_err("close()");
1977 return -1;
1978 }
1979
1980 /* child */
1981 data_map = mmap(0, page_size, PROT_READ | PROT_WRITE,
1982 MAP_SHARED | MAP_ANONYMOUS, -1, 0);
1983 if (data_map == MAP_FAILED) {
1984 pr_err("mmap()");
1985 return -1;
1986 }
1987
1988 randomize_buffer(data_map, page_size);
1989
1990 if (socketpair(PF_LOCAL, SOCK_SEQPACKET, 0, cmd_sock)) {
1991 pr_err("socketpair()");
1992 return -1;
1993 }
1994
1995 child = fork();
1996 if (child < 0) {
1997 pr_err("fork()");
1998 return -1;
1999 } else if (child) {
2000 if (close(cmd_sock[0])) {
2001 pr_err("close()");
2002 return -1;
2003 }
2004 return child_f(nr, test_desc_fd[0], cmd_sock[1], data_map);
2005 }
2006 if (close(cmd_sock[1])) {
2007 pr_err("close()");
2008 return -1;
2009 }
2010 return grand_child_f(nr, cmd_sock[0], data_map);
2011 }
2012
2013 static void exit_usage(char **argv)
2014 {
2015 printk("Usage: %s [nr_process]", argv[0]);
2016 exit(KSFT_FAIL);
2017 }
2018
2019 static int __write_desc(int test_desc_fd, struct xfrm_desc *desc)
2020 {
2021 ssize_t ret;
2022
2023 ret = write(test_desc_fd, desc, sizeof(*desc));
2024
2025 if (ret == sizeof(*desc))
2026 return 0;
2027
2028 pr_err("Writing test's desc failed %ld", ret);
2029
2030 return -1;
2031 }
2032
2033 static int write_desc(int proto, int test_desc_fd,
2034 char *a, char *e, char *c, char *ae)
2035 {
2036 struct xfrm_desc desc = {};
2037
2038 desc.type = CREATE_TUNNEL;
2039 desc.proto = proto;
2040
2041 if (a)
2042 strncpy(desc.a_algo, a, ALGO_LEN - 1);
2043 if (e)
2044 strncpy(desc.e_algo, e, ALGO_LEN - 1);
2045 if (c)
2046 strncpy(desc.c_algo, c, ALGO_LEN - 1);
2047 if (ae)
2048 strncpy(desc.ae_algo, ae, ALGO_LEN - 1);
2049
2050 return __write_desc(test_desc_fd, &desc);
2051 }
2052
2053 int proto_list[] = { IPPROTO_AH, IPPROTO_COMP, IPPROTO_ESP };
2054 char *ah_list[] = {
2055 "digest_null", "hmac(md5)", "hmac(sha1)", "hmac(sha256)",
2056 "hmac(sha384)", "hmac(sha512)", "hmac(rmd160)",
2057 "xcbc(aes)", "cmac(aes)"
2058 };
2059 char *comp_list[] = {
2060 "deflate",
2061 #if 0
2062 /* No compression backend realization */
2063 "lzs", "lzjh"
2064 #endif
2065 };
2066 char *e_list[] = {
2067 "ecb(cipher_null)", "cbc(des)", "cbc(des3_ede)", "cbc(cast5)",
2068 "cbc(blowfish)", "cbc(aes)", "cbc(serpent)", "cbc(camellia)",
2069 "cbc(twofish)", "rfc3686(ctr(aes))"
2070 };
2071 char *ae_list[] = {
2072 #if 0
2073 /* not implemented */
2074 "rfc4106(gcm(aes))", "rfc4309(ccm(aes))", "rfc4543(gcm(aes))",
2075 "rfc7539esp(chacha20,poly1305)"
2076 #endif
2077 };
2078
2079 const unsigned int proto_plan = ARRAY_SIZE(ah_list) + ARRAY_SIZE(comp_list) \
2080 + (ARRAY_SIZE(ah_list) * ARRAY_SIZE(e_list)) \
2081 + ARRAY_SIZE(ae_list);
2082
2083 static int write_proto_plan(int fd, int proto)
2084 {
2085 unsigned int i;
2086
2087 switch (proto) {
2088 case IPPROTO_AH:
2089 for (i = 0; i < ARRAY_SIZE(ah_list); i++) {
2090 if (write_desc(proto, fd, ah_list[i], 0, 0, 0))
2091 return -1;
2092 }
2093 break;
2094 case IPPROTO_COMP:
2095 for (i = 0; i < ARRAY_SIZE(comp_list); i++) {
2096 if (write_desc(proto, fd, 0, 0, comp_list[i], 0))
2097 return -1;
2098 }
2099 break;
2100 case IPPROTO_ESP:
2101 for (i = 0; i < ARRAY_SIZE(ah_list); i++) {
2102 int j;
2103
2104 for (j = 0; j < ARRAY_SIZE(e_list); j++) {
2105 if (write_desc(proto, fd, ah_list[i],
2106 e_list[j], 0, 0))
2107 return -1;
2108 }
2109 }
2110 for (i = 0; i < ARRAY_SIZE(ae_list); i++) {
2111 if (write_desc(proto, fd, 0, 0, 0, ae_list[i]))
2112 return -1;
2113 }
2114 break;
2115 default:
2116 printk("BUG: Specified unknown proto %d", proto);
2117 return -1;
2118 }
2119
2120 return 0;
2121 }
2122
2123 /*
2124 * Some structures in xfrm uapi header differ in size between
2125 * 64-bit and 32-bit ABI:
2126 *
2127 * 32-bit UABI | 64-bit UABI
2128 * -------------------------------------|-------------------------------------
2129 * sizeof(xfrm_usersa_info) = 220 | sizeof(xfrm_usersa_info) = 224
2130 * sizeof(xfrm_userpolicy_info) = 164 | sizeof(xfrm_userpolicy_info) = 168
2131 * sizeof(xfrm_userspi_info) = 228 | sizeof(xfrm_userspi_info) = 232
2132 * sizeof(xfrm_user_acquire) = 276 | sizeof(xfrm_user_acquire) = 280
2133 * sizeof(xfrm_user_expire) = 224 | sizeof(xfrm_user_expire) = 232
2134 * sizeof(xfrm_user_polexpire) = 168 | sizeof(xfrm_user_polexpire) = 176
2135 *
2136 * Check the affected by the UABI difference structures.
2137 * Also, check translation for xfrm_set_spdinfo: it has it's own attributes
2138 * which needs to be correctly copied, but not translated.
2139 */
2140 const unsigned int compat_plan = 5;
2141 static int write_compat_struct_tests(int test_desc_fd)
2142 {
2143 struct xfrm_desc desc = {};
2144
2145 desc.type = ALLOCATE_SPI;
2146 desc.proto = IPPROTO_AH;
2147 strncpy(desc.a_algo, ah_list[0], ALGO_LEN - 1);
2148
2149 if (__write_desc(test_desc_fd, &desc))
2150 return -1;
2151
2152 desc.type = MONITOR_ACQUIRE;
2153 if (__write_desc(test_desc_fd, &desc))
2154 return -1;
2155
2156 desc.type = EXPIRE_STATE;
2157 if (__write_desc(test_desc_fd, &desc))
2158 return -1;
2159
2160 desc.type = EXPIRE_POLICY;
2161 if (__write_desc(test_desc_fd, &desc))
2162 return -1;
2163
2164 desc.type = SPDINFO_ATTRS;
2165 if (__write_desc(test_desc_fd, &desc))
2166 return -1;
2167
2168 return 0;
2169 }
2170
2171 static int write_test_plan(int test_desc_fd)
2172 {
2173 unsigned int i;
2174 pid_t child;
2175
2176 child = fork();
2177 if (child < 0) {
2178 pr_err("fork()");
2179 return -1;
2180 }
2181 if (child) {
2182 if (close(test_desc_fd))
2183 printk("close(): %m");
2184 return 0;
2185 }
2186
2187 if (write_compat_struct_tests(test_desc_fd))
2188 exit(KSFT_FAIL);
2189
2190 for (i = 0; i < ARRAY_SIZE(proto_list); i++) {
2191 if (write_proto_plan(test_desc_fd, proto_list[i]))
2192 exit(KSFT_FAIL);
2193 }
2194
2195 exit(KSFT_PASS);
2196 }
2197
2198 static int children_cleanup(void)
2199 {
2200 unsigned ret = KSFT_PASS;
2201
2202 while (1) {
2203 int status;
2204 pid_t p = wait(&status);
2205
2206 if ((p < 0) && errno == ECHILD)
2207 break;
2208
2209 if (p < 0) {
2210 pr_err("wait()");
2211 return KSFT_FAIL;
2212 }
2213
2214 if (!WIFEXITED(status)) {
2215 ret = KSFT_FAIL;
2216 continue;
2217 }
2218
2219 if (WEXITSTATUS(status) == KSFT_FAIL)
2220 ret = KSFT_FAIL;
2221 }
2222
2223 return ret;
2224 }
2225
2226 typedef void (*print_res)(const char *, ...);
2227
2228 static int check_results(void)
2229 {
2230 struct test_result tr = {};
2231 struct xfrm_desc *d = &tr.desc;
2232 int ret = KSFT_PASS;
2233
2234 while (1) {
2235 ssize_t received = read(results_fd[0], &tr, sizeof(tr));
2236 print_res result;
2237
2238 if (received == 0) /* EOF */
2239 break;
2240
2241 if (received != sizeof(tr)) {
2242 pr_err("read() returned %zd", received);
2243 return KSFT_FAIL;
2244 }
2245
2246 switch (tr.res) {
2247 case KSFT_PASS:
2248 result = ksft_test_result_pass;
2249 break;
2250 case KSFT_FAIL:
2251 default:
2252 result = ksft_test_result_fail;
2253 ret = KSFT_FAIL;
2254 }
2255
2256 result(" %s: [%u, '%s', '%s', '%s', '%s', %u]\n",
2257 desc_name[d->type], (unsigned int)d->proto, d->a_algo,
2258 d->e_algo, d->c_algo, d->ae_algo, d->icv_len);
2259 }
2260
2261 return ret;
2262 }
2263
2264 int main(int argc, char **argv)
2265 {
2266 long nr_process = 1;
2267 int route_sock = -1, ret = KSFT_SKIP;
2268 int test_desc_fd[2];
2269 uint32_t route_seq;
2270 unsigned int i;
2271
2272 if (argc > 2)
2273 exit_usage(argv);
2274
2275 if (argc > 1) {
2276 char *endptr;
2277
2278 errno = 0;
2279 nr_process = strtol(argv[1], &endptr, 10);
2280 if ((errno == ERANGE && (nr_process == LONG_MAX || nr_process == LONG_MIN))
2281 || (errno != 0 && nr_process == 0)
2282 || (endptr == argv[1]) || (*endptr != '\0')) {
2283 printk("Failed to parse [nr_process]");
2284 exit_usage(argv);
2285 }
2286
2287 if (nr_process > MAX_PROCESSES || nr_process < 1) {
2288 printk("nr_process should be between [1; %u]",
2289 MAX_PROCESSES);
2290 exit_usage(argv);
2291 }
2292 }
2293
2294 srand(time(NULL));
2295 page_size = sysconf(_SC_PAGESIZE);
2296 if (page_size < 1)
2297 ksft_exit_skip("sysconf(): %m\n");
2298
2299 if (pipe2(test_desc_fd, O_DIRECT) < 0)
2300 ksft_exit_skip("pipe(): %m\n");
2301
2302 if (pipe2(results_fd, O_DIRECT) < 0)
2303 ksft_exit_skip("pipe(): %m\n");
2304
2305 if (init_namespaces())
2306 ksft_exit_skip("Failed to create namespaces\n");
2307
2308 if (netlink_sock(&route_sock, &route_seq, NETLINK_ROUTE))
2309 ksft_exit_skip("Failed to open netlink route socket\n");
2310
2311 for (i = 0; i < nr_process; i++) {
2312 char veth[VETH_LEN];
2313
2314 snprintf(veth, VETH_LEN, VETH_FMT, i);
2315
2316 if (veth_add(route_sock, route_seq++, veth, nsfd_childa, veth, nsfd_childb)) {
2317 close(route_sock);
2318 ksft_exit_fail_msg("Failed to create veth device");
2319 }
2320
2321 if (start_child(i, veth, test_desc_fd)) {
2322 close(route_sock);
2323 ksft_exit_fail_msg("Child %u failed to start", i);
2324 }
2325 }
2326
2327 if (close(route_sock) || close(test_desc_fd[0]) || close(results_fd[1]))
2328 ksft_exit_fail_msg("close(): %m");
2329
2330 ksft_set_plan(proto_plan + compat_plan);
2331
2332 if (write_test_plan(test_desc_fd[1]))
2333 ksft_exit_fail_msg("Failed to write test plan to pipe");
2334
2335 ret = check_results();
2336
2337 if (children_cleanup() == KSFT_FAIL)
2338 exit(KSFT_FAIL);
2339
2340 exit(ret);
2341 }
2342
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.