# pip 의존성에 해시를 고정하고 취약점 점검하기

> 오래된 requests 를 pip-audit 로 점검해 수정 버전을 확인하고, pip-compile 로 해시 잠금 파일을 만들어 --require-hashes 로 설치합니다. 해시를 바꾸거나 빼면 설치가 멈추는 것, 로컬 인덱스에서 같은 이름과 버전의 내용이 바뀌어도 해시가 잡아내는 것, 의존성 혼동이 생기는 조건까지 내 컴퓨터 안에서 재현합니다.

- 주소: https://copyandrun.com/blog/pip-require-hashes-lockfile-pip-audit/
- 분야: DevSecOps
- 발행일: 2026-10-25
- 태그: pip-audit, pip-tools, require-hashes, pypiserver, 의존성 혼동

의존성 관리에는 두 가지 질문이 있습니다. 쓰고 있는 버전에 알려진 취약점이 있는지, 그리고 지금 받는 파일이 처음 검토했던 그 파일과 같은지입니다. 앞의 질문은 pip-audit 가, 뒤의 질문은 해시 고정이 답합니다. 이 글은 오래된 requests 로 취약점을 찾고 고치는 것부터, 해시를 고정한 잠금 파일을 만들고 일부러 깨 보는 것, 로컬 PyPI 호환 서버에서 의존성 혼동과 내용이 바뀐 파일을 재현하는 것, 결과를 작은 웹 보고서로 보는 것까지 차례로 해 봅니다.

SBOM 생성과 Trivy 교차 확인은 [취약한 의존성 스캔하고 CycloneDX SBOM 만들기](/blog/sca-sbom-practice/)에서 다뤘으므로 여기서는 반복하지 않습니다. 이 글의 공격 재현은 모두 내 컴퓨터의 가상환경과 컨테이너 안에서만 합니다. 취약한 버전은 연습용 목록에만 쓰고, 실제 서비스의 의존성 파일에는 쓰지 않습니다. 연습용 패키지 `labdemo` 는 문장 하나를 돌려주는 무해한 코드이며 실제 악성 패키지는 쓰지 않습니다.

## 준비물

| 항목 | 버전 | 용도 |
|---|---|---|
| Python | 3.12.10 | 가상환경과 도구 실행 |
| pip-audit | 2.10.1 | 취약점 점검 |
| pip-tools (pip-compile) | 7.6.2 | 해시 잠금 파일 생성 |
| twine | 7.0.0 | 로컬 인덱스에 패키지 올리기 |
| Flask | 3.1.3 | 점검 보고서 웹 화면 |
| setuptools | 84.2.1 | 연습용 패키지 휠 만들기 |
| Docker | 29.5.3 | 로컬 PyPI 호환 서버 두 대 |
| pypiserver 이미지 | v2.4.2 | 로컬 인덱스 |

명령은 Git Bash 또는 리눅스·macOS 셸 기준이고 예상 소요 시간은 40분 안팎입니다. pip-audit 와 1, 2단계는 인터넷 연결이 필요합니다. 3단계 이후는 로컬 컨테이너만 씁니다. 포트는 19801, 19802, 19810 을 씁니다. 실행 환경이 Windows 가상환경이라 아래 활성화 명령은 `Scripts` 기준입니다.

| 운영체제 | 활성화 명령 |
|---|---|
| Linux, macOS | `source .venv/bin/activate` |
| Windows (Git Bash) | `source .venv/Scripts/activate` |

이 글의 코드는 모두 본문에 전체를 실었고, 글 맨 위의 실습 코드 내려받기에서도 같은 파일을 받을 수 있습니다. 가상환경 안 도구는 `.venv`, 설치 대상 가상환경은 `app-venv` 와 `chk` 로 따로 둡니다. 아래 명령에서 `chk/Scripts/python` 은 Linux 와 macOS 에서는 `chk/bin/python` 입니다.

```bash
mkdir pin-lab && cd pin-lab
export PIP_DISABLE_PIP_VERSION_CHECK=1
python -m venv .venv
source .venv/Scripts/activate
pip install pip-audit pip-tools twine flask setuptools
python -m venv app-venv
python -m venv chk
```

## 1. 취약한 버전을 점검하고 올리기

### 발견

일부러 오래된 requests 2.25.0 만 적은 목록을 만들고 pip-audit 로 점검합니다. pip-audit 는 목록을 임시 가상환경에 풀어 보고, 딸려 오는 의존성까지 함께 검사합니다.

```bash
cat > requirements-old.txt <<'EOT'
requests==2.25.0
EOT
```

```bash
pip-audit -r requirements-old.txt --progress-spinner off
echo "exit=$?"
```

기대 출력입니다. 건수는 취약점 데이터베이스가 갱신되면 달라집니다.

```text
Found 24 known vulnerabilities in 3 packages
Name     Version ID              Fix Versions
-------- ------- --------------- ------------
requests 2.25.0  PYSEC-2023-74   2.31.0
requests 2.25.0  PYSEC-2023-74   2.31.0
requests 2.25.0  PYSEC-2026-1873 2.32.0
requests 2.25.0  PYSEC-2026-1872 2.32.4
requests 2.25.0  PYSEC-2026-2275 2.33.0
...
exit=1
```

![오래된 requests 2.25.0 에서 24건이 나오고 requests, idna, urllib3 세 패키지에 수정 버전이 표시되며 exit=1 로 끝나는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/01-pip-audit-old.png)

같은 ID 가 여러 번 나오는 것은 같은 취약점이 여러 번 보고되었기 때문입니다. 중복을 빼면 requests 4건, idna 2건, urllib3 7건으로 모두 13건입니다. 직접 적은 것은 requests 하나뿐인데 세 패키지가 걸린 것을 눈여겨봅니다.

### 원인

requests 2.25.0 은 `idna<3`, `urllib3<1.27` 처럼 하위 의존성의 버전 범위를 좁게 묶어 둡니다. 그래서 목록에 적지 않은 idna 2.10 과 urllib3 1.26.20 이 함께 설치되고, 이들의 취약점도 같이 걸립니다. requests 자체의 PYSEC-2023-74 는 별칭이 CVE-2023-32681 이고, PYSEC-2026-1873 은 CVE-2024-35195 입니다. 수정 버전 중 가장 높은 것은 requests 2.33.0 입니다.

### 수정

직접 적는 목록은 `requirements.in` 으로 이름을 바꾸고 수정 버전 이상으로 올립니다. 이 글에서는 최신 안정 버전인 2.34.2 를 골랐습니다.

```bash
cat > requirements.in <<'EOT'
requests==2.34.2
EOT
```

### 재확인

```bash
pip-audit -r requirements.in --progress-spinner off
echo "exit=$?"
```

기대 출력:

```text
No known vulnerabilities found
exit=0
```

![requirements.in 의 requests 2.34.2 로 점검하면 No known vulnerabilities found 와 exit=0 이 나오는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/02-pip-audit-new.png)

버전을 올린 뒤에는 테스트를 돌려 호환성을 확인해야 합니다. 이 점검은 지금 알려진 취약점만 찾으므로 통과가 안전하다는 뜻은 아닙니다.

## 2. 해시 잠금 파일 만들고 깨 보기

버전을 고정해도 같은 `2.34.2` 라는 이름으로 내려오는 파일이 처음 본 파일과 같다는 보장은 없습니다. 파일의 sha256 해시를 함께 적어 두면 pip 가 받은 파일의 해시를 비교해 다르면 설치를 멈춥니다.

### 잠금 파일 만들기

```bash
pip-compile --generate-hashes --newline LF --quiet --strip-extras requirements.in -o requirements.lock
grep -oE '^[A-Za-z][A-Za-z0-9.-]*==[0-9.]+' requirements.lock
echo "hash 줄 수: $(grep -c -- '--hash=' requirements.lock)"
grep -A3 '^requests==' requirements.lock
```

기대 출력입니다. 해시 값은 배포되는 파일에 따라 정해지므로 같은 버전이면 같게 나옵니다.

```text
certifi==2026.10.23
charset-normalizer==3.5.2
idna==3.20
requests==2.34.2
urllib3==2.8.0
hash 줄 수: 180
requests==2.34.2 \
    --hash=sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0 \
    --hash=sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed
    # via -r requirements.in
```

직접 적은 requests 하나가 다섯 패키지로 풀렸고 모두 해시가 붙었습니다. 해시가 두 개인 것은 소스 압축본과 휠 파일을 각각 허용하기 때문입니다. charset-normalizer 는 플랫폼별 휠이 많아 해시 줄이 길어서, 잠금 파일(196줄)은 본문에 싣지 않고 위 명령으로 만듭니다. `--newline LF` 는 Windows 에서 줄 끝이 CRLF 로 바뀌는 것을 막습니다.

uv 를 쓴다면 같은 일을 `uv pip compile --generate-hashes requirements.in -o uv.lock` 으로 합니다. 이 글의 환경(uv 0.12.9)에서 같은 다섯 패키지와 해시 180줄이 나오는 것까지 확인했습니다.

### --require-hashes 로 설치

```bash
app-venv/Scripts/python -m pip install --require-hashes --no-cache-dir -r requirements.lock
app-venv/Scripts/python -m pip list
```

기대 출력의 마지막 부분입니다.

```text
Successfully installed certifi-2026.10.23 charset-normalizer-3.5.2 idna-3.20 requests-2.34.2 urllib3-2.8.0

Package            Version
------------------ ----------
certifi            2026.10.23
charset-normalizer 3.5.2
idna               3.20
pip                25.0.1
requests           2.34.2
urllib3            2.8.0
```

잠금 파일에 해시가 하나라도 있으면 pip 는 `--require-hashes` 를 자동으로 켭니다. 옵션을 직접 적는 것은 의도를 분명히 하고, 누가 해시를 지웠을 때 조용히 넘어가지 않게 하려는 것입니다. 잠금 파일 자체도 점검할 수 있습니다. `pip-audit -r requirements.lock` 은 같은 다섯 패키지에서 취약점을 찾지 못했습니다.

### 해시 한 글자만 바꾸기

연습용으로 잠금 파일을 망가뜨린 사본 두 개를 만드는 스크립트입니다. 첫 번째는 requests 의 해시 두 개 각각의 마지막 한 글자를 바꾼 것이고, 두 번째는 idna 의 해시 줄을 지운 것입니다.

```bash
cat > tamper_lock.py <<'EOT'
"""잠금 파일을 일부러 망가뜨린 연습용 사본 두 개를 만든다.

requirements.bad.lock    : requests 의 해시 각각의 마지막 한 글자를 바꾼다.
requirements.nohash.lock : idna 의 해시 줄을 지워 해시 없는 의존성을 섞는다.
"""
import re
from pathlib import Path

lines = Path("requirements.lock").read_text(encoding="utf-8").splitlines()
HASH = re.compile(r"(--hash=sha256:[0-9a-f]{63})([0-9a-f])")


def flip(m):
    return m.group(1) + ("0" if m.group(2) != "0" else "1")


bad, nohash, current = [], [], ""
for ln in lines:
    head = re.match(r"^([A-Za-z0-9._-]+)==", ln)
    if head:
        current = head.group(1).lower()
    bad.append(HASH.sub(flip, ln) if current == "requests" else ln)
    if current == "idna" and "--hash=sha256:" in ln:
        continue
    # idna 줄 끝의 이어쓰기 문자(역슬래시)도 함께 뗀다
    nohash.append(ln[:-2] if current == "idna" and ln.startswith("idna==") else ln)

Path("requirements.bad.lock").write_text("\n".join(bad) + "\n", encoding="utf-8", newline="\n")
Path("requirements.nohash.lock").write_text("\n".join(nohash) + "\n", encoding="utf-8", newline="\n")
print("만든 파일: requirements.bad.lock, requirements.nohash.lock")
EOT
```

```bash
python tamper_lock.py
diff requirements.lock requirements.bad.lock
chk/Scripts/python -m pip install --require-hashes --no-cache-dir -r requirements.bad.lock
```

기대 출력의 핵심입니다. 해시가 몇 개든 하나라도 맞으면 통과하므로, 두 해시를 모두 바꿔야 불일치가 됩니다.

```text
ERROR: THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS FILE. ...
    requests==2.34.2 from https://files.pythonhosted.org/packages/.../requests-2.34.2-py3-none-any.whl (from -r requirements.bad.lock (line 189)):
        Expected sha256 2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e1
        Expected     or f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9e0
             Got        2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0
```

![잠금 파일의 requests 해시가 한 글자씩 달라지자 Expected 두 값과 실제로 받은 Got 값이 어긋나 설치가 멈추는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/03-hash-mismatch.png)

`Got` 은 파일이 실제로 가진 해시이고, 잠금 파일의 `Expected` 와 마지막 한 글자만 다릅니다. 앞에서 certifi 와 idna 같은 패키지는 이미 내려받았지만, 해시를 검증하는 단계에서 requests 가 걸려 아무것도 설치되지 않았습니다.

### 해시 없는 의존성 섞기

```bash
diff requirements.lock requirements.nohash.lock
chk/Scripts/python -m pip install --require-hashes --no-cache-dir -r requirements.nohash.lock
```

기대 출력의 핵심입니다.

```text
ERROR: Hashes are required in --require-hashes mode, but they are missing from some requirements. ...
    idna==3.20 --hash=sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c
```

![idna 의 해시 줄을 지운 잠금 파일에서 해시가 빠진 요구사항이 있다며 설치가 멈추고, 받은 파일의 실제 해시가 안내되는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/04-hash-missing.png)

이 모드에서는 하위 의존성까지 모두 해시와 정확한 버전(`==`)으로 적어야 합니다. 그래서 손으로 쓰기보다 pip-compile 로 만드는 방식을 씁니다. 오류 메시지가 보여 주는 해시를 그대로 붙여 넣으면 통과하지만, 그 해시는 방금 받은 파일에서 계산한 것이라 검증된 값은 아닙니다. 믿을 만한 환경에서 만든 값인지 먼저 따져야 합니다.

## 3. 로컬 인덱스에서 의존성 혼동과 변조 재현

이제 PyPI 대신 내 컴퓨터의 PyPI 호환 서버를 씁니다. 서버 두 대를 띄웁니다. `internal`(19801)은 회사 안에서만 쓰는 인덱스 역할이고, `public`(19802)은 공개 PyPI 를 대신하는 가짜입니다. 실제 PyPI 에는 아무것도 올리지 않습니다.

```bash
cat > docker-compose.yml <<'EOT'
services:
  internal:
    image: pypiserver/pypiserver:v2.4.2
    container_name: cr-t4-internal
    command: run -P . -a . -o --disable-fallback /data/packages
    ports:
      - "127.0.0.1:19801:8080"
  public:
    image: pypiserver/pypiserver:v2.4.2
    container_name: cr-t4-public
    command: run -P . -a . -o --disable-fallback /data/packages
    ports:
      - "127.0.0.1:19802:8080"
EOT
```

`-P . -a .` 는 인증을 끄는 옵션이고 `-o` 는 같은 파일 이름을 덮어쓰게 합니다. 둘 다 이 실습의 재현을 위한 설정이며, 실제 인덱스에서는 쓰지 않습니다. 포트는 `127.0.0.1` 로만 열어 내 컴퓨터 밖에서 접근할 수 없습니다.

```bash
docker compose up -d
docker ps --filter name=cr-t4 --format 'table {{.Names}}\t{{.Ports}}'
```

기대 출력:

```text
NAMES            PORTS
cr-t4-internal   127.0.0.1:19801->8080/tcp
cr-t4-public     127.0.0.1:19802->8080/tcp
```

### 무해한 패키지 만들어 올리기

`labdemo` 는 문장 하나를 돌려주는 패키지입니다. 아래 스크립트는 이름, 버전, 문장을 받아 휠 파일을 만들므로, 같은 이름과 버전에 문장만 바꾸면 내용이 다른 파일이 됩니다.

```bash
cat > make_pkg.py <<'EOT'
"""무해한 연습용 패키지의 휠(.whl)을 만든다.

사용법: python make_pkg.py 이름 버전 "출력할 문장" 출력폴더
같은 이름과 버전이라도 문장을 바꾸면 내용이 다른 휠이 만들어진다.
"""
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path

name, version, message, out = sys.argv[1:5]

with tempfile.TemporaryDirectory() as tmp:
    src = Path(tmp)
    (src / name).mkdir()
    (src / name / "__init__.py").write_text(
        f'__version__ = "{version}"\n\n\ndef hello():\n    return "{message}"\n',
        encoding="utf-8",
    )
    (src / "pyproject.toml").write_text(
        '[build-system]\nrequires = ["setuptools"]\nbuild-backend = "setuptools.build_meta"\n\n'
        f'[project]\nname = "{name}"\nversion = "{version}"\n',
        encoding="utf-8",
    )
    Path(out).mkdir(parents=True, exist_ok=True)
    subprocess.run(
        [sys.executable, "-m", "pip", "wheel", "--disable-pip-version-check", "--no-deps", "--no-build-isolation", "-q", "-w", out, str(src)],
        check=True,
    )
    shutil.rmtree(src / "build", ignore_errors=True)
print(sorted(p.name for p in Path(out).glob(f"{name}-{version}*.whl")))
EOT
```

```bash
python make_pkg.py labdemo 1.0.0 'labdemo 1.0.0 internal' dist/internal
python make_pkg.py labdemo 1.0.1 'labdemo 1.0.1 internal' dist/internal
python make_pkg.py labdemo 9.0.0 'labdemo 9.0.0 public copy' dist/public
twine upload -u x -p x --repository-url http://127.0.0.1:19801 dist/internal/*
twine upload -u x -p x --repository-url http://127.0.0.1:19802 dist/public/*
```

기대 출력의 핵심입니다.

```text
['labdemo-1.0.0-py3-none-any.whl']
['labdemo-1.0.1-py3-none-any.whl']
['labdemo-9.0.0-py3-none-any.whl']
Uploading distributions to http://127.0.0.1:19801
Uploading labdemo-1.0.0-py3-none-any.whl
Uploading labdemo-1.0.1-py3-none-any.whl
Uploading distributions to http://127.0.0.1:19802
Uploading labdemo-9.0.0-py3-none-any.whl
```

브라우저로 `http://127.0.0.1:19801/` 을 열면 pypiserver 첫 화면이 나오고, 올린 패키지 수가 보입니다.

![로컬 pypiserver 첫 화면이 이 인덱스에 패키지 2개가 있다고 알려 주고 pip 의 --index-url 사용법을 보여 주는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/05-pypiserver-home.png)

### 의존성 혼동

내부 인덱스에 `labdemo` 1.0.1 이 있고, 공개 쪽 인덱스에는 같은 이름의 9.0.0 이 있다고 가정합니다. 내부 전용 패키지 이름을 공개 저장소에서 누가 먼저 차지하고 높은 버전을 올려 두면 벌어질 수 있는 일입니다. `--index-url` 은 기본 인덱스를 바꾸고 `--extra-index-url` 은 인덱스를 하나 더 추가합니다. 추가한 인덱스는 보조가 아니라 같은 후보 목록에 합쳐지며, pip 는 인덱스 순서가 아니라 가장 높은 버전을 고릅니다.

```bash
export INTERNAL=http://127.0.0.1:19801/simple/ PUBLIC=http://127.0.0.1:19802/simple/
python -m venv v1
python -m venv v2
v1/Scripts/python -m pip install -q --no-cache-dir labdemo --index-url $INTERNAL --extra-index-url $PUBLIC
v1/Scripts/python -c "import labdemo; print(labdemo.__version__, labdemo.hello())"
v2/Scripts/python -m pip install -q --no-cache-dir labdemo --index-url $INTERNAL
v2/Scripts/python -c "import labdemo; print(labdemo.__version__, labdemo.hello())"
```

기대 출력:

```text
9.0.0 labdemo 9.0.0 public copy
1.0.1 labdemo 1.0.1 internal
```

![index-url 에 extra-index-url 을 더하면 9.0.0 public copy 가 설치되고, index-url 만 쓰면 1.0.1 internal 이 설치되는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/06-confusion.png)

`--extra-index-url` 을 더하자 내부 인덱스에 없는 높은 버전이 이겼습니다. 이 글에서는 내가 올린 무해한 코드였지만, 실제 사고에서는 이 자리에 공격자의 코드가 들어옵니다. 막는 방법은 세 가지입니다. 인덱스를 하나만 쓰고(`--index-url`), 버전을 `==` 로 고정하고, 해시를 고정합니다. 공개 인덱스에도 같은 이름을 미리 등록해 두는 방법도 있습니다.

### 내부 패키지의 해시 잠금

```bash
cat > lab.in <<'EOT'
labdemo==1.0.1
EOT
```

```bash
python -m venv v3
pip-compile --generate-hashes --newline LF --quiet --strip-extras --no-header --index-url $INTERNAL lab.in -o lab.lock
cat lab.lock
v3/Scripts/python -m pip install -q --no-cache-dir --require-hashes -r lab.lock --extra-index-url $PUBLIC
v3/Scripts/python -c "import labdemo; print(labdemo.__version__, labdemo.hello())"
```

기대 출력입니다. labdemo 의 해시 값은 휠을 만들 때마다 달라지므로 본인 값으로 바뀝니다.

```text
--index-url http://127.0.0.1:19801/simple/

labdemo==1.0.1 \
    --hash=sha256:cb7a05df2c817af3ee1402ecb643e0679187a28d861fab708de2e03dc74399fa
    # via -r lab.in

1.0.1 labdemo 1.0.1 internal
```

같은 `--extra-index-url` 을 붙였는데도 이번에는 1.0.1 이 설치됩니다. `labdemo==1.0.1` 로 버전이 고정되어 9.0.0 은 후보가 되지 않기 때문입니다. 잠금 파일 첫 줄의 `--index-url` 도 pip 가 읽어 갑니다.

### 같은 이름, 같은 버전, 바뀐 내용

이제 내부 인덱스의 1.0.1 을 같은 이름으로 내용만 바꿔 덮어씁니다. 파일 이름과 버전은 그대로입니다.

```bash
python make_pkg.py labdemo 1.0.1 'labdemo 1.0.1 CHANGED' dist/changed
twine upload -u x -p x --repository-url http://127.0.0.1:19801 dist/changed/*
python -m venv v4
python -m venv v5
v4/Scripts/python -m pip install -q --no-cache-dir labdemo==1.0.1 --index-url $INTERNAL
v4/Scripts/python -c "import labdemo; print(labdemo.__version__, labdemo.hello())"
v5/Scripts/python -m pip install --no-cache-dir --require-hashes -r lab.lock
```

기대 출력의 핵심입니다.

```text
1.0.1 labdemo 1.0.1 CHANGED
Looking in indexes: http://127.0.0.1:19801/simple/
Collecting labdemo==1.0.1 (from -r lab.lock (line 3))
  Downloading http://127.0.0.1:19801/packages/labdemo-1.0.1-py3-none-any.whl (1.2 kB)

ERROR: THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS FILE. ...
        Expected sha256 cb7a05df2c817af3ee1402ecb643e0679187a28d861fab708de2e03dc74399fa
             Got        890262c190def092ec6ab28d77875d9fd5d345ef83c672a9e9dae9feb697837d
```

![해시 없이 설치하면 CHANGED 문장이 조용히 설치되고, 잠금 파일로 설치하면 Expected 와 Got 이 달라 멈추는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/07-locked-changed.png)

버전만 고정한 `labdemo==1.0.1` 은 바뀐 내용을 그대로 설치했고, 해시를 고정한 잠금 파일만 막았습니다. 버전 고정은 이름표를 고정하는 것이고, 해시 고정은 내용을 고정하는 것입니다.

## 4. 점검 결과를 웹 보고서로 보기

터미널의 표는 읽기 어려우니 pip-audit 의 JSON 과 해시 비교 결과를 읽어 두 화면으로 보여 주는 Flask 앱을 만듭니다. 해시 비교 결과는 잠금 파일의 해시와 인덱스가 지금 내주는 파일의 sha256 을 나란히 놓는 스크립트가 만듭니다. pip 가 속으로 하는 비교를 값이 보이게 풀어 쓴 것입니다.

```bash
cat > hash_check.py <<'EOT'
"""잠금 파일의 해시와 인덱스가 지금 내주는 파일의 해시를 나란히 비교해 JSON으로 남긴다.

사용법: python hash_check.py 잠금파일 인덱스주소 결과.json
pip install --require-hashes 가 속으로 하는 비교를, 어떤 값이 어긋났는지 보이게 풀어 쓴 것이다.
"""
import hashlib
import json
import re
import subprocess
import sys
import tempfile
from pathlib import Path

lock, index, out = sys.argv[1:4]

# 잠금 파일에서 "이름==버전"과 그 아래 --hash 줄들을 읽는다.
pins, current = [], None
for line in Path(lock).read_text(encoding="utf-8").splitlines():
    head = re.match(r"^([A-Za-z0-9._-]+)==(\S+)", line)
    if head:
        current = {"name": head.group(1), "version": head.group(2), "locked": []}
        pins.append(current)
    found = re.search(r"--hash=sha256:([0-9a-f]{64})", line)
    if found and current is not None:
        current["locked"].append(found.group(1))

rows = []
for pin in pins:
    with tempfile.TemporaryDirectory() as tmp:
        subprocess.run(
            [sys.executable, "-m", "pip", "download", "-q", "--no-deps", "--no-cache-dir",
             "-d", tmp, "-i", index, f"{pin['name']}=={pin['version']}"],
            check=True,
        )
        files = [f for f in Path(tmp).iterdir() if f.is_file()]
        actual = hashlib.sha256(files[0].read_bytes()).hexdigest()
        rows.append({
            "name": pin["name"],
            "version": pin["version"],
            "file": files[0].name,
            "locked": pin["locked"],
            "actual": actual,
            "match": actual in pin["locked"],
        })

Path(out).write_text(json.dumps({"index": index, "rows": rows}, indent=2), encoding="utf-8")
for r in rows:
    print(r["name"], r["version"], "일치" if r["match"] else "불일치")
EOT
```

```bash
cat > report_app.py <<'EOT'
"""점검 결과를 브라우저로 보여 주는 작은 Flask 보고서.

사용법: python report_app.py [포트]
같은 폴더의 audit-old.json, audit-new.json(pip-audit -f json 결과)과
hash-ok.json, hash-tampered.json(hash_check.py 결과)을 읽어 두 화면을 만든다.
  /        pip-audit 점검 보고서 (고치기 전과 후)
  /hashes  해시 비교 (정상일 때와 내용이 바뀐 뒤)
"""
import html
import json
import sys
from pathlib import Path

from flask import Flask

BASE = Path(__file__).resolve().parent
app = Flask(__name__)

STYLE = """<style>
body{font:15px 'Malgun Gothic',sans-serif;margin:28px auto;max-width:1100px;color:#1f2933}
h1{font-size:22px;margin:0 0 6px}h2{font-size:17px;margin:26px 0 8px}p{margin:0 0 12px;color:#52606d}
table{border-collapse:collapse;width:100%;margin-bottom:6px}
th,td{border:1px solid #d5dbe1;padding:7px 10px;text-align:left;vertical-align:top}
th{background:#f1f4f7;white-space:nowrap}code{font-size:12.5px;word-break:break-all}
.bad{color:#b71c1c;font-weight:700}.ok{color:#1b7f3b;font-weight:700}
.cols{display:flex;gap:18px}.cols>div{flex:1;min-width:0}
.box{border:1px solid #d5dbe1;border-radius:6px;padding:12px 14px}
</style>"""


def load(name):
    return json.loads((BASE / name).read_text(encoding="utf-8"))


def audit_table(data):
    rows, total = [], 0
    for dep in data["dependencies"]:
        vulns = {v["id"]: v for v in dep.get("vulns", [])}
        total += len(vulns)
        fixes = sorted({f for v in vulns.values() for f in v["fix_versions"]})
        cls = "bad" if vulns else "ok"
        rows.append(
            f"<tr><td>{html.escape(dep['name'])}</td><td>{html.escape(str(dep.get('version', '')))}</td>"
            f"<td class='{cls}'>{len(vulns)}</td><td>{html.escape(', '.join(fixes)) or '-'}</td>"
            f"<td><code>{html.escape(', '.join(sorted(vulns))) or '-'}</code></td></tr>"
        )
    head = "<tr><th>패키지</th><th>버전</th><th>취약점</th><th>수정 버전</th><th>ID</th></tr>"
    return total, f"<table>{head}{''.join(rows)}</table>"


@app.get("/")
def audit_page():
    old_total, old_table = audit_table(load("audit-old.json"))
    new_total, new_table = audit_table(load("audit-new.json"))
    return (
        f"<!doctype html><meta charset='utf-8'><title>의존성 점검 보고서</title>{STYLE}"
        "<h1>의존성 점검 보고서</h1>"
        "<p>같은 requirements를 pip-audit로 점검한 결과입니다. 취약점은 중복을 뺀 건수입니다.</p>"
        f"<h2>고치기 전: requirements-old.txt <span class='bad'>취약점 {old_total}건</span></h2>{old_table}"
        f"<h2>고친 뒤: requirements.in <span class='ok'>취약점 {new_total}건</span></h2>{new_table}"
    )


def hash_box(title, data):
    rows = []
    for r in data["rows"]:
        verdict = "<span class='ok'>일치</span>" if r["match"] else "<span class='bad'>불일치</span>"
        rows.append(
            f"<tr><td>{html.escape(r['name'])} {html.escape(r['version'])}</td>"
            f"<td><code>{html.escape(r['file'])}</code></td></tr>"
            f"<tr><th>잠금 파일</th><td><code>{html.escape(', '.join(r['locked']))}</code></td></tr>"
            f"<tr><th>서버가 내준 파일</th><td><code>{r['actual']}</code></td></tr>"
            f"<tr><th>판정</th><td>{verdict}</td></tr>"
        )
    return f"<div class='box'><h2>{html.escape(title)}</h2><table>{''.join(rows)}</table></div>"


@app.get("/hashes")
def hashes_page():
    ok, bad = load("hash-ok.json"), load("hash-tampered.json")
    return (
        f"<!doctype html><meta charset='utf-8'><title>해시 불일치 전후 비교</title>{STYLE}"
        "<h1>해시 불일치 전후 비교</h1>"
        "<p>같은 이름과 같은 버전인데 서버가 내주는 파일의 내용이 바뀌면 sha256 값이 달라집니다.</p>"
        f"<div class='cols'>{hash_box('정상일 때', ok)}{hash_box('내용이 바뀐 뒤', bad)}</div>"
    )


if __name__ == "__main__":
    app.run(host="127.0.0.1", port=int(sys.argv[1]) if len(sys.argv) > 1 else 19810)
EOT
```

3단계 끝에서 내부 인덱스는 내용이 바뀐 상태입니다. 이 상태가 불일치 화면의 재료입니다. 원래 파일을 다시 올리면 일치 화면의 재료가 됩니다.

```bash
pip-audit -r requirements-old.txt -f json -o audit-old.json --progress-spinner off
pip-audit -r requirements.in -f json -o audit-new.json --progress-spinner off
python hash_check.py lab.lock $INTERNAL hash-tampered.json
twine upload -u x -p x --repository-url http://127.0.0.1:19801 dist/internal/labdemo-1.0.1-py3-none-any.whl
python hash_check.py lab.lock $INTERNAL hash-ok.json
python report_app.py 19810
```

기대 출력의 핵심입니다. 첫 `pip-audit` 는 취약점이 있어 종료 코드 1로 끝나지만 JSON 파일은 만들어집니다.

```text
labdemo 1.0.1 불일치
Uploading labdemo-1.0.1-py3-none-any.whl
labdemo 1.0.1 일치
```

브라우저에서 `http://127.0.0.1:19810/` 을 엽니다. 고치기 전 목록과 고친 뒤 목록이 위아래로 나옵니다.

![고치기 전 requirements-old.txt 에서 취약점 13건이 requests 4, idna 2, urllib3 7 로 나뉘고, 고친 뒤 requirements.in 은 모두 0건으로 나오는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/08-audit-report.png)

`http://127.0.0.1:19810/hashes` 에서는 같은 파일의 해시가 정상일 때와 내용이 바뀐 뒤에 어떻게 달라지는지 좌우로 비교합니다.

![같은 labdemo 1.0.1 인데 정상일 때는 잠금 파일과 서버 파일의 해시가 같아 일치이고, 내용이 바뀐 뒤에는 서버 파일의 해시가 달라 불일치로 표시되는 것을 확인합니다.](https://copyandrun.com/img/pip-require-hashes-lockfile-pip-audit/09-hash-compare.png)

## 한계

- **첫 값이 정상이라는 전제입니다.** 해시 고정은 잠금 파일을 만든 시점에 받은 파일을 기준으로 삼습니다. 그때 이미 악성이었다면 그 악성 파일을 그대로 고정합니다.
- **pip-audit 는 알려진 취약점만 찾습니다.** 데이터베이스에 없는 취약점이나 악성 패키지는 통과합니다.
- **잠금 파일은 갱신해야 합니다.** 새 버전이 나오면 `requirements.in` 을 고치고 다시 컴파일해야 하고, 그때 바뀐 해시를 검토하는 과정이 필요합니다.
- **pip-compile 결과는 만든 환경 기준입니다.** 이 글의 잠금 파일은 Python 3.12 와 Windows 에서 만들었습니다. 다른 파이썬 버전이나 운영체제에서는 요구하는 패키지가 달라질 수 있어 배포 환경에서 만드는 것이 안전합니다.
- **`-o` 와 인증 끄기는 실습용입니다.** 덮어쓰기를 허용하는 인덱스가 바로 내용 변조가 가능한 인덱스입니다. 실제 인덱스는 같은 이름과 버전의 재업로드를 막는 쪽이 정상입니다.

## 자주 막히는 곳

**`Hashes are required in --require-hashes mode` 가 나옵니다.** 잠금 파일에 해시가 없는 줄이 있습니다. 직접 요구사항을 추가했다면 `requirements.in` 에 적고 pip-compile 로 다시 만듭니다.

**잠금 파일 줄 끝이 CRLF 로 바뀝니다.** Windows 에서 pip-compile 이 줄 끝을 바꾸어 diff 가 파일 전체로 나옵니다. `--newline LF` 를 붙입니다.

**`WARNING:venv:Actual environment location may have moved` 가 나옵니다.** 임시 폴더 경로가 짧은 이름으로 잡힐 때 Windows 에서 나오는 경고입니다. 결과에는 영향이 없었습니다.

**해시가 틀린데도 이미 설치돼 있어 오류가 나지 않습니다.** 같은 버전이 이미 설치된 가상환경에서는 pip 가 다시 받지 않습니다. 검증용 가상환경은 새로 만들거나 `--ignore-installed` 를 붙입니다. 캐시 때문에 통과하는 것을 막으려고 `--no-cache-dir` 도 씁니다.

## 이어서 해 볼 것

- 1단계 점검을 CI 에 넣어 PR 마다 `pip-audit -r requirements.lock` 을 돌립니다. 종료 코드 1이 게이트가 됩니다. 같은 구성의 워크플로는 [취약한 의존성 스캔하고 CycloneDX SBOM 만들기](/blog/sca-sbom-practice/)에 있습니다.
- `requirements.in` 에 개발용 도구를 따로 모아 잠금 파일을 둘로 나누고, 운영용 잠금 파일에는 필요한 패키지만 남깁니다.
- 3단계의 `public` 서버에서 9.0.0 을 지우고, `--extra-index-url` 을 붙인 설치가 어떻게 되는지 확인합니다.

## 확인 범위

- **해 본 것:** 1단계부터 4단계까지의 명령은 Windows의 Git Bash, Python 3.12.10 가상 환경과 Docker로 직접 실행했습니다. 취약점 건수는 2026-10-25 기준입니다. uv는 잠금 파일 생성만 확인했고, 이 글의 설치 단계는 pip로만 실행했습니다. PYSEC 권고에 관한 설명은 pip-audit가 알려 주는 별칭만 확인한 것입니다.
- **해 보지 않은 것:** 취약점 자체를 재현하지는 않았습니다. 같은 이름과 버전의 재업로드를 거부하는 pypiserver 기본 동작은 확인하지 못했습니다.
- **읽을 때 주의:** 해시 값은 같은 버전이면 고정입니다. 하지만 연습용 labdemo의 해시는 휠을 만들 때마다 달라집니다.
- **참고:** pip의 Secure installs 문서(https://pip.pypa.io/en/stable/topics/secure-installs/)와 pip-tools 문서(https://pip-tools.readthedocs.io/)를 참고했습니다.

3단계는 pypiserver 컨테이너 두 개를 씁니다. 끝나면 아래 명령으로 정리합니다.

```bash
docker compose down
```
