# capa로 실행 파일의 기능 규칙 맞춰 보기: 어떤 동작을 근거로 판단하는지

> Mandiant의 capa로 직접 컴파일한 시험 프로그램 세 개를 실행하지 않고 분석합니다. 규칙 이름, ATT&CK와 MBC 항목, 함수 주소와 API 근거를 읽고, JSON 결과를 파이썬으로 표로 요약합니다. capa가 기능의 존재를 알려 줄 뿐 악성 여부는 판정하지 않는다는 점도 결과로 확인합니다.

- 주소: https://copyandrun.com/blog/capa-rule-match-capabilities/
- 분야: 악성코드 분석
- 발행일: 2026-11-01
- 태그: capa, FLARE, ATT&CK, MBC, 정적 분석

capa는 Mandiant FLARE 팀이 만든 오픈소스 도구로, 실행 파일을 열어 보고 "파일을 쓴다", "소켓으로 연결한다" 같은 기능이 들어 있는지 규칙으로 알려 줍니다. 문자열 패턴 위주인 YARA와 달리 임포트한 API, 상수, 함수 구조를 함께 보고, 규칙마다 ATT&CK 전술과 MBC(악성코드 행위 분류) 번호가 붙어 있어 보고서에 옮기기 좋습니다.

이 글에서는 C로 직접 만든 무해한 프로그램 세 개(아무 기능 없는 것, 파일을 읽고 쓰는 것, 소켓 연결 코드가 든 것)를 윈도우 실행 파일(PE)로 컴파일해서 capa에 넣습니다. 모든 작업은 컨테이너 안에서 하며, 만든 프로그램은 실행하지 않고 분석 도구로 열기만 합니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| Docker | 29.5.3 (Docker Desktop, Windows) |
| 컨테이너 이미지 | `python:3.12-slim` (Python 3.12.16) |
| 컴파일러 | `x86_64-w64-mingw32-gcc` (GCC) 14-win32, apt 패키지 `mingw-w64` |
| capa | 10.0.0, GitHub 릴리스의 리눅스용 단일 실행 파일 |
| 규칙 | `capa-rules` 10.0.0 릴리스, 규칙 파일 1057개 |

컨테이너에서 인터넷에 연결할 수 있어야 합니다. 규칙은 capa 실행 파일 안에 들어 있지 않아서, 저장소의 릴리스를 따로 받아 `-r` 옵션으로 가리킵니다.

## 1. 도구와 규칙 준비

<!-- files: setup.sh -->

컨테이너를 만들고 `setup.sh`로 컴파일러, capa, 규칙을 설치합니다. 아래 전체 코드의 파일을 한 폴더에 모아 둔 상태에서 시작합니다.

```bash
docker run -d --name cr-m4-capa python:3.12-slim sleep 3600
docker cp . cr-m4-capa:/work
docker exec cr-m4-capa sh /work/setup.sh
```

```bash
capa 10.0.0
x86_64-w64-mingw32-gcc (GCC) 14-win32
```

`setup.sh`는 `/opt/capa/capa`에 실행 파일을, `/opt/capa-rules-10.0.0`에 규칙을 둡니다. 앞으로 나오는 `capa` 명령은 모두 이 경로를 씁니다. pip로 설치하는 `flare-capa`(같은 10.0.0 버전이 올라와 있습니다)도 쓸 수 있지만, 이 글에서는 릴리스 바이너리로 확인했습니다.

## 2. 시험 프로그램 세 개 만들기

<!-- files: empty.c, fileio.c, sockdemo.c, build.sh -->

- **`empty.c`**: `main`이 0만 돌려줍니다.
- **`fileio.c`**: `input.txt`를 읽어 `output.txt`에 씁니다.
- **`sockdemo.c`**: 소켓을 만들고 `127.0.0.1`의 9번 포트에 연결해 `hello`를 보내는 함수가 있습니다. 명령줄 인자가 정확히 99개일 때만 이 함수를 부르므로 평소에는 도달하지 않습니다.

소스는 아래 전체 코드에 있습니다. `build.sh`로 컴파일합니다.

```bash
docker exec -w /work cr-m4-capa sh build.sh
```

```
total 340
-rwxr-xr-x 1 root root 112666 Nov  1 02:46 empty.exe
-rwxr-xr-x 1 root root 113225 Nov  1 02:46 fileio.exe
-rwxr-xr-x 1 root root 115979 Nov  1 02:46 sockdemo.exe
```

아무 기능이 없는 프로그램도 110KB가 넘는 것은 MinGW의 C 런타임(프로그램 시작과 종료를 맡는 코드)이 함께 들어가기 때문입니다. 뒤에서 이 런타임 코드가 결과에 영향을 줍니다. 이 파일들은 어느 단계에서도 실행하지 않습니다.

## 3. 기본 출력 읽기

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

아무 옵션 없이 소켓 프로그램을 분석합니다.

```bash
docker exec -w /work cr-m4-capa /opt/capa/capa -r /opt/capa-rules-10.0.0 out/sockdemo.exe
```

출력은 위에서부터 파일 정보(해시, `os windows`, `format pe`, `arch amd64`, `analysis static`), ATT&CK 표, MBC 표, 기능(Capability) 표 순서입니다.

![capa 기본 출력에서 ATT&CK 표에는 Shared Modules 한 줄, MBC 표에는 Socket Communication과 C2 Communication 항목, 기능 표에는 send data와 act as TCP client가 있는 것을 확인합니다.](https://copyandrun.com/img/capa-rule-match-capabilities/02-capa-default-sockdemo.png)

- **기능 표**: 맞은 규칙 이름과 이름공간입니다. `initialize Winsock library`, `act as TCP client`, `send data`가 소켓 코드에서 나왔습니다.
- **MBC 표**: `Socket Communication::Connect Socket [C0001.004]`처럼 규칙에 적힌 MBC 번호입니다. `send data` 규칙은 `C2 Communication::Send Data [B0030.001]`을 달고 있어서 소켓으로 `hello`를 보내는 코드만으로도 COMMAND AND CONTROL 분류가 나옵니다. 분류 이름이 곧 악성 판정은 아닙니다.
- **ATT&CK 표**: 이 파일에서는 `Shared Modules [T1129]` 하나뿐입니다. 소켓 규칙에는 ATT&CK 번호가 붙어 있지 않기 때문입니다.
- **이름 옆 `(4 matches)`**: 같은 규칙이 함수 여러 곳에서 맞았다는 뜻입니다.
- **표의 줄 수와 규칙 수가 다른 이유**: 기본 출력의 기능 표는 다른 규칙의 하위 조건으로 쓰인 규칙(`connect socket`, `send data on socket` 등)을 줄여서 보여 줍니다. 아래 `summarize.py` 의 14개는 줄이지 않은 전체 맞은 규칙 수라서 표보다 많습니다.

## 4. 시험 프로그램 세 개 비교

<!-- files: run_capa.sh, summarize.py -->

세 파일을 JSON으로 저장하고 `summarize.py`로 표를 만듭니다. `-j` 옵션이 JSON 출력입니다. 스크립트는 다른 규칙의 부품으로만 쓰이는 라이브러리 규칙(`lib`)을 빼고, 규칙마다 일치 횟수와 ATT&CK, MBC 번호를 뽑습니다.

```bash
docker exec -w /work cr-m4-capa sh run_capa.sh
docker exec -w /work cr-m4-capa python3 summarize.py json/empty.json json/fileio.json json/sockdemo.json
```

![summarize.py 실행 결과에서 empty는 규칙 7개, fileio는 8개, sockdemo는 14개이고 fileio에만 read file on Windows가, sockdemo에만 Winsock과 TCP 관련 규칙이 더해진 것을 확인합니다.](https://copyandrun.com/img/capa-rule-match-capabilities/01-rules-per-program.png)

| 프로그램 | 맞은 규칙 수 | 이 프로그램에서만 더해진 규칙 |
|---|---|---|
| `empty.exe` | 7 | 없음 |
| `fileio.exe` | 8 | `read file on Windows`(MBC C0051) |
| `sockdemo.exe` | 14 | `initialize Winsock library`, `connect socket`, `connect TCP socket`, `create TCP socket`, `act as TCP client`, `send data on socket`, `send data` |

`write file on Windows`는 `fileio.exe`에서 2회, 나머지 두 파일에서 1회 일치했습니다. 세 파일에 공통으로 나온 규칙(`.tls` 구역, TLS 값 읽기, RWX 메모리 할당, 프로세스 종료, PE 구역 열거, PE 헤더 파싱, 파일 쓰기)은 프로그램 코드가 아니라 C 런타임에서 나온 것입니다. 이 점은 다음 단계에서 근거로 확인합니다.

## 5. -v와 -vv로 근거 보기

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

`-v`는 규칙마다 일치한 위치를 보여 줍니다.

```bash
docker exec -w /work cr-m4-capa sh -c '/opt/capa/capa -r /opt/capa-rules-10.0.0 -v out/fileio.exe | sed -n "/^read file/,/^get thread/{/^get thread/!p}"'
```

```
read file on Windows
namespace  host-interaction/file-system/read
scope      function                         
matches    0x140001450                       

write file on Windows (2 matches)
namespace  host-interaction/file-system/write
scope      function                          
matches    0x140001450                       
           0x140001810                       
```

규칙의 범위(`scope`)가 `function`이므로 일치 위치는 함수의 시작 주소입니다. `-vv`를 주면 그 함수 안에서 어떤 API와 상수가 규칙 조건을 채웠는지 나옵니다.

```bash
docker exec -w /work cr-m4-capa sh -c '/opt/capa/capa -r /opt/capa-rules-10.0.0 -vv out/fileio.exe | sed -n "/^write file on Windows/,/^get thread/{/^get thread/!p}"'
```

![capa -vv 출력에서 write file on Windows 규칙이 함수 0x140001450의 fopen과 fwrite 호출, 함수 0x140001810의 fwrite 호출로 맞았다는 근거를 확인합니다.](https://copyandrun.com/img/capa-rule-match-capabilities/03-capa-vv-evidence.png)

첫 함수 `0x140001450`에서는 `fopen`이 두 번(`0x140001479`, `0x1400014E4`), `fwrite`가 한 번(`0x140001521`) 호출됩니다. MinGW 심벌 목록(`x86_64-w64-mingw32-nm`)으로 확인하면 `0x140001450`은 `main`입니다. 즉 직접 쓴 코드입니다. 두 번째 함수 `0x140001810`은 심벌이 `__report_error`로, 런타임이 오류를 표준 오류로 출력하는 함수입니다. 직접 쓴 코드가 아닌데 같은 규칙이 맞았습니다.

`empty.exe`에서도 `write file on Windows`가 맞은 이유도 같습니다. 근거는 `0x140001730`의 `fwrite` 호출이고, 이 주소도 심벌로 확인하면 `__report_error`입니다. 아무 기능이 없는 프로그램에 "파일 쓰기" 기능이 찍힌 것입니다.

소켓 프로그램에서는 `connect socket` 규칙이 함수 `0x140001450` 안의 기본 블록 `0x1400014B7`에서 `connect` API 호출(`0x140001517`)로 맞았고, `initialize Winsock library`는 같은 함수의 `WSAStartup`(`0x140001473`)으로 맞았습니다. 심벌 목록에서 `0x140001450`은 `try_connect`였고 `main`은 다른 주소(`0x140001579`)였습니다. `main`이 이 함수를 부르는 조건은 인자 99개라서, 실제로는 거의 도달하지 않습니다. capa는 그 조건을 따지지 않고 "이 파일에 연결 코드가 있다"를 보고합니다.

## 6. 결과 해석

<!-- files: fileio.c, sockdemo.c -->

- **기능이 있다는 것과 악성이라는 것은 다릅니다.** 세 프로그램 모두 무해하지만, 소켓 프로그램은 `C2 Communication` MBC 항목까지 받았습니다. 정상 프로그램도 파일을 쓰고 네트워크에 연결하므로, 보고서에는 "이 기능이 있다"와 "이 기능을 근거로 어떻게 판단했다"를 나눠 적어야 합니다.
- **런타임 코드가 잡음을 만듭니다.** `empty.exe`에서도 7개 규칙이 맞았습니다. 그중 `.tls` 구역, 메모리 할당 같은 항목은 컴파일러가 넣은 코드의 흔적입니다. 비교용으로 "아무 기능 없는 파일"을 같은 방법으로 만들어 두면, 새 파일에서 무엇이 더해졌는지 알아보기 쉽습니다.
- **함수 주소를 심벌이나 디스어셈블러와 맞춰 봅니다.** 같은 규칙이 `main`과 런타임 함수에서 각각 맞았습니다. 주소를 열어 보지 않으면 어느 코드가 근거인지 알 수 없습니다.
- **도달 가능성은 알려 주지 않습니다.** 정적 분석이라 실행 경로나 인자 조건은 보지 않습니다. 연결 코드가 실제로 실행되는지는 별도로 확인해야 합니다.
- **규칙에 없는 동작은 나오지 않습니다.** 맞은 규칙이 적다고 안전한 파일은 아닙니다. 규칙이 다루지 않는 동작이나 패킹으로 가려진 코드는 놓칠 수 있습니다.

## 전체 코드

`web/public/code/capa-rule-match-capabilities/`에 있는 파일입니다. 한 폴더에 모아 두고 `docker cp . cr-m4-capa:/work`로 컨테이너에 복사해 씁니다. 실행 순서는 `setup.sh`, `build.sh`, `run_capa.sh`, `summarize.py`입니다.

```
capa-rule-match-capabilities/
  setup.sh        컴파일러, capa, 규칙 설치
  empty.c         시험 프로그램 (a)
  fileio.c        시험 프로그램 (b)
  sockdemo.c      시험 프로그램 (c)
  build.sh        PE 로 컴파일
  run_capa.sh     capa 실행, JSON 저장
  summarize.py    JSON 요약 표
```

`setup.sh`

```bash
#!/bin/sh
# 컨테이너 안에서 컴파일러와 capa, 규칙을 준비한다.
# 컨테이너는 python:3.12-slim 에서 시작했다(root 로 실행).
set -e
apt-get update -qq
apt-get install -y -qq mingw-w64 curl unzip binutils-mingw-w64-x86-64 > /dev/null
cd /tmp
curl -sL -o capa.zip https://github.com/mandiant/capa/releases/download/v10.0.0/capa-v10.0.0-linux.zip
curl -sL -o rules.zip https://github.com/mandiant/capa-rules/archive/refs/tags/v10.0.0.zip
mkdir -p /opt/capa
unzip -q -o capa.zip -d /opt/capa
unzip -q -o rules.zip -d /opt
chmod +x /opt/capa/capa
/opt/capa/capa --version
x86_64-w64-mingw32-gcc --version | head -1
```

`empty.c`

```c
/* 시험 프로그램 (a): 아무 기능이 없다. */
int main(void) {
    return 0;
}
```

`fileio.c`

```c
/* 시험 프로그램 (b): 파일을 읽고 다른 파일에 쓴다. 실행하지 않고 분석만 한다. */
#include <stdio.h>
#include <string.h>

int main(void) {
    char buf[256];
    FILE *in = fopen("input.txt", "rb");
    if (!in) return 1;
    size_t n = fread(buf, 1, sizeof(buf), in);
    fclose(in);

    FILE *out = fopen("output.txt", "wb");
    if (!out) return 2;
    fwrite(buf, 1, n, out);
    fclose(out);
    return 0;
}
```

`sockdemo.c`

```c
/* 시험 프로그램 (c): 소켓 연결 코드가 들어 있다.
 * 명령줄 인자가 정확히 99개일 때만 연결 함수를 부르므로 보통은 도달하지 않는다.
 * 주소는 127.0.0.1 이다. 실행하지 않고 분석만 한다. */
#include <winsock2.h>
#include <ws2tcpip.h>
#include <string.h>

static int try_connect(void) {
    WSADATA wsa;
    if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) return -1;
    SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (s == INVALID_SOCKET) return -2;
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(9);
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    int rc = connect(s, (struct sockaddr *)&addr, sizeof(addr));
    if (rc == 0) send(s, "hello", 5, 0);
    closesocket(s);
    WSACleanup();
    return rc;
}

int main(int argc, char **argv) {
    (void)argv;
    if (argc == 99) return try_connect();
    return 0;
}
```

`build.sh`

```bash
#!/bin/sh
# 시험 프로그램 세 개를 윈도우 실행 파일(PE)로 컴파일한다. 실행하지 않는다.
set -e
CC=x86_64-w64-mingw32-gcc
mkdir -p out
$CC -O0 -o out/empty.exe empty.c
$CC -O0 -o out/fileio.exe fileio.c
$CC -O0 -o out/sockdemo.exe sockdemo.c -lws2_32
ls -l out
```

`run_capa.sh`

```bash
#!/bin/sh
# 시험 프로그램 세 개를 capa 로 분석하고 결과를 JSON 으로 저장한다.
# 경로는 컨테이너 안 기준이다: capa 는 /opt/capa/capa, 규칙은 /opt/capa-rules-10.0.0
set -e
mkdir -p json
for name in empty fileio sockdemo; do
  /opt/capa/capa -r /opt/capa-rules-10.0.0 -j out/$name.exe > json/$name.json
done
ls -l json
```

`summarize.py`

```python
"""capa 의 JSON 결과(json/*.json)를 읽어 프로그램별 기능 규칙을 표로 요약한다.

사용법: python3 summarize.py json/empty.json json/fileio.json json/sockdemo.json
표준 라이브러리만 쓴다.
"""
import json
import sys
from pathlib import Path


def load(path):
    return json.loads(Path(path).read_text(encoding="utf-8"))


def rule_rows(doc):
    """규칙마다 (이름, 이름공간, 일치 횟수, ATT&CK ID 목록, MBC ID 목록)을 만든다."""
    rows = []
    for rule in doc["rules"].values():
        meta = rule["meta"]
        if meta.get("lib"):
            continue  # 다른 규칙의 부품으로만 쓰이는 라이브러리 규칙은 뺀다
        attack = [a["id"] for a in meta.get("attack", [])]
        mbc = [m["id"] for m in meta.get("mbc", [])]
        rows.append((meta["name"], meta.get("namespace", ""),
                     len(rule["matches"]), attack, mbc))
    return sorted(rows, key=lambda r: (r[1], r[0]))


def main(paths):
    for path in paths:
        doc = load(path)
        name = Path(path).stem
        rows = rule_rows(doc)
        print(f"== {name}: 기능 규칙 {len(rows)}개")
        print(f"{'규칙':<46} {'일치':>4}  {'ATT&CK':<8} MBC")
        for rule_name, _ns, n, attack, mbc in rows:
            print(f"{rule_name[:46]:<46} {n:>4}  {','.join(attack) or '-':<8} {','.join(mbc) or '-'}")
        print()


if __name__ == "__main__":
    if len(sys.argv) < 2:
        sys.exit("사용법: python3 summarize.py json/<파일>.json ...")
    main(sys.argv[1:])
```

## 자주 막히는 곳

- **규칙을 찾지 못한다는 오류**: `-r`로 규칙 폴더를 지정하지 않으면 capa가 규칙을 찾지 못합니다. 규칙은 따로 받아야 하며, 압축을 푼 폴더(`capa-rules-10.0.0`)를 가리킵니다.
- **Git Bash에서 `docker exec` 경로가 바뀜**: `/opt/...` 같은 경로가 `C:/Program Files/Git/...`로 바뀌어 "No such file"이 납니다. 명령 앞에 `MSYS_NO_PATHCONV=1`을 붙이거나 PowerShell에서 실행합니다.
- **아무 기능 없는 파일에도 규칙이 맞는 것**: 컴파일러의 런타임 코드 때문이며 정상입니다. `-vv`로 근거 주소를 보고 `nm`으로 함수 이름을 확인합니다.
- **분석 시간**: 이 글의 110KB짜리 파일은 금방 끝났지만, 큰 파일은 분석에 오래 걸릴 수 있습니다.

## 확인 범위

- 확인한 것: capa 10.0.0과 `capa-rules` 10.0.0으로 직접 컴파일한 PE 세 개를 정적 분석했고, 기본 출력, `-v`, `-vv`, `-j` 출력과 이를 요약하는 스크립트를 실행했습니다. 함수 주소는 MinGW `nm` 심벌로 대조했습니다.
- 확인하지 못한 것: 시험 프로그램을 한 번도 실행하지 않았으므로 실제 동작은 확인하지 않았습니다. 실제 악성코드나 패킹된 파일에서의 정확도, 다른 버전의 규칙과 결과 차이, pip 설치 방식은 확인하지 않았습니다. ATT&CK와 MBC 번호는 규칙 파일에 적힌 값을 그대로 옮긴 것이며, 매핑이 적절한지는 평가하지 않았습니다.
- 규칙 일치 개수와 주소는 이 컴파일러와 옵션(`-O0`)으로 만든 파일의 값입니다. 컴파일러나 옵션이 달라지면 달라질 수 있습니다.
