# 엔트로피와 섹션 이름으로 패킹된 파일 가려내기: UPX 전후 비교

> 무해한 시험 프로그램을 UPX로 압축해 원본과 섹션 이름, 섹션별 엔트로피, 임포트 수, 크기를 pefile과 직접 짠 Shannon 엔트로피로 비교합니다. 임계값 스크립트로 목록을 거르고, zip과 이미지가 오탐으로 걸리는 모습과 upx -d 해제 결과를 실행 결과로 확인합니다.

- 주소: https://copyandrun.com/blog/entropy-upx-packed-detect/
- 분야: 악성코드 분석
- 발행일: 2026-11-01
- 태그: 엔트로피, UPX, 패킹, pefile, PE

UPX는 실행 파일을 압축해 크기를 줄이는 오픈소스 패커입니다. 정상 프로그램 배포에도 쓰지만 악성코드에도 쓰이는 사례가 있어서, 분석을 시작할 때 "이 파일이 패킹되어 있는가"를 먼저 확인합니다. 이 글에서는 직접 만든 무해한 시험 프로그램을 UPX로 압축해 원본과 나란히 놓고, 섹션 이름, 섹션별 엔트로피, 임포트 수, 크기가 어떻게 달라지는지 파이썬으로 비교합니다. 이어서 임계값으로 파일 목록을 거르는 작은 스크립트를 만들고, zip이나 이미지 같은 정상 파일이 왜 같이 걸리는지도 확인합니다. 모든 파일은 컨테이너 안에서 만들고 열어 보기만 하며, 어느 것도 실행하지 않습니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| 실행 환경 | Docker 컨테이너(`python:3.12-slim-bookworm` 기반) |
| Python | 3.12.16 |
| pefile | 2024.8.26 (`pip install pefile`) |
| 컴파일러 | `x86_64-w64-mingw32-gcc` (GCC) 12-win32, Debian `gcc-mingw-w64-x86-64` 패키지 |
| UPX | 5.0.2 (GitHub 공식 릴리스 `upx-5.0.2-amd64_linux.tar.xz`) |

컨테이너 이미지는 아래 `Dockerfile`로 만듭니다. 컨테이너 안에서 컴파일한 결과는 윈도 PE 형식(`.exe`)이므로 리눅스 컨테이너에서는 실행되지 않고, 분석 도구로 열어 보기만 합니다.

## 1. 시험 프로그램 만들고 UPX로 압축

<!-- files: Dockerfile, hello.c -->

`hello.c`는 영문 문장 다섯 개의 해시값을 합쳐 한 줄을 출력하는 프로그램입니다. 파일을 쓰거나 네트워크를 쓰지 않습니다. 이미지를 만들고 컨테이너를 띄운 뒤 파일들을 `/work`에 복사하고 컨테이너 안으로 들어갑니다.

```bash
docker build -t cr-m3-entropy .
docker run -d --name cr-m3-entropy-lab cr-m3-entropy sleep 3600
docker exec cr-m3-entropy-lab mkdir -p /work
docker cp hello.c cr-m3-entropy-lab:/work/
docker cp entropy_report.py cr-m3-entropy-lab:/work/
docker cp scan_packed.py cr-m3-entropy-lab:/work/
docker cp make_samples.py cr-m3-entropy-lab:/work/
MSYS_NO_PATHCONV=1 docker exec -it -w /work cr-m3-entropy-lab bash
```

이후 명령은 컨테이너 안(`/work`)에서 실행합니다. 컴파일한 원본을 복사해 사본을 UPX로 압축합니다.

```
x86_64-w64-mingw32-gcc -O2 -s -o hello_plain.exe hello.c
cp hello_plain.exe hello_upx.exe && upx --best hello_upx.exe
ls -l *.exe
```

![컴파일 뒤 upx 가 40448바이트 파일을 20992바이트로 줄여 51.90% 비율로 보고하고, ls 로 두 파일 크기를 확인하는 것을 볼 수 있습니다.](https://copyandrun.com/img/entropy-upx-packed-detect/01-build-and-upx.png)

원본은 40,448바이트, 압축본은 20,992바이트로 약 절반입니다. 문장이 반복되는 시험 프로그램이라 잘 줄었고, 실제 프로그램의 압축률은 내용에 따라 다릅니다.

## 2. 섹션별 엔트로피와 구조 비교

<!-- files: entropy_report.py -->

엔트로피는 바이트 값이 얼마나 고르게 흩어져 있는지를 0에서 8까지의 숫자(비트/바이트)로 나타냅니다. 같은 글자만 반복되면 0에 가깝고, 무작위 데이터는 8에 가깝습니다. 압축된 데이터는 반복이 제거되어 무작위처럼 보이므로 높게 나옵니다. `entropy_report.py`는 Shannon 엔트로피를 직접 계산하고, pefile로 섹션 이름, 크기, 임포트 수를 읽습니다.

```bash
python entropy_report.py hello_plain.exe hello_upx.exe
```

![원본은 .text 6.27 을 포함한 10개 섹션과 임포트 함수 49개이고, 압축본은 UPX0, UPX1, UPX2 세 섹션과 임포트 함수 5개, UPX1 엔트로피 7.85 인 것을 확인합니다.](https://copyandrun.com/img/entropy-upx-packed-detect/02-section-entropy.png)

| 항목 | 원본 | UPX 압축본 |
|---|---|---|
| 파일 크기 | 40,448 | 20,992 |
| 파일 전체 엔트로피 | 5.85 | 7.72 |
| 섹션 | `.text`, `.data`, `.rdata` 등 10개 | `UPX0`, `UPX1`, `UPX2` 3개 |
| 가장 높은 섹션 엔트로피 | 6.27 (`.text`) | 7.85 (`UPX1`) |
| 임포트 함수 | 49개 (DLL 2개) | 5개 (DLL 2개) |

- **섹션 이름:** 컴파일러가 만든 `.text`, `.rdata`가 사라지고 `UPX0`, `UPX1`, `UPX2`로 바뀌었습니다. `UPX0`는 파일 안에서는 0바이트인데 메모리 크기는 53,248바이트입니다. 실행될 때 압축을 풀어 채울 빈 공간이라는 뜻입니다.
- **엔트로피:** 압축된 코드와 데이터가 들어 있는 `UPX1`이 7.85로 올랐습니다. 원본에서 가장 높았던 `.text`는 6.27이었습니다.
- **임포트:** 원본은 함수 49개를 임포트 표에 드러내지만, 압축본은 압축을 푸는 코드가 쓰는 5개만 남습니다. 임포트 수가 갑자기 적은 PE는 패킹을 의심하는 단서 중 하나입니다.

## 3. 임계값으로 목록 거르기

<!-- files: scan_packed.py -->

파일이 많으면 하나씩 표를 볼 수 없으므로 `scan_packed.py`로 거릅니다. 기준은 두 가지입니다. PE 파일은 섹션 이름이 `UPX`로 시작하거나 섹션 엔트로피가 임계값 이상이면 의심하고, PE가 아닌 파일은 파일 전체 엔트로피로 판단합니다. 의심 파일이 하나라도 있으면 종료 코드 1을 돌려주므로 스크립트나 CI에서 그대로 쓸 수 있습니다. 먼저 압축본만 임계값 7.0으로 검사합니다.

```bash
python scan_packed.py hello_upx.exe; echo exit=$?
```

```
# 기대 출력
파일                     종류        최대 엔트로피  판정
hello_upx.exe          PE           7.85  의심: 섹션 이름 UPX0, 섹션 이름 UPX1, 섹션 UPX1 엔트로피 7.85, 섹션 이름 UPX2
임계값 7.0, 의심 1건 / 전체 1건
exit=1
```

원본은 의심 없이 통과합니다(종료 코드 0). 임계값을 6.0으로 낮추자 원본의 `.text`(6.27)도 걸렸습니다.

```bash
python scan_packed.py --threshold 6.0 hello_plain.exe; echo exit=$?
```

```
# 기대 출력
파일                     종류        최대 엔트로피  판정
hello_plain.exe        PE           6.27  의심: 섹션 .text 엔트로피 6.27
임계값 6.0, 의심 1건 / 전체 1건
exit=1
```

임계값이 낮으면 정상 코드도 걸리고, 높으면 놓치는 파일이 생깁니다. 7.0은 이 시험 파일에서 두 경우를 가른 값일 뿐이며, 실제 환경에서는 가진 정상 파일 모음에 먼저 돌려 보고 정해야 합니다.

## 4. 오탐 확인: 정상 파일도 걸립니다

<!-- files: make_samples.py, scan_packed.py -->

엔트로피가 높다는 것은 "압축되었거나 암호화된 것 같다"는 뜻일 뿐 악성이라는 뜻이 아닙니다. 이를 보려고 `make_samples.py`로 무해한 파일 네 개를 만들어 같은 도구에 넣습니다. 평범한 텍스트(`notes.txt`), 그 텍스트를 담은 zip(`archive.zip`), 무작위 픽셀 PNG 이미지(`image.png`), 무작위 바이트 파일(`secret.bin`)입니다.

```bash
python make_samples.py
python scan_packed.py hello_plain.exe hello_upx.exe samples; echo exit=$?
```

![원본 exe 와 텍스트는 통과하고, UPX 압축본과 archive.zip(7.97), image.png(7.99), secret.bin(7.99)이 모두 의심으로 표시되어 종료 코드가 1 인 것을 확인합니다.](https://copyandrun.com/img/entropy-upx-packed-detect/03-scan-false-positive.png)

여섯 개 중 네 개가 걸렸는데 진짜 패킹은 `hello_upx.exe` 하나뿐입니다. zip, 이미지, 암호화된 자료는 모두 압축이나 무작위성 때문에 엔트로피가 7.9대로 나옵니다. 설치 프로그램처럼 압축 자료를 품은 정상 PE도 같은 이유로 걸릴 수 있습니다. 반대로 UPX 섹션 이름은 패킹의 근거는 되지만 악성의 근거는 아닙니다. 정상 소프트웨어도 UPX로 압축해 배포하는 경우가 있고, 이름은 쉽게 바뀔 수 있으므로 이름이 없다고 해서 안전한 것도 아닙니다. 그래서 이 결과는 "추가로 볼 파일의 후보"로만 쓰고, 최종 판단은 서명, 출처, 해시 평판, 동작 분석을 함께 보고 합니다.

## 5. UPX로 해제하기

UPX로 압축한 파일은 `upx -t`로 UPX 형식이 맞는지 시험하고, `upx -d`로 원래 모양으로 풀 수 있습니다. 풀고 나면 같은 도구에서 의심이 사라지는지 봅니다.

```bash
upx -t hello_upx.exe
cp hello_upx.exe unpacked.exe && upx -d unpacked.exe && python scan_packed.py unpacked.exe; echo exit=$?
```

![upx -t 가 OK 를 출력하고, 해제한 unpacked.exe 가 20992 에서 40448바이트로 복원되어 최대 엔트로피 6.27 로 의심 없이 종료 코드 0 이 되는 것을 확인합니다.](https://copyandrun.com/img/entropy-upx-packed-detect/04-upx-decompress.png)

해제한 파일은 크기가 40,448바이트로 돌아왔고, 섹션 엔트로피도 원본과 같은 6.27이었습니다. 임포트 함수 수는 `entropy_report.py`로 다시 확인합니다.

```bash
python entropy_report.py unpacked.exe | head -3
```

```
# 기대 출력
== unpacked.exe
파일 크기 40448 바이트, 파일 전체 엔트로피 5.83
임포트 DLL 2개, 임포트 함수 49개
```

임포트 함수는 49개로 원본과 같습니다. 다만 `sha256sum`으로 비교한 해시는 원본과 달랐고 파일 전체 엔트로피도 5.85가 아닌 5.83으로 측정되어, 바이트 단위로 똑같이 복원된 것은 아닙니다. 따라서 해제 결과를 원본과 같은 파일로 간주해 해시를 대조하면 안 됩니다. 해제본은 코드 구조를 보기 위한 용도로 씁니다.

UPX로 압축하지 않은 파일에 `upx -d`를 쓰면 UPX가 거부합니다. `archive.zip`에 시도하면 아래 메시지가 나오고 종료 코드는 2였습니다.

```
upx: samples/archive.zip: NotPackedException: not packed by UPX
```

UPX가 아닌 다른 패커나 사용자 지정 패커, UPX를 변형한 파일은 `upx -d`로 풀리지 않을 수 있습니다. 이 글에서는 그런 파일을 만들지도, 시험하지도 않았습니다.

## 결과 해석

- **패킹의 흔적은 한 가지만 보지 않고 여러 가지를 겹쳐서 봅니다.** 섹션 이름, 높은 섹션 엔트로피, 메모리 크기만 크고 파일 크기가 0인 섹션, 적은 임포트 수가 함께 나타날수록 패킹일 가능성이 큽니다. 하나만으로는 오탐이 많습니다.
- **엔트로피는 압축과 암호화를 구분하지 못합니다.** zip, PNG, 무작위 바이트 모두 높게 나왔습니다.
- **UPX는 해제할 수 있는 편입니다.** 공식 UPX로 압축한 파일은 `upx -d`로 풀어 정적 분석을 이어 갈 수 있지만, 해시가 달라지므로 원본 대조용으로는 맞지 않습니다.

## 전체 코드

폴더 구조는 아래와 같습니다. 컨테이너 안 `/work`에 `hello.c`와 세 스크립트를 복사해 위 명령을 실행합니다.

```
entropy-upx-packed-detect/
  Dockerfile
  hello.c
  entropy_report.py
  scan_packed.py
  make_samples.py
```

`Dockerfile`

```dockerfile
FROM python:3.12-slim-bookworm
RUN apt-get update \
 && apt-get install -y --no-install-recommends gcc-mingw-w64-x86-64 curl xz-utils ca-certificates \
 && rm -rf /var/lib/apt/lists/*
RUN pip install --no-cache-dir pefile==2024.8.26
# UPX 공식 릴리스(리눅스 x86_64)를 받아 설치합니다.
RUN curl -fsSL -o /tmp/upx.tar.xz https://github.com/upx/upx/releases/download/v5.0.2/upx-5.0.2-amd64_linux.tar.xz \
 && tar -xJf /tmp/upx.tar.xz -C /tmp \
 && cp /tmp/upx-5.0.2-amd64_linux/upx /usr/local/bin/upx \
 && rm -rf /tmp/upx*
WORKDIR /work
```

`hello.c`

```c
/* 시험용 무해한 프로그램: 문자열 표를 만들어 합계만 출력합니다. 실행하지 않고 분석 도구로 열기만 합니다. */
#include <stdio.h>
#include <string.h>

static const char *NOTES[] = {
    "alpha: this is a harmless sample used for entropy comparison.",
    "bravo: it only prints a checksum of a small text table.",
    "charlie: nothing is written to disk and no network is used.",
    "delta: the strings are plain English so they compress well.",
    "echo: packers shrink such text and raise the entropy.",
};

static unsigned int checksum(const char *s) {
    unsigned int h = 5381;
    while (*s) h = h * 33 + (unsigned char)*s++;
    return h;
}

int main(void) {
    unsigned int total = 0;
    for (int round = 0; round < 3; round++)
        for (size_t i = 0; i < sizeof(NOTES) / sizeof(NOTES[0]); i++)
            total += checksum(NOTES[i]) + (unsigned int)strlen(NOTES[i]);
    printf("checksum=%u\n", total);
    return 0;
}
```

`entropy_report.py`

```python
"""PE 파일의 섹션별 엔트로피, 섹션 이름, 임포트 수, 크기를 표로 보여 줍니다.

준비: pip install pefile
실행: python entropy_report.py hello_plain.exe hello_upx.exe
파일은 열어서 읽기만 하며 실행하지 않습니다.
"""
import math
import sys
from collections import Counter

import pefile


def shannon(data: bytes) -> float:
    """바이트 빈도로 Shannon 엔트로피를 구합니다(0.0 ~ 8.0, 단위는 비트/바이트)."""
    if not data:
        return 0.0
    n = len(data)
    return max(0.0, -sum(c / n * math.log2(c / n) for c in Counter(data).values()))


def report(path: str) -> None:
    raw = open(path, "rb").read()
    pe = pefile.PE(data=raw)
    imports = sum(len(e.imports) for e in getattr(pe, "DIRECTORY_ENTRY_IMPORT", []))
    dlls = len(getattr(pe, "DIRECTORY_ENTRY_IMPORT", []))
    print(f"== {path}")
    print(f"파일 크기 {len(raw)} 바이트, 파일 전체 엔트로피 {shannon(raw):.2f}")
    print(f"임포트 DLL {dlls}개, 임포트 함수 {imports}개")
    print(f"{'섹션':<8} {'파일 내 크기':>12} {'메모리 크기':>12} {'엔트로피':>8}")
    for s in pe.sections:
        name = s.Name.rstrip(b"\x00").decode("ascii", "replace")
        print(f"{name:<8} {s.SizeOfRawData:>12} {s.Misc_VirtualSize:>12} {shannon(s.get_data()):>8.2f}")


if __name__ == "__main__":
    for p in sys.argv[1:]:
        report(p)
```

`scan_packed.py`

```python
"""파일 목록에서 패킹이 의심되는 것을 골라 종료 코드로 알려 줍니다.

판정 기준(둘 중 하나라도 해당하면 의심):
  1) PE 파일에서 섹션 이름이 UPX 로 시작하거나, 파일 내 크기 512바이트 이상 섹션의 엔트로피가 임계값 이상
  2) PE 가 아닌 파일은 파일 전체 엔트로피가 임계값 이상(압축, 암호화 자료도 걸립니다)
종료 코드: 0 의심 없음, 1 의심 파일 있음
실행: python scan_packed.py [--threshold 7.0] 파일 또는 폴더 ...
파일은 읽기만 하며 실행하지 않습니다.
"""
import argparse
import math
import sys
from collections import Counter
from pathlib import Path

import pefile


def shannon(data: bytes) -> float:
    if not data:
        return 0.0
    n = len(data)
    return max(0.0, -sum(c / n * math.log2(c / n) for c in Counter(data).values()))


def judge(path: Path, threshold: float):
    """(종류, 엔트로피, 사유 목록)을 돌려줍니다."""
    raw = path.read_bytes()
    try:
        pe = pefile.PE(data=raw, fast_load=True)
    except pefile.PEFormatError:
        h = shannon(raw)
        return "기타", h, ([f"파일 전체 엔트로피 {h:.2f}"] if h >= threshold else [])
    reasons = []
    top = 0.0
    for s in pe.sections:
        name = s.Name.rstrip(b"\x00").decode("ascii", "replace")
        h = shannon(s.get_data())
        top = max(top, h) if s.SizeOfRawData >= 512 else top
        if name.upper().startswith("UPX"):
            reasons.append(f"섹션 이름 {name}")
        if s.SizeOfRawData >= 512 and h >= threshold:
            reasons.append(f"섹션 {name} 엔트로피 {h:.2f}")
    return "PE", top, reasons


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--threshold", type=float, default=7.0)
    ap.add_argument("paths", nargs="+")
    a = ap.parse_args()
    files = []
    for p in map(Path, a.paths):
        files += sorted(x for x in p.rglob("*") if x.is_file()) if p.is_dir() else [p]
    flagged = 0
    print(f"{'파일':<22} {'종류':<4} {'최대 엔트로피':>12}  판정")
    for f in files:
        kind, h, reasons = judge(f, a.threshold)
        flagged += bool(reasons)
        print(f"{f.name:<22} {kind:<4} {h:>12.2f}  {'의심: ' + ', '.join(reasons) if reasons else '-'}")
    print(f"임계값 {a.threshold}, 의심 {flagged}건 / 전체 {len(files)}건")
    return 1 if flagged else 0


if __name__ == "__main__":
    sys.exit(main())
```

`make_samples.py`

```python
"""오탐 확인용 파일 네 개를 samples/ 에 만듭니다(모두 무해한 자료, 표준 라이브러리만 사용).

notes.txt   평범한 영문 텍스트
archive.zip 위 텍스트와 비슷한 글 여러 개를 zip 으로 압축한 것
image.png   무작위 픽셀로 채운 PNG 이미지
secret.bin  무작위 바이트(암호화된 자료처럼 보이는 것)
"""
import os
import random
import struct
import zipfile
import zlib
from pathlib import Path

out = Path("samples")
out.mkdir(exist_ok=True)
rnd = random.Random(1)

words = "alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima".split()
text = "\n".join(" ".join(rnd.choice(words) for _ in range(12)) for _ in range(800))
(out / "notes.txt").write_text(text, encoding="utf-8")

with zipfile.ZipFile(out / "archive.zip", "w", zipfile.ZIP_DEFLATED) as z:
    for i in range(5):
        z.writestr(f"part{i}.txt", text)


def chunk(tag: bytes, body: bytes) -> bytes:
    return struct.pack(">I", len(body)) + tag + body + struct.pack(">I", zlib.crc32(tag + body))


w = h = 120
rows = b"".join(b"\x00" + bytes(rnd.randrange(256) for _ in range(w * 3)) for _ in range(h))
png = b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", struct.pack(">IIBBBBB", w, h, 8, 2, 0, 0, 0))
png += chunk(b"IDAT", zlib.compress(rows)) + chunk(b"IEND", b"")
(out / "image.png").write_bytes(png)

(out / "secret.bin").write_bytes(os.urandom(20000))
print("만든 파일:", ", ".join(sorted(p.name for p in out.iterdir())))
```

## 자주 막히는 곳

- **`docker exec -w /work`가 "Cwd must be an absolute path"로 실패합니다.** 윈도의 Git Bash에서 `/work`가 윈도 경로로 바뀐 것이 원인입니다. 컨테이너 안에서 `bash`를 열어 실행하거나, 명령 앞에 `MSYS_NO_PATHCONV=1`을 붙입니다.
- **섹션 엔트로피가 `-0.00`으로 찍힙니다.** 값이 하나뿐인 바이트로 채워진 섹션은 계산 결과가 음수 0이 되어 그렇게 보입니다. 코드의 `max(0.0, ...)`가 이를 막습니다.
- **`upx -d`가 "not packed by UPX"를 냅니다.** UPX로 압축한 파일이 아니라는 뜻입니다. 다른 패커를 쓴 파일이거나 패킹되지 않은 파일입니다.
- **`pefile.PEFormatError`가 납니다.** PE가 아닌 파일입니다. `scan_packed.py`는 이 경우 파일 전체 엔트로피로 판단하도록 처리했습니다.

## 확인 범위

- 확인한 것: 직접 만든 시험 프로그램 한 개를 Docker 컨테이너 안에서 mingw-w64로 컴파일하고, UPX 5.0.2(`--best`)로 압축한 파일과 비교했습니다. 섹션, 엔트로피, 임포트 수, 크기 변화와 `upx -t`, `upx -d` 해제를 실제로 실행해 얻은 값만 적었습니다. zip, PNG, 무작위 바이트, 텍스트 네 파일로 오탐을 확인했습니다.
- 확인하지 못한 것: 시험 파일은 실행하지 않았습니다. 작은 프로그램 한 개의 결과이므로 다른 컴파일러나 큰 프로그램, 다른 UPX 버전의 수치는 다를 수 있습니다. 실제 악성코드, UPX 외의 패커, 변형된 UPX, 정상 설치 프로그램은 다루지 않았습니다. 7.0이라는 임계값은 이 시험 파일 기준이며 일반적인 기준이 아닙니다.
