# strings와 FLOSS로 문자열 꺼내기: 평문, 인코딩, 실행 중에 조립하는 문자열

> 직접 만든 무해한 PE 파일에 평문, UTF-16, XOR, base64, 스택 조립 문자열을 넣고 strings와 FLOSS로 무엇이 보이고 안 보이는지 비교합니다. 파일은 실행하지 않고 열어서 읽기만 합니다.

- 주소: https://copyandrun.com/blog/strings-floss-obfuscated-strings/
- 분야: 악성코드 분석
- 발행일: 2026-11-01
- 태그: strings, FLOSS, 문자열 분석, 정적 분석, PE

의심스러운 실행 파일을 받았을 때 가장 먼저 해 볼 수 있는 일이 파일 안에 든 글자를 꺼내 보는 것입니다. 주소, 파일 경로, 레지스트리 키 모양의 글자는 이 프로그램이 무엇을 하려는지 알려 주는 단서가 됩니다. 다만 만드는 쪽이 글자를 숨기면 `strings`에는 보이지 않습니다. 이 글에서는 직접 만든 무해한 시험 프로그램에 글자를 다섯 가지 방식으로 넣고, `strings`와 FLOSS가 각각 무엇을 꺼내는지 비교합니다.

시험 프로그램은 컨테이너 안에서 Windows용 실행 파일(PE)로 컴파일만 하고 실행하지 않습니다. 글자는 모두 example.com 주소와 가짜 경로입니다. 실제 악성코드는 내려받지 않았습니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| Docker | 29.5.3 |
| 기본 이미지 | `python:3.12-slim-bookworm` (Python 3.12.16) |
| 컴파일러 | `x86_64-w64-mingw32-gcc` 12-win32 (패키지 `gcc-mingw-w64-x86-64-win32`) |
| strings | GNU strings 2.40 (binutils) |
| FLOSS | `flare-floss` 3.2.0 (`pip install flare-floss`, vivisect 1.3.2) |

FLOSS는 설치할 때 `binary2strings`를 컴파일하므로 C++ 컴파일러(`g++`)가 필요합니다. 처음에 `g++` 없이 설치했더니 `Failed to build binary2strings`로 멈췄습니다.

## 1. 시험 프로그램과 컨테이너 만들기

<!-- files: Dockerfile, demo.c, gen_encoded.py, run.sh -->

`demo.c`에는 글자를 다섯 가지 방식으로 넣었습니다. 전체 내용은 아래 전체 코드에 있습니다.

| 방식 | 코드에서의 모양 | 프로그램 안의 글자 |
|---|---|---|
| 평문 | `"http://plain.example.com/update/check"` 같은 문자열 상수 | 주소, 가짜 경로, 레지스트리 키 모양 |
| UTF-16 | `L"C:\\Temp\\demo-agent.log"` | 가짜 로그 경로 |
| XOR | 바이트 24개 배열, 실행 중에 키 `0x5A`로 풂 | `http://xor.example.com/a` |
| base64 | `"aHR0cDovL2I2NC5leGFtcGxlLmNvbS9j"`, 실행 중에 풂 | `http://b64.example.com/c` |
| 스택 조립 | `stack_url[0] = 'h'; stack_url[1] = 't'; ...` | `http://stack.example.com/b` |

XOR 바이트열과 base64 문자열은 `gen_encoded.py`가 만들어 준 값을 `demo.c`에 붙여 넣은 것입니다.

```bash
docker build -t cr-m2-strings .
docker run -d --name cr-m2-strings-1 cr-m2-strings sleep 3000
docker exec cr-m2-strings-1 sh run.sh
```

```
# 기대 출력(이 PC)
demo.exe: PE32+ executable (console) x86-64, for MS Windows, 19 sections
-rwxr-xr-x 1 root root 295998 Nov  1 02:49 demo.exe
```

`-O0`(최적화 없음)로 컴파일했습니다. 최적화를 켜면 컴파일러가 글자 대입을 다른 모양으로 바꿀 수 있어서, 이 글의 스택 문자열 결과가 달라질 수 있습니다. 이 글에서는 `-O0`만 시험했습니다. 시험 파일은 `docker exec`로 컴파일했을 뿐 실행하지 않았습니다.

## 2. strings로 ASCII 문자열 보기

<!-- files: demo.c -->

```bash
docker exec cr-m2-strings-1 sh -c 'strings -a demo.exe | wc -l'
docker exec cr-m2-strings-1 sh -c 'strings -a demo.exe | grep -E "http|Users|Software|aHR0"'
```

```
# 기대 출력(이 PC)
4738
http://plain.example.com/update/check
C:\Users\alice\AppData\Roaming\DemoAgent\config.dat
Software\DemoCorp\Agent\Settings
2..*`uu"5(t?";7*6?t957u;aHR0cDovL2I2NC5leGFtcGxlLmNvbS9j
```

![strings 실행 결과에서 평문 주소, 가짜 경로, 레지스트리 키 모양이 그대로 나오고 XOR 바이트가 깨진 글자로 base64 문자열 앞에 붙어 나오는 것을 확인합니다.](https://copyandrun.com/img/strings-floss-obfuscated-strings/01-strings-ascii.png)

파일 전체에서 4,738줄이 나옵니다. mingw 런타임 안의 함수 이름과 메시지가 대부분이라 그대로 읽기는 어렵고, `grep`으로 줄여서 봅니다.

- **평문 세 개는 그대로 보입니다.** 주소와 경로, `Software\...` 모양의 키는 한눈에 알아볼 수 있습니다. 분석에서 가장 먼저 건지는 단서입니다.
- **XOR 문자열은 깨진 글자로 보입니다.** `2..*`uu"5(t?";7*6?t957u;`가 그 24바이트입니다. 널(0) 문자로 끝나지 않아서 바로 뒤의 base64 문자열과 한 줄로 이어져 나왔습니다.
- **base64 문자열은 글자로는 보입니다.** 주소 모양은 아니지만, 영문과 숫자만 이어진 32글자에 `aHR0cD`로 시작하는 모양이라 알아보는 사람은 알아봅니다. `http://`로 시작하는 글자는 base64에서 `aHR0cDovL`로 시작하기 때문입니다.
- **스택 조립 문자열은 보이지 않습니다.** `grep -c "stack.example"`와 `grep -c "xor.example"`는 둘 다 0이었습니다. 글자가 한꺼번에 저장된 것이 아니라 명령어 하나하나에 한 글자씩 들어 있기 때문입니다.

## 3. strings -el로 UTF-16 문자열 보기

Windows 프로그램은 글자를 UTF-16LE(글자마다 2바이트)로 저장하는 일이 많습니다. 기본 `strings`는 이 모양을 찾지 못해서 `-el` 옵션을 줍니다.

```bash
docker exec cr-m2-strings-1 sh -c 'strings -a -el demo.exe'
```

```
# 기대 출력(이 PC)
C:\Temp\demo-agent.log
(null)
%*.*S
%-*.*S
%.*S
%*.*s
%-*.*s
%.*s
(null)
```

![strings -el 실행 결과에서 가짜 로그 경로 한 줄과 런타임의 서식 문자열 여덟 줄, 합계 9줄이 나오는 것을 확인합니다.](https://copyandrun.com/img/strings-floss-obfuscated-strings/02-strings-utf16.png)

`demo.c`에서 넣은 `C:\Temp\demo-agent.log`가 나왔습니다. 나머지 여덟 줄은 mingw 런타임이 쓰는 서식 문자열입니다. 기본 `strings`로는 이 경로를 찾지 못합니다. 문자열 도구를 쓸 때는 ASCII와 UTF-16 두 가지를 모두 돌립니다.

## 4. FLOSS로 같은 파일 읽기

<!-- files: demo.c -->

FLOSS는 정적 문자열 추출에 더해, 스택에서 조립하는 글자와 디코딩 함수가 풀어낸 글자를 코드를 흉내 내서(에뮬레이션) 꺼냅니다. 파일을 실제로 실행하지는 않습니다.

```bash
docker exec cr-m2-strings-1 sh -c 'floss demo.exe > floss.txt 2> floss.err; echo rc=$?'
```

```
# 기대 출력(이 PC)
rc=0
```

`floss.err`의 마지막 줄에 `finished execution after 15.15 seconds`가 찍혔습니다(이 PC에서 이 파일 기준). 결과 요약과 뒷부분은 아래와 같습니다.

```bash
docker exec cr-m2-strings-1 sh -c 'grep -E "RESULTS|static strings|stack strings|tight strings|decoded strings" floss.txt; tail -n 24 floss.txt'
```

```
# 기대 출력(이 PC)
FLARE FLOSS RESULTS (version 3.2.0)
|  static strings        | 4747 (51586 characters)                             |
|  stack strings         | 1                                                   |
|  tight strings         | 2                                                   |
|  decoded strings       | 3                                                   |

 ───────────────────────── 
  FLOSS STACK STRINGS (1)  
 ───────────────────────── 

http://stack.example.com/b

 ───────────────────────── 
  FLOSS TIGHT STRINGS (2)  
 ───────────────────────── 

F0056514
F0056514

 ─────────────────────────── 
  FLOSS DECODED STRINGS (3)  
 ─────────────────────────── 

110,348,61-A
110,348,61-
http://xor.example.com/a
```

![FLOSS 결과에서 정적 문자열 4747개, 스택 문자열 1개, 디코딩 문자열 3개가 집계되고 스택 문자열 http://stack.example.com/b와 디코딩 문자열 http://xor.example.com/a가 나오는 것을 확인합니다.](https://copyandrun.com/img/strings-floss-obfuscated-strings/03-floss-results.png)

- **스택 문자열을 찾았습니다.** `strings`에서 0건이던 `http://stack.example.com/b`가 `STACK STRINGS`에 나왔습니다.
- **XOR 문자열을 풀어서 찾았습니다.** `DECODED STRINGS`에 `http://xor.example.com/a`가 있습니다. 키를 알려 주지 않았는데도 FLOSS가 디코딩 루틴을 찾아 에뮬레이션해서 얻은 결과입니다.
- **base64 문자열은 풀지 못했습니다.** `http://b64.example.com/c`는 어느 구역에도 없었고, 정적 문자열 줄(`...;aHR0cDovL2I2NC5leGFtcGxlLmNvbS9j`)에만 그대로 나왔습니다. 이 시험 프로그램의 base64 해독 코드는 FLOSS가 디코딩 함수로 고르지 않은 것으로 보입니다. 이유까지는 확인하지 못했습니다.
- **쓸모없는 줄도 섞입니다.** `110,348,61-A`, `110,348,61-`, `F0056514`는 런타임 코드가 만든 값으로, 우리가 넣은 글자가 아닙니다. 결과를 그대로 믿지 말고 내용을 보고 거릅니다.
- **정적 문자열 숫자는 strings와 같습니다.** ASCII 4,738개는 `strings -a`의 줄 수와 같았고, UTF-16LE 9개는 `strings -a -el`의 줄 수와 같았습니다.

## 5. 직접 풀기: XOR과 base64

FLOSS가 풀지 못한 글자가 있거나 도구 없이 확인하고 싶을 때는 직접 풉니다. base64는 `base64 -d` 한 줄이면 됩니다. XOR은 키를 모를 때 `decode_xor.py`로 키 255개를 모두 대 보고, `http`로 시작하는 읽을 수 있는 글자가 나오는 곳을 찾습니다.

<!-- files: decode_xor.py, gen_encoded.py -->

```bash
docker exec cr-m2-strings-1 sh -c 'python decode_xor.py demo.exe; printf %s aHR0cDovL2I2NC5leGFtcGxlLmNvbS9j | base64 -d; echo'
```

```
# 기대 출력(이 PC)
키 0x5a, 위치 0xa0c0: http://xor.example.com/a;
http://b64.example.com/c
```

![decode_xor.py 실행 결과에서 키 0x5a로 http://xor.example.com/a가 나오고 base64 해독 결과 http://b64.example.com/c가 나오는 것을 확인합니다.](https://copyandrun.com/img/strings-floss-obfuscated-strings/04-manual-decode.png)

XOR 결과 끝의 `;`는 배열이 널 문자로 끝나지 않아서 뒤따르는 바이트까지 같이 풀린 것입니다. 이 방법으로는 `http`로 시작하는 글자만 찾을 수 있습니다. 다른 글자로 시작하는 문자열은 찾는 말을 바꿔야 합니다.

## 6. 결과 정리

<!-- files: demo.c -->

| 방식 | strings | strings -el | FLOSS |
|---|---|---|---|
| 평문 (ASCII) | 보임 | 안 보임 | 보임(정적) |
| 평문 (UTF-16) | 안 보임 | 보임 | 보임(정적) |
| XOR | 깨진 글자 | 안 보임 | 풀어서 보임 |
| base64 | 인코딩된 글자로 보임 | 안 보임 | 인코딩된 글자로만 보임 |
| 스택 조립 | 안 보임 | 안 보임 | 보임(스택 문자열) |

문자열이 분석 단서가 되는 경우와 한계는 아래와 같습니다.

- **단서가 되는 글자:** 외부 주소(URL), 파일 경로, `Software\...` 모양의 레지스트리 키, 사용하는 함수 이름은 프로그램이 무엇을 하려는지 짐작하게 합니다. 이 주소가 실제로 쓰이는지, 어떻게 쓰이는지는 문자열만으로는 알 수 없습니다.
- **경로 속 이름:** 이 시험 파일의 `C:\Users\alice\...`처럼 만든 사람의 계정이나 작업 폴더 이름이 남기도 합니다.
- **한계:** 글자가 아예 없는 것과 숨긴 것은 구별되지 않습니다. 문자열이 하나도 안 보인다고 해서 안전하다는 근거가 되지는 않습니다. 반대로 보인다고 해서 쓰인다는 뜻도 아닙니다. 라이브러리가 가진 글자일 수도 있습니다.
- **도구의 한계:** FLOSS가 모든 디코딩 루틴을 찾는 것은 아닙니다. 이 시험에서도 base64는 풀지 못했습니다. 4,738줄 중 쓸 만한 것은 몇 줄뿐이라, 결과를 줄이는 `grep`과 읽는 눈이 필요합니다.

## 전체 코드

폴더 구조는 아래와 같고, 한 폴더에 파일을 모두 두고 `docker build`를 실행합니다.

```
strings-floss-obfuscated-strings/
  Dockerfile
  demo.c
  gen_encoded.py
  decode_xor.py
  run.sh
```

### Dockerfile

```dockerfile
FROM python:3.12-slim-bookworm
RUN apt-get update \
 && apt-get install -y --no-install-recommends gcc-mingw-w64-x86-64-win32 binutils file g++ \
 && rm -rf /var/lib/apt/lists/*
RUN pip install --no-cache-dir flare-floss
WORKDIR /work
COPY demo.c decode_xor.py gen_encoded.py run.sh ./
```

### demo.c

```
/* 문자열 추출 시험용 프로그램. 네트워크 접속이나 파일 쓰기를 하지 않고 화면에 글자만 출력한다.
   이 글에서는 컴파일만 하고 실행하지 않는다. */
#include <stdio.h>
#include <string.h>
#include <wchar.h>

/* 1. 평문 문자열 */
static const char *PLAIN_URL = "http://plain.example.com/update/check";
static const char *PLAIN_PATH = "C:\\Users\\alice\\AppData\\Roaming\\DemoAgent\\config.dat";
static const char *PLAIN_KEY = "Software\\DemoCorp\\Agent\\Settings";

/* 2. UTF-16LE 로 저장되는 문자열 */
static const wchar_t *WIDE_LOG = L"C:\\Temp\\demo-agent.log";

/* 3. 인코딩한 문자열: XOR 키 0x5A 와 base64 */
static const unsigned char XOR_DATA[] = {
    0x32, 0x2e, 0x2e, 0x2a, 0x60, 0x75, 0x75, 0x22, 0x35, 0x28, 0x74, 0x3f,
    0x22, 0x3b, 0x37, 0x2a, 0x36, 0x3f, 0x74, 0x39, 0x35, 0x37, 0x75, 0x3b
};
static const char *B64_DATA = "aHR0cDovL2I2NC5leGFtcGxlLmNvbS9j";

static void xor_decode(const unsigned char *in, int n, char *out) {
    for (int i = 0; i < n; i++) out[i] = (char)(in[i] ^ 0x5A);
    out[n] = '\0';
}

static int b64_value(char c) {
    const char *t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    const char *p = strchr(t, c);
    return p ? (int)(p - t) : -1;
}

static void b64_decode(const char *in, char *out) {
    int n = 0, bits = 0, acc = 0;
    for (; *in && *in != '='; in++) {
        acc = (acc << 6) | b64_value(*in);
        bits += 6;
        if (bits >= 8) { bits -= 8; out[n++] = (char)((acc >> bits) & 0xFF); }
    }
    out[n] = '\0';
}

int main(void) {
    char xor_out[64], b64_out[64];

    /* 4. 실행 중에 한 글자씩 조립하는 문자열(스택 문자열) */
    char stack_url[32];
    stack_url[0] = 'h'; stack_url[1] = 't'; stack_url[2] = 't'; stack_url[3] = 'p';
    stack_url[4] = ':'; stack_url[5] = '/'; stack_url[6] = '/';
    stack_url[7] = 's'; stack_url[8] = 't'; stack_url[9] = 'a'; stack_url[10] = 'c';
    stack_url[11] = 'k'; stack_url[12] = '.'; stack_url[13] = 'e'; stack_url[14] = 'x';
    stack_url[15] = 'a'; stack_url[16] = 'm'; stack_url[17] = 'p'; stack_url[18] = 'l';
    stack_url[19] = 'e'; stack_url[20] = '.'; stack_url[21] = 'c'; stack_url[22] = 'o';
    stack_url[23] = 'm'; stack_url[24] = '/'; stack_url[25] = 'b'; stack_url[26] = '\0';

    xor_decode(XOR_DATA, (int)sizeof(XOR_DATA), xor_out);
    b64_decode(B64_DATA, b64_out);

    printf("%s\n%s\n%s\n", PLAIN_URL, PLAIN_PATH, PLAIN_KEY);
    wprintf(L"%ls\n", WIDE_LOG);
    printf("%s\n%s\n%s\n", xor_out, b64_out, stack_url);
    return 0;
}
```

### gen_encoded.py

```python
"""demo.c 에 넣을 인코딩 문자열을 만든다. XOR 키 0x5A 와 base64 두 가지."""
import base64

KEY = 0x5A
xor_text = "http://xor.example.com/a"
b64_text = "http://b64.example.com/c"

enc = bytes(b ^ KEY for b in xor_text.encode("ascii"))
print("XOR 바이트열:")
print("{ " + ", ".join(f"0x{b:02x}" for b in enc) + " }")
print("base64 문자열:")
print(base64.b64encode(b64_text.encode("ascii")).decode("ascii"))
```

### decode_xor.py

```python
"""실행 파일을 열지 않고 바이트만 읽어서 XOR 인코딩 문자열을 찾는다.
키를 0x01~0xFF 까지 모두 대 보고, 풀린 결과가 'http' 로 시작하면 보여 준다."""
import re
import sys

data = open(sys.argv[1], "rb").read()

for key in range(1, 256):
    # 'http' 를 이 키로 XOR 한 4바이트가 파일 안 어디에 있는지 찾는다
    needle = bytes(b ^ key for b in b"http")
    for m in re.finditer(re.escape(needle), data):
        chunk = data[m.start():m.start() + 40]
        text = bytes(b ^ key for b in chunk)
        end = text.find(b"\x00")
        text = text[:end] if end >= 0 else text
        # 읽을 수 있는 글자만 이어지는 앞부분까지 자른다
        ok = re.match(rb"[\x20-\x7e]+", text)
        if ok and len(ok.group()) >= 12 and key != 0:
            print(f"키 0x{key:02x}, 위치 0x{m.start():x}: {ok.group().decode()}")
```

### run.sh

```bash
#!/bin/sh
# 컨테이너 안에서 시험 파일을 컴파일하고 버전을 확인한다. 만든 파일은 실행하지 않는다.
set -e
x86_64-w64-mingw32-gcc -O0 -o demo.exe demo.c
file demo.exe
ls -l demo.exe
```


## 자주 막히는 곳

- **`pip install flare-floss`가 `Failed to build binary2strings`로 실패합니다.** `g++`가 없어서입니다. 이 글의 Dockerfile처럼 `g++`를 먼저 설치합니다.
- **`demo.exe`가 없다는 오류가 납니다.** 컴파일에 실패한 것입니다. `demo.c`의 경로 문자열에서 역슬래시가 하나만 있으면 `incomplete universal character name \U` 오류가 납니다. 코드 안에서는 `\\`로 두 번 씁니다.
- **`strings`로 UTF-16 글자가 안 나옵니다.** `-el` 옵션을 줍니다.
- **FLOSS가 오래 걸립니다.** 이 파일은 15초 정도였습니다. 파일이 크면 늘어납니다. 진행 표시줄이 `floss.err`에 계속 찍히니 표준 오류를 파일로 돌려 둡니다.
- **결과가 너무 깁니다.** FLOSS 출력은 4,800줄이 넘었습니다. 파일에 저장해 놓고 `grep`이나 `tail`로 구역별로 봅니다.

## 정리하기

글을 따라 만든 컨테이너와 이미지는 아래처럼 지웁니다.

```bash
docker rm -f cr-m2-strings-1
docker rmi cr-m2-strings
```

## 확인 범위

- **확인한 것:** 위 환경에서 시험 프로그램을 컴파일하고, `strings -a`, `strings -a -el`, FLOSS 3.2.0, 직접 만든 `decode_xor.py`의 결과를 모두 실제로 실행해 얻었습니다. 출력은 줄여서 보여 주었으나 고치지 않았습니다.
- **확인하지 못한 것:** 시험 프로그램을 실행해 보지 않았으므로 화면에 찍는 값은 확인하지 않았습니다. FLOSS가 base64 해독을 놓친 이유, `-O0` 이외의 최적화 수준, 다른 컴파일러(MSVC 등)에서의 결과도 확인하지 못했습니다.
- **실제 악성코드와의 차이:** 시험 프로그램은 글자 몇 개를 직접 넣은 것이라 단순합니다. 실제 파일은 패커로 압축되어 있거나 문자열 암호화가 더 복잡할 수 있고, 이 글의 결과로 FLOSS의 실제 탐지 성능을 말할 수는 없습니다.
