tools/testing/selftests/bpf/verifier/var_off.c

   1 {
   2         "variable-offset ctx access",
   3         .insns = {
   4         /* Get an unknown value */
   5         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
   6         /* Make it small and 4-byte aligned */
   7         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 4),
   8         /* add it to skb.  We now have either &skb->len or
   9          * &skb->pkt_type, but we don't know which
  10          */
  11         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_2),
  12         /* dereference it */
  13         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0),
  14         BPF_EXIT_INSN(),
  15         },
  16         .errstr = "variable ctx access var_off=(0x0; 0x4)",
  17         .result = REJECT,
  18         .prog_type = BPF_PROG_TYPE_LWT_IN,
  19 },
  20 {
  21         "variable-offset stack read, priv vs unpriv",
  22         .insns = {
  23         /* Fill the top 8 bytes of the stack */
  24         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
  25         /* Get an unknown value */
  26         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
  27         /* Make it small and 4-byte aligned */
  28         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 4),
  29         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 8),
  30         /* add it to fp.  We now have either fp-4 or fp-8, but
  31          * we don't know which
  32          */
  33         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
  34         /* dereference it for a stack read */
  35         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_2, 0),
  36         BPF_MOV64_IMM(BPF_REG_0, 0),
  37         BPF_EXIT_INSN(),
  38         },
  39         .result = ACCEPT,
  40         .result_unpriv = REJECT,
  41         .errstr_unpriv = "R2 variable stack access prohibited for !root",
  42         .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
  43 },
  44 {
  45         "variable-offset stack read, uninitialized",
  46         .insns = {
  47         /* Get an unknown value */
  48         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
  49         /* Make it small and 4-byte aligned */
  50         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 4),
  51         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 8),
  52         /* add it to fp.  We now have either fp-4 or fp-8, but
  53          * we don't know which
  54          */
  55         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
  56         /* dereference it for a stack read */
  57         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_2, 0),
  58         BPF_MOV64_IMM(BPF_REG_0, 0),
  59         BPF_EXIT_INSN(),
  60         },
  61         .result = REJECT,
  62         .errstr = "invalid variable-offset read from stack R2",
  63         .prog_type = BPF_PROG_TYPE_LWT_IN,
  64 },
  65 {
  66         "variable-offset stack write, priv vs unpriv",
  67         .insns = {
  68         /* Get an unknown value */
  69         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
  70         /* Make it small and 8-byte aligned */
  71         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 8),
  72         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 16),
  73         /* Add it to fp.  We now have either fp-8 or fp-16, but
  74          * we don't know which
  75          */
  76         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
  77         /* Dereference it for a stack write */
  78         BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
  79         /* Now read from the address we just wrote. This shows
  80          * that, after a variable-offset write, a priviledged
  81          * program can read the slots that were in the range of
  82          * that write (even if the verifier doesn't actually know
  83          * if the slot being read was really written to or not.
  84          */
  85         BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_2, 0),
  86         BPF_MOV64_IMM(BPF_REG_0, 0),
  87         BPF_EXIT_INSN(),
  88         },
  89         /* Variable stack access is rejected for unprivileged.
  90          */
  91         .errstr_unpriv = "R2 variable stack access prohibited for !root",
  92         .result_unpriv = REJECT,
  93         .result = ACCEPT,
  94 },
  95 {
  96         "variable-offset stack write clobbers spilled regs",
  97         .insns = {
  98         /* Dummy instruction; needed because we need to patch the next one
  99          * and we can't patch the first instruction.
 100          */
 101         BPF_MOV64_IMM(BPF_REG_6, 0),
 102         /* Make R0 a map ptr */
 103         BPF_LD_MAP_FD(BPF_REG_0, 0),
 104         /* Get an unknown value */
 105         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
 106         /* Make it small and 8-byte aligned */
 107         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 8),
 108         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 16),
 109         /* Add it to fp. We now have either fp-8 or fp-16, but
 110          * we don't know which.
 111          */
 112         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
 113         /* Spill R0(map ptr) into stack */
 114         BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -8),
 115         /* Dereference the unknown value for a stack write */
 116         BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
 117         /* Fill the register back into R2 */
 118         BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, -8),
 119         /* Try to dereference R2 for a memory load */
 120         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_2, 8),
 121         BPF_EXIT_INSN(),
 122         },
 123         .fixup_map_hash_8b = { 1 },
 124         /* The unprivileged case is not too interesting; variable
 125          * stack access is rejected.
 126          */
 127         .errstr_unpriv = "R2 variable stack access prohibited for !root",
 128         .result_unpriv = REJECT,
 129         /* In the priviledged case, dereferencing a spilled-and-then-filled
 130          * register is rejected because the previous variable offset stack
 131          * write might have overwritten the spilled pointer (i.e. we lose track
 132          * of the spilled register when we analyze the write).
 133          */
 134         .errstr = "R2 invalid mem access 'scalar'",
 135         .result = REJECT,
 136 },
 137 {
 138         "indirect variable-offset stack access, unbounded",
 139         .insns = {
 140         BPF_MOV64_IMM(BPF_REG_2, 6),
 141         BPF_MOV64_IMM(BPF_REG_3, 28),
 142         /* Fill the top 16 bytes of the stack. */
 143         BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, 0),
 144         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 145         /* Get an unknown value. */
 146         BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_1, offsetof(struct bpf_sock_ops,
 147                                                            bytes_received)),
 148         /* Check the lower bound but don't check the upper one. */
 149         BPF_JMP_IMM(BPF_JSLT, BPF_REG_4, 0, 4),
 150         /* Point the lower bound to initialized stack. Offset is now in range
 151          * from fp-16 to fp+0x7fffffffffffffef, i.e. max value is unbounded.
 152          */
 153         BPF_ALU64_IMM(BPF_SUB, BPF_REG_4, 16),
 154         BPF_ALU64_REG(BPF_ADD, BPF_REG_4, BPF_REG_10),
 155         BPF_MOV64_IMM(BPF_REG_5, 8),
 156         /* Dereference it indirectly. */
 157         BPF_EMIT_CALL(BPF_FUNC_getsockopt),
 158         BPF_MOV64_IMM(BPF_REG_0, 0),
 159         BPF_EXIT_INSN(),
 160         },
 161         .errstr = "invalid unbounded variable-offset indirect access to stack R4",
 162         .result = REJECT,
 163         .prog_type = BPF_PROG_TYPE_SOCK_OPS,
 164 },
 165 {
 166         "indirect variable-offset stack access, max out of bound",
 167         .insns = {
 168         /* Fill the top 8 bytes of the stack */
 169         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 170         /* Get an unknown value */
 171         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
 172         /* Make it small and 4-byte aligned */
 173         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 4),
 174         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 8),
 175         /* add it to fp.  We now have either fp-4 or fp-8, but
 176          * we don't know which
 177          */
 178         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
 179         /* dereference it indirectly */
 180         BPF_LD_MAP_FD(BPF_REG_1, 0),
 181         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 182         BPF_MOV64_IMM(BPF_REG_0, 0),
 183         BPF_EXIT_INSN(),
 184         },
 185         .fixup_map_hash_8b = { 5 },
 186         .errstr = "invalid variable-offset indirect access to stack R2",
 187         .result = REJECT,
 188         .prog_type = BPF_PROG_TYPE_LWT_IN,
 189 },
 190 {
 191         "indirect variable-offset stack access, min out of bound",
 192         .insns = {
 193         /* Fill the top 8 bytes of the stack */
 194         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 195         /* Get an unknown value */
 196         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
 197         /* Make it small and 4-byte aligned */
 198         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 4),
 199         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 516),
 200         /* add it to fp.  We now have either fp-516 or fp-512, but
 201          * we don't know which
 202          */
 203         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
 204         /* dereference it indirectly */
 205         BPF_LD_MAP_FD(BPF_REG_1, 0),
 206         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 207         BPF_MOV64_IMM(BPF_REG_0, 0),
 208         BPF_EXIT_INSN(),
 209         },
 210         .fixup_map_hash_8b = { 5 },
 211         .errstr = "invalid variable-offset indirect access to stack R2",
 212         .result = REJECT,
 213         .prog_type = BPF_PROG_TYPE_LWT_IN,
 214 },
 215 {
 216         "indirect variable-offset stack access, min_off < min_initialized",
 217         .insns = {
 218         /* Fill only the top 8 bytes of the stack. */
 219         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 220         /* Get an unknown value */
 221         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
 222         /* Make it small and 4-byte aligned. */
 223         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 4),
 224         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 16),
 225         /* Add it to fp.  We now have either fp-12 or fp-16, but we don't know
 226          * which. fp-16 size 8 is partially uninitialized stack.
 227          */
 228         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
 229         /* Dereference it indirectly. */
 230         BPF_LD_MAP_FD(BPF_REG_1, 0),
 231         BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
 232         BPF_MOV64_IMM(BPF_REG_0, 0),
 233         BPF_EXIT_INSN(),
 234         },
 235         .fixup_map_hash_8b = { 5 },
 236         .errstr = "invalid indirect read from stack R2 var_off",
 237         .result = REJECT,
 238         .prog_type = BPF_PROG_TYPE_LWT_IN,
 239 },
 240 {
 241         "indirect variable-offset stack access, priv vs unpriv",
 242         .insns = {
 243         /* Fill the top 16 bytes of the stack. */
 244         BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, 0),
 245         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 246         /* Get an unknown value. */
 247         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
 248         /* Make it small and 4-byte aligned. */
 249         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 4),
 250         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 16),
 251         /* Add it to fp.  We now have either fp-12 or fp-16, we don't know
 252          * which, but either way it points to initialized stack.
 253          */
 254         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
 255         /* Dereference it indirectly. */
 256         BPF_LD_MAP_FD(BPF_REG_1, 0),
 257         BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
 258         BPF_MOV64_IMM(BPF_REG_0, 0),
 259         BPF_EXIT_INSN(),
 260         },
 261         .fixup_map_hash_8b = { 6 },
 262         .errstr_unpriv = "R2 variable stack access prohibited for !root",
 263         .result_unpriv = REJECT,
 264         .result = ACCEPT,
 265         .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
 266 },
 267 {
 268         "indirect variable-offset stack access, ok",
 269         .insns = {
 270         /* Fill the top 16 bytes of the stack. */
 271         BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, 0),
 272         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 273         /* Get an unknown value. */
 274         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 0),
 275         /* Make it small and 4-byte aligned. */
 276         BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 4),
 277         BPF_ALU64_IMM(BPF_SUB, BPF_REG_2, 16),
 278         /* Add it to fp.  We now have either fp-12 or fp-16, we don't know
 279          * which, but either way it points to initialized stack.
 280          */
 281         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_10),
 282         /* Dereference it indirectly. */
 283         BPF_LD_MAP_FD(BPF_REG_1, 0),
 284         BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
 285         BPF_MOV64_IMM(BPF_REG_0, 0),
 286         BPF_EXIT_INSN(),
 287         },
 288         .fixup_map_hash_8b = { 6 },
 289         .result = ACCEPT,
 290         .prog_type = BPF_PROG_TYPE_LWT_IN,
 291 },