TL;DR

실행 파일 cie는 입력 PNG를 읽어 자체 포맷(HSPACE)로 인코딩한다.
flag.out은 해당 자체 포맷으로 인코딩되어있다.
최종 목표는 원본 이미지를 복원해 플래그를 추출하는 것이다.

Analysis

ELF

1. PNG stream load

1
_BOOL8 __fastcall sub_1CE90(__int64 *a1, __int64 a2)
2
{
3
  *a1 = sub_2420(a2, (__int64)(a1 + 1), (__int64)a1 + 12, (__int64)(a1 + 2), 3u);
4
  return *a1 != 0;
5
}
6

7

8
__int64 __fastcall sub_2420(__int64 a1, __int64 a2, __int64 a3, __int64 a4, unsigned int a5)
9
{
10
  __int64 v6; // [rsp+0h] [rbp-40h]
11
  FILE *stream; // [rsp+8h] [rbp-38h]
12

13
  stream = (FILE *)sub_24C0(a1, &unk_24680);
14
  if ( stream )
15
  {
16
    v6 = sub_2520(stream, a2, a3, a4, a5);
17
    fclose(stream);
18
    return v6;
19
  }
20
  else
21
  {
22
    sub_24F0("can't fopen");
23
    return 0;
24
  }
25
}

PNG를 로드하고 픽, 높이, 픽셀 수를 가져옴.

2. 스트림 변환

1
unsigned __int64 __fastcall sub_1D5B0(_DWORD *a1)
2
{
3
  unsigned __int64 result; // rax
4
  char v2; // [rsp+5h] [rbp-2Bh]
5
  char v3; // [rsp+6h] [rbp-2Ah]
6
  char v4; // [rsp+7h] [rbp-29h]
7
  char v5; // [rsp+17h] [rbp-19h]
8
  unsigned __int64 i; // [rsp+18h] [rbp-18h]
9
  unsigned __int64 v7; // [rsp+20h] [rbp-10h]
10

11
  v7 = 3 * a1[3] * a1[2];
12
  sub_1DD80(a1 + 6, v7);
13
  v3 = **(_BYTE **)a1;
14
  *(_BYTE *)sub_1DE20(a1 + 6, 0) = v3;
15
  v4 = *(_BYTE *)(*(_QWORD *)a1 + 1LL);
16
  *(_BYTE *)sub_1DE20(a1 + 6, 1) = v4;
17
  v5 = *(_BYTE *)(*(_QWORD *)a1 + 2LL);
18
  *(_BYTE *)sub_1DE20(a1 + 6, 2) = v5;
19
  for ( i = 3; ; ++i )
20
  {
21
    result = i;
22
    if ( i >= v7 )
23
      break;
24
    v2 = *(_BYTE *)(*(_QWORD *)a1 + i) - *(_BYTE *)(*(_QWORD *)a1 + i - 3);
25
    *(_BYTE *)sub_1DE20(a1 + 6, i) = v2;
26
  }
27
  return result;
28
}

RGB 스트림을 채널별 누적 델타로 변환한다. 첫 3바이트는 그대로, 이후 값은 같은 채널 이전 픽셀과의 차이

3. Huffman Codes

1
__int64 __fastcall sub_1D6B0(__int64 a1)
2
{
3
  _DWORD *v1; // rax
4
  int i; // [rsp+20h] [rbp-100h]
5
  __int64 v4; // [rsp+2Ch] [rbp-F4h]
6
  char v5; // [rsp+37h] [rbp-E9h] BYREF
7
  __int64 v6; // [rsp+38h] [rbp-E8h] BYREF
8
  _QWORD v7[2]; // [rsp+40h] [rbp-E0h] BYREF
9
  char v8; // [rsp+56h] [rbp-CAh]
10
  char v9; // [rsp+57h] [rbp-C9h] BYREF
11
  _BYTE v10[28]; // [rsp+58h] [rbp-C8h] BYREF
12
  _BYTE v11[12]; // [rsp+74h] [rbp-ACh] BYREF
13
  __int64 v12; // [rsp+80h] [rbp-A0h]
14
  __int64 v13; // [rsp+88h] [rbp-98h] BYREF
15
  _QWORD v14[2]; // [rsp+90h] [rbp-90h] BYREF
16
  __int64 v15; // [rsp+A0h] [rbp-80h] BYREF
17
  unsigned __int8 v16; // [rsp+AFh] [rbp-71h]
18
  __int64 v17; // [rsp+B0h] [rbp-70h] BYREF
19
  _QWORD v18[2]; // [rsp+B8h] [rbp-68h] BYREF
20
  char v19; // [rsp+DBh] [rbp-45h] BYREF
21
  int v20; // [rsp+DCh] [rbp-44h] BYREF
22
  _BYTE v21[24]; // [rsp+E0h] [rbp-40h] BYREF
23
  __int64 v22; // [rsp+F8h] [rbp-28h]
24
  char *v23; // [rsp+100h] [rbp-20h]
25
  char *v24; // [rsp+108h] [rbp-18h]
26
  char *v25; // [rsp+118h] [rbp-8h]
27

28
  v22 = a1;
29
  v20 = 0;
30
  v23 = &v19;
31
  v25 = &v19;
32
  sub_1E830(v21, 256, &v20);
33
  v24 = &v19;
34
  sub_1F720(&v19);
35
  v18[1] = a1 + 24;
36
  v18[0] = sub_1E8B0(a1 + 24);
37
  v17 = sub_1E8E0(a1 + 24);
38
  while ( (sub_1E910(v18, &v17) & 1) != 0 )
39
  {
40
    v16 = *(_BYTE *)sub_1E960(v18);
41
    v1 = (_DWORD *)sub_1E980(v21, v16);
42
    ++*v1;
43
    sub_1E9A0(v18);
44
  }
45
  v15 = 0;
46
  sub_1E9C0(a1, v21, &v15);
47
  sub_1ECD0(a1, v15, 0);
48
  v14[1] = a1 + 72;
49
  v14[0] = sub_1ED90(a1 + 72);
50
  v13 = sub_1EDC0(a1 + 72);
51
  while ( (sub_1EDF0(v14, &v13) & 1) != 0 )
52
  {
53
    v12 = sub_1EE20(v14);
54
    sub_1EE90(v11, v12, v12 + 4);
55
    sub_1EE60(a1 + 128, v11);
56
    sub_1EEC0(v14);
57
  }
58
  sub_1D2E0(v10);
59
  v9 = 0;
60
  v8 = 0;
61
  v7[1] = a1 + 24;
62
  v7[0] = sub_1E8B0(a1 + 24);
63
  v6 = sub_1E8E0(a1 + 24);
64
  while ( (sub_1E910(v7, &v6) & 1) != 0 )
65
  {
66
    v5 = *(_BYTE *)sub_1E960(v7);
67
    v4 = *(_QWORD *)sub_1EEF0(a1 + 72, &v5);
68
    for ( i = BYTE4(v4) - 1; i >= 0; --i )
69
    {
70
      v9 |= (((unsigned int)v4 >> i) & 1) << (7 - v8++);
71
      if ( v8 == 8 )
72
      {
73
        sub_1EF20(v10, &v9);
74
        v9 = 0;
75
        v8 = 0;
76
      }
77
    }
78
    sub_1E9A0(v7);
79
  }
80
  if ( v8 )
81
    sub_1EF20(v10, &v9);
82
  sub_1EFC0(a1 + 48, v10);
83
  sub_1F280(v10);
84
  return sub_1F2F0(v21);
85
}

델타 버퍼로부터 빈도를 계산해 허프만 코드북을 만들고 비트스트림을 생성한다. 출력은 (심볼, 코드길이, 코드) 12바이트 엔트리 묶음과 압축 데이터이다.

4. 상수 키 XOR

1
unsigned __int64 __fastcall sub_1DB00(__int64 a1, __int64 a2)
2
{
3
  unsigned __int64 v2; // rcx
4
  unsigned __int64 result; // rax
5
  _BYTE *v4; // rax
6
  char v5; // [rsp+4h] [rbp-2Ch]
7
  unsigned __int64 i; // [rsp+18h] [rbp-18h]
8

9
  for ( i = 0; ; ++i )
10
  {
11
    v2 = sub_1DC20(a2);
12
    result = i;
13
    if ( i >= v2 )
14
      break;
15
    v5 = *(_BYTE *)(a1 + (i & 0x1F) + 152);
16
    v4 = (_BYTE *)sub_1DE20(a2, i);
17
    *v4 ^= v5;
18
  }
19
  return result;
20
}
21

22
__int64 __fastcall sub_1DC20(_QWORD *a1)
23
{
24
  return a1[1] - *a1;
25
}
26

27

28
unsigned __int64 __fastcall sub_1DB90(__int64 a1, __int64 a2)
29
{
30
  unsigned __int64 v2; // rcx
31
  unsigned __int64 result; // rax
32
  unsigned __int8 *v4; // rax
33
  char v5; // [rsp+7h] [rbp-29h]
34
  unsigned __int64 i; // [rsp+18h] [rbp-18h]
35

36
  for ( i = 0; ; ++i )
37
  {
38
    v2 = sub_1DC20(a2);
39
    result = i;
40
    if ( i >= v2 )
41
      break;
42
    v4 = (unsigned __int8 *)sub_1DE20(a2, i);
43
    v5 = sub_23880(a1, *v4);
44
    *(_BYTE *)sub_1DE20(a2, i) = v5;
45
  }
46
  return result;
47
}
48

49
__int64 __fastcall sub_23880(__int64 a1, unsigned __int8 a2)
50
{
51
  return ((int)a2 >> 1) & 1u
52
       | (unsigned __int8)((2 * (((int)a2 >> 6) & 1))
53
                         | (4 * (((int)a2 >> 3) & 1))
54
                         | (8 * (((int)a2 >> 4) & 1))
55
                         | (16 * (((int)a2 >> 5) & 1))
56
                         | (32 * (((int)a2 >> 2) & 1))
57
                         | ((((int)a2 >> 7) & 1) << 6)
58
                         | ((a2 & 1) << 7));
59
}

32바이트 상수 키랑 XOR하고 sub_1DB90이 고정 비트순열을 적용한다.

상수값은 여기에 있다.

1
__int64 __fastcall sub_1CDE0(__int64 a1)
2
{
3
  __int64 result; // rax
4

5
  *(_QWORD *)a1 = 0;
6
  *(_DWORD *)(a1 + 8) = 0;
7
  *(_DWORD *)(a1 + 12) = 0;
8
  *(_DWORD *)(a1 + 16) = 0;
9
  sub_1D2E0(a1 + 24);
10
  sub_1D2E0(a1 + 48);
11
  sub_1D300(a1 + 72);
12
  sub_1D320(a1 + 128);
13
  result = a1;
14
  *(_QWORD *)(a1 + 152) = 0x22148FE000A8F028LL;
15
  *(_QWORD *)(a1 + 160) = 0xD59FC621AB138A2ELL;
16
  *(_QWORD *)(a1 + 168) = 0xF943272CFF4841EFLL;
17
  *(_QWORD *)(a1 + 176) = 0xA93EE157F3AEC4C9LL;
18
  return result;
19
}

정리하면 28f0a800e08f14222e8a13ab21c69fd5ef4148ff2c2743f9c9c4aef357e13ea9

마지막으로 헤더(36바이트) + 코드북(엔트리 수 x 6바이트) + 비트스트림으로 기록

flag.out

![[cie-flag.out.png]]

Offset	Size	Desc
0x00	6	HSPACE Magic
0x06	1	버전 (관측값 0x01)
0x07	1	플래그 (관측값 0xA8)
0x08	4	폭 (little endian)
0x0C	4	높이
0x10	4	압축 데이터 길이 (encoded_len)
0x14	4	원본 RGB 길이 (decoded_len)
0x18	4	허프만 엔트리 수 (code_count, 관측값 165)
0x1C	8	예약(0)
0x24	2	실제 코드북 엔트리 수 (헤더 값과 동일)
이후	6 x N	허프만 엔트리: sym(1) + len(1) + code(4)
마지막	encoded_len	비트스트림 (XOR/비트순열 적용됨)

Exploit

헤더, 코드북 파싱: 코드북은 (길이, 코드) $\rightarrow$ 심볼로 재구성
비트스트림 후처리
1. 복원비트순열 역변환: b7 b0 b5 b2 b3 b4 b1 b6
2. 32바이트 키와 반복 XOR.
허프만 복호화: 비트 단위로 읽어 코드북과 일치하는 순간 심볼 출력
델타 역변환: 인덱스 3부터 buf[i] = (buf[i] + buf[i-3]) & 0xFF.
폭과 높이에 맞춰 RGB Buffer를 PNG로 저장

1
import struct
2
from pathlib import Path
3
from PIL import Image
4

5
KEY = bytes.fromhex("28f0a800e08f14222e8a13ab21c69fd5ef4148ff2c2743f9c9c4aef357e13ea9")
6

7
def inv_perm(byte: int) -> int:
8
    return (
9
        ((byte >> 7) & 1)
10
        | (((byte >> 0) & 1) << 1)
11
        | (((byte >> 5) & 1) << 2)
12
        | (((byte >> 2) & 1) << 3)
13
        | (((byte >> 3) & 1) << 4)
14
        | (((byte >> 4) & 1) << 5)
15
        | (((byte >> 1) & 1) << 6)
16
        | (((byte >> 6) & 1) << 7)
17
    )
18

19
def read_header(data: bytes):
20
    header_fmt = "<6sBBIIIIIII"
21
    header_size = struct.calcsize(header_fmt)
22
    magic, version, flags, width, height, enc_len, total_len, code_count, _, _ = struct.unpack(
23
        header_fmt, data[:header_size]
24
    )
25
    if magic != b"HSPACE":
26
        raise ValueError("Invalid magic value")
27
    return {
28
        "width": width,
29
        "height": height,
30
        "encoded_len": enc_len,
31
        "decoded_len": total_len,
32
        "code_count": code_count,
33
    }, header_size
34

35
def parse_codebook(data: bytes, offset: int, count: int):
36
    (entry_count,) = struct.unpack_from("<H", data, offset)
37
    offset += 2
38
    table = {}
39
    for _ in range(entry_count):
40
        symbol = data[offset]
41
        length = data[offset + 1]
42
        code = struct.unpack_from("<I", data, offset + 2)[0]
43
        offset += 6
44
        code &= (1 << length) - 1
45
        table[(length, code)] = symbol
46
    return table, offset
47

48
def undo_postprocessing(payload: bytes) -> bytes:
49
    buf = bytearray(inv_perm(b) for b in payload)
50
    key_len = len(KEY)
51
    for i in range(len(buf)):
52
        buf[i] ^= KEY[i % key_len]
53
    return bytes(buf)
54

55
def huffman_decode(bitstream: bytes, table: dict, expected_len: int) -> bytearray:
56
    output = bytearray()
57
    acc = 0
58
    bits = 0
59
    max_len = max(length for length, _ in table.keys())
60
    for byte in bitstream:
61
        for shift in range(7, -1, -1):
62
            bit = (byte >> shift) & 1
63
            acc = ((acc << 1) | bit) & ((1 << max_len) - 1)
64
            bits += 1
65
            key = (bits, acc)
66
            symbol = table.get(key)
67
            if symbol is not None:
68
                output.append(symbol)
69
                acc = 0
70
                bits = 0
71
                if len(output) == expected_len:
72
                    return output
73
    return output
74

75
def reverse_delta(data: bytearray):
76
    for i in range(3, len(data)):
77
        data[i] = (data[i] + data[i - 3]) & 0xFF
78

79
def decode_hspace(path: Path) -> Image.Image:
80
    raw = path.read_bytes()
81
    header, offset = read_header(raw)
82
    codebook, offset = parse_codebook(raw, offset, header["code_count"])
83
    payload = raw[offset : offset + header["encoded_len"]]
84
    processed = undo_postprocessing(payload)
85
    decoded = huffman_decode(processed, codebook, header["decoded_len"])
86
    reverse_delta(decoded)
87
    return Image.frombytes("RGB", (header["width"], header["height"]), bytes(decoded))
88

89
if __name__ == "__main__":
90
    img = decode_hspace(Path("flag2.out"))
91
    img.save("flag.png")

![[cie-flag.png]]

1
HSPACE{3c1016249b1cb2308262855b5fe4e5e8432076c7f7ff5ae4df4670e9af86faed}

[CLUB LEAGUE] CIE writeup