0x0D 사이드 채널 공격 (Side-Channel Attacks: Meltdown & Spectre)

1. Meltdown과 Spectre 개요

1.1 취약점 정의

Meltdown과 Spectre는 3개 취약점의 별명:
• Variant 1: bounds check bypass (CVE-2017-5753) ← Spectre
• Variant 2: branch target injection (CVE-2017-5715) ← Spectre  
• Variant 3: rogue data cache load (CVE-2017-5754) ← Meltdown

분류:
Spectre: Variant 1 + Variant 2
Meltdown: Variant 3

1.2 영향 범위

하드웨어 영향

Meltdown:
• 영향: Intel, ARM, IBM 등
• 대상: 데스크톱, 랩톱, 클라우드 컴퓨터

Spectre:
• 영향: Intel, AMD, ARM, IBM 등
• 대상: 데스크톱, 랩톱, 클라우드 서버, 스마트폰

운영체제:
• 모든 운영체제 영향: Linux, Windows, macOS

보안 영향

Meltdown:
• 사용자 애플리케이션과 운영체제 간 근본적 격리 붕괴
• 프로그램이 다른 프로그램과 운영체제의 메모리/비밀 접근 가능

Spectre:
• 서로 다른 애플리케이션 간 격리 붕괴
• 공격자가 오류 없는 프로그램을 속여서 비밀 정보 유출 유도
• 모범 사례를 따르는 프로그램도 공격 가능

1.3 공격 원리

공격이 악용하는 현대 프로세서 설계:
1. Out-of-order Execution (비순차 실행)
2. Speculative Execution (투기적 실행)  
3. Caching (캐싱)

핵심 메커니즘:
• 사이드 채널을 이용하여 접근된 메모리 위치에서 정보 획득
• 하드웨어 최적화 기능을 보안 공격에 악용

2. 현대 프로세서 최적화 기법

2.1 비순차 실행 (Out-of-Order Execution)

기본 개념

비순차 실행:
• 고성능 마이크로프로세서가 피연산자가 준비되는 즉시 명령어 실행 시작
• 명령어는 순서대로 발행되지만 서로에 대해 비순차적으로 진행 가능
• 데이터 의존성으로 인한 대기 시간(stall) 방지가 목적

실행 단계

비순차 실행 6단계:
1. Instruction Fetch (명령어 페치)
2. Instruction Dispatch (명령어 큐로 디스패치)
3. Queue Wait (입력 피연산자 준비될 때까지 대기)
4. Execute (적절한 기능 유닛에서 실행)
5. Result Queue (결과 큐잉)
6. Retirement (이전 명령어들이 완료된 후 결과 레지스터에 쓰기)

일상 예시: 차 만들기

순차 실행:
차 컵 씻기 → 물 끓이기 → 차 만들기

비순차 실행:
차 컵 씻기 --------------------------------->|
                                            |->차 만들기
물 끓이기 → 끓은 물 →|

예외 상황 (컵이 깨진 경우):
차 컵 씻기 → 컵 깨짐 ---------------------->|  
                                            |->물 사용 안함
물 끓이기 → 끓은 물 →|

결과: 컵이 깨져도 끓인 물은 여전히 대기 영역(캐시)에 남아있음

2.2 투기적 실행 (Speculative Execution)

기본 개념

투기적 실행:
• 현대 CPU가 성능 향상을 위해 사용하는 기법
• CPU가 특정 작업들을 미리 실행하여 "추측"으로 완료

동작 방식:
• 작업이 필요하면: 이미 완료되어 속도 향상 달성
• 작업이 불필요하면: 변경사항 되돌리고 결과 무시

일상 예시: 커피 주문

성공적인 추측:
바리스타: 라떼 만들기 || 추측: 라떼 필요 → 라떼 만들기 → 라떼 준비
고객:    라떼 필요     || 라떼 필요 ----------------→ 받음!
날짜:    1일          || 2일

실패한 추측:
바리스타: 라떼 만들기 || 라떼 추측 || 바닐라 만들기 → 라떼 버리기
고객:    라떼 필요    || 라떼 필요 || 바닐라 필요
날짜:    1일         || 2일      || 3일

2.3 캐싱 (Caching)

캐시 원리:
• CPU가 메모리에서 데이터 요청 → 캐시에 저장
• 메모리 접근 속도 향상

지역성 원리:
1. Temporal Locality (시간적 지역성):
   • 최근에 접근한 메모리가 곧 다시 접근될 가능성
   • 예: 루프의 카운터 변수

2. Spatial Locality (공간적 지역성):
   • 최근 접근한 것과 가까운 메모리가 곧 접근될 가능성
   • 예: 배열의 원소들

3. 사이드 채널 공격 이론

3.1 사이드 채널 공격 정의

사이드 채널 공격:
• CPU의 마이크로 아키텍처 설계로 인해 가능한 공격
• 컴퓨터 시스템 구현에서 얻은 정보 기반

공격 유형:
• 캐시: 데이터 접근 속도 모니터링으로 캐시 상태 추론
• 타이밍: 다양한 연산의 소요 시간 모니터링
• 전력 모니터링: 다양한 연산 시 하드웨어 전력 소비 모니터링

3.2 캐시 사이드 채널 공격

캐시 접근 시간 차이 이용:
• 빠른 접근: 캐시에 저장된 데이터
• 느린 접근: 메인 메모리에 저장된 데이터

공격 원리:
접근 시간 측정 → 캐시 적중/실패 판별 → 비밀 정보 추론

3.3 캐시 공격 기법

Flush + Reload

단계:
1. Flush: 제어할 수 있는 메모리 데이터를 캐시에서 제거 (clflush 사용)
2. 실행: 악성/사용자 프로그램이 비밀로 제어 메모리에 접근하도록 허용
3. Reload: 제어 메모리의 원소들을 다시 로드하고 접근 속도 측정

결과 분석:
• 빠른 접근: 피해자가 해당 메모리 접근 (캐시 적중)
• 느린 접근: 피해자가 해당 메모리 미접근 (캐시 실패)

Evict + Reload

단계:
1. Evict: 다른(무작위) 데이터를 캐시에 로드하여 특정 캐시 라인 제거
2. 실행: 피해자 프로그램이 비밀로 메모리 접근
3. Reload: 데이터 다시 로드하고 접근 시간 측정

캐시 크기 제한 활용:
• 제한된 캐시 크기로 특정 캐시 라인 강제 제거
• 피해자 접근 패턴 추론

3.4 권한 검사 우회

현대 CPU의 권한 검사:
• 프로그램이 커널 메모리 접근 시 권한 검사 수행
• 투기적 실행 중에는 권한 검사가 너무 늦게 발생

타이밍 문제:
1. 투기적 실행으로 데이터 이미 읽음
2. 명령어 완료 시점에서야 권한 검사 수행
3. 권한 없는 실행은 무효화되고 예외 발생 (SIGSEGV)
4. 하지만 최근 접근한 메모리는 여전히 캐시에 남아있음

핵심: 권한 검사 전에 이미 캐시 상태 변경 완료

4. Meltdown 공격

4.1 Meltdown 공격 개요

Meltdown 핵심 아이디어:
• 투기적 실행과 권한 검사 타이밍 차이 악용
• 커널 메모리를 읽고 캐시 상태 변경
• 사이드 채널로 캐시 상태 관찰하여 정보 추출

4.2 Meltdown 공격 단계별 분석

1단계: 메모리 블록 할당

메모리 준비:
• 256개 페이지로 구성된 메모리 블록 할당 (256 * 4096 bytes)
• 레지스터 RBX에 주소 저장
• 각 페이지는 아직 접근하지 않아 캐시되지 않은 상태

메모리 레이아웃:
RBX → [Page 0][Page 1][Page 2]...[Page 255]
       4KB     4KB     4KB       4KB

2단계: 레지스터 초기화

xor rax, rax    ; RAX 레지스터를 0으로 초기화

목적: 이후 단계에서 RAX에 읽은 바이트 값 저장

3단계: 커널 메모리 읽기

mov al, byte [rcx]    ; RCX의 커널 주소에서 1바이트를 AL로 로드

레지스터 관계:
0x1122334455667788
================ rax (64비트)
======== eax (32비트)  
==== ax (16비트)
==      ah (8비트)
==      al (8비트) ← 여기에 커널 데이터 저장

문제: 이 단계에서 권한 검사 실패 → 예외 발생
하지만: 투기적 실행으로 이미 데이터 읽음

4단계: 페이지 인덱스 계산

shl rax, 0xc    ; RAX를 12비트 왼쪽 시프트

계산:
• 12비트 시프트 = 2^12배 = 4096배
• 4096 bytes = 4KB = 1 페이지 크기
• 결과: (읽은 바이트 값) * 4096

예시:
• 읽은 값이 21이면: 21 * 4096 = 86016
• 86016 = 21번째 페이지의 오프셋

5단계: 루프 제어

jz retry    ; RAX가 0이면 다시 시도

목적:
• AL에 아무것도 복사되지 않았으면 RAX는 여전히 0
• 유효한 데이터를 읽을 때까지 루프 반복

6단계: 캐시 상태 변경

mov rbx, qword [rbx + rax]    ; 프로브 배열의 RAX 인덱스 위치 접근

효과:
• 계산된 인덱스(RAX)를 사용하여 할당된 메모리 블록 접근
• 특정 페이지(N번째, N=읽은 바이트 값)에서 1바이트 읽기
• 해당 페이지가 캐시에 로드됨

예시: 커널에서 읽은 값이 21이면 21번째 페이지가 캐시됨

7단계: 경쟁 조건

비순차 실행 시작:
• 4단계(mov al, byte [rcx])의 권한 검사와 이후 코드 간 경쟁 조건
• 권한 검사가 5단계 코드 완료 후 끝날 수 있음
• 할당된 메모리 블록 중 하나의 페이지가 CPU에 캐시됨

캐시된 페이지:
• 커널 주소에서 읽은 바이트와 직접 관련
• 예: 커널 주소의 값이 21이면 21번째 페이지가 캐시됨

8단계: 사이드 채널 관찰

비순차 실행의 부작용 관찰:
1. 4단계 코드의 권한 검사 예외 처리
2. 할당된 메모리 블록의 모든 페이지 순회
3. 각 페이지에서 1바이트 읽는 시간 측정
4. 빠르게 로드되는 바이트 → 해당 페이지가 캐시됨 → 비밀 값 발견

결과 분석:
• 페이지 0~20: 느린 읽기 (캐시되지 않음)
• 페이지 21: 빠른 읽기 (캐시됨) → 비밀 값은 21
• 페이지 22~255: 느린 읽기 (캐시되지 않음)

5. Spectre 공격

5.1 Spectre Variant 1: 조건부 분기 예측 오류 악용

공격 대상 코드

// 일반적이고 올바른 코드
if (x < array1_size) {
    y = array2[array1[x] * 256];
}

변수 설정:
• x = (읽고 싶은 비밀 바이트 주소) - (array1의 기본 주소)
• 비밀 값의 주소를 secret이라 하고, A = secret - array1이면
• array1[A]로 비밀 값에 접근 가능

분기 예측 조작

정상 실행 (학습 단계):
1. x가 유효한 범위 (x < array1_size)로 여러 번 실행
2. 분기 예측기가 "다음에도 조건이 참일 것"으로 학습
3. CPU가 조건부 분기 예측에 의존하게 됨

공격 실행:
1. x에 A 값 할당 (A = secret - array1)
2. 분기 예측기가 루프 실행을 예측 (실제로는 실행하면 안 됨)
3. CPU가 루프 본문을 투기적으로 실행
4. 비밀 값이 캐시에 로드되고 array2 접근에 사용됨
5. CPU가 최종적으로 루프가 실행되면 안 됨을 발견
6. 루프에서 얻은 값들은 무효화됨

정보 추출

사이드 채널 분석:
1. array2의 모든 주소 읽기 시간 측정
2. 짧은 시간에 읽히는 주소 = 캐시된 주소 = 비밀 값

예시:
• array2[0 * 256] ~ array2[20 * 256]: 느린 접근
• array2[21 * 256]: 빠른 접근 ← 비밀 값 21 발견
• array2[22 * 256] ~ array2[255 * 256]: 느린 접근

5.2 Spectre Variant 2: 간접 분기 중독

기본 개념

간접 분기 중독:
• 간접 분기: 메모리 위치의 코드로 점프 (예: jmp [eax])
• Variant 1과 유사하지만 데이터 룩업 대신 분기 예측 악용
• CPU의 함수 포인터 호출 예측 기능 악용

공격 요구사항:
• "Spectre 가젯" 위치 파악 필요
• 가젯: 투기적 실행으로 피해자의 민감한 정보를 은밀한 채널로 전송하는 코드 조각

Branch Target Buffer (BTB)

BTB (Branch Target Buffer):
• 최근 실행된 분기 명령어 주소에서 목적지 주소로의 매핑 유지
• 분기 명령어 디코딩 전에도 미래 코드 주소 예측 가능
• 투기적 실행으로 성능 향상

BTB 특성:
• 분기 주소의 하위 31비트만 BTB 인덱싱에 사용
• 예측된 간접 분기 대상에서 코드를 투기적 실행 가능

BTB 중독 공격

공격 과정:
1. 공격자가 피해자 주소 공간에서 "Spectre 가젯" 선택
2. BTB를 훈련시켜 간접 분기 명령어에서 가젯 주소로 잘못 예측하도록 조작
3. 가젯의 투기적 실행 결과 발생
4. 분기 예측 오류로 인해 가젯 코드가 투기적 실행됨
5. 결과가 캐시에 로드됨
6. 캐시 사이드 채널 공격으로 비밀 값 획득

특징:
• 피해자 코드의 취약점에 의존하지 않음
• 공격자는 가젯의 가상 주소를 찾아야 함

6. 완화 기법

6.1 일반적 완화 접근법

하드웨어 해결책:
• 최선의 해결책: CPU 재설계
• 문제점: 많은 시간과 비용 소요

현실적 제약:
• 모든 사용자가 CPU 교체할 수 없음
• 금전적, 시간적, 기술적 한계

소프트웨어 패치:
• 하드웨어 취약점을 소프트웨어 방식으로 완화
• 상대적으로 빠른 배포 가능
• 성능 저하 트레이드오프 존재

6.2 Meltdown 완화: KPTI

KPTI 개요

KPTI (Kernel Page Table Isolation):
• 이전 이름: KAISER
• 커널 페이지 테이블 격리
• 커널 주소 격리로 사이드 채널 효율적 제거
• 여전히 성능 저하 존재

각 프로세스당 두 개의 페이지 테이블:
1. 완전한 페이지 테이블: 커널 + 사용자 공간 (커널 모드 시에만 사용)
2. 그림자 페이지 테이블: 사용자 공간 + 최소 커널 공간 (사용자 모드 시 사용)

KPTI 동작 메커니즘

그림자 페이지 테이블:
• 모든 사용자 공간 매핑 복사본 포함
• 커널 쪽은 제외
• 시스템 콜과 인터럽트 처리에 필요한 최소한의 커널 공간 매핑만 포함

사용자 모드 실행:
• 그림자 페이지 테이블 활성화
• 커널 주소 공간의 대부분이 프로세스에서 완전히 숨겨짐
• 알려진 하드웨어 기반 공격 차단

모드 전환:
• 커널 모드 전환 시: 완전한 페이지 테이블로 교체
• 사용자 공간 복귀 시: 그림자 페이지 테이블로 재전환

추가 완화 기법

KASLR (Kernel Address Space Layout Randomization):
• 부팅할 때마다 커널 주소 공간 위치 무작위화
• 공격자가 정확한 커널 주소 예측 어렵게 만듦
• KPTI와 함께 사용하여 보안 강화

업데이트 권장:
• 운영체제와 소프트웨어를 최신 버전으로 업데이트
• 보안 패치 즉시 적용

6.3 Spectre 완화

Spectre 완화의 어려움

Spectre 특성:
• Meltdown보다 악용하기 어려움
• 완화하기도 더 어려움
• 알려진 특정 익스플로잇 방지는 소프트웨어 패치로 가능

완화 전략:
• 운영체제와 소프트웨어 최신 버전 유지
• 알려진 Spectre 공격 차단

완화 기법 분류

1. 투기적 실행 방지:
   • 제어 흐름이 명령어를 이끌도록 보장
   • 직렬화 또는 투기 차단 소프트웨어 사용
   • 상당한 성능 저하 발생

2. 비밀 데이터 접근 방지 (JIT 컴파일러 중심):
   • Chrome: 웹사이트당 별도 프로세스

3. 은밀한 채널에서 데이터 추출 제한

4. 분기 중독 방지

구체적 완화 기법

Google Retpoline:
• Spectre Variant 2 완화를 위한 패치
• 간접 분기를 안전한 패턴으로 대체

Linux 커널 완화:
• 다양한 Spectre 변형에 대한 상세한 완화 기법 제공
• 성능과 보안 간 균형 고려

미래 프로세서:
• 데이터가 은밀한 채널에 들어가는 것을 방지
• 현재는 이런 설계 없음

KAISER/KPTI 한계:
• Spectre 완화에는 도움이 되지 않음
• Meltdown 전용 완화 기법

7. 실용적 대응

7.1 취약점 확인 도구

Linux 시스템에서 Meltdown과 Spectre 취약점 확인:

$ git clone https://github.com/speed47/spectre-meltdown-checker.git
$ cd spectre-meltdown-checker
$ sudo ./spectre-meltdown-checker.sh

확인 결과:
• 일부 Spectre 변형은 여전히 해결되지 않음
• 지속적인 모니터링과 업데이트 필요

7.2 보안 권장사항

즉시 조치:
1. 운영체제 업데이트
   • Linux: KPTI 패치 포함 커널
   • Windows: 마이크로소프트 보안 업데이트
   • macOS: Apple 보안 업데이트

2. 브라우저 업데이트
   • Chrome: 사이트 격리 기능
   • Firefox: 보안 패치
   • Safari: 웹킷 보안 업데이트

3. 중요 소프트웨어 업데이트
   • 가상화 소프트웨어
   • 클라우드 서비스 제공업체 확인

장기적 대응:
1. 성능 모니터링
   • KPTI로 인한 성능 저하 확인
   • I/O 집약적 작업에서 최대 20% 성능 저하

2. 보안 정책 수립
   • 정기적인 보안 업데이트 절차
   • 취약점 모니터링 체계

예상 시험문제

1. Meltdown과 Spectre의 차이점과 공통점

문제: Meltdown과 Spectre 공격의 공통점과 차이점을 설명하고, 각각이 악용하는 하드웨어 최적화 기법과 공격 대상을 비교하시오.

모범답안:

공통점:

하드웨어 기반 사이드 채널 공격:
• 현대 프로세서의 성능 최적화 기법 악용
• 캐시 상태 변화를 통한 정보 유출
• 투기적 실행과 비순차 실행 활용
• 권한 검사 타이밍 취약점 이용

사용하는 기술:
• Out-of-order Execution (비순차 실행)
• Speculative Execution (투기적 실행)
• Cache Side-channel (캐시 사이드 채널)
• Timing Attack (타이밍 공격)

영향 범위:
• 거의 모든 현대 프로세서 (Intel, AMD, ARM)
• 모든 운영체제 (Linux, Windows, macOS)
• 데스크톱, 서버, 모바일 기기

차이점:

구분	Meltdown	Spectre
CVE 번호	CVE-2017-5754	CVE-2017-5753, CVE-2017-5715
공격 대상	사용자-커널 경계	프로세스 간 경계
권한 상승	커널 메모리 직접 접근	같은 권한 내 정보 유출
공격 복잡도	상대적으로 단순	더 복잡, 정교함
완화 난이도	상대적으로 쉬움 (KPTI)	매우 어려움
성능 영향	높음 (최대 20%)	다양함

Meltdown 특성:

공격 메커니즘:
• 커널 메모리 직접 읽기 시도
• 권한 검사 전에 투기적 실행으로 데이터 캐시에 로드
• 예외 발생 후 캐시 상태 분석으로 데이터 추출

공격 대상:
• 운영체제 커널 메모리
• 다른 프로세스의 메모리
• 하이퍼바이저 메모리

영향:
• 사용자-커널 격리 완전 붕괴
• 시스템의 모든 메모리 접근 가능
• 암호화 키, 패스워드 등 중요 정보 유출

Spectre 특성:

Variant 1 - 조건부 분기 예측 오류:
• 분기 예측기 훈련으로 잘못된 코드 경로 실행 유도
• 배열 경계 검사 우회
• 피해자 프로그램의 메모리 영역 내에서 정보 유출

Variant 2 - 간접 분기 대상 주입:
• Branch Target Buffer (BTB) 중독
• 간접 분기의 예측 대상 조작
• 임의의 코드 조각(가젯) 실행 유도

공격 대상:
• 같은 프로세스 내 다른 영역
• 브라우저에서 다른 웹사이트 정보
• 가상화 환경에서 게스트 간 정보

2. 비순차 실행과 투기적 실행의 보안 영향

문제: 현대 프로세서의 비순차 실행(Out-of-order Execution)과 투기적 실행(Speculative Execution)이 성능 향상에 기여하는 원리를 설명하고, 이러한 최적화 기법이 어떻게 보안 취약점으로 이어지는지 분석하시오.

모범답안:

비순차 실행 (Out-of-order Execution):

성능 향상 원리:

데이터 의존성 문제 해결:
• 전통적 순차 실행: 이전 명령어 완료까지 대기
• 비순차 실행: 의존성 없는 명령어는 즉시 실행

예시:
순차 실행:
ADD R1, R2, R3    ; R1 = R2 + R3
LOAD R4, [R5]     ; R4 = Memory[R5] (메모리 접근 지연)
ADD R6, R7, R8    ; R7, R8와 무관하지만 대기

비순차 실행:
ADD R1, R2, R3    ; 즉시 실행
LOAD R4, [R5]     ; 실행 시작 (메모리 접근)
ADD R6, R7, R8    ; LOAD 완료 전에 실행 ← 성능 향상!

성능 이득:
• CPU 기능 유닛 활용률 극대화
• 메모리 지연 시간 숨김
• 전체 처리량 증가

보안 취약점 발생 메커니즘:

권한 검사 지연 문제:
1. 명령어 발행 (권한 검사 시작)
2. 비순차 실행 진행 (데이터 이미 캐시에 로드)
3. 권한 검사 완료 (위반 발견)
4. 실행 결과 무효화 (하지만 캐시 상태는 이미 변경됨)

Meltdown에서의 악용:
mov al, byte [rcx]    ; 커널 주소 접근 (권한 위반)
shl rax, 0xc          ; 비순차로 먼저 실행될 수 있음
mov rbx, [rbx + rax]  ; 캐시 상태 변경 (부작용 발생)

결과: 권한 위반으로 예외 발생하지만 캐시에 비밀 정보 흔적 남음

투기적 실행 (Speculative Execution):

성능 향상 원리:

분기 예측 기반 사전 실행:
• 조건부 분기의 결과 예측
• 예측된 경로의 명령어들을 미리 실행
• 예측이 맞으면 시간 절약, 틀리면 결과 폐기

예시:
if (condition) {
    // Path A - 복잡한 연산들
    result = complex_calculation();
} else {
    // Path B - 단순한 연산
    result = simple_value;
}

투기적 실행:
1. condition 평가 전에 Path A 실행 시작 (예측)
2. condition이 true → Path A 결과 사용 (성능 향상)
3. condition이 false → Path A 결과 폐기, Path B 실행

분기 예측 정확도:
• 현대 프로세서: 95% 이상 정확도
• 예측 실패 시에도 전체적으로 성능 향상

보안 취약점 발생 메커니즘:

Spectre Variant 1에서의 악용:
// 정상 코드
if (x < array1_size) {           // 분기 조건
    y = array2[array1[x] * 256]; // 투기적 실행 대상
}

공격 과정:
1. 학습 단계: x < array1_size가 항상 참이 되도록 여러 번 실행
2. 분기 예측기가 "항상 참"으로 학습
3. 공격 단계: x를 배열 범위 밖 값으로 설정
4. 분기 예측기가 "참"으로 잘못 예측하여 if 문 내부 실행
5. array1[x]에서 범위 밖 메모리(비밀 값) 읽기
6. 투기적으로 array2[비밀값 * 256] 접근하여 캐시 상태 변경
7. 최종적으로 조건이 거짓임을 발견하고 결과 폐기
8. 하지만 캐시 상태 변화는 되돌릴 수 없음

핵심 문제: 투기적 실행의 부작용(캐시 변화)은 실행 취소 시에도 남아있음

성능과 보안의 근본적 모순:

최적화의 딜레마:
• 성능 향상을 위해서는 추측과 사전 실행 필요
• 보안을 위해서는 모든 검사 완료 후 실행해야 함
• 두 요구사항이 근본적으로 상충

해결의 어려움:
• 하드웨어 재설계 필요 (비용과 시간 막대)
• 소프트웨어 완화는 성능 저하 불가피
• 완벽한 해결책 부재

미래 방향:
• 보안을 고려한 새로운 프로세서 설계
• 성능과 보안의 균형점 모색
• 소프트웨어 기반 완화 기법 지속 개선

3. KPTI의 동작 원리와 성능 영향

문제: KPTI(Kernel Page Table Isolation)가 Meltdown 공격을 방어하는 원리를 설명하고, 이 완화 기법이 시스템 성능에 미치는 영향과 그 이유를 분석하시오.

모범답안:

KPTI 방어 원리:

기존 문제점:

Meltdown 공격 가능 이유:
• 사용자 프로세스의 페이지 테이블에 커널 메모리 매핑 포함
• 투기적 실행으로 권한 검사 전에 커널 메모리 접근
• 접근된 커널 데이터가 캐시에 남아 사이드 채널로 유출

전통적 페이지 테이블:
┌─────────────────┐ ← 사용자 프로세스 페이지 테이블
│   User Space    │   0x00000000 - 0x7FFFFFFF
├─────────────────┤
│  Kernel Space   │   0x80000000 - 0xFFFFFFFF ← Meltdown 공격 대상
└─────────────────┘

KPTI 해결 방법:

이중 페이지 테이블 구조:

1. 사용자 모드용 (Shadow Page Table):
┌─────────────────┐
│   User Space    │ ← 모든 사용자 공간 매핑
├─────────────────┤
│ Minimal Kernel  │ ← 시스템 콜/인터럽트 처리용 최소 커널 공간
│   (Trampoline)  │   (입구/출구점만)
└─────────────────┘

2. 커널 모드용 (Full Page Table):
┌─────────────────┐
│   User Space    │ ← 전체 사용자 공간 매핑
├─────────────────┤
│ Full Kernel     │ ← 전체 커널 공간 매핑
│     Space       │
└─────────────────┘

핵심 아이디어:
• 사용자 모드에서는 커널 메모리가 거의 보이지 않음
• 투기적 실행으로도 접근할 수 있는 커널 메모리 극소화
• Meltdown 공격의 공격 표면 근본적 제거

페이지 테이블 전환 메커니즘:

사용자 → 커널 모드 전환:
1. 시스템 콜, 인터럽트, 예외 발생
2. CR3 레지스터를 Full Page Table로 변경
3. 전체 커널 공간에 접근 가능해짐
4. 커널 코드 실행

커널 → 사용자 모드 복귀:
1. 커널 작업 완료
2. CR3 레지스터를 Shadow Page Table로 변경
3. 커널 공간 다시 숨김
4. 사용자 코드 실행 재개

어셈블리 수준 구현:
// 커널 진입
mov rax, full_page_table_phys
mov cr3, rax                    ; 전체 페이지 테이블 활성화

// 사용자 복귀
mov rax, shadow_page_table_phys
mov cr3, rax                    ; 그림자 페이지 테이블 활성화

성능 영향 분석:

오버헤드 발생 원인:

1. 페이지 테이블 전환 비용:
   • CR3 레지스터 변경: 매우 비싼 연산
   • TLB (Translation Lookaside Buffer) 플러시
   • 캐시 미스 증가

2. 시스템 콜 빈도에 비례:
   • 시스템 콜마다 2번의 페이지 테이블 전환 (진입/복귀)
   • I/O 집약적 작업에서 시스템 콜 빈발
   • 네트워크, 파일 시스템 작업 특히 영향 큼

3. TLB 효율성 저하:
   • TLB 엔트리가 두 페이지 테이블 간 공유되지 않음
   • 전환 후 TLB 미스 급증
   • 주소 변환 성능 저하

성능 측정 결과:

워크로드별 성능 영향:
• CPU 집약적 작업: 1-3% 성능 저하
• 일반적인 작업: 5-10% 성능 저하  
• I/O 집약적 작업: 10-20% 성능 저하
• 네트워크 서버: 15-25% 성능 저하

벤치마크 예시:
- 컴파일 작업: 3% 느려짐
- 데이터베이스: 15% 느려짐
- 웹 서버: 20% 느려짐
- 파일 복사: 12% 느려짐

가장 큰 영향:
• 시스템 콜 호출이 빈번한 애플리케이션
• 작은 I/O 요청을 많이 하는 프로그램
• 실시간 시스템

최적화 기법:

PCID (Process Context Identifier) 활용:
• Intel 하스웰 이후 프로세서 지원
• TLB 엔트리에 프로세스 식별자 태그 추가
• 페이지 테이블 전환 시 TLB 플러시 회피
• 성능 오버헤드 상당 부분 감소

최적화 전:
CR3 변경 → 전체 TLB 플러시 → 모든 주소 변환 재계산

최적화 후:
CR3 변경 → PCID로 TLB 엔트리 구분 → 기존 엔트리 재사용

성능 개선:
• PCID 지원 시스템에서 오버헤드 50-70% 감소
• 최신 프로세서에서 5-10% 성능 저하로 완화

KPTI의 한계:

보안 한계:
• Spectre 공격에는 효과 없음
• L1TF (L1 Terminal Fault) 등 새로운 공격에 제한적 효과
• 사이드 채널 공격 모두를 막지는 못함

성능 한계:
• 근본적인 오버헤드 완전 제거 불가능
• 레거시 시스템에서 큰 성능 저하
• 실시간 시스템에서 지연 시간 증가

호환성 한계:
• 일부 특수한 커널 모듈과 충돌 가능
• 가상화 환경에서 추가 복잡성
• 디버깅 도구와의 상호작용 문제

4. 캐시 사이드 채널 공격의 원리와 방어

문제: Flush+Reload와 Evict+Reload 캐시 사이드 채널 공격의 차이점을 설명하고, 이러한 공격들이 암호화 시스템에서 키 정보를 유출하는 과정을 분석하시오.

모범답안:

캐시 사이드 채널 공격 기본 원리:

캐시 시스템 특성:

캐시 접근 시간 차이:
• 캐시 적중 (Cache Hit): 1-3 CPU 사이클
• 캐시 실패 (Cache Miss): 100-300 CPU 사이클

시간 차이를 이용한 정보 추론:
• 빠른 접근: 데이터가 캐시에 있음 → 최근에 접근됨
• 느린 접근: 데이터가 메모리에 있음 → 최근에 접근 안됨

공격 모델:
공격자 ←→ 공유 캐시 ←→ 피해자 프로세스
• 공격자가 캐시 상태 조작 및 관찰
• 피해자의 메모리 접근 패턴 추론
• 비밀 정보 (암호화 키 등) 유출

Flush+Reload 공격:

공격 단계:

1. 준비 단계 (Setup):
   • 공격자가 모니터링할 메모리 주소들 선택
   • 일반적으로 암호화 라이브러리의 룩업 테이블 주소들

2. Flush 단계:
   clflush [target_address]  ; 특정 주소를 캐시에서 제거
   • 모든 캐시 계층에서 해당 주소 데이터 제거
   • 다음 접근 시 메모리에서 새로 로드해야 함

3. 실행 단계 (Victim Execution):
   • 피해자 프로세스 실행 (암호화 연산 등)
   • 피해자가 비밀값에 따라 특정 메모리 주소들에 접근
   • 접근된 주소들이 다시 캐시에 로드됨

4. Reload 단계:
   rdtsc; mov eax, [target_address]; rdtsc  ; 접근 시간 측정
   • 모든 모니터링 주소들에 대해 접근 시간 측정
   • 빠른 접근: 피해자가 해당 주소 접근함 (캐시 적중)
   • 느린 접근: 피해자가 해당 주소 접근 안함 (캐시 실패)

Evict+Reload 공격:

공격 단계:

1. 준비 단계 (Setup):
   • 타겟 주소와 같은 캐시 세트에 매핑되는 더미 주소들 준비
   • 캐시 어소시에이티비티 정보 활용

2. Evict 단계:
   for (i = 0; i < cache_ways * 2; i++) {
       access(dummy_addresses[i]);  ; 더미 데이터로 캐시 라인 채움
   }
   • 제한된 캐시 크기를 이용하여 타겟 데이터 강제 퇴출
   • 다른 데이터로 캐시 라인을 가득 채워서 타겟 데이터 제거

3. 실행 단계 (Victim Execution):
   • 피해자 프로세스가 암호화 연산 수행
   • 비밀값에 따라 특정 주소 접근 여부 결정

4. Reload 단계:
   • 타겟 주소들 접근 시간 측정
   • 빠른 접근: 피해자가 해당 주소를 다시 캐시에 로드함
   • 느린 접근: 피해자가 해당 주소 접근하지 않음

두 공격의 비교:

구분	Flush+Reload	Evict+Reload
제거 방법	clflush 명령어	캐시 어소시에이티비티 이용
정확도	높음 (직접 제거)	중간 (간접 제거)
필요 권한	clflush 실행 권한	일반 메모리 접근 권한
탐지 가능성	높음 (특수 명령어)	낮음 (일반 메모리 접근)
적용 범위	공유 메모리 필요	캐시 공유면 충분

암호화 키 유출 과정:

AES 키 유출 예시:

AES 암호화의 취약점:
• AES S-Box 룩업 테이블 사용
• 입력값에 따라 테이블의 다른 부분 접근
• 키와 평문의 XOR 결과에 따라 접근 패턴 변화

S-Box 테이블 구조:
SBox[256] = {0x63, 0x7c, 0x77, 0x7b, ...}

AES 연산:
state[i] = SBox[plaintext[i] ^ key[i]]
           ↑
    이 인덱스 값이 캐시 접근 패턴으로 유출

공격 과정:
1. 256개 S-Box 엔트리 모두 캐시에서 제거
2. 알려진 평문으로 AES 암호화 실행
3. 어떤 S-Box 엔트리가 캐시에 로드되었는지 확인
4. 접근된 엔트리: SBox[plaintext[i] ^ key[i]]
5. 알려진 plaintext[i]와 접근된 인덱스로 key[i] 계산
6. 모든 키 바이트에 대해 반복하여 전체 키 복구

RSA 키 유출 예시:

RSA CRT (Chinese Remainder Theorem) 구현:
• 개인키 p, q를 이용한 최적화된 연산
• 지수 연산에서 비트별로 다른 연산 수행

Square-and-Multiply 알고리즘:
for bit in private_key:
    result = square(result)
    if bit == 1:
        result = multiply(result, base)  ← 조건부 실행

캐시 공격:
1. 곱셈 함수들의 코드/데이터를 캐시에서 제거
2. RSA 연산 실행
3. 어떤 곱셈 함수가 호출되었는지 캐시 상태로 확인
4. 호출 패턴으로 개인키 비트 값 추론
5. 전체 개인키 복구

방어 기법:

소프트웨어 방어:

1. 상수 시간 구현 (Constant-Time Implementation):
   • 비밀값에 무관하게 동일한 메모리 접근 패턴
   • 조건부 분기 제거
   • 테이블 룩업 대신 비트 연산 사용

2. 메모리 접근 패턴 은닉:
   • 더미 메모리 접근으로 패턴 혼란
   • 모든 가능한 메모리 위치에 접근
   • 실제 필요한 값만 선택적으로 사용

3. 알고리즘 변경:
   • 테이블 기반 → 비트 슬라이싱
   • AES T-table → S-Box + 행렬 연산
   • RSA CRT → 몽고메리 래더

하드웨어 방어:

1. 캐시 분할 (Cache Partitioning):
   • 프로세스별 전용 캐시 할당
   • 캐시 공유 방지
   • 성능 저하와 하드웨어 복잡성 증가

2. 캐시 무작위화:
   • 캐시 매핑을 무작위화
   • 공격자가 캐시 세트 예측 어렵게 만듦
   • 성능 오버헤드 발생

3. 메모리 암호화:
   • 메모리 버스상 데이터 암호화
   • 캐시 외부에서 데이터 관찰 방지
   • Intel TME (Total Memory Encryption)

시스템 수준 방어:

1. 프로세스 격리 강화:
   • 컨테이너 기반 격리
   • 가상화 기반 격리
   • 하드웨어 기반 격리 (SGX, TrustZone)

2. 실행 환경 제어:
   • 공유 캐시 접근 제한
   • 정밀한 타이밍 측정 방지
   • rdtsc 명령어 접근 제한

3. 모니터링 및 탐지:
   • 비정상적인 메모리 접근 패턴 탐지
   • 사이드 채널 공격 시그니처 모니터링
   • 런타임 이상 탐지 시스템

핵심 요약

• Meltdown과 Spectre는 현대 프로세서의 성능 최적화 기법(비순차 실행, 투기적 실행, 캐싱)을 악용한 하드웨어 사이드 채널 공격
• Meltdown은 사용자-커널 경계를 붕괴시켜 커널 메모리 직접 접근이 가능하며, KPTI로 완화 가능하지만 성능 저하 발생
• Spectre는 분기 예측 오류를 악용하여 프로세스 간 격리를 우회하며, 완화가 매우 어려워 다양한 소프트웨어 패치 필요
• 권한 검사 타이밍 문제가 핵심으로, 투기적 실행으로 데이터를 먼저 캐시에 로드한 후 권한 검사가 이루어져 사이드 채널 공격 가능
• 캐시 사이드 채널 공격은 Flush+Reload, Evict+Reload 등의 기법으로 암호화 키 등 비밀 정보를 유출할 수 있음
• 완화 기법은 소프트웨어 패치(KPTI, Retpoline)가 주를 이루지만 성능 저하가 불가피하며, 근본적 해결책은 하드웨어 재설계
• 상수 시간 구현과 메모리 접근 패턴 은닉 등으로 암호화 시스템을 사이드 채널 공격으로부터 보호 가능
• 지속적인 업데이트와 보안 모니터링이 필수적이며, 새로운 변형 공격에 대한 지속적인 대응 필요

💡 중요: Meltdown과 Spectre는 하드웨어와 소프트웨어 보안의 패러다임을 바꾼 획기적인 공격으로, 성능과 보안 간의 근본적 모순을 드러냈습니다. 완벽한 해결책은 없지만 다층 방어와 지속적인 업데이트를 통해 위험을 최소화할 수 있으며, 향후 프로세서 설계에서는 보안을 우선 고려한 아키텍처 개발이 필요합니다.