์์ฝ: VS์ __asm{} ๋ด๋ถ์ _emit์ผ๋ก 0xE9/0xE8๋ฑ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์
ํด, ๋์ค์ด์
๋ธ๋ฌ์ ์ ์์ ์ธ ๋ฐ์ด๋๋ฆฌ ํด์์ ๋ฐฉํดํ ์ ์์
anti disassembly๋?
๋์ค์ด์
๋ธ๋ฌ ํ๋ก๊ทธ๋จ์ด ์คํํ์ผ์ ์ฝ๊ณ ๊ทธ ํ๋ฆ์ ๋ถ์ํ๋ ๊ฒ์ ๋ฐฉํดํ๋ ๊ธฐ์ .
์ค์ ์คํ๊ณผ๋ ๋ค๋ฅธ ๋ช
๋ น์ด๋ฅผ ๋ณด์ฌ์ฃผ๋๋ก ๋์ค์ด์
๋ธ๋ฌ๋ฅผ ์์ด๋ ๊ฒ์ด ๊ฐ๋ฅํ๋ค.
์๋ฆฌ
๋์ค์ด์
๋ธ๋ฌ์ ๊ฐ์ ๊ณผ ์ ์ฝ์ ์ด์ฉํ์ฌ, ์ ํจํ ๋ช
๋ น์ ๋์ค์ด์
๋ธ๋ฌ๋ก๋ถํฐ ์จ๊ธธ ์ ์๋ค
๋์ค์ด์
๋ธ๋ฌ๋ ํฌ๊ฒ ์ ํ ์ค์ฌ/ํ๋ฆ ์ค์ฌ์ผ๋ก ๋๋๋๋ฐ, ์ ํ ์ค์ฌ์ ๋์ค์ด์
๋ธ๋ฌ๋ opcode๋ฅผ ํ๋ํ๋ ๋ฒ์ญํ๊ณ , ํ๋ฆ ์ค์ฌ ๋์ค์ด์
๋ธ๋ฌ๋ ๋ถ๊ธฐ๋ฌธ์ ์ ์ํ๋ฉฐ opcode๋ฅผ ๋ฒ์ญํ๋ค.
ํํ๋ค ์ฌ์ฉํ๋ IDA์ ๊ฒฝ์ฐ๋ ๋ํ์ ์ธ ํ๋ฆ ์ค์ฌ ๋์ค์ด์
๋ธ๋ฌ๋ก, JZ/JNZ ๋ฑ ์กฐ๊ฑด๋ถ ์ ํ๊ฐ ์ํ๋ ๋ false branch (์กฐ๊ฑด์ ๋ง์ง ์์ ๋์ ์ฝ๋)์ ์ด์ ์ ๋ง์ถฐ ๋์ค์ด์
๋ธ์ ์ํํ๋ค. ์ด๋ฌํ ์ ์ ์ญ์ผ๋ก ์ด์ฉํ๋ฉด ์์ฝ๊ฒ ์ํฐ ๋์ค์ด์
๋ธ ๊ธฐ์ ์ ๊ตฌํํ ์๊ฐ ์๋ค.
์๋ฅผ ๋ค์ด๋ณด์๋ฉด,
xor eax, eax
jz label1
mov eax, 1
label1:
์ด๋ฐ ์ฝ๋๊ฐ ์๋ค.
eax๋ฅผ 0์ผ๋ก ๋ง๋ ๋ค ZF๊ฐ ์ธํ
๋์ด label1๋ก ์ ํํ๋ ๊ฐ๋จํ ์ฝ๋์ธ๋ฐ, ํ ๋์ ๋ด๋ mov eax, 1์ด๋ผ๋ ๋ช
๋ น์ด๋ ์คํ๋์ง ์์ ๊ฒ์์ ์ ์ ์๋ค. ๊ทธ๋ ์ง๋ง ํ๋ฆ ์ค์ฌ์ ๋์ค์ด์
๋ธ๋ฌ๋ jz์ false branch์ธ mov eax, 1 ์ฝ๋์ ์ด์ ์ ๋ง์ถฐ ๋์ค์ด์
๋ธ์ ์งํํ๋ค. ์ฌ์ฉ๋์ง ์๋ opcode๋ฅผ ๋จผ์ ํด์ํด ๋ฒ๋ฆฐ ๊ฒ์ผ๋ก, ์ด ํน์ฑ์ ์ด์ฉํด ์กฐ๊ฑด ๋ถ๊ธฐ์ ์ฌ์ฉ๋์ง ์๋ false branch ์์ญ์ 0xE9 (jmp) / 0xE8 (call) ๋ฑ์ opcode๋ก ํด์๋ ์ ์๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ์
ํ๋ฉด ๋์ค์ด์
๋ธ ๊ณผ์ ์ ํผ๋์ ์ผ๊ธฐํ ์ ์๋ค. ์ฐธ ์ฝ์ฃ ?
์์ ์ฝ๋
1. JZ + JNZ ๋์ผํ ์ฃผ์
๋์ค์ด์
๋ธ๋ฌ๋ ํ ๋ฒ์ ํ ๋ช
๋ น๋ง ํด์ํ ์ ์์ผ๋ฏ๋ก ์ฐ์๋ JZ์ JNZ ๋ช
๋ น์ operand๊ฐ ๋์ผํ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌ์ผ๋ ์ด๋ฅผ ํ์
ํ์ง ๋ชปํ๋ค. (์๋์๋... ๋ด๊ฐ ๊ฐํ ํ๋ ธ์์๋)
#include <stdio.h>
//compiler: visual studio 2019, x86 debug
int main(void){
__asm{
jz label1
jnz label1
_emit 0xE9 //0xE9 == JMP, 0xE8 == CALL
}
label1:
printf("Successfully executed!\n");
return 0;
}
ํ์๊ฐ ์ฌ์ฉํ๋ x32dbg์ ๊ฒฝ์ฐ, ํ๋ก๊ทธ๋จ์ ์ฝ์
๋ 0xE9๋ผ๋ ๋ฐ์ดํฐ ๋๋ฌธ์ ๋์ค์ด์
๋ธ์ ์ํํ ์คํํ์ง ๋ชปํ๊ณ , ๋๋ฒ๊ฑฐ๋ฅผ ๋ถ์ฌ ์คํ ์ ๋๋ฒ๊น
์ด ์ค์ง๋๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
2. XOR [arg], [arg] -> JZ [mem]
๋๊ฐ์ operand๋ฅผ xor ํ์ผ๋ฏ๋ก ZF๊ฐ ์ธํ
, ๋ฌด์กฐ๊ฑด์ ์ผ๋ก JZ๊ฐ ์คํ๋์ง๋ง ๋ง์ฐฌ๊ฐ์ง๋ก ๋์ค์ด์
๋ธ๋ฌ๋ ์คํ๋์ง ์๋ false branch์ ์ค์ ์ ๋์ด ์๋ํ๊ธฐ ๋๋ฌธ์ JZ false branch์ ๋ฐ์ดํฐ, 0xE9๋ 0xE8์ด opcode๋ก ํด์๋๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ก ์ด ์์ญ๋ถํฐ ํ๋ก๊ทธ๋จ์ ์ด์
๋ธ๋ฆฌ ์ฝ๋ ํด์์ด ๋ฐ๋ฆฐ๋ค.
#include <stdio.h>
int main(void){
__asm{
xor eax, eax
jz label1
_emit 0xE9
}
label1:
printf("Successfully executed!\n");
return 0;
}
๋น์ฐํ ์๋ฆฌ์ง๋ง _emit 0xE9 ๋ค์ "Successfully executed!\n" ๋ฌธ์์ด๋ ๊ฒ์ํ ์ ์๋ค.
๋ถ์ ๋ฐฉ๋ฒ
๊ธฐ๋ณธ์ ์ผ๋ก IDA๋ anti disassemble ๊ธฐ๋ฒ์ด ์ ์ฉ๋ ๊ฒ์ผ๋ก ๋ณด์ด๋ ์์ญ์ ๋นจ๊ฐ๊ฒ ํ์ด๋ผ์ดํ
ํด ๋ณด์ฌ์ฃผ๋๋ฐ, ์ด ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ Hex view ์ฐฝ์์ anti disassemble์ ์ํด ์ฝ์
๋ ํฅ์ค ๊ฐ์ 0x90 (==nop)์ผ๋ก ํจ์นํ ์ ์๋ค.

๋๋ฒ๊ฑฐ๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ์์ ์์์ ๊ทผ๊ฑฐํ์ฌ (jnz+jz / xor+jz) ํ๋ก๊ทธ๋จ ํ๋ฆ์ด ๋ง๊ฐ์ง๊ธฐ ์์ํ๋ ๋ถ๋ถ์ ์ฐพ๊ณ , ๊ทธ ๋ถ๋ถ์ 0x90์ผ๋ก ํจ์นํ๋ฉด ๋๋ค.
์๋ฆฌ๋ ์ด๋ ต์ง ์๊ณ ์ฝ๊ฒ ๊ตฌํ ๊ฐ๋ฅํ์ง๋ง, ํ๋งํฐ๋ฉด ๋ถ์๊ฐ๋ฅผ ์์ผ ์ ์๋ ๊ฐ๋ ฅํ ๊ธฐ์ ์์ ํ๋ฆผ์์ด ๋ณด์ธ๋ค. ๋์ค์ด์
๋ธ๋ฌ์ ๊ธฐ๋ณธ์ ์ธ ๊ฐ์ ์ ํ์ฉํด ์ด๋ฐ ๊ธฐ์ ์ ๋ง๋ค์ด ๋๋ค๋ ์ ์ด ํฅ๋ฏธ๋กญ๋ค.
'reverse engineering' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[PE ํ๋กํ ํฐ ์ ์] PE ํ์ฑํ๊ธฐ (0) | 2023.12.17 |
---|---|
[Anti-Reversing] IsDebuggerPresent() ๊ตฌํ (4) | 2022.08.09 |
[๋ฆฌ๋ฒ์ฑ ํต์ฌ์๋ฆฌ] DLL injection ์์ ์ฝ๋ ํด์ค (0) | 2021.07.11 |
[RCE] PE file format (1) (0) | 2021.05.02 |
Bank Robbery ๋ฌธ์ ํ์ด ๋ณด๊ณ ์ (2) | 2021.01.23 |