1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2019 Facebook 3 4 #include <fcntl.h> 5 #include <stdint.h> 6 #include <stdio.h> 7 #include <stdlib.h> 8 #include <string.h> 9 #include <unistd.h> 10 11 #include <linux/filter.h> 12 13 #include <bpf/bpf.h> 14 #include <bpf/libbpf.h> 15 16 #include <bpf/bpf_endian.h> 17 #include "bpf_util.h" 18 #include "cgroup_helpers.h" 19 #include "testing_helpers.h" 20 21 #define CG_PATH "/foo" 22 #define MAX_INSNS 512 23 #define FIXUP_SYSCTL_VALUE 0 24 25 char bpf_log_buf[BPF_LOG_BUF_SIZE]; 26 27 struct sysctl_test { 28 const char *descr; 29 size_t fixup_value_insn; 30 struct bpf_insn insns[MAX_INSNS]; 31 const char *prog_file; 32 enum bpf_attach_type attach_type; 33 const char *sysctl; 34 int open_flags; 35 int seek; 36 const char *newval; 37 const char *oldval; 38 enum { 39 LOAD_REJECT, 40 ATTACH_REJECT, 41 OP_EPERM, 42 SUCCESS, 43 } result; 44 }; 45 46 static struct sysctl_test tests[] = { 47 { 48 .descr = "sysctl wrong attach_type", 49 .insns = { 50 BPF_MOV64_IMM(BPF_REG_0, 1), 51 BPF_EXIT_INSN(), 52 }, 53 .attach_type = 0, 54 .sysctl = "kernel/ostype", 55 .open_flags = O_RDONLY, 56 .result = ATTACH_REJECT, 57 }, 58 { 59 .descr = "sysctl:read allow all", 60 .insns = { 61 BPF_MOV64_IMM(BPF_REG_0, 1), 62 BPF_EXIT_INSN(), 63 }, 64 .attach_type = BPF_CGROUP_SYSCTL, 65 .sysctl = "kernel/ostype", 66 .open_flags = O_RDONLY, 67 .result = SUCCESS, 68 }, 69 { 70 .descr = "sysctl:read deny all", 71 .insns = { 72 BPF_MOV64_IMM(BPF_REG_0, 0), 73 BPF_EXIT_INSN(), 74 }, 75 .attach_type = BPF_CGROUP_SYSCTL, 76 .sysctl = "kernel/ostype", 77 .open_flags = O_RDONLY, 78 .result = OP_EPERM, 79 }, 80 { 81 .descr = "ctx:write sysctl:read read ok", 82 .insns = { 83 /* If (write) */ 84 BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_1, 85 offsetof(struct bpf_sysctl, write)), 86 BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 1, 2), 87 88 /* return DENY; */ 89 BPF_MOV64_IMM(BPF_REG_0, 0), 90 BPF_JMP_A(1), 91 92 /* else return ALLOW; */ 93 BPF_MOV64_IMM(BPF_REG_0, 1), 94 BPF_EXIT_INSN(), 95 }, 96 .attach_type = BPF_CGROUP_SYSCTL, 97 .sysctl = "kernel/ostype", 98 .open_flags = O_RDONLY, 99 .result = SUCCESS, 100 }, 101 { 102 .descr = "ctx:write sysctl:write read ok", 103 .insns = { 104 /* If (write) */ 105 BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_1, 106 offsetof(struct bpf_sysctl, write)), 107 BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 1, 2), 108 109 /* return DENY; */ 110 BPF_MOV64_IMM(BPF_REG_0, 0), 111 BPF_JMP_A(1), 112 113 /* else return ALLOW; */ 114 BPF_MOV64_IMM(BPF_REG_0, 1), 115 BPF_EXIT_INSN(), 116 }, 117 .attach_type = BPF_CGROUP_SYSCTL, 118 .sysctl = "kernel/domainname", 119 .open_flags = O_WRONLY, 120 .newval = "(none)", /* same as default, should fail anyway */ 121 .result = OP_EPERM, 122 }, 123 { 124 .descr = "ctx:write sysctl:write read ok narrow", 125 .insns = { 126 /* u64 w = (u16)write & 1; */ 127 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 128 BPF_LDX_MEM(BPF_H, BPF_REG_7, BPF_REG_1, 129 offsetof(struct bpf_sysctl, write)), 130 #else 131 BPF_LDX_MEM(BPF_H, BPF_REG_7, BPF_REG_1, 132 offsetof(struct bpf_sysctl, write) + 2), 133 #endif 134 BPF_ALU64_IMM(BPF_AND, BPF_REG_7, 1), 135 /* return 1 - w; */ 136 BPF_MOV64_IMM(BPF_REG_0, 1), 137 BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_7), 138 BPF_EXIT_INSN(), 139 }, 140 .attach_type = BPF_CGROUP_SYSCTL, 141 .sysctl = "kernel/domainname", 142 .open_flags = O_WRONLY, 143 .newval = "(none)", /* same as default, should fail anyway */ 144 .result = OP_EPERM, 145 }, 146 { 147 .descr = "ctx:write sysctl:read write reject", 148 .insns = { 149 /* write = X */ 150 BPF_MOV64_IMM(BPF_REG_0, 0), 151 BPF_STX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 152 offsetof(struct bpf_sysctl, write)), 153 BPF_MOV64_IMM(BPF_REG_0, 1), 154 BPF_EXIT_INSN(), 155 }, 156 .attach_type = BPF_CGROUP_SYSCTL, 157 .sysctl = "kernel/ostype", 158 .open_flags = O_RDONLY, 159 .result = LOAD_REJECT, 160 }, 161 { 162 .descr = "ctx:file_pos sysctl:read read ok", 163 .insns = { 164 /* If (file_pos == X) */ 165 BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_1, 166 offsetof(struct bpf_sysctl, file_pos)), 167 BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 3, 2), 168 169 /* return ALLOW; */ 170 BPF_MOV64_IMM(BPF_REG_0, 1), 171 BPF_JMP_A(1), 172 173 /* else return DENY; */ 174 BPF_MOV64_IMM(BPF_REG_0, 0), 175 BPF_EXIT_INSN(), 176 }, 177 .attach_type = BPF_CGROUP_SYSCTL, 178 .sysctl = "kernel/ostype", 179 .open_flags = O_RDONLY, 180 .seek = 3, 181 .result = SUCCESS, 182 }, 183 { 184 .descr = "ctx:file_pos sysctl:read read ok narrow", 185 .insns = { 186 /* If (file_pos == X) */ 187 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 188 BPF_LDX_MEM(BPF_B, BPF_REG_7, BPF_REG_1, 189 offsetof(struct bpf_sysctl, file_pos)), 190 #else 191 BPF_LDX_MEM(BPF_B, BPF_REG_7, BPF_REG_1, 192 offsetof(struct bpf_sysctl, file_pos) + 3), 193 #endif 194 BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 4, 2), 195 196 /* return ALLOW; */ 197 BPF_MOV64_IMM(BPF_REG_0, 1), 198 BPF_JMP_A(1), 199 200 /* else return DENY; */ 201 BPF_MOV64_IMM(BPF_REG_0, 0), 202 BPF_EXIT_INSN(), 203 }, 204 .attach_type = BPF_CGROUP_SYSCTL, 205 .sysctl = "kernel/ostype", 206 .open_flags = O_RDONLY, 207 .seek = 4, 208 .result = SUCCESS, 209 }, 210 { 211 .descr = "ctx:file_pos sysctl:read write ok", 212 .insns = { 213 /* file_pos = X */ 214 BPF_MOV64_IMM(BPF_REG_0, 2), 215 BPF_STX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 216 offsetof(struct bpf_sysctl, file_pos)), 217 BPF_MOV64_IMM(BPF_REG_0, 1), 218 BPF_EXIT_INSN(), 219 }, 220 .attach_type = BPF_CGROUP_SYSCTL, 221 .sysctl = "kernel/ostype", 222 .open_flags = O_RDONLY, 223 .oldval = "nux\n", 224 .result = SUCCESS, 225 }, 226 { 227 .descr = "sysctl_get_name sysctl_value:base ok", 228 .insns = { 229 /* sysctl_get_name arg2 (buf) */ 230 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 231 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 232 BPF_MOV64_IMM(BPF_REG_0, 0), 233 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 234 235 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 236 237 /* sysctl_get_name arg3 (buf_len) */ 238 BPF_MOV64_IMM(BPF_REG_3, 8), 239 240 /* sysctl_get_name arg4 (flags) */ 241 BPF_MOV64_IMM(BPF_REG_4, BPF_F_SYSCTL_BASE_NAME), 242 243 /* sysctl_get_name(ctx, buf, buf_len, flags) */ 244 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_name), 245 246 /* if (ret == expected && */ 247 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, sizeof("tcp_mem") - 1, 6), 248 /* buf == "tcp_mem\0") */ 249 BPF_LD_IMM64(BPF_REG_8, 250 bpf_be64_to_cpu(0x7463705f6d656d00ULL)), 251 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 252 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 253 254 /* return ALLOW; */ 255 BPF_MOV64_IMM(BPF_REG_0, 1), 256 BPF_JMP_A(1), 257 258 /* else return DENY; */ 259 BPF_MOV64_IMM(BPF_REG_0, 0), 260 BPF_EXIT_INSN(), 261 }, 262 .attach_type = BPF_CGROUP_SYSCTL, 263 .sysctl = "net/ipv4/tcp_mem", 264 .open_flags = O_RDONLY, 265 .result = SUCCESS, 266 }, 267 { 268 .descr = "sysctl_get_name sysctl_value:base E2BIG truncated", 269 .insns = { 270 /* sysctl_get_name arg2 (buf) */ 271 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 272 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 273 BPF_MOV64_IMM(BPF_REG_0, 0), 274 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 275 276 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 277 278 /* sysctl_get_name arg3 (buf_len) too small */ 279 BPF_MOV64_IMM(BPF_REG_3, 7), 280 281 /* sysctl_get_name arg4 (flags) */ 282 BPF_MOV64_IMM(BPF_REG_4, BPF_F_SYSCTL_BASE_NAME), 283 284 /* sysctl_get_name(ctx, buf, buf_len, flags) */ 285 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_name), 286 287 /* if (ret == expected && */ 288 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -E2BIG, 6), 289 290 /* buf[0:7] == "tcp_me\0") */ 291 BPF_LD_IMM64(BPF_REG_8, 292 bpf_be64_to_cpu(0x7463705f6d650000ULL)), 293 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 294 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 295 296 /* return ALLOW; */ 297 BPF_MOV64_IMM(BPF_REG_0, 1), 298 BPF_JMP_A(1), 299 300 /* else return DENY; */ 301 BPF_MOV64_IMM(BPF_REG_0, 0), 302 BPF_EXIT_INSN(), 303 }, 304 .attach_type = BPF_CGROUP_SYSCTL, 305 .sysctl = "net/ipv4/tcp_mem", 306 .open_flags = O_RDONLY, 307 .result = SUCCESS, 308 }, 309 { 310 .descr = "sysctl_get_name sysctl:full ok", 311 .insns = { 312 /* sysctl_get_name arg2 (buf) */ 313 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 314 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -24), 315 BPF_MOV64_IMM(BPF_REG_0, 0), 316 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 317 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 8), 318 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 16), 319 320 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 321 322 /* sysctl_get_name arg3 (buf_len) */ 323 BPF_MOV64_IMM(BPF_REG_3, 17), 324 325 /* sysctl_get_name arg4 (flags) */ 326 BPF_MOV64_IMM(BPF_REG_4, 0), 327 328 /* sysctl_get_name(ctx, buf, buf_len, flags) */ 329 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_name), 330 331 /* if (ret == expected && */ 332 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 16, 14), 333 334 /* buf[0:8] == "net/ipv4" && */ 335 BPF_LD_IMM64(BPF_REG_8, 336 bpf_be64_to_cpu(0x6e65742f69707634ULL)), 337 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 338 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 10), 339 340 /* buf[8:16] == "/tcp_mem" && */ 341 BPF_LD_IMM64(BPF_REG_8, 342 bpf_be64_to_cpu(0x2f7463705f6d656dULL)), 343 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 8), 344 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 6), 345 346 /* buf[16:24] == "\0") */ 347 BPF_LD_IMM64(BPF_REG_8, 0x0ULL), 348 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 16), 349 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 350 351 /* return ALLOW; */ 352 BPF_MOV64_IMM(BPF_REG_0, 1), 353 BPF_JMP_A(1), 354 355 /* else return DENY; */ 356 BPF_MOV64_IMM(BPF_REG_0, 0), 357 BPF_EXIT_INSN(), 358 }, 359 .attach_type = BPF_CGROUP_SYSCTL, 360 .sysctl = "net/ipv4/tcp_mem", 361 .open_flags = O_RDONLY, 362 .result = SUCCESS, 363 }, 364 { 365 .descr = "sysctl_get_name sysctl:full E2BIG truncated", 366 .insns = { 367 /* sysctl_get_name arg2 (buf) */ 368 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 369 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -16), 370 BPF_MOV64_IMM(BPF_REG_0, 0), 371 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 372 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 8), 373 374 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 375 376 /* sysctl_get_name arg3 (buf_len) */ 377 BPF_MOV64_IMM(BPF_REG_3, 16), 378 379 /* sysctl_get_name arg4 (flags) */ 380 BPF_MOV64_IMM(BPF_REG_4, 0), 381 382 /* sysctl_get_name(ctx, buf, buf_len, flags) */ 383 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_name), 384 385 /* if (ret == expected && */ 386 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -E2BIG, 10), 387 388 /* buf[0:8] == "net/ipv4" && */ 389 BPF_LD_IMM64(BPF_REG_8, 390 bpf_be64_to_cpu(0x6e65742f69707634ULL)), 391 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 392 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 6), 393 394 /* buf[8:16] == "/tcp_me\0") */ 395 BPF_LD_IMM64(BPF_REG_8, 396 bpf_be64_to_cpu(0x2f7463705f6d6500ULL)), 397 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 8), 398 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 399 400 /* return ALLOW; */ 401 BPF_MOV64_IMM(BPF_REG_0, 1), 402 BPF_JMP_A(1), 403 404 /* else return DENY; */ 405 BPF_MOV64_IMM(BPF_REG_0, 0), 406 BPF_EXIT_INSN(), 407 }, 408 .attach_type = BPF_CGROUP_SYSCTL, 409 .sysctl = "net/ipv4/tcp_mem", 410 .open_flags = O_RDONLY, 411 .result = SUCCESS, 412 }, 413 { 414 .descr = "sysctl_get_name sysctl:full E2BIG truncated small", 415 .insns = { 416 /* sysctl_get_name arg2 (buf) */ 417 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 418 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 419 BPF_MOV64_IMM(BPF_REG_0, 0), 420 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 421 422 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 423 424 /* sysctl_get_name arg3 (buf_len) */ 425 BPF_MOV64_IMM(BPF_REG_3, 7), 426 427 /* sysctl_get_name arg4 (flags) */ 428 BPF_MOV64_IMM(BPF_REG_4, 0), 429 430 /* sysctl_get_name(ctx, buf, buf_len, flags) */ 431 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_name), 432 433 /* if (ret == expected && */ 434 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -E2BIG, 6), 435 436 /* buf[0:8] == "net/ip\0") */ 437 BPF_LD_IMM64(BPF_REG_8, 438 bpf_be64_to_cpu(0x6e65742f69700000ULL)), 439 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 440 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 441 442 /* return ALLOW; */ 443 BPF_MOV64_IMM(BPF_REG_0, 1), 444 BPF_JMP_A(1), 445 446 /* else return DENY; */ 447 BPF_MOV64_IMM(BPF_REG_0, 0), 448 BPF_EXIT_INSN(), 449 }, 450 .attach_type = BPF_CGROUP_SYSCTL, 451 .sysctl = "net/ipv4/tcp_mem", 452 .open_flags = O_RDONLY, 453 .result = SUCCESS, 454 }, 455 { 456 .descr = "sysctl_get_current_value sysctl:read ok, gt", 457 .insns = { 458 /* sysctl_get_current_value arg2 (buf) */ 459 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 460 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 461 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 462 463 /* sysctl_get_current_value arg3 (buf_len) */ 464 BPF_MOV64_IMM(BPF_REG_3, 8), 465 466 /* sysctl_get_current_value(ctx, buf, buf_len) */ 467 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_current_value), 468 469 /* if (ret == expected && */ 470 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 6, 6), 471 472 /* buf[0:6] == "Linux\n\0") */ 473 BPF_LD_IMM64(BPF_REG_8, 474 bpf_be64_to_cpu(0x4c696e75780a0000ULL)), 475 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 476 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 477 478 /* return ALLOW; */ 479 BPF_MOV64_IMM(BPF_REG_0, 1), 480 BPF_JMP_A(1), 481 482 /* else return DENY; */ 483 BPF_MOV64_IMM(BPF_REG_0, 0), 484 BPF_EXIT_INSN(), 485 }, 486 .attach_type = BPF_CGROUP_SYSCTL, 487 .sysctl = "kernel/ostype", 488 .open_flags = O_RDONLY, 489 .result = SUCCESS, 490 }, 491 { 492 .descr = "sysctl_get_current_value sysctl:read ok, eq", 493 .insns = { 494 /* sysctl_get_current_value arg2 (buf) */ 495 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 496 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 497 BPF_MOV64_IMM(BPF_REG_0, 0), 498 BPF_STX_MEM(BPF_B, BPF_REG_7, BPF_REG_0, 7), 499 500 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 501 502 /* sysctl_get_current_value arg3 (buf_len) */ 503 BPF_MOV64_IMM(BPF_REG_3, 7), 504 505 /* sysctl_get_current_value(ctx, buf, buf_len) */ 506 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_current_value), 507 508 /* if (ret == expected && */ 509 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 6, 6), 510 511 /* buf[0:6] == "Linux\n\0") */ 512 BPF_LD_IMM64(BPF_REG_8, 513 bpf_be64_to_cpu(0x4c696e75780a0000ULL)), 514 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 515 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 516 517 /* return ALLOW; */ 518 BPF_MOV64_IMM(BPF_REG_0, 1), 519 BPF_JMP_A(1), 520 521 /* else return DENY; */ 522 BPF_MOV64_IMM(BPF_REG_0, 0), 523 BPF_EXIT_INSN(), 524 }, 525 .attach_type = BPF_CGROUP_SYSCTL, 526 .sysctl = "kernel/ostype", 527 .open_flags = O_RDONLY, 528 .result = SUCCESS, 529 }, 530 { 531 .descr = "sysctl_get_current_value sysctl:read E2BIG truncated", 532 .insns = { 533 /* sysctl_get_current_value arg2 (buf) */ 534 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 535 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 536 BPF_MOV64_IMM(BPF_REG_0, 0), 537 BPF_STX_MEM(BPF_H, BPF_REG_7, BPF_REG_0, 6), 538 539 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 540 541 /* sysctl_get_current_value arg3 (buf_len) */ 542 BPF_MOV64_IMM(BPF_REG_3, 6), 543 544 /* sysctl_get_current_value(ctx, buf, buf_len) */ 545 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_current_value), 546 547 /* if (ret == expected && */ 548 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -E2BIG, 6), 549 550 /* buf[0:6] == "Linux\0") */ 551 BPF_LD_IMM64(BPF_REG_8, 552 bpf_be64_to_cpu(0x4c696e7578000000ULL)), 553 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 554 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 555 556 /* return ALLOW; */ 557 BPF_MOV64_IMM(BPF_REG_0, 1), 558 BPF_JMP_A(1), 559 560 /* else return DENY; */ 561 BPF_MOV64_IMM(BPF_REG_0, 0), 562 BPF_EXIT_INSN(), 563 }, 564 .attach_type = BPF_CGROUP_SYSCTL, 565 .sysctl = "kernel/ostype", 566 .open_flags = O_RDONLY, 567 .result = SUCCESS, 568 }, 569 { 570 .descr = "sysctl_get_current_value sysctl:read EINVAL", 571 .insns = { 572 /* sysctl_get_current_value arg2 (buf) */ 573 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 574 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 575 576 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 577 578 /* sysctl_get_current_value arg3 (buf_len) */ 579 BPF_MOV64_IMM(BPF_REG_3, 8), 580 581 /* sysctl_get_current_value(ctx, buf, buf_len) */ 582 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_current_value), 583 584 /* if (ret == expected && */ 585 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -EINVAL, 4), 586 587 /* buf[0:8] is NUL-filled) */ 588 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 589 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0, 2), 590 591 /* return DENY; */ 592 BPF_MOV64_IMM(BPF_REG_0, 0), 593 BPF_JMP_A(1), 594 595 /* else return ALLOW; */ 596 BPF_MOV64_IMM(BPF_REG_0, 1), 597 BPF_EXIT_INSN(), 598 }, 599 .attach_type = BPF_CGROUP_SYSCTL, 600 .sysctl = "net/ipv6/conf/lo/stable_secret", /* -EIO */ 601 .open_flags = O_RDONLY, 602 .result = OP_EPERM, 603 }, 604 { 605 .descr = "sysctl_get_current_value sysctl:write ok", 606 .fixup_value_insn = 6, 607 .insns = { 608 /* sysctl_get_current_value arg2 (buf) */ 609 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 610 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 611 612 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 613 614 /* sysctl_get_current_value arg3 (buf_len) */ 615 BPF_MOV64_IMM(BPF_REG_3, 8), 616 617 /* sysctl_get_current_value(ctx, buf, buf_len) */ 618 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_current_value), 619 620 /* if (ret == expected && */ 621 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 4, 6), 622 623 /* buf[0:4] == expected) */ 624 BPF_LD_IMM64(BPF_REG_8, FIXUP_SYSCTL_VALUE), 625 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 626 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 627 628 /* return DENY; */ 629 BPF_MOV64_IMM(BPF_REG_0, 0), 630 BPF_JMP_A(1), 631 632 /* else return ALLOW; */ 633 BPF_MOV64_IMM(BPF_REG_0, 1), 634 BPF_EXIT_INSN(), 635 }, 636 .attach_type = BPF_CGROUP_SYSCTL, 637 .sysctl = "net/ipv4/route/mtu_expires", 638 .open_flags = O_WRONLY, 639 .newval = "600", /* same as default, should fail anyway */ 640 .result = OP_EPERM, 641 }, 642 { 643 .descr = "sysctl_get_new_value sysctl:read EINVAL", 644 .insns = { 645 /* sysctl_get_new_value arg2 (buf) */ 646 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 647 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 648 BPF_MOV64_IMM(BPF_REG_0, 0), 649 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 650 651 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 652 653 /* sysctl_get_new_value arg3 (buf_len) */ 654 BPF_MOV64_IMM(BPF_REG_3, 8), 655 656 /* sysctl_get_new_value(ctx, buf, buf_len) */ 657 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_new_value), 658 659 /* if (ret == expected) */ 660 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -EINVAL, 2), 661 662 /* return ALLOW; */ 663 BPF_MOV64_IMM(BPF_REG_0, 1), 664 BPF_JMP_A(1), 665 666 /* else return DENY; */ 667 BPF_MOV64_IMM(BPF_REG_0, 0), 668 BPF_EXIT_INSN(), 669 }, 670 .attach_type = BPF_CGROUP_SYSCTL, 671 .sysctl = "net/ipv4/tcp_mem", 672 .open_flags = O_RDONLY, 673 .result = SUCCESS, 674 }, 675 { 676 .descr = "sysctl_get_new_value sysctl:write ok", 677 .insns = { 678 /* sysctl_get_new_value arg2 (buf) */ 679 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 680 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 681 682 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 683 684 /* sysctl_get_new_value arg3 (buf_len) */ 685 BPF_MOV64_IMM(BPF_REG_3, 4), 686 687 /* sysctl_get_new_value(ctx, buf, buf_len) */ 688 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_new_value), 689 690 /* if (ret == expected && */ 691 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 3, 4), 692 693 /* buf[0:4] == "606\0") */ 694 BPF_LDX_MEM(BPF_W, BPF_REG_9, BPF_REG_7, 0), 695 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 696 bpf_ntohl(0x36303600), 2), 697 698 /* return DENY; */ 699 BPF_MOV64_IMM(BPF_REG_0, 0), 700 BPF_JMP_A(1), 701 702 /* else return ALLOW; */ 703 BPF_MOV64_IMM(BPF_REG_0, 1), 704 BPF_EXIT_INSN(), 705 }, 706 .attach_type = BPF_CGROUP_SYSCTL, 707 .sysctl = "net/ipv4/route/mtu_expires", 708 .open_flags = O_WRONLY, 709 .newval = "606", 710 .result = OP_EPERM, 711 }, 712 { 713 .descr = "sysctl_get_new_value sysctl:write ok long", 714 .insns = { 715 /* sysctl_get_new_value arg2 (buf) */ 716 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 717 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -24), 718 719 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 720 721 /* sysctl_get_new_value arg3 (buf_len) */ 722 BPF_MOV64_IMM(BPF_REG_3, 24), 723 724 /* sysctl_get_new_value(ctx, buf, buf_len) */ 725 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_new_value), 726 727 /* if (ret == expected && */ 728 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 23, 14), 729 730 /* buf[0:8] == "3000000 " && */ 731 BPF_LD_IMM64(BPF_REG_8, 732 bpf_be64_to_cpu(0x3330303030303020ULL)), 733 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 734 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 10), 735 736 /* buf[8:16] == "4000000 " && */ 737 BPF_LD_IMM64(BPF_REG_8, 738 bpf_be64_to_cpu(0x3430303030303020ULL)), 739 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 8), 740 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 6), 741 742 /* buf[16:24] == "6000000\0") */ 743 BPF_LD_IMM64(BPF_REG_8, 744 bpf_be64_to_cpu(0x3630303030303000ULL)), 745 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 16), 746 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 747 748 /* return DENY; */ 749 BPF_MOV64_IMM(BPF_REG_0, 0), 750 BPF_JMP_A(1), 751 752 /* else return ALLOW; */ 753 BPF_MOV64_IMM(BPF_REG_0, 1), 754 BPF_EXIT_INSN(), 755 }, 756 .attach_type = BPF_CGROUP_SYSCTL, 757 .sysctl = "net/ipv4/tcp_mem", 758 .open_flags = O_WRONLY, 759 .newval = "3000000 4000000 6000000", 760 .result = OP_EPERM, 761 }, 762 { 763 .descr = "sysctl_get_new_value sysctl:write E2BIG", 764 .insns = { 765 /* sysctl_get_new_value arg2 (buf) */ 766 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 767 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 768 BPF_MOV64_IMM(BPF_REG_0, 0), 769 BPF_STX_MEM(BPF_B, BPF_REG_7, BPF_REG_0, 3), 770 771 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 772 773 /* sysctl_get_new_value arg3 (buf_len) */ 774 BPF_MOV64_IMM(BPF_REG_3, 3), 775 776 /* sysctl_get_new_value(ctx, buf, buf_len) */ 777 BPF_EMIT_CALL(BPF_FUNC_sysctl_get_new_value), 778 779 /* if (ret == expected && */ 780 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -E2BIG, 4), 781 782 /* buf[0:3] == "60\0") */ 783 BPF_LDX_MEM(BPF_W, BPF_REG_9, BPF_REG_7, 0), 784 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 785 bpf_ntohl(0x36300000), 2), 786 787 /* return DENY; */ 788 BPF_MOV64_IMM(BPF_REG_0, 0), 789 BPF_JMP_A(1), 790 791 /* else return ALLOW; */ 792 BPF_MOV64_IMM(BPF_REG_0, 1), 793 BPF_EXIT_INSN(), 794 }, 795 .attach_type = BPF_CGROUP_SYSCTL, 796 .sysctl = "net/ipv4/route/mtu_expires", 797 .open_flags = O_WRONLY, 798 .newval = "606", 799 .result = OP_EPERM, 800 }, 801 { 802 .descr = "sysctl_set_new_value sysctl:read EINVAL", 803 .insns = { 804 /* sysctl_set_new_value arg2 (buf) */ 805 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 806 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 807 BPF_MOV64_IMM(BPF_REG_0, 808 bpf_ntohl(0x36303000)), 809 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 810 811 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 812 813 /* sysctl_set_new_value arg3 (buf_len) */ 814 BPF_MOV64_IMM(BPF_REG_3, 3), 815 816 /* sysctl_set_new_value(ctx, buf, buf_len) */ 817 BPF_EMIT_CALL(BPF_FUNC_sysctl_set_new_value), 818 819 /* if (ret == expected) */ 820 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -EINVAL, 2), 821 822 /* return ALLOW; */ 823 BPF_MOV64_IMM(BPF_REG_0, 1), 824 BPF_JMP_A(1), 825 826 /* else return DENY; */ 827 BPF_MOV64_IMM(BPF_REG_0, 0), 828 BPF_EXIT_INSN(), 829 }, 830 .attach_type = BPF_CGROUP_SYSCTL, 831 .sysctl = "net/ipv4/route/mtu_expires", 832 .open_flags = O_RDONLY, 833 .result = SUCCESS, 834 }, 835 { 836 .descr = "sysctl_set_new_value sysctl:write ok", 837 .fixup_value_insn = 2, 838 .insns = { 839 /* sysctl_set_new_value arg2 (buf) */ 840 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 841 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 842 BPF_LD_IMM64(BPF_REG_0, FIXUP_SYSCTL_VALUE), 843 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 844 845 BPF_MOV64_REG(BPF_REG_2, BPF_REG_7), 846 847 /* sysctl_set_new_value arg3 (buf_len) */ 848 BPF_MOV64_IMM(BPF_REG_3, 3), 849 850 /* sysctl_set_new_value(ctx, buf, buf_len) */ 851 BPF_EMIT_CALL(BPF_FUNC_sysctl_set_new_value), 852 853 /* if (ret == expected) */ 854 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 855 856 /* return ALLOW; */ 857 BPF_MOV64_IMM(BPF_REG_0, 1), 858 BPF_JMP_A(1), 859 860 /* else return DENY; */ 861 BPF_MOV64_IMM(BPF_REG_0, 0), 862 BPF_EXIT_INSN(), 863 }, 864 .attach_type = BPF_CGROUP_SYSCTL, 865 .sysctl = "net/ipv4/route/mtu_expires", 866 .open_flags = O_WRONLY, 867 .newval = "606", 868 .result = SUCCESS, 869 }, 870 { 871 "bpf_strtoul one number string", 872 .insns = { 873 /* arg1 (buf) */ 874 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 875 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 876 BPF_MOV64_IMM(BPF_REG_0, 877 bpf_ntohl(0x36303000)), 878 BPF_STX_MEM(BPF_W, BPF_REG_7, BPF_REG_0, 0), 879 880 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 881 882 /* arg2 (buf_len) */ 883 BPF_MOV64_IMM(BPF_REG_2, 4), 884 885 /* arg3 (flags) */ 886 BPF_MOV64_IMM(BPF_REG_3, 0), 887 888 /* arg4 (res) */ 889 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 890 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 891 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 892 893 BPF_EMIT_CALL(BPF_FUNC_strtoul), 894 895 /* if (ret == expected && */ 896 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 3, 4), 897 /* res == expected) */ 898 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 899 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 600, 2), 900 901 /* return ALLOW; */ 902 BPF_MOV64_IMM(BPF_REG_0, 1), 903 BPF_JMP_A(1), 904 905 /* else return DENY; */ 906 BPF_MOV64_IMM(BPF_REG_0, 0), 907 BPF_EXIT_INSN(), 908 }, 909 .attach_type = BPF_CGROUP_SYSCTL, 910 .sysctl = "net/ipv4/route/mtu_expires", 911 .open_flags = O_RDONLY, 912 .result = SUCCESS, 913 }, 914 { 915 "bpf_strtoul multi number string", 916 .insns = { 917 /* arg1 (buf) */ 918 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 919 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 920 /* "600 602\0" */ 921 BPF_LD_IMM64(BPF_REG_0, 922 bpf_be64_to_cpu(0x3630302036303200ULL)), 923 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 924 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 925 926 /* arg2 (buf_len) */ 927 BPF_MOV64_IMM(BPF_REG_2, 8), 928 929 /* arg3 (flags) */ 930 BPF_MOV64_IMM(BPF_REG_3, 0), 931 932 /* arg4 (res) */ 933 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 934 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 935 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 936 937 BPF_EMIT_CALL(BPF_FUNC_strtoul), 938 939 /* if (ret == expected && */ 940 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 3, 18), 941 /* res == expected) */ 942 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 943 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 600, 16), 944 945 /* arg1 (buf) */ 946 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 947 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 948 BPF_ALU64_REG(BPF_ADD, BPF_REG_7, BPF_REG_0), 949 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 950 951 /* arg2 (buf_len) */ 952 BPF_MOV64_IMM(BPF_REG_2, 8), 953 BPF_ALU64_REG(BPF_SUB, BPF_REG_2, BPF_REG_0), 954 955 /* arg3 (flags) */ 956 BPF_MOV64_IMM(BPF_REG_3, 0), 957 958 /* arg4 (res) */ 959 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 960 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -16), 961 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 962 963 BPF_EMIT_CALL(BPF_FUNC_strtoul), 964 965 /* if (ret == expected && */ 966 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 4, 4), 967 /* res == expected) */ 968 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 969 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 602, 2), 970 971 /* return ALLOW; */ 972 BPF_MOV64_IMM(BPF_REG_0, 1), 973 BPF_JMP_A(1), 974 975 /* else return DENY; */ 976 BPF_MOV64_IMM(BPF_REG_0, 0), 977 BPF_EXIT_INSN(), 978 }, 979 .attach_type = BPF_CGROUP_SYSCTL, 980 .sysctl = "net/ipv4/tcp_mem", 981 .open_flags = O_RDONLY, 982 .result = SUCCESS, 983 }, 984 { 985 "bpf_strtoul buf_len = 0, reject", 986 .insns = { 987 /* arg1 (buf) */ 988 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 989 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 990 BPF_MOV64_IMM(BPF_REG_0, 991 bpf_ntohl(0x36303000)), 992 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 993 994 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 995 996 /* arg2 (buf_len) */ 997 BPF_MOV64_IMM(BPF_REG_2, 0), 998 999 /* arg3 (flags) */ 1000 BPF_MOV64_IMM(BPF_REG_3, 0), 1001 1002 /* arg4 (res) */ 1003 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1004 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1005 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1006 1007 BPF_EMIT_CALL(BPF_FUNC_strtoul), 1008 1009 BPF_MOV64_IMM(BPF_REG_0, 1), 1010 BPF_EXIT_INSN(), 1011 }, 1012 .attach_type = BPF_CGROUP_SYSCTL, 1013 .sysctl = "net/ipv4/route/mtu_expires", 1014 .open_flags = O_RDONLY, 1015 .result = LOAD_REJECT, 1016 }, 1017 { 1018 "bpf_strtoul supported base, ok", 1019 .insns = { 1020 /* arg1 (buf) */ 1021 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 1022 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1023 BPF_MOV64_IMM(BPF_REG_0, 1024 bpf_ntohl(0x30373700)), 1025 BPF_STX_MEM(BPF_W, BPF_REG_7, BPF_REG_0, 0), 1026 1027 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1028 1029 /* arg2 (buf_len) */ 1030 BPF_MOV64_IMM(BPF_REG_2, 4), 1031 1032 /* arg3 (flags) */ 1033 BPF_MOV64_IMM(BPF_REG_3, 8), 1034 1035 /* arg4 (res) */ 1036 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1037 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1038 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1039 1040 BPF_EMIT_CALL(BPF_FUNC_strtoul), 1041 1042 /* if (ret == expected && */ 1043 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 3, 4), 1044 /* res == expected) */ 1045 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 1046 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 63, 2), 1047 1048 /* return ALLOW; */ 1049 BPF_MOV64_IMM(BPF_REG_0, 1), 1050 BPF_JMP_A(1), 1051 1052 /* else return DENY; */ 1053 BPF_MOV64_IMM(BPF_REG_0, 0), 1054 BPF_EXIT_INSN(), 1055 }, 1056 .attach_type = BPF_CGROUP_SYSCTL, 1057 .sysctl = "net/ipv4/route/mtu_expires", 1058 .open_flags = O_RDONLY, 1059 .result = SUCCESS, 1060 }, 1061 { 1062 "bpf_strtoul unsupported base, EINVAL", 1063 .insns = { 1064 /* arg1 (buf) */ 1065 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 1066 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1067 BPF_MOV64_IMM(BPF_REG_0, 1068 bpf_ntohl(0x36303000)), 1069 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1070 1071 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1072 1073 /* arg2 (buf_len) */ 1074 BPF_MOV64_IMM(BPF_REG_2, 4), 1075 1076 /* arg3 (flags) */ 1077 BPF_MOV64_IMM(BPF_REG_3, 3), 1078 1079 /* arg4 (res) */ 1080 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1081 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1082 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1083 1084 BPF_EMIT_CALL(BPF_FUNC_strtoul), 1085 1086 /* if (ret == expected) */ 1087 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -EINVAL, 2), 1088 1089 /* return ALLOW; */ 1090 BPF_MOV64_IMM(BPF_REG_0, 1), 1091 BPF_JMP_A(1), 1092 1093 /* else return DENY; */ 1094 BPF_MOV64_IMM(BPF_REG_0, 0), 1095 BPF_EXIT_INSN(), 1096 }, 1097 .attach_type = BPF_CGROUP_SYSCTL, 1098 .sysctl = "net/ipv4/route/mtu_expires", 1099 .open_flags = O_RDONLY, 1100 .result = SUCCESS, 1101 }, 1102 { 1103 "bpf_strtoul buf with spaces only, EINVAL", 1104 .insns = { 1105 /* arg1 (buf) */ 1106 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 1107 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1108 BPF_MOV64_IMM(BPF_REG_0, 1109 bpf_ntohl(0x0d0c0a09)), 1110 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1111 1112 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1113 1114 /* arg2 (buf_len) */ 1115 BPF_MOV64_IMM(BPF_REG_2, 4), 1116 1117 /* arg3 (flags) */ 1118 BPF_MOV64_IMM(BPF_REG_3, 0), 1119 1120 /* arg4 (res) */ 1121 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1122 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1123 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1124 1125 BPF_EMIT_CALL(BPF_FUNC_strtoul), 1126 1127 /* if (ret == expected) */ 1128 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -EINVAL, 2), 1129 1130 /* return ALLOW; */ 1131 BPF_MOV64_IMM(BPF_REG_0, 1), 1132 BPF_JMP_A(1), 1133 1134 /* else return DENY; */ 1135 BPF_MOV64_IMM(BPF_REG_0, 0), 1136 BPF_EXIT_INSN(), 1137 }, 1138 .attach_type = BPF_CGROUP_SYSCTL, 1139 .sysctl = "net/ipv4/route/mtu_expires", 1140 .open_flags = O_RDONLY, 1141 .result = SUCCESS, 1142 }, 1143 { 1144 "bpf_strtoul negative number, EINVAL", 1145 .insns = { 1146 /* arg1 (buf) */ 1147 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 1148 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1149 /* " -6\0" */ 1150 BPF_MOV64_IMM(BPF_REG_0, 1151 bpf_ntohl(0x0a2d3600)), 1152 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1153 1154 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1155 1156 /* arg2 (buf_len) */ 1157 BPF_MOV64_IMM(BPF_REG_2, 4), 1158 1159 /* arg3 (flags) */ 1160 BPF_MOV64_IMM(BPF_REG_3, 0), 1161 1162 /* arg4 (res) */ 1163 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1164 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1165 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1166 1167 BPF_EMIT_CALL(BPF_FUNC_strtoul), 1168 1169 /* if (ret == expected) */ 1170 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -EINVAL, 2), 1171 1172 /* return ALLOW; */ 1173 BPF_MOV64_IMM(BPF_REG_0, 1), 1174 BPF_JMP_A(1), 1175 1176 /* else return DENY; */ 1177 BPF_MOV64_IMM(BPF_REG_0, 0), 1178 BPF_EXIT_INSN(), 1179 }, 1180 .attach_type = BPF_CGROUP_SYSCTL, 1181 .sysctl = "net/ipv4/route/mtu_expires", 1182 .open_flags = O_RDONLY, 1183 .result = SUCCESS, 1184 }, 1185 { 1186 "bpf_strtol negative number, ok", 1187 .insns = { 1188 /* arg1 (buf) */ 1189 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 1190 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1191 /* " -6\0" */ 1192 BPF_MOV64_IMM(BPF_REG_0, 1193 bpf_ntohl(0x0a2d3600)), 1194 BPF_STX_MEM(BPF_W, BPF_REG_7, BPF_REG_0, 0), 1195 1196 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1197 1198 /* arg2 (buf_len) */ 1199 BPF_MOV64_IMM(BPF_REG_2, 4), 1200 1201 /* arg3 (flags) */ 1202 BPF_MOV64_IMM(BPF_REG_3, 10), 1203 1204 /* arg4 (res) */ 1205 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1206 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1207 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1208 1209 BPF_EMIT_CALL(BPF_FUNC_strtol), 1210 1211 /* if (ret == expected && */ 1212 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 3, 4), 1213 /* res == expected) */ 1214 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 1215 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, -6, 2), 1216 1217 /* return ALLOW; */ 1218 BPF_MOV64_IMM(BPF_REG_0, 1), 1219 BPF_JMP_A(1), 1220 1221 /* else return DENY; */ 1222 BPF_MOV64_IMM(BPF_REG_0, 0), 1223 BPF_EXIT_INSN(), 1224 }, 1225 .attach_type = BPF_CGROUP_SYSCTL, 1226 .sysctl = "net/ipv4/route/mtu_expires", 1227 .open_flags = O_RDONLY, 1228 .result = SUCCESS, 1229 }, 1230 { 1231 "bpf_strtol hex number, ok", 1232 .insns = { 1233 /* arg1 (buf) */ 1234 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 1235 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1236 /* "0xfe" */ 1237 BPF_MOV64_IMM(BPF_REG_0, 1238 bpf_ntohl(0x30786665)), 1239 BPF_STX_MEM(BPF_W, BPF_REG_7, BPF_REG_0, 0), 1240 1241 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1242 1243 /* arg2 (buf_len) */ 1244 BPF_MOV64_IMM(BPF_REG_2, 4), 1245 1246 /* arg3 (flags) */ 1247 BPF_MOV64_IMM(BPF_REG_3, 0), 1248 1249 /* arg4 (res) */ 1250 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1251 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1252 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1253 1254 BPF_EMIT_CALL(BPF_FUNC_strtol), 1255 1256 /* if (ret == expected && */ 1257 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 4, 4), 1258 /* res == expected) */ 1259 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 1260 BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 254, 2), 1261 1262 /* return ALLOW; */ 1263 BPF_MOV64_IMM(BPF_REG_0, 1), 1264 BPF_JMP_A(1), 1265 1266 /* else return DENY; */ 1267 BPF_MOV64_IMM(BPF_REG_0, 0), 1268 BPF_EXIT_INSN(), 1269 }, 1270 .attach_type = BPF_CGROUP_SYSCTL, 1271 .sysctl = "net/ipv4/route/mtu_expires", 1272 .open_flags = O_RDONLY, 1273 .result = SUCCESS, 1274 }, 1275 { 1276 "bpf_strtol max long", 1277 .insns = { 1278 /* arg1 (buf) 9223372036854775807 */ 1279 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 1280 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -24), 1281 BPF_LD_IMM64(BPF_REG_0, 1282 bpf_be64_to_cpu(0x3932323333373230ULL)), 1283 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1284 BPF_LD_IMM64(BPF_REG_0, 1285 bpf_be64_to_cpu(0x3336383534373735ULL)), 1286 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 8), 1287 BPF_LD_IMM64(BPF_REG_0, 1288 bpf_be64_to_cpu(0x3830370000000000ULL)), 1289 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 16), 1290 1291 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1292 1293 /* arg2 (buf_len) */ 1294 BPF_MOV64_IMM(BPF_REG_2, 19), 1295 1296 /* arg3 (flags) */ 1297 BPF_MOV64_IMM(BPF_REG_3, 0), 1298 1299 /* arg4 (res) */ 1300 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1301 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1302 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1303 1304 BPF_EMIT_CALL(BPF_FUNC_strtol), 1305 1306 /* if (ret == expected && */ 1307 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 19, 6), 1308 /* res == expected) */ 1309 BPF_LD_IMM64(BPF_REG_8, 0x7fffffffffffffffULL), 1310 BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0), 1311 BPF_JMP_REG(BPF_JNE, BPF_REG_8, BPF_REG_9, 2), 1312 1313 /* return ALLOW; */ 1314 BPF_MOV64_IMM(BPF_REG_0, 1), 1315 BPF_JMP_A(1), 1316 1317 /* else return DENY; */ 1318 BPF_MOV64_IMM(BPF_REG_0, 0), 1319 BPF_EXIT_INSN(), 1320 }, 1321 .attach_type = BPF_CGROUP_SYSCTL, 1322 .sysctl = "net/ipv4/route/mtu_expires", 1323 .open_flags = O_RDONLY, 1324 .result = SUCCESS, 1325 }, 1326 { 1327 "bpf_strtol overflow, ERANGE", 1328 .insns = { 1329 /* arg1 (buf) 9223372036854775808 */ 1330 BPF_MOV64_REG(BPF_REG_7, BPF_REG_10), 1331 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -24), 1332 BPF_LD_IMM64(BPF_REG_0, 1333 bpf_be64_to_cpu(0x3932323333373230ULL)), 1334 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1335 BPF_LD_IMM64(BPF_REG_0, 1336 bpf_be64_to_cpu(0x3336383534373735ULL)), 1337 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 8), 1338 BPF_LD_IMM64(BPF_REG_0, 1339 bpf_be64_to_cpu(0x3830380000000000ULL)), 1340 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 16), 1341 1342 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1343 1344 /* arg2 (buf_len) */ 1345 BPF_MOV64_IMM(BPF_REG_2, 19), 1346 1347 /* arg3 (flags) */ 1348 BPF_MOV64_IMM(BPF_REG_3, 0), 1349 1350 /* arg4 (res) */ 1351 BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -8), 1352 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1353 BPF_MOV64_REG(BPF_REG_4, BPF_REG_7), 1354 1355 BPF_EMIT_CALL(BPF_FUNC_strtol), 1356 1357 /* if (ret == expected) */ 1358 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, -ERANGE, 2), 1359 1360 /* return ALLOW; */ 1361 BPF_MOV64_IMM(BPF_REG_0, 1), 1362 BPF_JMP_A(1), 1363 1364 /* else return DENY; */ 1365 BPF_MOV64_IMM(BPF_REG_0, 0), 1366 BPF_EXIT_INSN(), 1367 }, 1368 .attach_type = BPF_CGROUP_SYSCTL, 1369 .sysctl = "net/ipv4/route/mtu_expires", 1370 .open_flags = O_RDONLY, 1371 .result = SUCCESS, 1372 }, 1373 { 1374 "C prog: deny all writes", 1375 .prog_file = "./test_sysctl_prog.o", 1376 .attach_type = BPF_CGROUP_SYSCTL, 1377 .sysctl = "net/ipv4/tcp_mem", 1378 .open_flags = O_WRONLY, 1379 .newval = "123 456 789", 1380 .result = OP_EPERM, 1381 }, 1382 { 1383 "C prog: deny access by name", 1384 .prog_file = "./test_sysctl_prog.o", 1385 .attach_type = BPF_CGROUP_SYSCTL, 1386 .sysctl = "net/ipv4/route/mtu_expires", 1387 .open_flags = O_RDONLY, 1388 .result = OP_EPERM, 1389 }, 1390 { 1391 "C prog: read tcp_mem", 1392 .prog_file = "./test_sysctl_prog.o", 1393 .attach_type = BPF_CGROUP_SYSCTL, 1394 .sysctl = "net/ipv4/tcp_mem", 1395 .open_flags = O_RDONLY, 1396 .result = SUCCESS, 1397 }, 1398 }; 1399 1400 static size_t probe_prog_length(const struct bpf_insn *fp) 1401 { 1402 size_t len; 1403 1404 for (len = MAX_INSNS - 1; len > 0; --len) 1405 if (fp[len].code != 0 || fp[len].imm != 0) 1406 break; 1407 return len + 1; 1408 } 1409 1410 static int fixup_sysctl_value(const char *buf, size_t buf_len, 1411 struct bpf_insn *prog, size_t insn_num) 1412 { 1413 union { 1414 uint8_t raw[sizeof(uint64_t)]; 1415 uint64_t num; 1416 } value = {}; 1417 1418 if (buf_len > sizeof(value)) { 1419 log_err("Value is too big (%zd) to use in fixup", buf_len); 1420 return -1; 1421 } 1422 if (prog[insn_num].code != (BPF_LD | BPF_DW | BPF_IMM)) { 1423 log_err("Can fixup only BPF_LD_IMM64 insns"); 1424 return -1; 1425 } 1426 1427 memcpy(value.raw, buf, buf_len); 1428 prog[insn_num].imm = (uint32_t)value.num; 1429 prog[insn_num + 1].imm = (uint32_t)(value.num >> 32); 1430 1431 return 0; 1432 } 1433 1434 static int load_sysctl_prog_insns(struct sysctl_test *test, 1435 const char *sysctl_path) 1436 { 1437 struct bpf_insn *prog = test->insns; 1438 LIBBPF_OPTS(bpf_prog_load_opts, opts); 1439 int ret, insn_cnt; 1440 1441 insn_cnt = probe_prog_length(prog); 1442 1443 if (test->fixup_value_insn) { 1444 char buf[128]; 1445 ssize_t len; 1446 int fd; 1447 1448 fd = open(sysctl_path, O_RDONLY | O_CLOEXEC); 1449 if (fd < 0) { 1450 log_err("open(%s) failed", sysctl_path); 1451 return -1; 1452 } 1453 len = read(fd, buf, sizeof(buf)); 1454 if (len == -1) { 1455 log_err("read(%s) failed", sysctl_path); 1456 close(fd); 1457 return -1; 1458 } 1459 close(fd); 1460 if (fixup_sysctl_value(buf, len, prog, test->fixup_value_insn)) 1461 return -1; 1462 } 1463 1464 opts.log_buf = bpf_log_buf; 1465 opts.log_size = BPF_LOG_BUF_SIZE; 1466 1467 ret = bpf_prog_load(BPF_PROG_TYPE_CGROUP_SYSCTL, NULL, "GPL", prog, insn_cnt, &opts); 1468 if (ret < 0 && test->result != LOAD_REJECT) { 1469 log_err(">>> Loading program error.\n" 1470 ">>> Verifier output:\n%s\n-------\n", bpf_log_buf); 1471 } 1472 1473 return ret; 1474 } 1475 1476 static int load_sysctl_prog_file(struct sysctl_test *test) 1477 { 1478 struct bpf_object *obj; 1479 int prog_fd; 1480 1481 if (bpf_prog_test_load(test->prog_file, BPF_PROG_TYPE_CGROUP_SYSCTL, &obj, &prog_fd)) { 1482 if (test->result != LOAD_REJECT) 1483 log_err(">>> Loading program (%s) error.\n", 1484 test->prog_file); 1485 return -1; 1486 } 1487 1488 return prog_fd; 1489 } 1490 1491 static int load_sysctl_prog(struct sysctl_test *test, const char *sysctl_path) 1492 { 1493 return test->prog_file 1494 ? load_sysctl_prog_file(test) 1495 : load_sysctl_prog_insns(test, sysctl_path); 1496 } 1497 1498 static int access_sysctl(const char *sysctl_path, 1499 const struct sysctl_test *test) 1500 { 1501 int err = 0; 1502 int fd; 1503 1504 fd = open(sysctl_path, test->open_flags | O_CLOEXEC); 1505 if (fd < 0) 1506 return fd; 1507 1508 if (test->seek && lseek(fd, test->seek, SEEK_SET) == -1) { 1509 log_err("lseek(%d) failed", test->seek); 1510 goto err; 1511 } 1512 1513 if (test->open_flags == O_RDONLY) { 1514 char buf[128]; 1515 1516 if (read(fd, buf, sizeof(buf)) == -1) 1517 goto err; 1518 if (test->oldval && 1519 strncmp(buf, test->oldval, strlen(test->oldval))) { 1520 log_err("Read value %s != %s", buf, test->oldval); 1521 goto err; 1522 } 1523 } else if (test->open_flags == O_WRONLY) { 1524 if (!test->newval) { 1525 log_err("New value for sysctl is not set"); 1526 goto err; 1527 } 1528 if (write(fd, test->newval, strlen(test->newval)) == -1) 1529 goto err; 1530 } else { 1531 log_err("Unexpected sysctl access: neither read nor write"); 1532 goto err; 1533 } 1534 1535 goto out; 1536 err: 1537 err = -1; 1538 out: 1539 close(fd); 1540 return err; 1541 } 1542 1543 static int run_test_case(int cgfd, struct sysctl_test *test) 1544 { 1545 enum bpf_attach_type atype = test->attach_type; 1546 char sysctl_path[128]; 1547 int progfd = -1; 1548 int err = 0; 1549 1550 printf("Test case: %s .. ", test->descr); 1551 1552 snprintf(sysctl_path, sizeof(sysctl_path), "/proc/sys/%s", 1553 test->sysctl); 1554 1555 progfd = load_sysctl_prog(test, sysctl_path); 1556 if (progfd < 0) { 1557 if (test->result == LOAD_REJECT) 1558 goto out; 1559 else 1560 goto err; 1561 } 1562 1563 if (bpf_prog_attach(progfd, cgfd, atype, BPF_F_ALLOW_OVERRIDE) < 0) { 1564 if (test->result == ATTACH_REJECT) 1565 goto out; 1566 else 1567 goto err; 1568 } 1569 1570 errno = 0; 1571 if (access_sysctl(sysctl_path, test) == -1) { 1572 if (test->result == OP_EPERM && errno == EPERM) 1573 goto out; 1574 else 1575 goto err; 1576 } 1577 1578 if (test->result != SUCCESS) { 1579 log_err("Unexpected success"); 1580 goto err; 1581 } 1582 1583 goto out; 1584 err: 1585 err = -1; 1586 out: 1587 /* Detaching w/o checking return code: best effort attempt. */ 1588 if (progfd != -1) 1589 bpf_prog_detach(cgfd, atype); 1590 close(progfd); 1591 printf("[%s]\n", err ? "FAIL" : "PASS"); 1592 return err; 1593 } 1594 1595 static int run_tests(int cgfd) 1596 { 1597 int passes = 0; 1598 int fails = 0; 1599 int i; 1600 1601 for (i = 0; i < ARRAY_SIZE(tests); ++i) { 1602 if (run_test_case(cgfd, &tests[i])) 1603 ++fails; 1604 else 1605 ++passes; 1606 } 1607 printf("Summary: %d PASSED, %d FAILED\n", passes, fails); 1608 return fails ? -1 : 0; 1609 } 1610 1611 int main(int argc, char **argv) 1612 { 1613 int cgfd = -1; 1614 int err = 0; 1615 1616 cgfd = cgroup_setup_and_join(CG_PATH); 1617 if (cgfd < 0) 1618 goto err; 1619 1620 /* Use libbpf 1.0 API mode */ 1621 libbpf_set_strict_mode(LIBBPF_STRICT_ALL); 1622 1623 if (run_tests(cgfd)) 1624 goto err; 1625 1626 goto out; 1627 err: 1628 err = -1; 1629 out: 1630 close(cgfd); 1631 cleanup_cgroup_environment(); 1632 return err; 1633 } 1634