zinosec 2편 — .env·.git·.aws, 서버 비밀 파일을 긁어 가려는 요청 (no-server-secrets)

2026-11-17·1분 읽기·

zinosec 2편 — .env·.git·.aws, 서버 비밀 파일을 긁어 가려는 요청 (no-server-secrets)

zino.kr 은 Next.js 정적 배포라 .env 도 .git 도 서버에 없는데, 88일 동안 그 비밀 파일을 노린 요청이 1만9천 건, 974개 IP 에서 들어왔다. 커스텀 WAF 룰 zinosec/no-server-secrets 가 그걸 어떻게 잡는지 — 로그로 건수를 직접 세고, .env 뒤에 붙는 464가지 이름 변형과 .git 저장소를 통째로 훑는 패턴을 들추고, 공격을 Kali 에서 재현해 Wireshark 로 403 패킷까지 보고, 두 갈래 정규식을 조각내 해부하고, .well-known 은 살리면서 88일 내내 오탐이 0 이었음을 실측한다. 방어자 시점 분석.

이 글의 범위

1편에서 가장 많이 걸린 .php 룰을 뜯었다. 두 번째로 많이 걸린 게 zinosec/no-server-secrets 다. 이름 그대로 서버의 비밀 파일을 노리는 요청을 막는다.

.env(환경변수), .git/config(소스 저장소), .aws/credentials(클라우드 키), .ssh/id_rsa(개인 키), .vscode/sftp.json(FTP 비번), 그리고 backup.sql·db.bak 같은 백업 파일. 공통점은 털리면 끝장이라는 것, 그리고 이 서버엔 하나도 없다는 것이다. zino.kr 은 Next.js 정적 배포라 소스도 환경변수도 빌드 산출물 바깥에 있고, .git 은 배포에 포함되지 않는다.

그런데도 88일 동안 이 파일들을 노린 요청이 1만9천 건 넘게, 974개 IP 에서 들어왔다. 정상 사용자가 /.aws/credentials 를 칠 일은 없으니 100퍼센트 정찰이다.

비밀 파일 하나가 털렸을 때 공격자가 얻는 것 — .env 는 모든 자격증명, .git 은 소스 전체, .aws·.ssh 는 클라우드와 서버 접근, .vscode 는 FTP 비번, 백업은 DB 덤프
비밀 파일 하나가 털렸을 때 공격자가 얻는 것 — .env 는 모든 자격증명, .git 은 소스 전체, .aws·.ssh 는 클라우드와 서버 접근, .vscode 는 FTP 비번, 백업은 DB 덤프

이 글도 1편과 같은 순서로 해부한다. 로그로 건수를 직접 세고(§막은 숫자), 실제 요청을 보고(§실제 요청), 무엇을 노리는지 묶고(§노린 것), 공격을 랩에서 재현해 패킷까지 뜯고(§패킷), 두 갈래 정규식을 조각내고(§룰 설계), 88일 내내 오탐이 0 이었음을 실측한다(§오탐 검증).

먼저 룰 파일을 본다. 1편의 .php 룰보다 길다.

cat /etc/crowdsec/appsec-rules/zinosec-no-server-secrets.yaml
zinosec/no-server-secrets 룰 파일 — URI 를 소문자로 내린 뒤 점으로 시작하는 비밀 디렉터리 이름과 백업 확장자를 OR 로 묶은 정규식에 매치하면 scan 으로 분류한다
zinosec/no-server-secrets 룰 파일 — URI 를 소문자로 내린 뒤 점으로 시작하는 비밀 디렉터리 이름과 백업 확장자를 OR 로 묶은 정규식에 매치하면 scan 으로 분류한다

핵심은 value 한 줄과 transform: lowercase 다. 파일 맨 위 주석의 숫자(env_secrets 3,219건)는 룰을 만들던 5월 시점의 분석값이고, 아래 집계는 보존된 로그(8/22 이후)로 다시 센 88일 창이라 다르다. 그 정규식이 왜 이렇게 생겼는지는 §룰 설계에서 조각낸다. 먼저 무엇을 막았는지부터.



이 룰이 막은 숫자

메트릭은 재시작 때 0 으로 날아가므로 믿지 않는다. 룰의 정규식을 88일치 nginx 로그에 그대로 다시 먹여 직접 센다. 내 테일스케일·칼리·루프백·자가점검 UA(zinosec-lab·waf-selftest) 요청은 뺀다.

# secrets_count.py — zinosec/no-server-secrets 룰이 막은 요청을 nginx 로그에서 직접 다시 센다.
# 룰과 똑같은 정규식을 URI 경로에 lowercase 로 적용한다.
# 소스: /var/log/nginx/zino.access.log* (adm 그룹이라 sudo 없이 읽힌다)
import re, gzip, glob
from collections import Counter
from datetime import datetime
 
# zinosec/no-server-secrets 룰의 match.value 를 그대로 가져온다 (transform: lowercase).
RULE = re.compile(r'((^|/)\.(git|svn|hg|aws|ssh|env|htpasswd|htaccess|vscode|idea)([./]|$)'
                  r'|\.(sql|bak|backup|old|swp)($|[?#]))')
 
LINE = re.compile(
    r'(?P<ip>\S+) \S+ \S+ \[(?P<t>[^\]]+)\] '
    r'"(?P<method>\S+) (?P<uri>\S+) [^"]*" (?P<st>\d{3}) \d+ "[^"]*" "(?P<ua>[^"]*)"')
# 내 테일스케일/칼리/루프백에서 쏜 자가점검·재현 요청은 통계에서 뺀다.
MINE = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
# 경로 종류 — 위에서부터 먼저 맞는 것으로 분류
KINDS = [
    (".env 류",          re.compile(r'(^|/)\.env([./]|$)')),
    (".git 류",          re.compile(r'(^|/)\.git([./]|$)')),
    (".aws 류",          re.compile(r'(^|/)\.aws([./]|$)')),
    (".ssh 류",          re.compile(r'(^|/)\.ssh([./]|$)')),
    (".vscode 류",       re.compile(r'(^|/)\.vscode([./]|$)')),
    (".idea 류",         re.compile(r'(^|/)\.idea([./]|$)')),
    (".svn/.hg",         re.compile(r'(^|/)\.(svn|hg)([./]|$)')),
    (".htaccess/.htpasswd", re.compile(r'(^|/)\.ht(access|passwd)([./]|$)')),
    ("백업(.sql/.bak/.old/.swp)", re.compile(r'\.(sql|bak|backup|old|swp)($|[?#])')),
]
 
def logs():
    for fn in glob.glob('/var/log/nginx/zino.access.log*'):
        op = gzip.open if fn.endswith('.gz') else open
        with op(fn, 'rt', errors='replace') as fh:
            for ln in fh:
                yield ln
 
total = hits = 0
ips = set()
first = last = None
status = Counter()
kinds = Counter()
 
for ln in logs():
    m = LINE.match(ln)
    if not m:
        continue
    if MINE.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
        continue
    total += 1
    ts = datetime.strptime(m.group('t'), '%d/%b/%Y:%H:%M:%S %z')
    if first is None or ts < first: first = ts
    if last is None or ts > last: last = ts
    path = m.group('uri').split('?', 1)[0].lower()
    if not RULE.search(path):
        continue
    hits += 1
    ips.add(m.group('ip'))
    status[m.group('st')] += 1
    kinds[next((k for k, rx in KINDS if rx.search(path)), "기타")] += 1
 
print(f"로그 구간   : {first:%Y-%m-%d} ~ {last:%Y-%m-%d}  ({(last-first).days+1}일)")
print(f"스캔한 요청 : {total:,} 줄")
print(f"룰 매칭     : {hits:,} 건  (비밀 파일·VCS·백업 접근)")
print(f"고유 공격 IP: {len(ips):,} 개")
print()
print("응답 코드 분포 (매칭된 요청):")
for st, n in status.most_common():
    print(f"  {st}  {n:>6,}")
print()
print("경로 종류별:")
for k, n in kinds.most_common():
    print(f"  {n:>6,}  {k}")
python3 secrets_count.py
secrets_count.py 실행 결과 — 88일간 비밀파일 요청 1만9천 건, 고유 IP 974개. 응답은 403 과 301 이 대부분이고 200/304 는 없다. 종류별로 .env 가 1만3천으로 압도적
secrets_count.py 실행 결과 — 88일간 비밀파일 요청 1만9천 건, 고유 IP 974개. 응답은 403 과 301 이 대부분이고 200/304 는 없다. 종류별로 .env 가 1만3천으로 압도적

88일에 19,173건, 974개 IP. 응답은 403(WAF 차단) 1만5천, 301(평문 HTTP 를 HTTPS 로 올리는 엣지 업그레이드) 2천4백이다. 200 이나 304 는 한 건도 없다 — §오탐 검증에서 다시 중요해진다.

종류별로는 .env 가 12,950건으로 압도적이다. 그 뒤로 .git(3,144), .aws(1,530), 백업 파일(876) 순이다. 왜 .env 가 이렇게 많은지는 뒤에서 뜯는다 — 한 파일에 비밀이 전부 들었기 때문이다.


실제로 들어온 요청

숫자만으론 심심하니 원문을 본다. 공격자 IP 는 끝자리를 가리고, 경로별로 하나씩 골랐다. 쿼리스트링은 토큰이 섞일 수 있어 아예 잘라냈다.

# secrets_samples.py — 실제로 들어온 비밀 파일 요청 원문을 경로별로 한 줄씩 보여준다.
# 공격자 IP는 마지막 옥텟을 가린다(x). 쿼리스트링은 토큰이 섞일 수 있어 아예 잘라낸다.
import re, gzip, glob
 
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[(?P<t>[^\]]+)\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" '
                  r'(?P<st>\d{3}) \d+ "[^"]*" "(?P<ua>[^"]*)"')
MINE_IP = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
def mask(ip):
    if ':' in ip:  # IPv6
        return ip.rsplit(':', 1)[0] + ':x'
    return ip.rsplit('.', 1)[0] + '.x'
 
# 보고 싶은 경로 — 정확히 이 경로로 들어온 첫 요청을 고른다
WANT = ['/.env', '/.env.production', '/api/.env', '/.git/config', '/.git/HEAD',
        '/.aws/credentials', '/.ssh/id_rsa', '/.vscode/sftp.json', '/backup.sql']
picked = {}
for fn in sorted(glob.glob('/var/log/nginx/zino.access.log*')):
    op = gzip.open if fn.endswith('.gz') else open
    for ln in op(fn, 'rt', errors='replace'):
        m = LINE.match(ln)
        if not m or MINE_IP.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        path = m.group('uri').split('?', 1)[0]
        if path in WANT and path not in picked and m.group('st') == '403':
            picked[path] = m
    if len(picked) == len(WANT):
        break
 
for w in WANT:
    m = picked.get(w)
    if not m:
        continue
    ua = m.group('ua')
    ua = (ua[:44] + '…') if len(ua) > 45 else ua
    print(f'{mask(m.group("ip")):<17} [{m.group("t")[:11]}] {m.group("m")} {w:<20} {m.group("st")}')
    print(f'    └ UA: {ua}')
python3 secrets_samples.py
secrets_samples.py 실행 결과 — .env, .env.production, api/.env, .git/config, .git/HEAD, .aws/credentials, .ssh/id_rsa, .vscode/sftp.json, backup.sql 요청 원문과 User-Agent, 전부 403
secrets_samples.py 실행 결과 — .env, .env.production, api/.env, .git/config, .git/HEAD, .aws/credentials, .ssh/id_rsa, .vscode/sftp.json, backup.sql 요청 원문과 User-Agent, 전부 403

전형적인 비밀 수집 봇이다. 대부분 평범한 브라우저 UA 로 위장하는데, .git/HEAD 는 curl/8.5.0, .ssh/id_rsa 는 Go-http-client/1.1 처럼 스캐너 UA 를 그대로 달고 온다. 한 IP(207.175.202.x)가 .env.production·/api/.env·.aws/credentials·backup.sql 을 같은 날 연달아 찌른 게 보인다 — 한 봇이 비밀 파일 목록을 통째로 훑고 있다는 뜻이고, 그 패턴은 §체크리스트에서 따로 본다.


노린 것 — 파일 하나가 내주는 것

이 요청들이 성공했다면 공격자가 뭘 얻었을지는 파일마다 다르다.

  • .env — 앱이 쓰는 환경변수 파일. DB 접속정보·API 키·세션 시크릿·SMTP 비번이 평문으로 한 파일에 들어 있다. 그래서 봇이 제일 많이 찌른다(1만3천 건).
  • .aws/credentials·.ssh/id_rsa — 클라우드 액세스 키와 개인 SSH 키. 서버 한 대가 아니라 계정 전체·인프라로 번진다.
  • .vscode/sftp.json — 에디터가 배포 편의로 저장한 FTP/SFTP 호스트·아이디·비번. 개발자 편의가 그대로 자격증명 유출 통로가 된다.
  • 백업 파일(.sql·.bak·.old·.swp) — 배포에서 지웠어야 할 DB 덤프·소스 백업·편집 중 스왑 파일. 경로만 알면 열린다.

이건 MITRE ATT&CK 가 T1552.001 (Credentials In Files) 로 분류하는 전형적 기법이다. 파일 시스템과 원격 공유에서 설정 파일·자격증명 파일에 무심코 저장된 비밀을 긁는 행위다.

MITRE ATT&CK T1552.001 — Unsecured Credentials: Credentials In Files. 공격자가 로컬 파일 시스템과 원격 공유에서 설정 파일·자격증명 파일에 저장된 비밀을 찾아 긁는 기법
MITRE ATT&CK T1552.001 — Unsecured Credentials: Credentials In Files. 공격자가 로컬 파일 시스템과 원격 공유에서 설정 파일·자격증명 파일에 저장된 비밀을 찾아 긁는 기법

Source: MITRE ATT&CK — T1552.001 Credentials In Files

.git 은 조금 다르다. 그건 파일 하나가 아니라 저장소 전체를 내주기 때문에, 섹션을 따로 뺀다. 먼저 .env 부터.


.env 하나를 두고 벌이는 추측 게임

.env 요청이 왜 1만3천 건이나 될까. 봇은 "이 서버 어딘가에 .env 가 있을 텐데, 어떤 이름으로 어느 폴더에 두었을까"를 사전처럼 찍어 본다. 그래서 .env 하나를 두고 이름 변형과 폴더 조합이 폭발한다.

.env 요청을 두 갈래로 쪼갰다 — 뒤에 붙인 이름(.env.production)과 앞에 붙인 폴더(/api/.env).

# env_variants.py — .env 요청을 두 갈래로 쪼갠다.
#  ① 파일 이름 변형: .env 뒤에 무엇을 붙였나 (.env.production, .env.bak …)
#  ② 놓인 폴더: .env 앞에 어떤 디렉터리를 붙였나 (/api/.env, /backend/.env …)
# 공격자가 "개발자가 어디에 무슨 이름으로 두었을까"를 어떻게 추측하는지가 보인다.
import re, gzip, glob
from collections import Counter
 
ENV = re.compile(r'^(?P<dir>(/[^/]+)*)/\.env(?P<suf>[./][^/]*)?$')
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[[^\]]+\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" '
                  r'\d{3} \d+ "[^"]*" "(?P<ua>[^"]*)"')
MINE = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
suf = Counter(); dirs = Counter(); total = 0
for fn in glob.glob('/var/log/nginx/zino.access.log*'):
    op = gzip.open if fn.endswith('.gz') else open
    for ln in op(fn, 'rt', errors='replace'):
        m = LINE.match(ln)
        if not m or MINE.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        e = ENV.match(m.group('uri').split('?', 1)[0].lower())
        if not e:
            continue
        total += 1
        suf['.env' + (e.group('suf') or '')] += 1
        dirs[(e.group('dir') or '') + '/'] += 1
 
print(f".env 로 끝나거나 .env.* 인 요청 {total:,} 건 · 이름 변형 {len(suf):,} 종 · 폴더 {len(dirs):,} 종")
print()
L, R = suf.most_common(12), dirs.most_common(12)
print("  이름 변형 TOP 12" + " " * 14 + "놓인 폴더 TOP 12")
for (s, a), (d, b) in zip(L, R):
    print(f"  {a:>5,}  {s:<20}  {b:>5,}  {d[:30]}")
python3 env_variants.py
env_variants.py 실행 결과 — .env 요청 1만3천 건이 464가지 이름 변형과 575가지 폴더로 흩어진다. .env.local·.env.production·.env.bak 이 상위, 폴더는 app·api·backend·config 순
env_variants.py 실행 결과 — .env 요청 1만3천 건이 464가지 이름 변형과 575가지 폴더로 흩어진다. .env.local·.env.production·.env.bak 이 상위, 폴더는 app·api·backend·config 순

.env 하나에 464가지 이름 변형과 575가지 폴더가 붙었다. .env.local·.env.production·.env.bak·.env.backup·.env.staging·.env.development… 개발자가 쓸 법한 모든 접미사를 사전으로 돌린다. 폴더도 /app·/api·/backend·/config·/laravel·/frontend 처럼 흔한 디렉터리 구조를 전부 시도한다.

여기서 룰 설계의 힌트가 나온다. 이 많은 변형을 일일이 나열할 수는 없다. 그래서 룰은 ".env 로 시작하는 접근"이라는 모양 하나로 전부 잡는다 — .env 든 .env.bak 든 /app/.env 든, ([./]|$) 경계 하나로 묶인다.



.git 은 파일이 아니라 저장소다

.git/config 한 줄이 왜 위험한지는 .env 와 결이 다르다. .env 는 그 파일만 털리지만, .git 이 노출되면 저장소 전체가 복원된다 — 지운 줄까지 커밋 기록에 남아 있으니, 소스와 과거 비밀이 통째로 넘어간다.

.git/config 한 줄이 위험한 이유 — HEAD 로 존재 확인, git-dumper 로 저장소를 통째로 당기기, git checkout 으로 소스 복원, 소스와 커밋에서 하드코딩된 키·비번을 수확하는 4단계
.git/config 한 줄이 위험한 이유 — HEAD 로 존재 확인, git-dumper 로 저장소를 통째로 당기기, git checkout 으로 소스 복원, 소스와 커밋에서 하드코딩된 키·비번을 수확하는 4단계

이 1→4 과정을 명령 한 줄로 자동화하는 공개 도구가 git-dumper 다(GitHub 2.7k 스타). 디렉터리 리스팅이 꺼져 있어도 .git/config·.git/HEAD 가 열리면, objects 와 refs 를 한 파일씩 긁어 로컬에 저장소를 재구성한다.

git-dumper GitHub 저장소 — "A tool to dump a git repository from a website" 소개와 2.7k 스타, MIT 라이선스. 노출된 .git 에서 저장소 전체를 복원하는 공개 도구
git-dumper GitHub 저장소 — "A tool to dump a git repository from a website" 소개와 2.7k 스타, MIT 라이선스. 노출된 .git 에서 저장소 전체를 복원하는 공개 도구

Source: GitHub — arthaud/git-dumper

그래서 봇이 .git 을 어떻게 훑는지 보면, .git/config 하나만 찍는 게 아니라 저장소 내부 구조를 통째로 노린다. .git/ 뒤에 무엇을 붙였는지 세어 봤다.

# git_paths.py — .git 요청을 '.git/ 뒤에 무엇을 붙였나'로 나눠 센다.
# config·HEAD 한 번 찔러보는 정찰인지, 저장소 내부 구조(index·refs·logs·objects)까지 훑는지 본다.
import re, gzip, glob
from collections import Counter
 
GIT = re.compile(r'(^|/)\.git(?P<rest>/.*)?$', re.I)   # 판정은 대소문자 무시(룰의 lowercase), 표시는 원문 그대로
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[[^\]]+\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" '
                  r'\d{3} \d+ "[^"]*" "(?P<ua>[^"]*)"')
MINE = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
sub = Counter(); ips = {}; total = 0
for fn in glob.glob('/var/log/nginx/zino.access.log*'):
    op = gzip.open if fn.endswith('.gz') else open
    for ln in op(fn, 'rt', errors='replace'):
        m = LINE.match(ln)
        if not m or MINE.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        g = GIT.search(m.group('uri').split('?', 1)[0])
        if not g:
            continue
        total += 1
        rest = (g.group('rest') or '/').lstrip('/')
        # objects/ab/cdef… 처럼 해시가 붙는 건 한 묶음으로
        key = re.sub(r'^objects/.*', 'objects/…', rest, flags=re.I) or '(디렉터리 자체)'
        key = re.sub(r'^refs/heads/.*', 'refs/heads/…', key, flags=re.I)
        sub[key] += 1
        ips.setdefault(key, set()).add(m.group('ip'))
 
print(f".git 요청 {total:,} 건 — .git/ 뒤에 붙인 경로별")
print("    건수    IP  경로")
for k, n in sub.most_common(14):
    print(f"  {n:>6,} {len(ips[k]):>5}  .git/{k if k != '(디렉터리 자체)' else ''}"
          + ('   (디렉터리 자체)' if k == '(디렉터리 자체)' else ''))
python3 git_paths.py
git_paths.py 실행 결과 — .git 요청 3천 건 중 config 이 1,759건으로 1위, 그 뒤로 HEAD·refs/heads·logs/HEAD·index·packed-refs·COMMIT_EDITMSG 까지 저장소 내부 구조를 훑는다
git_paths.py 실행 결과 — .git 요청 3천 건 중 config 이 1,759건으로 1위, 그 뒤로 HEAD·refs/heads·logs/HEAD·index·packed-refs·COMMIT_EDITMSG 까지 저장소 내부 구조를 훑는다

.git/config 이 1,759건으로 압도적이지만, 그 아래가 중요하다. HEAD·refs/heads/·logs/HEAD·index·packed-refs·COMMIT_EDITMSG — 이건 git-dumper 가 저장소를 재구성할 때 순서대로 받는 파일들이다. config 만 찍는 건 존재 확인이고, 그 뒤가 따라오면 복원을 시도하는 것이다. 그래서 룰은 .git/config 한 경로가 아니라 .git 으로 시작하는 접근 자체를 1번 단계(존재 확인)에서 끊는다.


체크리스트처럼 훑는다

지금까지 "한 봇이 목록을 통째로 훑는다"고 몇 번 말했다. 그걸 실제 로그로 보여 준다. IP 별로 서로 다른 비밀 파일 경로를 몇 개나 시도했는지 세고, 1위 IP 의 요청을 시간순으로 펼친다.

# secrets_checklist.py — 한 IP 가 비밀 파일 경로를 '목록 순서대로' 훑는 패턴을 찾는다.
# IP 별로 요청 수·서로 다른 경로 수·걸린 시간을 세고, 1위 IP 의 요청을 시간순으로 앞에서부터 보여준다.
import re, gzip, glob
from collections import defaultdict
from datetime import datetime
 
RULE = re.compile(r'((^|/)\.(git|svn|hg|aws|ssh|env|htpasswd|htaccess|vscode|idea)([./]|$)'
                  r'|\.(sql|bak|backup|old|swp)($|[?#]))')
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[(?P<t>[^\]]+)\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" '
                  r'(?P<st>\d{3}) \d+ "[^"]*" "(?P<ua>[^"]*)"')
MINE = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
def mask(ip):
    return ip.rsplit(':', 1)[0] + ':x' if ':' in ip else ip.rsplit('.', 1)[0] + '.x'
 
reqs = defaultdict(list)       # ip → [(시각, 경로, 상태, UA)]
for fn in glob.glob('/var/log/nginx/zino.access.log*'):
    op = gzip.open if fn.endswith('.gz') else open
    for ln in op(fn, 'rt', errors='replace'):
        m = LINE.match(ln)
        if not m or MINE.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        p = m.group('uri').split('?', 1)[0]
        if RULE.search(p.lower()):
            ts = datetime.strptime(m.group('t'), '%d/%b/%Y:%H:%M:%S %z')
            reqs[m.group('ip')].append((ts, p, m.group('st'), m.group('ua')))
 
rank = sorted(reqs, key=lambda ip: -len({r[1] for r in reqs[ip]}))
print(f"{'IP':<17}{'요청':>6}{'고유경로':>9}  {'걸린 시간':<10} UA")
for ip in rank[:5]:
    rs = sorted(reqs[ip]); span = rs[-1][0] - rs[0][0]
    ua = rs[0][3][:26]
    print(f"{mask(ip):<17}{len(rs):>6,}{len({r[1] for r in rs}):>9,}  {str(span):<10} {ua}")
 
top = sorted(reqs[rank[0]])
t0 = top[0][0]
print()
print(f"1위 {mask(rank[0])} — {t0:%Y-%m-%d %H:%M:%S} 부터 요청 순서 (앞 16건):")
for ts, p, st, _ in top[:16]:
    print(f"  +{int((ts - t0).total_seconds()):>3}s  {st}  {p[:52]}")
python3 secrets_checklist.py
secrets_checklist.py 실행 결과 — 한 IP 가 357개의 서로 다른 비밀 파일 경로를 시도했고, 다른 IP 는 324개 경로를 7초 만에 훑었다. 1위 IP 는 .env.backup·.env.bak·.env.bkp 처럼 알파벳순 사전으로 찍는다
secrets_checklist.py 실행 결과 — 한 IP 가 357개의 서로 다른 비밀 파일 경로를 시도했고, 다른 IP 는 324개 경로를 7초 만에 훑었다. 1위 IP 는 .env.backup·.env.bak·.env.bkp 처럼 알파벳순 사전으로 찍는다

1위 IP 는 357개의 서로 다른 비밀 파일 경로를 시도했다. 요청 순서를 펼치면 /.env.backup·/.env.bak·/.env.bkp·/.env.copy·/.env.deploy·/.env.dev·/.env.development… 알파벳순 사전을 그대로 쏟아붓는 게 보인다. 사람은 이렇게 안 친다. 2·3위의 WebSiphon/next-0.1 은 324개 경로를 7초 만에 훑었다 — 전형적인 사전 스캔이다.

이 행위는 MITRE ATT&CK 의 T1083 (File and Directory Discovery) 에 해당한다. 룰도 이걸 attack.T1083 으로 분류한다.

MITRE ATT&CK T1083 — File and Directory Discovery. 공격자가 파일·디렉터리를 열거해 후속 공격의 방향을 잡는 정찰 기법
MITRE ATT&CK T1083 — File and Directory Discovery. 공격자가 파일·디렉터리를 열거해 후속 공격의 방향을 잡는 정찰 기법

Source: MITRE ATT&CK — T1083 File and Directory Discovery

이걸 88일 전체로 펼치면 꾸준한 배경 소음에 가끔 폭주가 섞인다. 주 단위로 쌓아 봤다.

# secrets_timeline.py — no-server-secrets 매칭 요청을 주(週) 단위로 쌓아 본다.
# 주마다 전체 건수 막대 + 종류별(.env/.git/.aws/기타) 건수. 하루에 몰리는 '폭주 스캔'도 같이 찾는다.
import re, gzip, glob
from collections import Counter, defaultdict
from datetime import datetime, timedelta
 
RULE = re.compile(r'((^|/)\.(git|svn|hg|aws|ssh|env|htpasswd|htaccess|vscode|idea)([./]|$)'
                  r'|\.(sql|bak|backup|old|swp)($|[?#]))')
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[(?P<t>[^\]]+)\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" '
                  r'(?P<st>\d{3}) \d+ "[^"]*" "(?P<ua>[^"]*)"')
MINE = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
def kind(p):
    for k in ('env', 'git', 'aws'):
        if re.search(rf'(^|/)\.{k}([./]|$)', p):
            return k
    return 'etc'
 
week = defaultdict(Counter)   # 주 시작일(월요일) → 종류별 건수
day = Counter()
for fn in glob.glob('/var/log/nginx/zino.access.log*'):
    op = gzip.open if fn.endswith('.gz') else open
    for ln in op(fn, 'rt', errors='replace'):
        m = LINE.match(ln)
        if not m or MINE.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        p = m.group('uri').split('?', 1)[0].lower()
        if not RULE.search(p):
            continue
        d = datetime.strptime(m.group('t')[:11], '%d/%b/%Y').date()
        week[d - timedelta(days=d.weekday())][kind(p)] += 1
        day[d] += 1
 
mx = max(sum(c.values()) for c in week.values())
print(f"{'주 시작':<11}{'합계':>6}  {'.env':>5} {'.git':>5} {'.aws':>5} {'기타':>5}")
for w in sorted(week):
    c = week[w]; tot = sum(c.values())
    bar = '█' * max(1, round(tot / mx * 28))
    print(f"{w:%Y-%m-%d} {tot:>6,}  {c['env']:>5,} {c['git']:>5,} {c['aws']:>5,} {c['etc']:>5,}  {bar}")
print()
print("가장 많이 몰린 날 TOP 3:")
for d, n in day.most_common(3):
    print(f"  {d:%Y-%m-%d}  {n:,} 건")
python3 secrets_timeline.py
secrets_timeline.py 실행 결과 — 주별 비밀파일 요청 막대그래프. 매주 1천~2천 건이 꾸준하고, .env 가 대부분을 차지하며 특정 주에 .git 과 .aws 가 폭증하는 스캐너 캠페인이 섞인다
secrets_timeline.py 실행 결과 — 주별 비밀파일 요청 막대그래프. 매주 1천~2천 건이 꾸준하고, .env 가 대부분을 차지하며 특정 주에 .git 과 .aws 가 폭증하는 스캐너 캠페인이 섞인다

매주 1천~2천 건이 꾸준한 배경 소음이고, 거기에 캠페인이 얹힌다. 10/19 주는 .git 이 896건으로 튀고(git-dumper 류 캠페인), 10/26·11/2 주는 .aws 가 350건대로 몰린다. 가장 센 날은 10/21 하루에 977건이었다 — §오탐 검증에서 이 폭주가 다시 등장한다.



패킷으로 보기 — 공격자 자리에서

로그의 숫자를 패킷으로 확인한다. 로그에 남은 비밀 파일 요청을 내 통제 하의 Kali VM 에서 똑같이 재현해, 공격자 자리에서 요청이 나가고 403 이 돌아오는 걸 Wireshark 로 본다. Kali 는 테일스케일 대역(100.64.0.0/10)이라 CrowdSec 화이트리스트에 들어 ban 은 안 되지만, WAF 403 은 그대로 난다. 재현 요청엔 식별용으로 UA zinosec-lab/1.0 을 달았다.

먼저 커맨드라인에서 네 경로를 쏴 본다.

# kali_probe_secrets.sh — 공격자 자리(Kali)에서 로그에 남은 비밀파일 공격을 재현한다.
# 테일스케일 경로로 zino.kr(100.84.130.6)에 직접. UA 로 재현 요청임을 표시.
ssh kali 'for p in \
    "/.env" \
    "/.git/config" \
    "/.aws/credentials" \
    "/.vscode/sftp.json"; do
  curl -s -o /dev/null -w "  %{http_code}  http/%{http_version}  $p\n" --http2 \
       --resolve zino.kr:443:100.84.130.6 -A "zinosec-lab/1.0" "https://zino.kr$p"
done'
bash kali_probe_secrets.sh
kali_probe_secrets.sh 실행 결과 — Kali 에서 테일스케일 경로로 .env·.git/config·.aws/credentials·.vscode/sftp.json 네 가지를 재현한 결과, 전부 HTTP/2 403
kali_probe_secrets.sh 실행 결과 — Kali 에서 테일스케일 경로로 .env·.git/config·.aws/credentials·.vscode/sftp.json 네 가지를 재현한 결과, 전부 HTTP/2 403

넷 다 403. 이제 이 요청들을 패킷으로 뜬다. TLS 라 그냥 뜨면 암호문이니, SSLKEYLOGFILE 로 세션 키를 저장하면서 tcpdump 로 캡처한다.

# Kali 에서 — 캡처와 동시에 재현
sudo tcpdump -i tailscale0 -w ~/zinosec/02.pcapng 'host 100.84.130.6 and port 443' &
export SSLKEYLOGFILE=$HOME/zinosec/keys.log
for p in /.env /.git/config /.aws/credentials /.vscode/sftp.json; do
  curl -s -o /dev/null --http2 --resolve zino.kr:443:100.84.130.6 -A 'zinosec-lab/1.0' "https://zino.kr$p"
done

캡처한 pcap 을 키로그와 함께 Wireshark 로 열면 HTTP/2 가 복호되어 요청 줄과 응답이 보인다. .env·.git·.aws·.vscode 를 담은 헤더와 403 응답만 디스플레이 필터로 남겼다.

wireshark -r ~/zinosec/02.pcapng -o tls.keylog_file:$HOME/zinosec/keys.log \
  -Y 'http2.header.value contains ".env" or http2.header.value contains ".git" or http2.header.value contains ".aws" or http2.header.value contains ".vscode" or http2.headers.status==403'
Kali 의 Wireshark — HTTP/2 복호 화면. path 에 .env, .git/config, .aws/credentials, .vscode/sftp.json 네 요청이 보이고 각각 403 Forbidden 이 돌아온다. 아래 Decrypted TLS 탭이 복호 증거다
Kali 의 Wireshark — HTTP/2 복호 화면. path 에 .env, .git/config, .aws/credentials, .vscode/sftp.json 네 요청이 보이고 각각 403 Forbidden 이 돌아온다. 아래 Decrypted TLS 탭이 복호 증거다

패킷 목록의 Info 열에 GET /.env, GET /.git/config, GET /.aws/credentials, GET /.vscode/sftp.json 이 그대로 찍히고, 그 사이사이 403 Forbidden 응답이 보인다. 아래 "Decrypted TLS" 탭은 TLS 가 실제로 복호됐다는 증거다. 같은 pcap 을 터미널에서 tshark 로 읽으면 HTTP/2 헤더가 요청·응답 쌍으로 떨어진다.

# kali_tshark_secrets.sh — Kali 가 뜬 pcap 을 원격으로 읽어 HTTP/2 요청/응답 헤더를 뽑는다.
# keys.log(TLS 세션 키)로 복호한다. :path(비밀 파일 경로)와 :status(403)가 한 쌍으로 보인다.
ssh kali 'cd ~/zinosec && tshark -r 02.pcapng -o tls.keylog_file:keys.log \
  -Y "http2.header or http2.data.data" \
  -T fields -e http2.header.name -e http2.header.value' 2>/dev/null \
  | grep -iE ":path|:status"
bash kali_tshark_secrets.sh
kali_tshark_secrets.sh 실행 결과 — tshark 로 추출한 HTTP/2 헤더. 요청 줄에 path 로 네 비밀 파일 경로, 응답 줄에 status 403 과 server nginx 가 한 쌍씩 떨어진다
kali_tshark_secrets.sh 실행 결과 — tshark 로 추출한 HTTP/2 헤더. 요청 줄에 path 로 네 비밀 파일 경로, 응답 줄에 status 403 과 server nginx 가 한 쌍씩 떨어진다

요청 줄엔 :path 에 비밀 파일 경로가, 응답 줄엔 :status 에 403·server 에 nginx 가 담긴다. 공격자가 보낸 것과 서버가 돌려준 것이 한 쌍으로 대응된다.


서버 안에서 본 WAF 판정

공격자 자리에서는 "403 을 받았다"까지만 보인다. 그 403 이 어떻게 났는지는 서버 안에서 봐야 한다. nginx 바운서는 들어온 요청을 내부 AppSec 엔진(127.0.0.1:7422)에 넘기고, 엔진의 판정을 받아 403 을 반환한다. 재현하는 몇 초 동안만 루프백(lo)을 떠서 그 내부 구간을 들여다봤다.

이 구간에는 x-crowdsec-appsec-api-key(비밀)가 실린다. 그래서 출력 직전에 <redacted> 로 치환하고, 클라이언트 IP 끝자리도 가린다. 루프백엔 헬스체크 스트림도 섞이므로, .git/config 요청이 든 TCP 스트림만 골라낸다.

# 미니PC 에서 — 재현하는 몇 초만 lo:7422 를 캡처
sudo tcpdump -i lo -w /tmp/z2_lo.pcap 'tcp port 7422'
# (이 창이 도는 동안 .git/config 등을 재현)
# wire_secrets.sh — lo.pcap 을 tshark 로 읽어 nginx→AppSec 요청과 판정을 보여준다.
# ⚠️ x-crowdsec-appsec-api-key(비밀)는 <redacted>, 클라이언트 IP 끝자리는 .x 로 가린다.
PCAP="${1:?pcap 경로 필요}"
TMP="/tmp/.wire.$$.pcap"; cp "$PCAP" "$TMP"; trap 'rm -f "$TMP"' EXIT   # tshark 는 /tmp 만 읽는다(AppArmor)
 
redact() { sed -E 's/(appsec-api-key:).*/\1 <redacted>/I; s/(appsec-ip: [0-9]+\.[0-9]+\.[0-9]+)\.[0-9]+/\1.x/I'; }
 
# .git/config 를 담은 AppSec 요청이 들어 있는 TCP 스트림을 찾는다(루프백엔 헬스체크 스트림도 섞여 있다).
STREAM=$(tshark -r "$TMP" -Y 'http.request' -T fields -e tcp.stream -e http.request.line 2>/dev/null \
         | grep -i 'appsec-uri: /\.git' | head -1 | cut -f1)
 
echo "▶ nginx 가 AppSec(:7422) 에 넘긴 요청 메타데이터 (.git/config 재현, stream $STREAM)"
tshark -r "$TMP" -Y "http.request and tcp.stream==$STREAM" -T fields -e http.request.line 2>/dev/null \
  | grep -i '\.git/config' | head -1 | tr ',' '\n' \
  | grep -i 'x-crowdsec-appsec' | sed 's/\\r\\n//' | redact | sed 's/^/    /'
 
echo
echo "▶ AppSec 의 판정 (같은 스트림의 응답)"
code=$(tshark -r "$TMP" -Y "http.response and tcp.stream==$STREAM" -T fields -e http.response.code 2>/dev/null | head -1)
echo "    HTTP $code  (zinosec/no-server-secrets 매치 → 차단)"
echo "    → nginx 가 이 판정을 받아 클라이언트에 403 을 돌려준다 (Next.js 는 호출되지 않음)"
bash wire_secrets.sh /tmp/z2_lo.pcap
wire_secrets.sh 실행 결과 — nginx 가 AppSec 에 넘긴 x-crowdsec-appsec-uri 에 .git/config 가 담기고, api-key 는 가려지고, AppSec 응답은 403. nginx 는 이 판정을 받아 클라이언트에 403 을 돌려준다
wire_secrets.sh 실행 결과 — nginx 가 AppSec 에 넘긴 x-crowdsec-appsec-uri 에 .git/config 가 담기고, api-key 는 가려지고, AppSec 응답은 403. nginx 는 이 판정을 받아 클라이언트에 403 을 돌려준다

nginx 는 원 요청의 메타데이터(메서드·호스트·URI·UA)를 헤더로 포장해 AppSec 에 넘긴다. AppSec 은 x-crowdsec-appsec-uri 의 /.git/config 를 룰에 대보고 매치시켜 403 을 돌려준다. Next.js 는 이 요청을 받은 적이 없다 — 판정은 전부 nginx↔AppSec 사이에서 끝난다. (캡처가 끝나면 비밀이 담긴 pcap 은 즉시 지웠다.)



룰 설계 — 두 갈래 정규식

이제 룰이 왜 그렇게 생겼는지. 1편의 .php 룰은 한 덩어리였지만, 이 룰은 |(OR)로 두 갈래가 묶여 있다.

정규식 해부 — 갈래 A 는 점으로 시작하는 숨김 디렉터리 이름(git·svn·hg·aws·ssh·env·htpasswd·htaccess·vscode·idea), 갈래 B 는 백업 확장자(sql·bak·backup·old·swp). 경계 조각이 오탐을 막는다
정규식 해부 — 갈래 A 는 점으로 시작하는 숨김 디렉터리 이름(git·svn·hg·aws·ssh·env·htpasswd·htaccess·vscode·idea), 갈래 B 는 백업 확장자(sql·bak·backup·old·swp). 경계 조각이 오탐을 막는다
  • 갈래 A — (^|/)\.(git|svn|hg|aws|ssh|env|htpasswd|htaccess|vscode|idea)([./]|$)
    • (^|/)\. — 경로 맨 앞이거나 슬래시 뒤에 오는 점. /app/.env 처럼 하위 폴더 안에 있어도 잡는다.
    • 가운데 목록 — 막을 이름들. 내 로그에 실제로 들어온 것만 넣었다.
    • ([./]|$) — 바로 뒤가 점·슬래시거나 끝. .git/config 도 .env.bak 도 잡되, .environment·.gitignore 같은 엉뚱한 이름은 비껴간다.
  • 갈래 B — \.(sql|bak|backup|old|swp)($|[?#])
    • 이름이 아니라 확장자로 잡는다. db.sql·x.bak·config.old·편집 중 .swp.
    • ($|[?#]) — 확장자가 경로 끝일 때만. 쿼리·앵커 앞에서 끊는다.
  • transform: lowercase — 경로를 소문자로 내린 뒤 매칭. .ENV·.Git 같은 대소문자 우회를 무력화한다.

두 경계 조각(([./]|$)·($|[?#]))이 오탐을 막는 핵심이다. .env 하나로 464가지 변형을 잡으면서도, 이름에 env·git 이 든 멀쩡한 경로는 건드리지 않는 게 이 경계 덕분이다. 정말 그런지는 §오탐 검증에서 실측한다.


심층 방어 — WAF 가 깜빡여도

여기서 한 가지 짚고 갈 게 있다. 이 룰은 방어의 한 겹일 뿐이고, 설령 WAF 가 없어도 이 서버는 이 파일들을 내주지 않는다. 그걸 직접 확인한다. nginx·AppSec 을 건너뛰고 Next.js(127.0.0.1:2000)에 같은 경로를 직접 보내 본다.

# next_direct.sh — WAF 를 빼고 Next.js(127.0.0.1:2000)에 같은 경로를 직접 보낸다.
# nginx·AppSec 을 거치지 않으니 룰이 없는 상태와 같다. 본문은 버리고 상태코드만 본다.
UA='zinosec-lab/1.0 (direct)'
direct() { curl -s -o /dev/null -w '%{http_code}' -H 'Host: zino.kr' -A "$UA" "http://127.0.0.1:2000$1"; }
waf()    { curl -s -o /dev/null -w '%{http_code}' --resolve zino.kr:443:100.84.130.6 -A "$UA" "https://zino.kr$1"; }
 
echo "  경로                     Next.js 직접   nginx+WAF"
for p in "/.env" "/.env.production" "/api/.env" "/.git/config" "/.git/HEAD" \
         "/.aws/credentials" "/.ssh/id_rsa" "/.vscode/sftp.json" "/backup.sql"; do
  printf "  %-24s %-14s %s\n" "$p" "$(direct "$p")" "$(waf "$p")"
done
bash next_direct.sh
next_direct.sh 실행 결과 — 같은 비밀 파일 경로가 Next.js 직접 요청에서는 전부 404, nginx+WAF 경로에서는 전부 403. WAF 가 없어도 Next.js 에 그 파일이 없어 404 가 난다
next_direct.sh 실행 결과 — 같은 비밀 파일 경로가 Next.js 직접 요청에서는 전부 404, nginx+WAF 경로에서는 전부 403. WAF 가 없어도 Next.js 에 그 파일이 없어 404 가 난다

WAF 경로는 403, Next.js 직접은 전부 404 다. 즉 WAF 가 깜빡여서 요청이 앱까지 가도 그 파일이 없어 404 다. WAF 는 "존재하지 않는 걸 403 으로 빨리 끊는" 역할이지, 유일한 방어선이 아니다.

한 가지 더. nginx 는 location /images/ 같은 규칙으로 일부 디렉터리를 Next.js 없이 직접 서빙한다(1편 끝의 함정이 그거였다). 그 디렉터리들에 점으로 시작하는 파일이나 백업 파일이 섞여 있으면 경로만 알면 열린다. 그래서 설정에서 직접 서빙 디렉터리를 뽑아 개수만 확인한다 — 파일 내용은 열지 않는다.

# served_dirs_check.sh — nginx 가 Next.js 를 거치지 않고 직접 내주는 디렉터리(alias/root)를 설정에서 뽑아,
# 그 안에 점(.)으로 시작하는 파일·백업 확장자 파일이 있는지 '개수만' 센다. 파일 내용은 열지 않는다.
CONF=/etc/nginx/sites-enabled/zino
sudo grep -oP '^\s*(alias|root)\s+\K[^;]+' "$CONF" | sort -u | while read -r d; do
  dot=$(find "$d" -name '.*' -not -name '.' 2>/dev/null | wc -l)
  bak=$(find "$d" -type f \( -iname '*.sql' -o -iname '*.bak' -o -iname '*.backup' \
        -o -iname '*.old' -o -iname '*.swp' \) 2>/dev/null | wc -l)
  printf "  점파일 %3s  백업파일 %3s  %s\n" "$dot" "$bak" "${d/#\/home\/jinho/\~}"
done
bash served_dirs_check.sh
served_dirs_check.sh 실행 결과 — nginx 가 직접 서빙하는 모든 alias·root 디렉터리에서 점으로 시작하는 파일 0개, 백업 확장자 파일 0개. 직접 서빙 경로에 노출될 비밀 파일이 없다
served_dirs_check.sh 실행 결과 — nginx 가 직접 서빙하는 모든 alias·root 디렉터리에서 점으로 시작하는 파일 0개, 백업 확장자 파일 0개. 직접 서빙 경로에 노출될 비밀 파일이 없다

전부 0 이다. 직접 서빙 디렉터리 어디에도 점 파일·백업 파일이 없다. WAF 룰은 "공격 요청을 싸게 끊는" 겹이고, 그 뒤에 "애초에 내줄 파일이 없다"는 더 단단한 겹이 받친다.


오탐 검증 — 정상은 통과, .well-known 은 산다

설계가 맞는지는 살아있는 서버에 직접 쏴서 확인한다. 정상 경로는 403 이 아니어야 하고, 비밀 파일 경로는 403 이어야 한다. 특히 .well-known/ 은 막히면 안 된다 — ACME 인증서 발급과 보안 정책이 거기로 다닌다.

# fp_check_secrets.sh — 오탐 검증. 정상 경로는 403 이 아니어야 하고, 비밀 파일 경로는 403 이어야 한다.
# 테일스케일 IP(100.84.130.6)로 실제 nginx→WAF 경로를 그대로 탄다. 본문은 버리고 상태코드만 본다.
UA='zinosec-lab/1.0 (fp-check)'
probe() { curl -s -o /dev/null -w '%{http_code}' --path-as-is \
            --resolve zino.kr:443:100.84.130.6 -A "$UA" "https://zino.kr$1"; }
 
echo "── 정상 경로 (403 이면 안 된다) ──"
for p in "/" "/blog" "/research" "/blog/development-env" \
         "/blog/dreamhack-sane-env-writeup" "/.well-known/acme-challenge/x" "/api/posts?tag=git"; do
  printf "  %-38s %s\n" "$p" "$(probe "$p")"
done
 
echo "── 비밀 파일 경로 (403 이어야 한다) ──"
for p in "/.env" "/.git/config" "/.aws/credentials" "/.ssh/id_rsa" \
         "/.vscode/sftp.json" "/backup.sql" "/.ENV" "/app/.env.bak"; do
  printf "  %-38s %s\n" "$p" "$(probe "$p")"
done
bash fp_check_secrets.sh
fp_check_secrets.sh 실행 결과 — 정상 경로 7개는 200 또는 404(403 아님), .well-known 도 404 로 살아 있다. 비밀 파일 경로 8개는 대문자 우회까지 전부 403
fp_check_secrets.sh 실행 결과 — 정상 경로 7개는 200 또는 404(403 아님), .well-known 도 404 로 살아 있다. 비밀 파일 경로 8개는 대문자 우회까지 전부 403

정상 경로는 전부 200(또는 존재하지 않는 API 는 404 — 어쨌든 403 이 아니다). 중요한 건 /.well-known/acme-challenge/x 가 404(403 아님)라는 것이다. .well-known 은 이름이 점으로 시작하지만 룰의 목록(git·env·ssh…)에 well-known 이 없으니 비껴간다 — 인증서 발급이 안 끊긴다. 반대로 비밀 파일 경로는 대문자 우회(.ENV)와 폴더+변형(/app/.env.bak)까지 전부 403.

이건 "지금 이 순간"의 실측이다. 더 센 증거는 88일 로그 전체다. 룰에 걸린 요청 중 성공 응답(200/304)이 한 건이라도 있었으면, 정상 콘텐츠를 막은 것이다.

# fp_in_logs_secrets.py — "오탐이 정말 0인가"를 로그 전체에서 확인한다.
# no-server-secrets 정규식에 걸린 요청 중 성공 응답(200/304)이 한 건이라도 있었는지 센다.
# 하나라도 있으면 정상 콘텐츠를 막았다는 뜻 → 반드시 0 이어야 한다.
import re, gzip, glob
from collections import Counter
 
RULE = re.compile(r'((^|/)\.(git|svn|hg|aws|ssh|env|htpasswd|htaccess|vscode|idea)([./]|$)'
                  r'|\.(sql|bak|backup|old|swp)($|[?#]))')
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[[^\]]+\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" '
                  r'(?P<st>\d{3}) \d+ "[^"]*" "(?P<ua>[^"]*)"')
MINE = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
st = Counter(); served = []
for fn in glob.glob('/var/log/nginx/zino.access.log*'):
    op = gzip.open if fn.endswith('.gz') else open
    for ln in op(fn, 'rt', errors='replace'):
        m = LINE.match(ln)
        if not m or MINE.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        if not RULE.search(m.group('uri').split('?', 1)[0].lower()):
            continue
        st[m.group('st')] += 1
        if m.group('st') in ('200', '304'):
            served.append(m.group('uri'))
 
total = sum(st.values())
print(f"룰에 걸린 비밀파일 요청 총 {total:,} 건의 최종 응답 코드:")
note = {'403': 'WAF 차단', '301': 'HTTP→HTTPS 업그레이드(:80, WAF 도달 전)',
        '404': 'AppSec passthrough → Next.js(해당 파일 없음)', '499': '클라이언트 연결 종료',
        '400': '잘못된 요청', '307': '리다이렉트', '408': '타임아웃'}
for code, n in sorted(st.items(), key=lambda x: -x[1]):
    print(f"  {code}  {n:>7,}   {note.get(code, '')}")
print()
print(f"★ 정상 응답(200/304) = {len(served)} 건")
print("  → 88일 동안 이 룰이 '진짜 콘텐츠'를 내보낸 적은 한 번도 없다. 오탐 0.")
python3 fp_in_logs_secrets.py
fp_in_logs_secrets.py 실행 결과 — 룰에 걸린 1만9천 건의 응답 분포. 403 과 301 이 대부분이고 404 가 637건, 정상 응답 200/304 는 0건
fp_in_logs_secrets.py 실행 결과 — 룰에 걸린 1만9천 건의 응답 분포. 403 과 301 이 대부분이고 404 가 637건, 정상 응답 200/304 는 0건

정상 응답 0건. 88일 동안 이 룰이 진짜 콘텐츠를 막은 적은 한 번도 없다. 애초에 이 서버에 .env·.git 이 없으니, 전부 막아도 잃을 게 없다.

여기서 404 가 637건 눈에 띈다. 룰을 통과한 게 아니다 — 그 정체를 다음 절에서 들여다본다.


404 는 룰 구멍이 아니다 — passthrough 를 들여다본다

403 이어야 할 요청이 404 로 찍힌 637건은 뭘까. CrowdSec 의 nginx 바운서는 AppSec 엔진이 그 순간 못 받으면(재시작·순간 과부하) 요청을 막지 않고 통과시키도록 설정돼 있다(APPSEC_FAILURE_ACTION=passthrough). 그렇게 샌 요청은 Next.js 까지 가는데, 거기에도 그 파일이 없어 404 가 난다. 이게 폭주 스캔과 겹치는지 보려고, 각 요청 순간 같은 IP 가 1초에 몇 건을 쏘고 있었는지로 나눠 센다.

# secrets_passthrough.py — 룰에 걸려야 할 요청이 403 이 아닌 응답(404·307)을 받은 경우를 들여다본다.
# 그 순간 같은 IP 가 1초에 몇 건을 쏘고 있었는지(폭주 정도)로 나눠 센다.
# 404/307 은 WAF 판정이 빠져 Next.js 까지 내려갔다는 뜻이다. 그때도 200/304 가 있었는지가 핵심.
import re, gzip, glob
from collections import Counter
 
RULE = re.compile(r'((^|/)\.(git|svn|hg|aws|ssh|env|htpasswd|htaccess|vscode|idea)([./]|$)'
                  r'|\.(sql|bak|backup|old|swp)($|[?#]))')
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[(?P<t>[^\]]+)\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" '
                  r'(?P<st>\d{3}) \d+ "[^"]*" "(?P<ua>[^"]*)"')
MINE = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
per_sec = Counter()     # (IP, 초) → 그 초에 그 IP 가 보낸 전체 요청 수
rows = []
for fn in glob.glob('/var/log/nginx/zino.access.log*'):
    op = gzip.open if fn.endswith('.gz') else open
    for ln in op(fn, 'rt', errors='replace'):
        m = LINE.match(ln)
        if not m or MINE.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        key = (m.group('ip'), m.group('t')[:20])
        per_sec[key] += 1
        if RULE.search(m.group('uri').split('?', 1)[0].lower()):
            rows.append((key, m.group('st')))
 
def bucket(n):
    return '1건' if n <= 1 else '2~4건' if n < 5 else '5~19건' if n < 20 else '20건+'
 
B = ['1건', '2~4건', '5~19건', '20건+']
tab = {st: Counter() for st in ('403', '404', '307')}
for key, st in rows:
    if st in tab:
        tab[st][bucket(per_sec[key])] += 1
 
print("같은 IP 가 그 1초에 보낸 요청 수별 응답 (no-server-secrets 매칭분)")
print(f"{'':>6}" + ''.join(f"{b:>9}" for b in B) + f"{'합계':>8}")
for st, c in tab.items():
    print(f"  {st}" + ''.join(f"{c[b]:>10,}" for b in B) + f"{sum(c.values()):>9,}")
print()
ok = sum(1 for _, st in rows if st in ('200', '304'))
print(f"WAF 를 지나 Next.js 까지 간 요청 중 200/304 = {ok} 건")
python3 secrets_passthrough.py
secrets_passthrough.py 실행 결과 — 404 응답 637건 중 474건이 초당 20건 이상 폭주하는 순간에 몰려 있다. 그렇게 샌 요청 중 200/304 는 0건
secrets_passthrough.py 실행 결과 — 404 응답 637건 중 474건이 초당 20건 이상 폭주하는 순간에 몰려 있다. 그렇게 샌 요청 중 200/304 는 0건

404 637건 중 474건이 초당 20건 이상 폭주하는 순간에 몰려 있다. 한 스캐너가 1초에 수십 건을 몰아칠 때 AppSec 이 잠깐 못 따라가 passthrough 된 것이다. 하지만 그렇게 샌 요청조차 200/304 는 0건 — 뒤에 내줄 파일이 없으니 404 로 끝난다. WAF 가 깜빡여도 심층 방어가 받친다는 걸 로그가 다시 보여 준다.



커뮤니티 룰과 무엇이 다른가

솔직히 말하면, CrowdSec 허브에도 .env 와 .git 을 막는 커뮤니티 룰이 있다(vpatch-env-access·vpatch-git-config). 그럼 내 커스텀 룰은 중복일까. 같은 로그에 세 룰을 다 돌려 겹치는 몫과 이 룰만 잡는 몫을 나눠 봤다.

# secrets_overlap.py — no-server-secrets 에 걸리는 요청 중, 허브 vpatch 룰과 겹치는 몫과 이 룰만 잡는 몫을 나눈다.
# vpatch 두 룰의 match 를 /etc/crowdsec/appsec-rules/ 에서 그대로 옮겼다 (둘 다 transform: lowercase, zones: URI).
#   crowdsecurity/vpatch-env-access : endsWith ".env"
#   crowdsecurity/vpatch-git-config : regex  /\.git/(config|head|index|refs|hooks|)$|/\.svn/(wc\.db|entries|format|)$|/\.hg/(hgrc|)$
import re, gzip, glob
from collections import Counter
 
ZINO = re.compile(r'((^|/)\.(git|svn|hg|aws|ssh|env|htpasswd|htaccess|vscode|idea)([./]|$)'
                  r'|\.(sql|bak|backup|old|swp)($|[?#]))')
VP_GIT = re.compile(r'/\.git/(config|head|index|refs|hooks|)$|/\.svn/(wc\.db|entries|format|)$|/\.hg/(hgrc|)$')
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[[^\]]+\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" '
                  r'\d{3} \d+ "[^"]*" "(?P<ua>[^"]*)"')
MINE = re.compile(r'^(100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|127\.|::1$|172\.30\.)')
MINE_UA = re.compile(r'zinosec-lab|waf-selftest', re.I)
 
who = Counter(); only = Counter()
for fn in glob.glob('/var/log/nginx/zino.access.log*'):
    op = gzip.open if fn.endswith('.gz') else open
    for ln in op(fn, 'rt', errors='replace'):
        m = LINE.match(ln)
        if not m or MINE.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        p = m.group('uri').split('?', 1)[0].lower()
        if not ZINO.search(p):
            continue
        if p.endswith('.env'):
            who['vpatch-env-access 와 겹침'] += 1
        elif VP_GIT.search(p):
            who['vpatch-git-config 와 겹침'] += 1
        else:
            who['no-server-secrets 만 잡음'] += 1
            only[p] += 1
 
total = sum(who.values())
print(f"no-server-secrets 정규식에 걸린 요청 {total:,} 건")
for k in ('vpatch-env-access 와 겹침', 'vpatch-git-config 와 겹침', 'no-server-secrets 만 잡음'):
    print(f"  {who[k]:>7,}  ({who[k]/total*100:4.1f}%)  {k}")
print()
print("이 룰만 잡는 요청 — 많이 들어온 경로 TOP 10:")
for p, n in only.most_common(10):
    print(f"  {n:>6,}  {p[:50]}")
python3 secrets_overlap.py
secrets_overlap.py 실행 결과 — 전체의 33.6%는 vpatch-env-access, 11.9%는 vpatch-git-config 와 겹치지만, 54.5%는 이 룰만 잡는다. .aws/credentials·.env.local·.env.production 처럼 변형과 다른 비밀 파일이 그 절반이다
secrets_overlap.py 실행 결과 — 전체의 33.6%는 vpatch-env-access, 11.9%는 vpatch-git-config 와 겹치지만, 54.5%는 이 룰만 잡는다. .aws/credentials·.env.local·.env.production 처럼 변형과 다른 비밀 파일이 그 절반이다

허브 룰과 겹치는 건 45.5%뿐이다. vpatch-env-access 는 정확히 .env 로 끝나는 것만 잡아서 .env.local·.env.production 같은 접미사 변형을 놓치고, vpatch-git-config 는 .git/config·.git/HEAD 같은 특정 파일만 잡는다. 나머지 54.5%는 이 룰만 잡는다 — .aws/credentials·.ssh/id_rsa·.vscode/sftp.json, 그리고 464가지 .env.* 변형 전부. 커뮤니티 룰은 "세상 모든 서버"를 가정해 보수적으로 좁게 잡지만, 내 서버는 이 경로가 전부 존재하지 않으니 더 넓게 막아도 된다. 중복이 아니라 넓힘이다.


앱엔 흔적이 없다 — 지금도 도는 룰

차단은 전부 nginx↔AppSec 사이에서 끝나므로, Next.js 애플리케이션 로그에는 이 요청들의 흔적이 없다. 앱은 자기가 무슨 공격을 받았는지도 모른다. "지금 이 룰이 살아서 도는가"는 메트릭으로 본다. 메트릭은 휘발성이라 11/17 새벽 허브 자동 업그레이드 재시작 이후 누적분이고, 내 재현 요청도 섞여 있어 절대값은 로그와 다르다 — 룰이 활발히 도는 것만 본다.

sudo cscli metrics show appsec | grep -E 'zino-waf|Rule ID|zinosec/|vpatch-env-access|vpatch-git-config'
cscli metrics 의 AppSec Rules Metrics — zinosec/no-server-secrets 가 커스텀 룰 7종과 vpatch 룰 사이에서 활발히 트리거되고 있다. 재시작 이후 짧은 창인데도 no-php-execution 다음으로 많이 걸린다
cscli metrics 의 AppSec Rules Metrics — zinosec/no-server-secrets 가 커스텀 룰 7종과 vpatch 룰 사이에서 활발히 트리거되고 있다. 재시작 이후 짧은 창인데도 no-php-execution 다음으로 많이 걸린다

재시작 이후 짧은 창인데도 no-server-secrets 가 no-php-execution 다음으로 많이 걸린다. 1편과 2편의 두 룰이 내 커스텀 룰 트래픽의 대부분을 차지한다 — 그래서 이 둘을 먼저 다룬다.


한계 — 이 룰이 못 막는 것

솔직하게. 이 룰은 만능이 아니다. 어디까지 잡고 어디서 놓치는지 살아있는 WAF 에 직접 쏴 본다. 요청마다 cscli 의 룰별 카운터를 앞뒤로 떠서, 403 을 어느 룰이 냈는지 이름으로 찍는다.

# limits_probe.sh — 이 룰이 어디까지 잡고 어디서 놓치는지 살아있는 WAF 에 직접 쏴 본다.
# 요청마다 cscli 의 AppSec 룰별 Triggered 카운터 표를 앞뒤로 떠서, 403 을 '어느 룰이' 냈는지 이름으로 찍는다.
# 응답 본문은 버리고 상태코드만 본다.
UA='zinosec-lab/1.0 (limits)'
snap() { sudo cscli metrics show appsec 2>/dev/null \
           | awk -F'|' '/Rules Metrics/{f=1} f && NF>=4 {gsub(/ /,"",$2); gsub(/ /,"",$3); if ($3 ~ /^[0-9]+$/) print $2, $3}'; }
probe() { curl -s -o /dev/null -w '%{http_code}' --path-as-is \
            --resolve zino.kr:443:100.84.130.6 -A "$UA" "https://zino.kr$1"; }
 
row() {
  local before after code fired
  before=$(snap); code=$(probe "$1"); sleep 1; after=$(snap)
  fired=$(comm -13 <(echo "$before" | sort) <(echo "$after" | sort) | awk '{print $1}' | tr '\n' ' ')
  printf "  %-22s %s  %s\n" "$1" "$code" "${fired:--}"
}
 
echo "── 우회 시도 (대소문자·인코딩·중복 슬래시) ──"
for p in "/.ENV.PRODUCTION" "//.aws/credentials" "/%2eaws/credentials" "/.%65nv.local" "/.git%2flogs/HEAD"; do row "$p"; done
echo "── 이 룰 목록에 없는 비밀 파일 이름 ──"
for p in "/.git-credentials" "/.env~" "/backup.sql.gz" "/config.json" \
         "/credentials.json" "/.npmrc" "/.docker/config.json" "/id_rsa"; do row "$p"; done
bash limits_probe.sh
limits_probe.sh 실행 결과 — 대소문자·단일 인코딩·중복 슬래시 우회는 전부 zinosec/no-server-secrets 가 403 으로 잡지만, config.json·credentials.json·.npmrc·id_rsa 처럼 다른 이름의 비밀 파일은 룰이 없어 404 로 통과한다
limits_probe.sh 실행 결과 — 대소문자·단일 인코딩·중복 슬래시 우회는 전부 zinosec/no-server-secrets 가 403 으로 잡지만, config.json·credentials.json·.npmrc·id_rsa 처럼 다른 이름의 비밀 파일은 룰이 없어 404 로 통과한다
  • 잡는다: 대소문자(.ENV.PRODUCTION), 중복 슬래시(//.aws/credentials), 단일 URL 인코딩(%2eaws → .aws, .%65nv → .env, .git%2flogs). nginx 가 한 번 디코드한 뒤 AppSec 이 보므로 이 정도 우회는 전부 no-server-secrets 가 403 으로 잡는다.
  • 못 잡는다: 다른 이름의 비밀 파일. config.json·credentials.json·.npmrc·.docker/config.json·id_rsa(점 없는 이름)·.git-credentials·backup.sql.gz 는 룰 목록에 없어 404 로 통과한다. 다만 이것도 이 서버엔 그 파일이 없어 실행이나 유출로 이어지진 않는다 — 전부 404 다.
  • 이중 인코딩: /%252eenv(= %2e → .env)는 nginx 정규화 단계를 비껴가 룰이 못 잡는다. 하지만 이 역시 Next.js 가 404 를 준다.
  • 쿼리스트링: 일부러 경로(쿼리 앞)만 본다. ?file=.env 같은 건 LFI 쪽(zinosec/lfi-traversal)이 담당한다.

핵심은 "완벽한 룰"이 아니라 "오탐 0 으로 대부분을 막는 룰"이다. 못 막는 변종조차 이 서버에선 실행·유출로 이어지지 않는다 — 비밀 파일 자체가 없기 때문이다. 룰을 억지로 키워 config.json 까지 넣으면, 정작 멀쩡한 config.json(공개 설정)을 막아 오탐이 날 뿐이다. 그래서 목록은 내 로그에 실제로 들어온 것으로만 좁혔다.



마치며

1만9천 건, 974개 IP, 88일. 그리고 오탐 0. .env·.git·.aws 를 노린 요청은 끊이지 않지만, 이 서버엔 그 파일들이 없어서 전부 헛손질이다. no-server-secrets 룰은 그 헛손질을 Next.js 에 닿기 전에 403 으로 끊는다.

봇은 네가 어디에 뭘 두었는지 모른다 — 그래서 사전을 돌린다. .env 하나에 464가지 이름 변형과 575가지 폴더가 붙는 걸 보면, 공격이 얼마나 자동화된 추측 게임인지 실감한다. 그래서 룰도 개별 이름이 아니라 "비밀 파일의 모양" 하나로 잡는다.

룰은 한 겹일 뿐이다. WAF 가 깜빡여 요청이 앱까지 가도 Next.js 는 404 를 주고, 직접 서빙 디렉터리엔 점 파일이 하나도 없다. 진짜 안전은 "애초에 서버에 비밀 파일을 두지 않는다"는 데서 온다 — .env 는 빌드 바깥, .git 은 배포 제외, 백업은 서버 밖. WAF 는 그 위에 얹는 싸고 빠른 그물이다.

다음 편은 zinosec/wordpress-api-probe 다. 이 서버는 워드프레스가 아닌데도 /wp-json·/wp-admin·/wp-includes 를 노린 요청이 끊이지 않는다 — 1편의 wp-login.php 와 이어지는, 옛 CMS 의 그림자를 쫓는 봇들의 이야기다.

이 글이 도움이 됐나요?

Comments

댓글

0개

댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)

댓글 불러오는 중…

Related

관련 글

3개
zinosec 1편 — PHP 없는 서버에 쏟아지는 .php 공격 (no-php-execution)
research

zinosec 1편 — PHP 없는 서버에 쏟아지는 .php 공격 (no-php-execution)

zino.kr 은 Next.js 라 PHP 가 한 줄도 없는데, 88일 동안 .php 를 노린 요청이 4만4천 건, 3천여 개 IP 에서 들어왔다. 커스텀 WAF 룰 zinosec/no-php-execution 이 그걸 어떻게 잡는지 — 로그로 건수를 직접 세고, 봇이 아직 기억하는 옛 워드프레스 한글 슬러그를 들추고, 공격을 Kali 에서 재현해 Wireshark 로 403 패킷까지 보고, 정규식 한 조각씩 설계를 해부하고, 88일 내내 오탐이 0 이었음을 실측으로 확인한다. 방어자 시점 분석.
#security#waf#crowdsec+7
2026-11-17#security +8
zinosec 0편 — 내 서버가 막은 공격들 (프롤로그)
research

zinosec 0편 — 내 서버가 막은 공격들 (프롤로그)

zino.kr 은 Next.js 단일 앱인데 매일 수백 번 PHP·워드프레스·Exchange·라우터를 노린 요청을 받는다. nginx 앞단의 CrowdSec 4계층 방어가 그걸 어떻게 걸러내는지, 그리고 '이 서버에 존재할 수 없는 것만 막는다'는 무오탐 원칙으로 내 로그에서 직접 만든 커스텀 WAF 룰 7종이 88일 동안 무엇을 몇 건 막았는지 — 이 시리즈가 한 편씩 해부한다. 숫자는 nginx 로그와 cscli 로 직접 다시 셌다.
#security#waf#crowdsec+6
2026-11-17#security +7
집 서버에 WAF/IPS를 직접 짓다 — nginx + CrowdSec 4계층 방어 구축 리서치
research

집 서버에 WAF/IPS를 직접 짓다 — nginx + CrowdSec 4계층 방어 구축 리서치

zino.kr은 집에 있는 미니 PC 한 대다. 8일치 nginx 로그를 까보니 16만 요청 중 2만 건 넘게 공격이었다. CrowdSec(IPS) + AppSec(WAF) + AbuseIPDB(평판)로 4계층 심층 방어를 직접 구축하고, 실제 공격 로그에서 커스텀 룰을 뽑고, 8일치 로그를 리플레이해 검증하고, 관제 대시보드까지 만든 전 과정 기록.
#security#waf#ips+7
2026-05-22#security +5