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