dcheng69/cve-2022-0185-case-studyCVE-2022-0185에 대한 교육용 사례 연구 및 익스플로잇 개발 워크스루입니다. 로컬 권한 상승을 가능하게 하는 Linux 커널 힙 기반 버퍼 오버플로우 취약점입니다. POC, QEMU 디버깅, 그리고 상세 기술 분석이 포함된 우분투 익스플로잇을 제공합니다.
이 사례 연구는 ECE 9069: 해킹 입문 과제의 결과물입니다: https://whisperlab.org/introduction-to-hacking/
CVE-2022-0185는 Linux 커널의 Filesystem Context 기능에서 legacy_parse_param 함수가 제공된 매개변수 길이를 검증하는 방식에서 발견된 힙 기반 버퍼 오버플로 취약점입니다. (unprivileged user namespaces가 활성화된 경우 비특권, 그렇지 않으면 namespaced CAP_SYS_ADMIN 권한 필요) 로컬 사용자가 Filesystem Context API를 지원하지 않는 파일시스템을 열어 (따라서 레거시 처리로 대체) 이 결함을 이용하여 시스템에서 권한을 상승시킬 수 있습니다. [1]
이 취약점이 보고된 후, 이 버그를 수정하기 위한 패치가 릴리스되었습니다:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=722d94847de2
https://ubuntu.com/security/CVE-2022-0185#impact-score
explorer의 상세 분석 글: https://www.hackthebox.com/blog/CVE-2022-0185:_A_case_study
이 저장소에서는 이 취약점을 재현하기 위한 기본 단계와 관련 배경 정보를 설명합니다. 또한, 이해가 안 되는 부분이 있으면 exmail:[email protected]로 문의해 주세요. 기꺼이 답변해 드리겠습니다.
CVE-2022-0185 취약점은 2022년 2월 11일에 공개되었으며, CVSS 3.x 기본 점수는 8.4(높음)입니다.[1] 이 취약점은 부호 없는 정수 언더플로우로 인해 발생하는 힙 기반 버퍼 오버플로입니다.
이 취약점은 Linux v5.1 커널에서 도입되어, 커널 버전 5.1 이상의 모든 Linux 배포판에 영향을 미쳤습니다. 예를 들어, Ubuntu 20.04 LTS (focal)가 이 버그에 취약했습니다. 그러나 패치가 릴리스되어 버전 5.4.0-96.109부터 사용 가능합니다.[3]
이 취약점을 악용하면 비특권 로컬 사용자가 시스템에서 권한을 상승시켜 잠재적으로 전체 시스템을 손상시킬 수 있습니다.[1][2]
다음은 CVSS 점수에 대한 상세 분석입니다: 기본 점수: 8.4, 즉각적인 주의가 필요한 심각한 보안 위험을 나타냅니다. 영향 점수: 5.9, 악용될 경우 상당한 잠재적 피해를 시사합니다. 높은 기밀성, 무결성, 가용성 값이 이 점수에 기여합니다. 악용 가능성 점수: 2.5, 비교적 높은 악용 가능성을 시사합니다. 로컬 공격 벡터, 높은 무결성, 높은 가용성 값이 이 점수에 기여합니다.
| CVSS v3.1 심각도 | 값 |
|---|---|
| 기본 점수 | 8.4 높음 |
| 영향 점수 | 5.9 |
| 악용 가능성 점수 | 2.5 |
표 1.1 CVSS 심각도 점수[1]
표 1.2 CVSS 벡터[1]
현대 컴퓨터에는 signed와 unsigned 두 가지 정수 유형이 있습니다. signed 숫자의 표현은 일반적으로 2의 보수(2's complement)라는 연산을 포함합니다.[4] "2의 보수는 가장 큰 자릿값을 가진 이진수를 부호로 사용하여 이진수가 양수인지 음수인지 나타냅니다."[4]
2의 보수를 도입하면 뺄셈 계산을 덧셈으로 변환하여 CPU의 설계와 구현을 단순화합니다. 정수의 2의 보수를 생성하는 단계는 다음과 같습니다:[4]
그림 2.1.1.1은 변환 과정을 "-6"을 2의 보수 형식으로 변환하는 실제 예제와 함께 다이어그램으로 보여줍니다.
그림 2.1.1.2 2의 보수를 사용한 덧셈
그림 2.1.1.2는 '-6'의 2의 보수를 '+6'에 더하는 과정을 보여줍니다. 이는 2의 보수를 사용하면 덧셈이 뺄셈을 대체할 수 있음을 보여줍니다.
그림 2.1.1.2 2의 보수를 사용한 덧셈
2.1.1절에서 우리는 이미 2의 보수가 무엇인지 이해했습니다. 이제 컴퓨터에서 부호 없는 숫자 언더플로우 시나리오를 살펴보겠습니다. 현대 컴퓨터에서 부호 없는 숫자를 사용할 때, 최상위 비트는 부호 비트로 처리되지 않고, 대신 부호 없는 숫자 자체의 일부입니다. 이 상황은 부호 없는 숫자로 뺄셈을 수행할 때 주의해야 함을 의미하며, 부호 없는 숫자 언더플로우라고 알려진 상태로 이어질 수 있습니다.[5]
그림 2.1.2.1은 8비트 부호 없는 숫자에 대해 5에서 6을 빼는 상황을 보여줍니다. 부호 없는 숫자 래핑으로 인해 최종 결과는 255입니다. 이 언더플로우가 조건문에서 발생하면, 해당 문의 기능을 방해할 수 있습니다.
그림 2.1.2.1 부호 없는 숫자 언더플로우
리눅스 커널에서 슬랩 할당기(Slab Allocator)는 작은 메모리 청크를 효율적으로 할당 및 해제하는 데 사용되는 메모리 관리 메커니즘입니다. 각각 고정 크기 메모리 블록을 포함하는 여러 슬랩 캐시를 유지함으로써 성능을 제공합니다. 일반적으로 kmalloc-32는 32바이트 메모리를 할당하며, 이는 kmalloc-32 슬랩입니다. 반면 kmalloc-4k는 4096바이트 메모리를 할당하며, 이는 kmalloc-4k 슬랩입니다.[6]
또한, 리눅스 커널의 슬랩 할당은 일반적으로 커널 힙 메모리 영역 내의 연속적인 주소 공간에서 메모리를 할당하는 것을 포함합니다. 이 연속적인 주소는 커널에 의해 관리되며 다양한 커널 객체 및 데이터 구조에 메모리를 할당하는 데 사용됩니다. 그림 2.2.1.1은 리눅스 커널 메모리의 슬랩 레이아웃을 보여줍니다.
그림 2.2.1.1 리눅스의 슬랩 할당기 [7] (이 그림의 작성자는 https://leviathan.vip/입니다.)
자체 컴파일된 리눅스 커널로 이 과정을 재현하려면 다음 마크다운 파일을 읽어 배경 정보를 얻으십시오:
참고: 모든 마크다운 파일과 코드 및 스크립트는 이 저장소의 다른 폴더에 있으며, 각 폴더에는 자체 마크다운 파일이 있으므로 무언가를 시도하기 전에 읽으십시오!
2.1절에서 우리는 부호 없는 언더플로우의 작동 방식을 설명했습니다. 이제 이 취약점을 포함하는 커널 함수를 살펴보겠습니다.
사용자 "clubby789"이 커널 함수 legacy_parse_param에서 취약점을 발견했습니다. 이 함수는 주로 커널에 전달된 매개변수를 구문 분석하는 역할을 합니다. CVE-2022-0185에서는 fsopen을 사용하여 파일 디스크립터를 연 후, fsconfig 함수를 사용하여 구성 키-값 쌍을 커널에 전달한 후에 호출되었습니다. legacy_parse_param의 단순화된 버전은 다음 코드에 나와 있습니다. [2]```c static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param) { struct legacy_fs_context *ctx = fc->fs_private; // [1] unsigned int size = ctx->data_size; // [2] size_t len = 0; int ret; [ ... ] switch (param->type) { case fs_value_is_string: len = 1 + param->size; // [3] case fs_value_is_flag: len += strlen(param->key); break; default: return invalf(fc, "VFS: Legacy: Parameter type for '%s' not supported", param->key); } if (len > PAGE_SIZE-2-size) return invalf(fc, "VFS: Legacy: Cumulative options too large"); // [4] [ ... ] if (!ctx->legacy_data) { ctx->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL); // [5] if (!ctx->legacy_data) return -ENOMEM; } ctx->legacy_data[size++] = ','; // [6] len = strlen(param->key); memcpy(ctx->legacy_data + size, param->key, len); size += len; if (param->type == fs_value_is_string) { ctx->legacy_data[size++] = '='; memcpy(ctx->legacy_data + size, param->string, param->size); size += param->size; } ctx->legacy_data[size] = '\0'; ctx->data_size = size; ctx->param_type = LEGACY_FS_INDIVIDUAL_PARAMS; return 0; }
위 코드 조각에서 볼 수 있듯이, [1]번째 줄과 [2]번째 줄은 코드의 컨텍스트를 설정하고, [4]번째 줄에는 부호 없는 언더플로우가 발생하는 문장이 포함되어 있습니다. [5]번째 줄은 힙 슬랩 할당을 처리하며, [6]번째 줄과 [7]번째 줄은 할당된 슬랩에 데이터를 채우는 역할을 합니다. 특히 [6]번째 줄에서는 쉼표(',')를 별도의 구분자로 추가하고 등호('=')도 추가되어 실제 데이터 크기를 초과하는 2바이트가 더 발생합니다.
[4]번째 줄에서 if 문 내의 변수에는 PAGE_SIZE (4096으로 설정된 매크로)와 size (부호 없는 64비트 숫자)가 포함됩니다. 부호 없는 숫자가 4095까지 누적되면 언더플로우가 발생하여 if 문이 항상 false로 평가됩니다. 이로 인해 인접한 슬랩에 대한 경계를 벗어난 쓰기가 가능해집니다. 언더플로우는 부호 없는 숫자를 뺄셈하여 발생하며, 4096 - 4095의 결과로 부호 없는 숫자 18446744073709551615가 생성됩니다.[2]
`18446744073709551615`의 결과는 다음 텍스트에서 설명됩니다:```c
if (len > PAGE_SIZE-2-size) return invalf(fc, "VFS: Legacy: Cumulative options too large");
Notice that, here the PAGE_SIZE equals to 4096 bytes, and the 2 equals to the character , and = added to separate each key-value pair. The issue is that size is an unsigned value, thus when size reach 4095, the statement of PAGE_SIZE-2-size will equals to signed value: -1, however for unsigned value: 18446744073709551615 because the 2's complement as shown in the following diagram! [3]
따라서 위의 if 문은 항상 거짓이 되며, 이는 나머지 데이터가 할당된 slab을 넘어 힙에 복사된다는 것을 의미합니다!
이 부호 없는 숫자 언더플로우가 어떻게 발생할 수 있는지 이해한 후, 취약점을 입증하기 위한 개념 증명(POC) 코드를 작성할 수 있습니다.
사용자 “clubby789”가 다음 코드 조각에 표시된 상세한 POC 코드를 제공합니다. 코드는 간결합니다. 먼저 ext4라는 파일 디스크립터를 열고, 그런 다음 fsconfig를 여러 번 사용하여 데이터를 커널에 채웁니다.
여기서 주목할 점 두 가지:
legacy_parse_param 함수는 앞에 쉼표(',')를 삽입하고 키와 값 사이에 등호('=')를 삽입합니다. 결과적으로 각 사이클에서 실제로 차지하는 크기는 35입니다.```c
#define _GNU_SOURCE
#include <sys/syscall.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef __NR_fsconfig
#define __NR_fsconfig 431
#endif
#ifndef __NR_fsopen
#define __NR_fsopen 430
#endif
#define FSCONFIG_SET_STRING 1
#define fsopen(name, flags) syscall(__NR_fsopen, name, flags)
#define fsconfig(fd, cmd, key, value, aux) syscall(__NR_fsconfig, fd, cmd, key, value, aux)
int main(void) {
char* key = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; // 33 characters [1]
int fd = 0;
fd = fsopen("ext4", 0); // [2]
if (fd < 0) {
puts("Open failed!\n");
exit(-1);
}
for (int i = 0; i < 130; i++) {
fsconfig(fd, FSCONFIG_SET_STRING, "\x00", key, 0); //[3]
}
return 0;
}섹션 3.1.1에서, 범위를 벗어난 쓰기(out-of-bounds write)를 관찰하기 전에 4095바이트의 데이터를 채워야 한다고 언급했습니다. 각 사이클은 35바이트만 채우므로, 힙 메모리를 관찰하여 개념 증명을 완료하려면 연산을 117번(4095 / 35) 수행해야 합니다.
### 3.1.3 POC with QEMU
이 저장소: GitHub - dcheng69/CVE-2022-0185-Case-Study 에서 디버깅 과정을 돕기 위해 poc.sh라는 셸 스크립트를 제공했습니다. 설정을 시작하기 전에 Poc 폴더의 마크다운 파일을 읽어주세요.
legacy_parse_param은 커널 함수이므로, 커널 함수를 디버깅해야 합니다. 이를 위해 필요한 심볼과 소스 코드를 얻으려면 커널 소스를 컴파일해야 합니다. 또한 이 과정을 안내하는 상세한 마크다운 파일도 제공했습니다. 자세한 내용은 Compile_linux 폴더를 참조하십시오.
그림 3.1.3.1에서는 커널 힙에 4095바이트의 데이터를 채운 후, 부호 없는 언더플로(unsigned underflow)를 악용하여 범위를 벗어난 쓰기(out-of-bounds write)를 성공적으로 트리거했음을 보여주었습니다. 또한 kmalloc-4k 슬랩에 총 4130바이트의 데이터를 채워 인접한 슬랩을 성공적으로 손상시켰습니다. 이 예제에서는 인접 슬랩에 정보가 없지만(모두 0), 코드를 신중하게 구성하여 이 기능을 악성 데이터 쓰기에 활용할 수 있습니다. 이를 달성하는 방법은 3.2 익스플로잇 섹션에서 보여드리겠습니다.
**그림 3.1.3.1 QEMU를 사용한 POC**
For more details please refer to https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/Poc/poc.md under the `Poc` folder of this repository!
## 3.2 익스플로잇
이 취약점을 알게 된 후, 이를 이용한 익스플로잇을 진행할 수 있습니다. 자세한 내용은 `exploit-ubuntu` 폴더와 이 마크다운 파일에 문서화되어 있습니다: https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/explot-ubuntu/exploit.md
간단히 말해, 우분투 소스 코드를 컴파일하여 deb 파일을 얻고, 가상 머신에서 테스트하여 특정 커널 버전을 확인합니다. 그런 다음 `System.map` 파일에서 찾은 정보를 사용하여 익스플로잇 코드의 오프셋을 해당 커널 버전에 맞게 수정합니다. 마지막으로 grub을 업데이트하고 재부팅하여 익스플로잇을 실행합니다!
### 3.2.1 익스플로잇 개요
사용자 'clubby789'이 상세한 익스플로잇 코드를 제공했습니다. 먼저 개요를 설명하고, 다이어그램을 사용하여 몇 가지 핵심 개념을 설명한 후, 가상 머신(VirtualBox)에서 실행되는 우분투를 사용한 익스플로잇 결과를 제시하겠습니다.
이 취약점에 대한 개념 증명을 보여준 후, 이제 익스플로잇을 진행할 수 있습니다. 그림 3.2.1.1은 이 취약점을 익스플로잇하는 방법의 개요를 보여줍니다:
- 왼쪽 부분은 리눅스 커널 베이스 주소를 획득하는 데 중점을 둡니다. 이는 부호 없는 언더플로(unsigned underflow)를 악용하여 msg_msg 구조체의 m_ts를 덮어씀으로써 범위를 벗어난 읽기를 수행하고 이전에 스프레이한 커널 구조체에 접근할 수 있게 합니다.
- 오른쪽 부분은 루트 권한을 획득하는 것을 목표로 합니다. 이는 부호 없는 언더플로를 사용하여 msg_msg 구조체의 next 포인터를 덮어쓰고 modprobe_path를 가리키도록 합니다. 그런 다음 페이지 폴트를 트리거하여 우리가 구성한 fuse 코드를 호출하고, 커널 공간에서 임의 쓰기를 가능하게 합니다.
**그림 3.2.1.1 익스플로잇 개요**
### 3.2.2 리눅스 커널 베이스 주소 획득
앞서 분석한 바와 같이, 이 부분에서는 부호 없는 언더플로를 악용하여 msg_msg 구조체의 m_ts 필드를 덮어써서 범위를 벗어난 읽기를 가능하게 합니다. 커널 포인터를 포함하는 구조체로 힙을 스프레이하여 메모리 누수를 얻을 수 있기를 바랍니다.
struct msg_msg는 System V 메시지 큐를 구현하는 데 사용되는 리눅스 커널의 데이터 구조입니다. 이 섹션에서는 struct msg_msg의 내부 구조와 메시지 전송, 수신 및 할당과 관련된 함수의 로직에 초점을 맞춥니다. 그림 3.2.2.1에 표시된 것처럼, 이는 우리가 이해해야 할 함수들입니다.
struct msg_msg는 System V 메시지 큐를 구현하는 데 사용되는 리눅스 커널의 데이터 구조입니다.[8] 이 논의에서는 struct msg_msg의 내부 구조와 메시지 전송, 수신 및 할당과 관련된 함수의 로직에 초점을 맞춥니다. 그림 3.2.2.1에 표시된 것처럼, 이는 우리가 이해해야 할 함수들입니다.
메시지 전송의 구현은 msg.c 파일에 있으며, 메시지의 최대 길이를 8192바이트로 정의합니다. alloc_msg 함수에서 메시지는 길이에 따라 세그먼트로 분할됩니다. 메시지의 길이가 메시지 헤더와 함께 한 페이지(4096바이트)를 초과하면, 메시지는 포인터로 연결된 여러 세그먼트에 저장됩니다.
**그림 3.2.2.1 struct msg_msg 전송 및 수신**
그림 3.2.2.2에서는 struct msg_msg가 메시지 헤더 역할을 하며 0x30바이트의 메모리를 차지하는 것을 볼 수 있습니다. 메시지에 잔여 데이터가 있으면 메시지 세그먼트에 저장되고 struct msg_msgseg에 연결됩니다. 따라서 커널이 최대 8192바이트의 메시지를 허용하는 경우, 데이터는 최대 3개의 메시지 세그먼트에 저장됩니다.
**그림 3.2.2.2 struct msg_msg**
그림 3.2.2.3에서는 struct msg_msg의 구조를 설명합니다. 코드에서 m_ts 필드가 범위를 벗어난 읽기를 위해 덮어써야 할 필드임을 알 수 있습니다. (필요한 경우 `res` 폴더에서 draw.io 소스 파일을 찾을 수 있습니다!)
**그림 3.2.2.2 struct msg_msg 구조**
이제 struct msg_msg의 구조를 이해했으므로, 커널 누수를 얻는 방법을 배워야 합니다. 리눅스 커널에는 KASLR(Kernel Address Space Layout Randomization) 기능이 있어 커널 코드가 부팅 단계에서 결정된 임의의 주소에 로드됩니다. 그러나 커널 시작점에서 임의의 함수 주소까지의 오프셋은 일정하게 유지되므로, 특정 커널 함수를 포함하는 구조체로 힙 공간을 채우는 특정 연산을 수행할 수 있습니다. 오프셋을 줄여가며 커널 시작 주소를 찾을 수 있습니다.
다행히도, /proc/self/stat을 열어 seq_operations 구조체로 힙을 쉽게 스프레이할 수 있습니다. 이 구조체는 kmalloc-32 슬랩에 위치합니다. seq_operations의 정의는 그림 3.2.2.3에 나와 있습니다.
**그림 3.2.2.3 커널 누수를 위한 구조체**
마지막으로, 전체 과정은 그림 3.2.2.4에 설명되어 있습니다. 먼저 legacy_data에 4095바이트의 데이터를 채워 덮어쓰기를 준비합니다. 그런 다음 struct msg_msg를 사용하여 메시지를 구성합니다. 힙 메모리는 연속적으로 할당되므로, 구성된 메시지는 인접한 kmalloc-4k 슬랩과 인접할 가능성이 높습니다. legacy_data에 쓰는 데이터를 제어하여 m_ts 필드를 덮어씁니다.
다음으로, 여러 개의 kmalloc-32 seq_operations 구조체로 힙을 스프레이합니다. 그런 다음 메시지 큐에서 데이터를 수신하여 범위를 벗어난 읽기를 트리거합니다. 커널 함수로부터의 오프셋을 조정하여 커널 베이스 주소를 얻을 수 있습니다.
**그림 3.2.2.3 범위를 벗어난 읽기 개요**
### 3.2.3 루트 권한 획득
앞서 분석한 것과 유사하게, 이 부분에서는 사용자 공간 코드가 커널 공간의 페이지 폴트를 처리할 수 있도록 FUSE 파일 시스템을 설정해야 합니다. 동시에 msg_msgseg *next 포인터를 덮어써서 modprobe_path를 가리키도록 하여 커널 공간에서 임의 쓰기를 가능하게 합니다.
먼저 그림 3.2.3.1에 묘사된 FUSE 호출 스택을 살펴보겠습니다. 일반적으로 FUSE를 사용하면 사용자 공간에서 파일 시스템을 구현할 수 있습니다. 새로운 작업이 있으면 시스템이 FUSE를 위해 정의한 코드를 호출합니다!
**그림 3.2.3.1 FUSE 개요**
FUSE를 사용하여 커널 공간에서 임의 쓰기를 달성하는 방법을 분석해 보겠습니다. 먼저 struct msg_msg의 메시지 전송 연산을 고려해 봅시다. 이 연산은 커널 공간에 데이터를 쓰는 작업을 포함합니다. 메시지가 두 개의 세그먼트를 갖도록 구성하면 포인터를 덮어쓰고 임의의 커널 주소에 쓸 수 있습니다. 이 개념은 그림 3.2.3.2에 설명되어 있습니다.
또한, 큐에 메시지를 보내는 로직을 살펴보면, 이 과정이 사용자 공간에서 커널 공간으로 버퍼를 복사하는 작업을 포함한다는 것을 알 수 있습니다. 메시지가 충분히 길면 세그먼트 단위로 복사됩니다. 이 과정 중에 페이지 폴트를 트리거할 수 있다면, 그림 3.2.3.2에 표시된 시나리오를 달성할 수 있습니다.
다행히도 FUSE는 필요한 기능을 제공합니다. 페이지를 FUSE에 매핑하면 페이지 폴트가 트리거될 때 시스템이 FUSE 읽기 함수를 호출하여 페이지 폴트를 처리합니다. 부호 없는 언더플로가 msg_msg_seg *next 포인터를 덮어쓸 때까지 읽기 프로세스를 일시 중지한 다음 메시지 전송 프로세스를 재개함으로써 임의 쓰기를 달성할 수 있습니다. 전체 과정은 그림 3.2.3.3에 설명되어 있습니다.
**그림 3.2.3.2 메시지 전송 사용**
**그림 3.2.3.3 FUSE와 메시지 전송**
### 3.2.4 Virtual Box를 이용한 익스플로잇
Following the markdown file of: https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/explot-ubuntu/exploit.md
컴파일이 완료되면 그림 3.2.4.1에서 익스플로잇의 결과를 확인할 수 있습니다.
**그림 3.2.4.1 Virtual Box 익스플로잇**
# 4. 취약점 완화
## 4.1 공식 패치
이 취약점이 보고된 후, 리눅스와 많은 배포판에서 이 버그를 수정하기 위해 패치를 병합했습니다.[9] [10] [11]
다음 스크린샷에서는 Linus Torvalds가 병합한 패치를 보여줍니다. 이 언더플로 문제의 완화 방법은 간단히 뺄셈 연산을 덧셈으로 변환하는 것입니다.
# 5. 실제 영향
이 보고서에서는 이 취약점이 어떻게 우분투 시스템을 손상시키는 데 악용될 수 있는지 보여줍니다. 또한 정기적인 보안 업데이트가 부족한 오래된 시스템을 대상으로 할 수 있습니다.
쿠버네티스의 경우, 이 취약점은 권한 상승, 컨테이너 탈출 또는 서비스 거부 공격으로 이어질 수 있습니다.
이 취약점으로 인한 손실에 대한 뉴스 보도는 없었지만, 이는 중요한 보안 업데이트를 지속적으로 적용하는 것이 중요함을 강조합니다. 이 취약점을 보고한 연구자는 우리 모두가 지향해야 할 윤리적 해킹 관행을 보여줍니다.[12]
# 참고문헌
[1] https://nvd.nist.gov/vuln/detail/CVE-2022-0185
[2] https://www.hackthebox.com/blog/CVE-2022-0185:_A_case_study
[3] https://ubuntu.com/security/CVE-2022-0185#impact-score
[4] [https://en.wikipedia.org/wiki/Two%27s_complement](https://en.wikipedia.org/wiki/Two's_complement)
[5]https://www.gnu.org/software/c-intro-and-ref/manual/html_node/Unsigned-Overflow.html
[6] https://www.kernel.org/doc/gorman/html/understand/understand011.html
[7] https://leviathan.vip/
[8] https://www.willsroot.io/2021/08/corctf-2021-fire-of-salvation-writeup.html
[9] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=722d94847de2
[10] https://ubuntu.com/security/CVE-2022-0185
[11] https://access.redhat.com/security/cve/CVE-2022-0185
[12]https://jfrog.com/blog/the-impact-of-cve-2022-0185-linux-kernel-vulnerability-on-popular-kubernetes-engines/
[14] https://github.com/chenaotian/CVE-2022-0185?tab=readme-ov-file
[15] https://www.tutorialspoint.com/two-s-complement
| CVSS v3.1 메트릭 | 값 |
|---|
| 공격 벡터(AV) | 로컬 |
| 필요 권한(PR) | 없음 |
| 사용자 상호작용(UI) | 없음 |
| 기밀성(C) | 높음 |
| 무결성(I) | 높음 |
| 가용성(A) | 높음 |