samples/seccomp/bpf-helper.h

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /*
0003  * Example wrapper around BPF macros.
0004  *
0005  * Copyright (c) 2012 The Chromium OS Authors <chromium-os-dev@chromium.org>
0006  * Author: Will Drewry <wad@chromium.org>
0007  *
0008  * The code may be used by anyone for any purpose,
0009  * and can serve as a starting point for developing
0010  * applications using prctl(PR_SET_SECCOMP, 2, ...).
0011  *
0012  * No guarantees are provided with respect to the correctness
0013  * or functionality of this code.
0014  */
0015 #ifndef __BPF_HELPER_H__
0016 #define __BPF_HELPER_H__
0017
0018 #include <asm/bitsperlong.h>    /* for __BITS_PER_LONG */
0019 #include <endian.h>
0020 #include <linux/filter.h>
0021 #include <linux/seccomp.h>  /* for seccomp_data */
0022 #include <linux/types.h>
0023 #include <linux/unistd.h>
0024 #include <stddef.h>
0025
0026 #define BPF_LABELS_MAX 256
0027 struct bpf_labels {
0028     int count;
0029     struct __bpf_label {
0030         const char *label;
0031         __u32 location;
0032     } labels[BPF_LABELS_MAX];
0033 };
0034
0035 int bpf_resolve_jumps(struct bpf_labels *labels,
0036               struct sock_filter *filter, size_t count);
0037 __u32 seccomp_bpf_label(struct bpf_labels *labels, const char *label);
0038 void seccomp_bpf_print(struct sock_filter *filter, size_t count);
0039
0040 #define JUMP_JT 0xff
0041 #define JUMP_JF 0xff
0042 #define LABEL_JT 0xfe
0043 #define LABEL_JF 0xfe
0044
0045 #define ALLOW \
0046     BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW)
0047 #define DENY \
0048     BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL)
0049 #define JUMP(labels, label) \
0050     BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \
0051          JUMP_JT, JUMP_JF)
0052 #define LABEL(labels, label) \
0053     BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \
0054          LABEL_JT, LABEL_JF)
0055 #define SYSCALL(nr, jt) \
0056     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (nr), 0, 1), \
0057     jt
0058
0059 /* Lame, but just an example */
0060 #define FIND_LABEL(labels, label) seccomp_bpf_label((labels), #label)
0061
0062 #define EXPAND(...) __VA_ARGS__
0063
0064 /* Ensure that we load the logically correct offset. */
0065 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
0066 #define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
0067 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
0068 #define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
0069 #else
0070 #error "Unknown endianness"
0071 #endif
0072
0073 /* Map all width-sensitive operations */
0074 #if __BITS_PER_LONG == 32
0075
0076 #define JEQ(x, jt) JEQ32(x, EXPAND(jt))
0077 #define JNE(x, jt) JNE32(x, EXPAND(jt))
0078 #define JGT(x, jt) JGT32(x, EXPAND(jt))
0079 #define JLT(x, jt) JLT32(x, EXPAND(jt))
0080 #define JGE(x, jt) JGE32(x, EXPAND(jt))
0081 #define JLE(x, jt) JLE32(x, EXPAND(jt))
0082 #define JA(x, jt) JA32(x, EXPAND(jt))
0083 #define ARG(i) ARG_32(i)
0084
0085 #elif __BITS_PER_LONG == 64
0086
0087 /* Ensure that we load the logically correct offset. */
0088 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
0089 #define ENDIAN(_lo, _hi) _lo, _hi
0090 #define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
0091 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
0092 #define ENDIAN(_lo, _hi) _hi, _lo
0093 #define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
0094 #endif
0095
0096 union arg64 {
0097     struct {
0098         __u32 ENDIAN(lo32, hi32);
0099     };
0100     __u64 u64;
0101 };
0102
0103 #define JEQ(x, jt) \
0104     JEQ64(((union arg64){.u64 = (x)}).lo32, \
0105           ((union arg64){.u64 = (x)}).hi32, \
0106           EXPAND(jt))
0107 #define JGT(x, jt) \
0108     JGT64(((union arg64){.u64 = (x)}).lo32, \
0109           ((union arg64){.u64 = (x)}).hi32, \
0110           EXPAND(jt))
0111 #define JGE(x, jt) \
0112     JGE64(((union arg64){.u64 = (x)}).lo32, \
0113           ((union arg64){.u64 = (x)}).hi32, \
0114           EXPAND(jt))
0115 #define JNE(x, jt) \
0116     JNE64(((union arg64){.u64 = (x)}).lo32, \
0117           ((union arg64){.u64 = (x)}).hi32, \
0118           EXPAND(jt))
0119 #define JLT(x, jt) \
0120     JLT64(((union arg64){.u64 = (x)}).lo32, \
0121           ((union arg64){.u64 = (x)}).hi32, \
0122           EXPAND(jt))
0123 #define JLE(x, jt) \
0124     JLE64(((union arg64){.u64 = (x)}).lo32, \
0125           ((union arg64){.u64 = (x)}).hi32, \
0126           EXPAND(jt))
0127
0128 #define JA(x, jt) \
0129     JA64(((union arg64){.u64 = (x)}).lo32, \
0130            ((union arg64){.u64 = (x)}).hi32, \
0131            EXPAND(jt))
0132 #define ARG(i) ARG_64(i)
0133
0134 #else
0135 #error __BITS_PER_LONG value unusable.
0136 #endif
0137
0138 /* Loads the arg into A */
0139 #define ARG_32(idx) \
0140     BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx))
0141
0142 /* Loads lo into M[0] and hi into M[1] and A */
0143 #define ARG_64(idx) \
0144     BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx)), \
0145     BPF_STMT(BPF_ST, 0), /* lo -> M[0] */ \
0146     BPF_STMT(BPF_LD+BPF_W+BPF_ABS, HI_ARG(idx)), \
0147     BPF_STMT(BPF_ST, 1) /* hi -> M[1] */
0148
0149 #define JEQ32(value, jt) \
0150     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 0, 1), \
0151     jt
0152
0153 #define JNE32(value, jt) \
0154     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 1, 0), \
0155     jt
0156
0157 #define JA32(value, jt) \
0158     BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (value), 0, 1), \
0159     jt
0160
0161 #define JGE32(value, jt) \
0162     BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 0, 1), \
0163     jt
0164
0165 #define JGT32(value, jt) \
0166     BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 0, 1), \
0167     jt
0168
0169 #define JLE32(value, jt) \
0170     BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 1, 0), \
0171     jt
0172
0173 #define JLT32(value, jt) \
0174     BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 1, 0), \
0175     jt
0176
0177 /*
0178  * All the JXX64 checks assume lo is saved in M[0] and hi is saved in both
0179  * A and M[1]. This invariant is kept by restoring A if necessary.
0180  */
0181 #define JEQ64(lo, hi, jt) \
0182     /* if (hi != arg.hi) goto NOMATCH; */ \
0183     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
0184     BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
0185     /* if (lo != arg.lo) goto NOMATCH; */ \
0186     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 0, 2), \
0187     BPF_STMT(BPF_LD+BPF_MEM, 1), \
0188     jt, \
0189     BPF_STMT(BPF_LD+BPF_MEM, 1)
0190
0191 #define JNE64(lo, hi, jt) \
0192     /* if (hi != arg.hi) goto MATCH; */ \
0193     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 3), \
0194     BPF_STMT(BPF_LD+BPF_MEM, 0), \
0195     /* if (lo != arg.lo) goto MATCH; */ \
0196     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 2, 0), \
0197     BPF_STMT(BPF_LD+BPF_MEM, 1), \
0198     jt, \
0199     BPF_STMT(BPF_LD+BPF_MEM, 1)
0200
0201 #define JA64(lo, hi, jt) \
0202     /* if (hi & arg.hi) goto MATCH; */ \
0203     BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (hi), 3, 0), \
0204     BPF_STMT(BPF_LD+BPF_MEM, 0), \
0205     /* if (lo & arg.lo) goto MATCH; */ \
0206     BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (lo), 0, 2), \
0207     BPF_STMT(BPF_LD+BPF_MEM, 1), \
0208     jt, \
0209     BPF_STMT(BPF_LD+BPF_MEM, 1)
0210
0211 #define JGE64(lo, hi, jt) \
0212     /* if (hi > arg.hi) goto MATCH; */ \
0213     BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
0214     /* if (hi != arg.hi) goto NOMATCH; */ \
0215     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
0216     BPF_STMT(BPF_LD+BPF_MEM, 0), \
0217     /* if (lo >= arg.lo) goto MATCH; */ \
0218     BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 0, 2), \
0219     BPF_STMT(BPF_LD+BPF_MEM, 1), \
0220     jt, \
0221     BPF_STMT(BPF_LD+BPF_MEM, 1)
0222
0223 #define JGT64(lo, hi, jt) \
0224     /* if (hi > arg.hi) goto MATCH; */ \
0225     BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
0226     /* if (hi != arg.hi) goto NOMATCH; */ \
0227     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
0228     BPF_STMT(BPF_LD+BPF_MEM, 0), \
0229     /* if (lo > arg.lo) goto MATCH; */ \
0230     BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 0, 2), \
0231     BPF_STMT(BPF_LD+BPF_MEM, 1), \
0232     jt, \
0233     BPF_STMT(BPF_LD+BPF_MEM, 1)
0234
0235 #define JLE64(lo, hi, jt) \
0236     /* if (hi < arg.hi) goto MATCH; */ \
0237     BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
0238     /* if (hi != arg.hi) goto NOMATCH; */ \
0239     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
0240     BPF_STMT(BPF_LD+BPF_MEM, 0), \
0241     /* if (lo <= arg.lo) goto MATCH; */ \
0242     BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
0243     BPF_STMT(BPF_LD+BPF_MEM, 1), \
0244     jt, \
0245     BPF_STMT(BPF_LD+BPF_MEM, 1)
0246
0247 #define JLT64(lo, hi, jt) \
0248     /* if (hi < arg.hi) goto MATCH; */ \
0249     BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
0250     /* if (hi != arg.hi) goto NOMATCH; */ \
0251     BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
0252     BPF_STMT(BPF_LD+BPF_MEM, 0), \
0253     /* if (lo < arg.lo) goto MATCH; */ \
0254     BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 2, 0), \
0255     BPF_STMT(BPF_LD+BPF_MEM, 1), \
0256     jt, \
0257     BPF_STMT(BPF_LD+BPF_MEM, 1)
0258
0259 #define LOAD_SYSCALL_NR \
0260     BPF_STMT(BPF_LD+BPF_W+BPF_ABS, \
0261          offsetof(struct seccomp_data, nr))
0262
0263 #endif  /* __BPF_HELPER_H__ */