文章目录
- 啥是seccomp
- #ifndef #define #endif使用
- 使用格式
- seccomp
- 无参数条件禁用系统调用
- 有参数条件禁用系统调用
- prctl
- 实例
- seccomp_export_bpf
啥是seccomp
就是可以禁用掉某些系统调用，然后只能允许某些系统调用
#ifndef #define #endif使用
#ifndef #define #endif作用就是防止头文件被重复引用，
其实“被重复引用”是指一个头文件在同一个cpp文件中被include了多次，这种错误常常是由于include嵌套造成的或者是简单地include多次。比如：存在a.h文件 #include "c.h"而此时b.cpp文件还有了=#include “a.h” 和#include "c.h"此时就会造成c.h重复引用。
头文件被重复引用引起的后果：
有些头文件重复引用只是增加了编译工作的工作量，不会引起太大的问题，仅仅是编译效率低一些，但是对于大工程而言编译效率低下那就比较严重了。
有些头文件重复包含，会引起错误，比如在头文件中定义了全局变量(虽然这种方式不被推荐，但确实是C规范允许的)，在重复引用后会引起重复定义。这样就可能会报错、
下面给一个#ifndef/#define/#endif的格式：
#ifndef A_H意思是"if not define a.h" 如果不存在a.h
接着的语句应该#define A_H 然后相关头文件的内容
最后一句应该写#endif A_H 结束过程
使用格式
#ifndef <标识>
#define <标识>
....
#endif <标识>
<标识>在理论上来说可以 是自由命名的，但每个头文件的这个“标识”都应该是唯一的。标识的命名规则一般是头文件名全大写，前后加下划线，并把文件名中的“.”也变成下划线，如：stdio.h 对应得标识为 STDIO_H
例如要编写头文件sys.h，需要在sys.h文件开头写上:
#ifndef SYS_H
#define SYS_H
....
#endif SYS_H
那么当#include"sys.h"时会判断是否sys.h已经被导入了
如果此时是第一次#include"sys.h"，那么会执行#define SYS_H，此时_SYS_H被定义了
当第二次#include"sys.h"，由于此时已经定义了SYS_H，所以不会执行#define SYS_H以及之后的内容
seccomp
seccomp学习
一般seccomp得使用流程
ctx = seccomp_init(SCMP_ACT_ALLOW);
seccomp_init(uint32_t def_action)
def_action 是过滤器工作模式
seccomp_init是初始化的过滤状态,这里用的是SCMP_ACT_ALLOW,表示默认允许所有的syscacll.如果初始化状态为SCMP_ACT_KILL,则表示默认不允许所有的syscall
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);
int seccomp_rule_add(scmp_filter_ctx " ctx ", uint32_t " action ",int " syscall ",unsigned int " arg_cnt ", " ... ");
ctx ：初始化定义的过滤器
action ：规则模式，匹配到系统调用后执行的操作，和初始化过滤器的 def_action类型一样
syscall ：系统调用号，可以使用 SCMP_SYS(函数名) 代替具体调用号
arg_cnt ：需要参数限制规则个数 seccomp_rule_add 限制参数接口定义在 seccomp.h.in 。主要是取参数操作 SCMP_AX ，运算比较 scmp_compare 。当这些规则都满足后才能此seccomp_rule_add函数成功执行
只要匹配系统调用，不管参数内容：那么arg_cnt=0。匹配系统调用后，根据参数内容决定是否执行 action ：arg_cnt=N(规则条数)，后面再跟N个参数
seccomp_load(ctx);
seccomp_load是应用过滤,加载沙箱规则,如果不调用seccomp_load则上面所有的过滤都不会生效
无参数条件禁用系统调用
seccomp_rule_add(ctx,SCMP_ACT_KILL,SCMP_SYS(execve),0); //add roles into filter
seccomp_rule_add(ctx,SCMP_ACT_KILL,SCMP_SYS(write),0); //add roles into filter
此时禁止write和execve的系统调用，不管其系统调用对应函数的参数咋样
有参数条件禁用系统调用
当有限制规则时，对应规则通过以下宏编写
/**
* Specify an argument comparison struct for use in declaring rules
* @param arg the argument number, starting at 0
* @param op the comparison operator, e.g. SCMP_CMP_*
* @param datum_a dependent on comparison
* @param datum_b dependent on comparison, optional
*/
#define SCMP_CMP(...) ((struct scmp_arg_cmp){__VA_ARGS__})
/**
* Specify an argument comparison struct for argument 0
*/
#define SCMP_A0(...) SCMP_CMP(0, __VA_ARGS__)
/**
* Specify an argument comparison struct for argument 1
*/
#define SCMP_A1(...) SCMP_CMP(1, __VA_ARGS__)
/**
* Specify an argument comparison struct for argument 2
*/
#define SCMP_A2(...) SCMP_CMP(2, __VA_ARGS__)
/**
* Specify an argument comparison struct for argument 3
*/
#define SCMP_A3(...) SCMP_CMP(3, __VA_ARGS__)
/**
* Specify an argument comparison struct for argument 4
*/
#define SCMP_A4(...) SCMP_CMP(4, __VA_ARGS__)
/**
* Specify an argument comparison struct for argument 5
*/
#define SCMP_A5(...) SCMP_CMP(5, __VA_ARGS__)
/**
* Comparison operators
*/
enum scmp_compare {
_SCMP_CMP_MIN = 0,
SCMP_CMP_NE = 1, /**< not equal */
SCMP_CMP_LT = 2, /**< less than */
SCMP_CMP_LE = 3, /**< less than or equal */
SCMP_CMP_EQ = 4, /**< equal */
SCMP_CMP_GE = 5, /**< greater than or equal */
SCMP_CMP_GT = 6, /**< greater than */
SCMP_CMP_MASKED_EQ = 7, /**< masked equality */
_SCMP_CMP_MAX,
};
/**
* Argument datum
*/
typedef uint64_t scmp_datum_t;
/**
* Argument / Value comparison definition
*/
struct scmp_arg_cmp {
unsigned int arg; /**< argument number, starting at 0 */
enum scmp_compare op; /**< the comparison op, e.g. SCMP_CMP_* */
scmp_datum_t datum_a;
scmp_datum_t datum_b;
};
seccomp_rule_add(ctx,SCMP_ACT_KILL,SCMP_SYS(write),1,SCMP_A0(SCMP_CMP_LE,0x10)); //add roles into filter
/*read的第0个参数为文件描述符，其小于等于0x10时不能使用*/
seccomp_rule_add(ctx,SCMP_ACT_KILL,SCMP_SYS(read),2,
SCMP_A0(SCMP_CMP_LE,0x10),
SCMP_A2(SCMP_CMP_GT,0x8)); //add roles into filter此时read有两天规则，第0个参数需要小于等于0x10，第2个参数需要大于0x8,那么将禁止其使用
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(write),1,SCMP_A2(SCMP_CMP_EQ,0x10));//第2(从0开始数起)个参数等于0x10 此时如果write函数的第2个参数即写入长度等于0x10将使用失败
prctl
int prctl(int option, unsigned long arg2, unsigned long arg3,
unsigned long arg4, unsigned long arg5);
prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);
当option为PR_SET_NO_NEW_PRIVS(38),且arg2为1时,将无法获得特权，即能getshell，但无法获得root权限
当option为PR_SET_SECCOMP(22)时,效果就是我们上面的seccomp了,只不过这里的格式略有不同。此时还与参数2有关
如果arg2为SECCOMP_MODE_STRICT(1),则只允许调用read,write,_exit(not exit_group),sigreturn这几个系统调用
如果arg2为SECCOMP_MODE_FILTER(2),则为过滤模式,其中对syscall的限制通过arg3用BPF(Berkeley Packet Filter)的形式传进来,是指向struct sock_fprog数组的指针
/*
* Try and keep these values and structures similar to BSD, especially
* the BPF code definitions which need to match so you can share filters
*/
struct sock_filter { /* Filter block */
__u16 code; /* Actual filter code */
__u8 jt; /* Jump true 符合jmp条件时跳过的规则数*/
__u8 jf; /* Jump false不符合jmp条件时跳过的规则数 */
__u32 k; /* Generic multiuse field */
};
struct sock_fprog { /* Required for SO_ATTACH_FILTER. */
unsigned short len; /* Number of filter blocks */
struct sock_filter *filter;
};
关于filter中的格式其实可以分为BPF_STMT和BPF_JUMP两种格式，注意k的位置在宏定义中的参数和对应的filter中是不同，k在filter中都是第四个，但BPF_JUMP(code, k, jt, jf)为第二个
#ifndef BPF_STMT
#define BPF_STMT(code, k) { (unsigned short)(code), 0, 0, k }
#endif
#ifndef BPF_JUMP
#define BPF_JUMP(code, k, jt, jf) { (unsigned short)(code), jt, jf, k }
#endif
此时两种格式中code的值是由各种宏或得到的
/* Instruction classes */
#define BPF_CLASS(code) ((code) & 0x07) //指定操作的类别
#define BPF_LD 0x00 //将值复制到累加器中
#define BPF_LDX 0x01 //将值加载到索引寄存器中
#define BPF_ST 0x02 //将累加器中的值存到暂存器
#define BPF_STX 0x03 //将索引寄存器的值存储在暂存器中
#define BPF_ALU 0x04 //用索引寄存器或常数作为操作数在累加器上执行算数或逻辑运算
#define BPF_JMP 0x05 //跳转
#define BPF_RET 0x06 //返回
#define BPF_MISC 0x07 // 其他类别
/* ld/ldx fields */
#define BPF_SIZE(code) ((code) & 0x18)
#define BPF_W 0x00 /* 32-bit */ //字
#define BPF_H 0x08 /* 16-bit */ //半字
#define BPF_B 0x10 /* 8-bit */ //字节
/* eBPF BPF_DW 0x18 64-bit */ //双字
#define BPF_MODE(code) ((code) & 0xe0)
#define BPF_IMM 0x00 //常数
#define BPF_ABS 0x20 //固定偏移量的数据包数据(绝对偏移)
#define BPF_IND 0x40 //可变偏移量的数据包数据(相对偏移)
#define BPF_MEM 0x60 //暂存器中的一个字
#define BPF_LEN 0x80 //数据包长度
#define BPF_MSH 0xa0
/* alu/jmp fields */
#define BPF_OP(code) ((code) & 0xf0) //当操作码类型为ALU时，指定具体运算符
#define BPF_ADD 0x00
#define BPF_SUB 0x10
#define BPF_MUL 0x20
#define BPF_DIV 0x30
#define BPF_OR 0x40
#define BPF_AND 0x50
#define BPF_LSH 0x60
#define BPF_RSH 0x70
#define BPF_NEG 0x80
#define BPF_MOD 0x90
#define BPF_XOR 0xa0
//当操作码是jmp时指定跳转类型
#define BPF_JA 0x00
#define BPF_JEQ 0x10
#define BPF_JGT 0x20
#define BPF_JGE 0x30
#define BPF_JSET 0x40
#define BPF_SRC(code) ((code) & 0x08)
#define BPF_K 0x00 //常数
#define BPF_X 0x08 //索引寄存器
k也可以是以下宏定义
/*
* All BPF programs must return a 32-bit value.
* The bottom 16-bits are for optional return data.
* The upper 16-bits are ordered from least permissive values to most,
* as a signed value (so 0x8000000 is negative).
*
* The ordering ensures that a min_t() over composed return values always
* selects the least permissive choice.
*/
#define SECCOMP_RET_KILL_PROCESS 0x80000000U /* kill the process */
#define SECCOMP_RET_KILL_THREAD 0x00000000U /* kill the thread */
#define SECCOMP_RET_KILL SECCOMP_RET_KILL_THREAD
#define SECCOMP_RET_TRAP 0x00030000U /* disallow and force a SIGSYS */
#define SECCOMP_RET_ERRNO 0x00050000U /* returns an errno */
#define SECCOMP_RET_USER_NOTIF 0x7fc00000U /* notifies userspace */
#define SECCOMP_RET_TRACE 0x7ff00000U /* pass to a tracer or disallow */
#define SECCOMP_RET_LOG 0x7ffc0000U /* allow after logging */
#define SECCOMP_RET_ALLOW 0x7fff0000U /* allow */
/* Masks for the return value sections. */
#define SECCOMP_RET_ACTION_FULL 0xffff0000U
#define SECCOMP_RET_ACTION 0x7fff0000U
#define SECCOMP_RET_DATA 0x0000ffffU
下面这段代码定义了一些编写seccomp BPF code可能会用到的东西，根据注释可知，我们可以在BPF code中获取该系统调用的：系统调用号、处理器架构、指令地址、6个参数的值。具体选择获取什么通过字段k来决定，k相当于seccomp_data结构体的偏移量，若指定k=0，则为获取nr，即系统调用号，若k=4，则为获取处理器架构等。
/**
* struct seccomp_data - the format the BPF program executes over.
* @nr: the system call number
* @arch: indicates system call convention as an AUDIT_ARCH_* value
* as defined in <linux/audit.h>.
* @instruction_pointer: at the time of the system call.
* @args: up to 6 system call arguments always stored as 64-bit values
* regardless of the architecture.
*/
struct seccomp_data {
int nr;
__u32 arch;
__u64 instruction_pointer;
__u64 args[6];
};
实例
K指的是AUDIT_ARCH_X86_64，定义于/include/uapi/linux/audit.h，其中为所有架构都定义了独特的标识符，而0xc000003e则是AUDIT_ARCH_X86_64的值。对于整个seccomp code而言，可能需要的外部数据也就只有seccomp_data了。
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 LD | ABS | Word, R0 = arch
0001: 0x15 0x00 0x19 0xc000003e JMP | JEQ after 0x19, R0 == AUDIT_ARCH_X86_64
0002: 0x20 0x00 0x00 0x00000000 LD | ABS | Word, R0 = nr
0003: 0x35 0x00 0x01 0x40000000 JMP | JGE after 0x01, R0 >= 0x40000000 ?
0004: 0x15 0x00 0x16 0xffffffff JMP | JEQ after 0x16, R0 == 0xFFFFFFFF ?
0005: 0x15 0x15 0x00 0x00000000 JMP | JEQ after 0x15, R0 == 0 ?
0006: 0x15 0x14 0x00 0x00000001 JMP | JEQ after 0x14, R0 == 1 ?
0007: 0x15 0x13 0x00 0x00000002 JMP | JEQ after 0x13, R0 == 2 ?
...
0026: 0x06 0x00 0x00 0x7fff0000 return SECCOMP_RET_ALLOW
0027: 0x06 0x00 0x00 0x00000000 return SECCOMP_RET_KILL
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 LD | ABS | Word, R0 = arch
code为0x20是BDF_LD(0x00)|BDF_ABS(0X20)|BOF_W的结果，就是将一个字的值通过固定偏移量复制到累加器中，此时k对应为偏移量4，即seccomp_data偏移量为4的位置正好是arch的结构
line CODE JT JF K
=================================
0001: 0x15 0x00 0x19 0xc000003e JMP | JEQ after 0x19, R0 == AUDIT_ARCH_X86_64
此时code 15是BPF_JMP(0x05)|BPF_JEQ(0x10)的结果，此时是相等跳转指令，相等则跳转到下一条指令，不相等则跳转到下条指令+0x19的位置，将累加器与k的值做对比，此时累加器的值是之前取的arch
seccomp_export_bpf
参考
seccomp_export_bpf的函数能够将设置的seccomp以bpf的形式导出
//gcc -g simple_syscall_seccomp.c -o simple_syscall_seccomp -lseccomp
#include <unistd.h>
#include <seccomp.h>
#include <linux/seccomp.h>
#include <fcntl.h>
int main(void){
scmp_filter_ctx ctx;
ctx = seccomp_init(SCMP_ACT_ALLOW);
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(write),1,SCMP_A2(SCMP_CMP_EQ,0x10));
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve),0);
seccomp_load(ctx);
int fd = open("bpf.out",O_WRONLY);
seccomp_export_bpf(ctx,fd);
close(fd);
char * filename = "/bin/sh";
char * argv[] = {"/bin/sh",NULL};
char * envp[] = {NULL};
write(1,"i will give you a shell\n",24);
write(1,"1234567812345678",0x10);
syscall(0x4000003b,filename,argv,envp);//execve
return 0;
}
得到对应的bpf的二进制文件
$ hexdump bpf.out
0000000 0020 0000 0004 0000 0015 0900 003e c000
0000010 0020 0000 0000 0000 0035 0007 0000 4000
0000020 0015 0006 003b 0000 0015 0400 0001 0000
0000030 0020 0000 0024 0000 0015 0200 0000 0000
0000040 0020 0000 0020 0000 0015 0001 0010 0000
0000050 0006 0000 0000 7fff 0006 0000 0000 0000
0000060 0000 0000 0000 0000 0000 0000 0000 0000
改用prctl
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/filter.h>
#include <linux/seccomp.h>
int main(void){
prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);
struct sock_filter sfi[] = {
{0x20,0x00,0x00,0x00000004},
{0x15,0x00,0x09,0xc000003e},
{0x20,0x00,0x00,0x00000000},
{0x35,0x07,0x00,0x40000000},
{0x15,0x06,0x00,0x0000003b},
{0x15,0x00,0x04,0x00000001},
{0x20,0x00,0x00,0x00000024},
{0x15,0x00,0x02,0x00000000},
{0x20,0x00,0x00,0x00000020},
{0x15,0x01,0x00,0x00000010},
{0x06,0x00,0x00,0x7fff0000},
{0x06,0x00,0x00,0x00000000}
};
struct sock_fprog sfp = {12,sfi};
prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&sfp);
char * filename = "/bin/sh";
char * argv[] = {"/bin/sh",NULL};
char * envp[] = {NULL};
write(1,"i will give you a shell\n",24);
write(1,"1234567812345678",0x10);
syscall(0x4000003b,filename,argv,envp);//execve
return 0;
}
成功拦截函数
