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

2026-11-17·1분 읽기·

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 이었음을 실측으로 확인한다. 방어자 시점 분석.

이 글의 범위

프롤로그에서 본 커스텀 룰 7종 중 가장 많이 걸린 게 zinosec/no-php-execution 이다. 이름 그대로, PHP 파일 접근 시도를 막는다.

재미있는 건 zino.kr 에 PHP 가 한 줄도 없다는 점이다. Next.js 앱이라 .php 파일은 존재할 수도, 실행될 수도 없다. 그런데도 88일 동안 .php 를 노린 요청이 4만4천 건 넘게, 3천 개가 넘는 IP 에서 들어왔다. 전부 100퍼센트 정찰 아니면 공격이다 — 정상 사용자는 이 서버에서 .php 를 칠 일이 없으니까.

이 글은 그 룰을 방어자 시점으로 해부한다. 로그로 건수를 직접 세고(§막은 숫자), 실제 들어온 요청을 보고(§실제 요청), 공격을 랩에서 재현해 패킷까지 뜯고(§패킷), 정규식을 조각내 설계를 설명하고(§룰 설계), 88일 내내 오탐이 0 이었음을 실측한다(§오탐 검증).

.php 요청은 어디서 죽는가 — 같은 서버에서 공격 요청은 403 에서 끝나고 정상 요청만 Next.js 가 처리한다
.php 요청은 어디서 죽는가 — 같은 서버에서 공격 요청은 403 에서 끝나고 정상 요청만 Next.js 가 처리한다

룰 정의는 딱 한 줄의 정규식이다. 먼저 룰 파일을 본다.

sudo cat /etc/crowdsec/appsec-rules/zinosec-no-php-execution.yaml
zinosec/no-php-execution 룰 파일 — URI 를 소문자로 내린 뒤 정규식 .php 숫자 경계 패턴에 매치하면 scan 으로 분류한다
zinosec/no-php-execution 룰 파일 — URI 를 소문자로 내린 뒤 정규식 .php 숫자 경계 패턴에 매치하면 scan 으로 분류한다

핵심은 value: '\.php[0-9]?($|[/?#])' 와 transform: lowercase 두 줄이다. 이게 왜 이렇게 생겼는지는 §룰 설계에서 조각낸다. 먼저 이 룰이 실제로 무엇을 막았는지부터.



이 룰이 막은 숫자

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

# php_count.py — zinosec/no-php-execution 룰이 막은 요청을 nginx 로그에서 직접 다시 센다.
# 룰과 똑같은 정규식(\.php[0-9]?($|[/?#]))을 URI 경로에 lowercase 로 적용한다.
# 소스: /var/log/nginx/zino.access.log* (adm 그룹이라 sudo 없이 읽힌다)
import re, gzip, glob
from collections import Counter
from datetime import datetime
 
# zinosec/no-php-execution 룰의 match.value 를 그대로 가져온다 (transform: lowercase).
RULE = re.compile(r'\.php[0-9]?($|[/?#])')
 
LINE = re.compile(
    r'(?P<ip>\S+) \S+ \S+ \[(?P<t>[^\]]+)\] '
    r'"(?P<method>\S+) (?P<uri>\S+) [^"]*" (?P<st>\d{3}) ')
# 내 테일스케일/칼리/루프백에서 쏜 자가점검·재현 요청은 통계에서 뺀다.
MINE = re.compile(r'^(100\.84\.130\.|100\.82\.133\.|127\.|::1|172\.30\.)')
 
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 = 0
hits = 0
ips = set()
first = last = None
status = Counter()
targets = Counter()     # .php 파일 이름(basename) 상위
 
for ln in logs():
    m = LINE.match(ln)
    if not m:
        continue
    if MINE.match(m.group('ip')):
        continue
    total += 1
    uri = m.group('uri')
    path = uri.split('?', 1)[0].lower()
    if not RULE.search(path):
        continue
    hits += 1
    ips.add(m.group('ip'))
    status[m.group('st')] += 1
    base = path.rstrip('/').split('/')[-1]
    targets[base] += 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
 
print(f"로그 구간   : {first:%Y-%m-%d} ~ {last:%Y-%m-%d}  ({(last-first).days+1}일)")
print(f"스캔한 요청 : {total:,} 줄")
print(f"룰 매칭     : {hits:,} 건  (.php 접근)")
print(f"고유 공격 IP: {len(ips):,} 개")
print()
print("응답 코드 분포 (매칭된 .php 요청):")
for st, n in status.most_common():
    print(f"  {st}  {n:>6,}")
print()
print("가장 많이 찔린 .php 파일 이름 TOP 12:")
for name, n in targets.most_common(12):
    print(f"  {n:>5,}  {name}")
python3 php_count.py
php_count.py 실행 결과 — 88일간 .php 요청 4만4천 건, 고유 IP 3,104개. 응답은 403 과 301 이 대부분이고 200/304 는 없다
php_count.py 실행 결과 — 88일간 .php 요청 4만4천 건, 고유 IP 3,104개. 응답은 403 과 301 이 대부분이고 200/304 는 없다

88일에 44,610건, 3,104개 IP. 응답 코드를 보면 403(WAF 차단)이 2만4천, 301(평문 HTTP 를 HTTPS 로 올리는 엣지 업그레이드)이 1만8천이다. 봇이 :80 에 쏘면 WAF 에 닿기도 전에 301 을 받고, HTTPS 로 다시 오면 403 을 받는다. 200 이나 304 는 한 건도 없다 — 이게 §오탐 검증에서 다시 중요해진다.


실제로 들어온 요청

숫자만으론 심심하니 원문을 본다. 공격자 IP 는 끝자리를 가리고, 성격이 다른 요청을 하나씩 골랐다.

# php_samples.py — 실제로 들어온 .php 공격 요청 원문을 몇 줄 보여준다.
# 공격자 IP는 마지막 옥텟을 가린다(x). 서로 다른 성격의 요청을 하나씩 고른다.
import re, gzip, glob
 
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[(?P<t>[^\]]+)\] "(?P<req>[^"]*)" (?P<st>\d{3}) \d+ "[^"]*" "(?P<ua>[^"]*)"')
RULE = re.compile(r'\.php[0-9]?($|[/?#])')
 
def mask(ip):
    if ':' in ip:  # IPv6
        return ip.rsplit(':', 1)[0] + ':x'
    return ip.rsplit('.', 1)[0] + '.x'
 
# 내 자가 점검/재현 요청은 표본에서 뺀다 (진짜 외부 공격만 보이게)
MINE_UA = re.compile(r'zinosec-lab|selftest|curl/|python-requests', re.I)
MINE_IP = re.compile(r'^(127\.|::1|100\.84\.130\.|100\.82\.133\.|172\.30\.)')
 
# 보고 싶은 성격별 대표 한 줄씩
WANT = [r'wp-login\.php', r'xmlrpc\.php', r'eval-stdin\.php',
        r'wp_filemanager\.php', r'/boaform', r'alfa', r'phpinfo\.php']
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:
            continue
        toks = m.group('req').split(' ')
        if len(toks) < 2:
            continue
        path = toks[1].split('?', 1)[0].lower()   # 메서드/프로토콜 빼고 URI 경로만
        if not RULE.search(path):
            continue
        if MINE_IP.match(m.group('ip')) or MINE_UA.search(m.group('ua')):
            continue
        for w in WANT:
            if w not in picked and re.search(w, m.group('req'), re.I):
                picked[w] = 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[:38] + '…') if len(ua) > 39 else ua
    print(f'{mask(m.group("ip")):<18} [{m.group("t")[:11]}] "{m.group("req")[:72]}" {m.group("st")}')
    print(f'    └ UA: {ua}')
python3 php_samples.py
php_samples.py 실행 결과 — wp-login.php, xmlrpc.php, eval-stdin.php, wp_filemanager.php, alfa.php, phpinfo.php 요청 원문과 User-Agent
php_samples.py 실행 결과 — wp-login.php, xmlrpc.php, eval-stdin.php, wp_filemanager.php, alfa.php, phpinfo.php 요청 원문과 User-Agent

전형적인 봇 트래픽이다. xmlrpc.php 는 평범한 브라우저 UA 로 위장하고, eval-stdin.php 는 libredtail-http 같은 스캐너 UA 를 그대로 달고 온다. wp_filemanager.php 는 UA 조차 비웠다(-).

맨 위 wp-login.php 요청의 redirect_to 파라미터를 잘 보면 이상한 게 있다. http://1.240.148.x/raspberry-pi/... — 이 서버의 예전 공인 IP 를 가리킨다. 여기서 이 글의 훅이 나온다.



봇은 옛 워드프레스를 기억한다

zino.kr 은 지금은 Next.js 지만, 예전엔 워드프레스였다. 그때 올린 글들은 /raspberry-pi/linux-file-압축-백업-방법/ 같은 한글 슬러그 URL 을 갖고 있었다. 사이트를 갈아엎은 지 한참인데, 봇들은 그 시절 URL 을 아직도 기억하고 wp-login.php 의 redirect_to 에 그대로 실어 보낸다.

redirect_to 값은 이중 URL 인코딩이라 두 번 디코드해야 한글이 보인다. 예전 공인 IP 는 끝자리를 가린다.

# wp_hook.py — wp-login.php?redirect_to= 에 담긴 옛 워드프레스 URL을 들춘다.
# 이 사이트가 워드프레스였을 때의 한글 슬러그를 봇들이 아직 기억하고 찌른다.
# redirect_to 값은 이중 URL 인코딩이라 두 번 unquote 한다. 예전 공인 IP는 끝자리를 가린다.
import re, gzip, glob, urllib.parse as up
from collections import Counter
 
LINE = re.compile(r'\S+ \S+ \S+ \[[^\]]+\] "(?P<req>[^"]*)" \d{3} ')
RT = re.compile(r'redirect_to=([^&"\s]+)')
 
cnt = 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 'wp-login.php' not in m.group('req'):
            continue
        rt = RT.search(m.group('req'))
        if not rt:
            continue
        total += 1
        dest = up.unquote(up.unquote(rt.group(1)))          # 이중 디코드
        dest = re.sub(r'(\d+\.\d+\.\d+)\.\d+', r'\1.x', dest)  # IP 끝자리 가림
        cnt[dest] += 1
 
print(f"wp-login.php?redirect_to= 요청 : {total:,} 건")
print(f"고유 목적지 URL               : {len(cnt):,} 개")
print()
print("가장 많이 되가리킨 '예전 워드프레스 주소' TOP 10:")
for url, n in cnt.most_common(10):
    print(f"  {n:>4}  {url[:88]}")
python3 wp_hook.py
wp_hook.py 실행 결과 — 봇들이 되가리키는 옛 워드프레스 한글 슬러그 목록, frida 안드로이드 모의해킹이나 kali 설치 같은 옛 글 주소가 보인다
wp_hook.py 실행 결과 — 봇들이 되가리키는 옛 워드프레스 한글 슬러그 목록, frida 안드로이드 모의해킹이나 kali 설치 같은 옛 글 주소가 보인다

1,853건의 wp-login.php 요청이 58개의 옛 워드프레스 주소를 되가리킨다. /programming/frida-활용-안드로이드-모의해킹/, /linux/kali-libreoffice-사용하기/ 같은, 몇 년 전에 지운 글들이다. 봇넷의 타깃 목록은 한 번 긁은 사이트맵을 좀처럼 안 버린다 — 사이트를 통째로 바꿔도 옛 URL 로 계속 두드리는 이유다.

이들에게 wp-login.php 는 그냥 로그인 폼이 아니라 무차별 대입의 입구다. 그게 이 서버엔 없을 뿐이다.


노린 것 — 무엇을 찾고 있나

.php 요청을 의도별로 묶어 본다. 경로를 버킷에 넣고 세는 단순 분류다.

# php_targets.py — .php 요청을 "공격자가 뭘 노렸나"로 묶는다.
# no-php-execution 룰에 걸린 요청만 대상으로, 경로를 의도별 버킷에 넣고 센다.
import re, gzip, glob
from collections import Counter
 
RULE = re.compile(r'\.php[0-9]?($|[/?#])')
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[[^\]]+\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" \d{3} ')
 
# 의도 버킷 (경로 소문자 기준, 위에서부터 먼저 맞는 것으로 분류)
BUCKETS = [
    ("wp-login 무차별 대입",  re.compile(r'wp-login\.php')),
    ("xmlrpc 증폭/대입",      re.compile(r'xmlrpc\.php')),
    ("phpunit eval-stdin RCE (CVE-2017-9841)", re.compile(r'eval-stdin\.php')),
    ("Zabbix api_jsonrpc RCE", re.compile(r'api_jsonrpc\.php')),
    ("파일매니저/업로더 웹셸", re.compile(r'(filemanager|file_manager|fileupload|elfinder|kcfinder|dropdown)')),
    ("설정/정보 노출 (phpinfo 등)", re.compile(r'(phpinfo|_info|/info\.php|config|setup|install)')),
    ("알려진 웹셸 이름",      re.compile(r'(alfa|wso|r57|c99|shell|cmd|/by\.php|/ls\.php|hello_world|radio|moon|xleet)')),
    ("관리자 패널 추정",      re.compile(r'(wp-admin|/admin|/login\.php|/manage|/user\.php)')),
]
def bucket(p):
    for name, rx in BUCKETS:
        if rx.search(p):
            return name
    base = p.rstrip('/').split('/')[-1]
    # 랜덤/숫자/짧은 이름 .php = 미리 심어둔 웹셸이 있는지 찍어보는 존재 확인
    if re.match(r'(\d{1,4}|[a-z0-9]{8,}|[a-z]{1,3})\.php', base):
        return "웹셸 존재 확인 (랜덤/숫자/한두 글자 이름)"
    return "기타 .php 정찰 (index.php 등)"
 
cnt = Counter(); sample = {}
MINE = re.compile(r'^(100\.84\.130\.|100\.82\.133\.|127\.|::1|172\.30\.)')  # 자가점검 제외
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')):
            continue
        p = m.group('uri').split('?', 1)[0].lower()
        if not RULE.search(p):
            continue
        b = bucket(p)
        cnt[b] += 1
        sample.setdefault(b, m.group('uri').split('?', 1)[0])
 
for name, n in cnt.most_common():
    print(f"{n:>6,}  {name}")
    print(f"        예: {sample[name][:60]}")
python3 php_targets.py
php_targets.py 실행 결과 — wp-login 무차별 대입, 웹셸 존재 확인, phpunit eval-stdin RCE, 파일매니저 웹셸 등 의도별 집계
php_targets.py 실행 결과 — wp-login 무차별 대입, 웹셸 존재 확인, phpunit eval-stdin RCE, 파일매니저 웹셸 등 의도별 집계

가장 큰 두 덩어리는 "웹셸 존재 확인"과 "기타 .php 정찰"이다. 1.php, 3PJcpMFsD8B.php, this_is_a_new_hello_world.php 처럼 랜덤하거나 의미 없는 이름을 던지는 건, 이미 누가 심어 둔 웹셸이 있나 찍어보는 행위다. 있으면 그 파일로 명령을 실행하려는 것이다.

눈에 띄는 건 280건의 eval-stdin.php 다. 이건 특정 CVE 를 노린다.

NVD CVE-2017-9841 — PHPUnit 의 eval-stdin.php 가 POST 본문의 PHP 코드를 그대로 실행하는 원격 코드 실행 취약점
NVD CVE-2017-9841 — PHPUnit 의 eval-stdin.php 가 POST 본문의 PHP 코드를 그대로 실행하는 원격 코드 실행 취약점

Source: NVD — CVE-2017-9841

CVE-2017-9841 은 PHPUnit 의 Util/PHP/eval-stdin.php 가 POST 본문에 담긴 <?php ... 를 그대로 실행해 버리는 고전적 RCE 다. 2017년 취약점인데 아직도 매일 긁는다 — 어딘가엔 아직 취약한 서버가 있다는 뜻이고, 봇은 그걸 자동으로 쓸어 담는다. 우리 서버엔 vendor 디렉터리도, PHP 도 없으니 그냥 403 이다.



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

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

재현 요청엔 식별용으로 UA zinosec-lab/1.0 을 달았다. 먼저 커맨드라인에서 세 가지 공격을 쏴 본다.

# kali_probe.sh — 공격자 자리(Kali)에서 로그에 남은 .php 공격을 재현한다.
# 테일스케일 경로로 zino.kr(100.84.130.6)에 직접. UA 로 재현 요청임을 표시.
ssh kali 'for p in \
    "/wp-login.php?redirect_to=http://1.240.148.44/raspberry-pi/" \
    "/xmlrpc.php" \
    "/vendor/phpunit/phpunit/src/Util/PHP/eval-stdin.php"; 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.sh
Kali 에서 테일스케일 경로로 세 가지 .php 공격을 재현한 결과 — 세 요청 모두 HTTP/2 403 을 받는다
Kali 에서 테일스케일 경로로 세 가지 .php 공격을 재현한 결과 — 세 요청 모두 HTTP/2 403 을 받는다

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

# Kali 에서 — 캡처와 동시에 재현
sudo tcpdump -i tailscale0 -w ~/zinosec/01.pcapng 'host 100.84.130.6 and port 443' &
export SSLKEYLOGFILE=$HOME/zinosec/keys.log
curl --http2 --resolve zino.kr:443:100.84.130.6 -A "zinosec-lab/1.0" \
     "https://zino.kr/wp-login.php?redirect_to=http://1.240.148.44/raspberry-pi/"
# ... xmlrpc.php, eval-stdin.php 도 같은 방식으로

캡처한 pcap 을 키로그와 함께 Wireshark 로 열면 HTTP/2 가 복호되어 요청 줄과 응답이 보인다.

wireshark -r ~/zinosec/01.pcapng -o tls.keylog_file:$HOME/zinosec/keys.log \
          -Y 'http2.header.value contains ".php" or http2.headers.status==403'
Kali 의 Wireshark — HTTP/2 복호 화면. :path 에 wp-login.php, xmlrpc.php, eval-stdin.php 가 보이고 각 요청에 403 Forbidden 응답이 돌아온다
Kali 의 Wireshark — HTTP/2 복호 화면. :path 에 wp-login.php, xmlrpc.php, eval-stdin.php 가 보이고 각 요청에 403 Forbidden 응답이 돌아온다

디스플레이 필터로 .php 를 담은 헤더와 403 응답만 남겼다. 패킷 목록의 Info 열에 GET /wp-login.php?redirect_to=http://1.240.148.44/raspberry-pi/, GET /xmlrpc.php, GET /vendor/phpunit/.../eval-stdin.php 가 그대로 찍히고, 그 사이사이 403 Forbidden 응답이 보인다. 아래 "Decrypted TLS" 탭은 TLS 가 실제로 복호됐다는 증거다.

같은 pcap 을 터미널에서 tshark 로 읽으면 HTTP/2 헤더가 떨어진다. 한 줄에 헤더 이름들(탭 뒤에 값들)이 콤마로 묶여 나온다.

# kali_tshark.sh — Kali 가 뜬 pcap 을 원격으로 읽어 HTTP/2 요청/응답 헤더를 뽑는다.
# keys.log(TLS 세션 키)로 복호한다. :path(공격 경로)와 :status(403)가 한 쌍으로 보인다.
ssh kali 'cd ~/zinosec && tshark -r 01.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.sh
tshark 로 추출한 HTTP/2 헤더 — 요청 줄에 method GET 과 path 세 가지 .php 경로, 응답 줄에 status 403 과 server nginx 가 한 쌍씩 떨어진다
tshark 로 추출한 HTTP/2 헤더 — 요청 줄에 method GET 과 path 세 가지 .php 경로, 응답 줄에 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 끝자리도 가린다.

# 미니PC 에서 — 재현하는 몇 초만 lo:7422 를 캡처
sudo tcpdump -i lo -w lo.pcap 'tcp port 7422'
# (이 창이 도는 동안 Kali 에서 wp-login.php 를 재현)
# wire.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'; }
 
echo "▶ nginx 가 AppSec(:7422) 에 넘긴 요청 메타데이터 (wp-login.php 재현)"
tshark -r "$TMP" -Y 'http.request' -T fields -e http.request.line 2>/dev/null \
  | grep -i 'wp-login' | head -1 | tr ',' '\n' \
  | grep -i 'x-crowdsec-appsec' | sed 's/\\r\\n//' | redact | sed 's/^/    /'
 
echo
echo "▶ AppSec 의 판정 (같은 TCP 스트림의 응답)"
code=$(tshark -r "$TMP" -Y 'http.response' -T fields -e http.response.code 2>/dev/null | head -1)
echo "    HTTP $code  (zinosec/no-php-execution 매치)"
echo "    → nginx 가 이 판정을 받아 클라이언트에 403 을 돌려준다 (Next.js 는 호출되지 않음)"
bash wire.sh lo.pcap
wire.sh 실행 결과 — nginx 가 AppSec 에 넘긴 x-crowdsec-appsec-uri 에 wp-login.php 가 담기고, api-key 는 redacted, AppSec 응답은 403
wire.sh 실행 결과 — nginx 가 AppSec 에 넘긴 x-crowdsec-appsec-uri 에 wp-login.php 가 담기고, api-key 는 redacted, AppSec 응답은 403

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



룰 설계 — 정규식 한 조각씩

이제 룰이 왜 \.php[0-9]?($|[/?#]) 로 생겼는지. 짧지만 모든 조각에 이유가 있다.

정규식 해부 — 리터럴 .php, 선택적 숫자 한 자리, 끝/슬래시/물음표/샵 경계, 그리고 lowercase 변환
정규식 해부 — 리터럴 .php, 선택적 숫자 한 자리, 끝/슬래시/물음표/샵 경계, 그리고 lowercase 변환
  • \.php — 리터럴 .php. 점을 이스케이프해 "임의 문자"가 아니라 진짜 점으로 고정한다.
  • [0-9]? — 뒤에 숫자 한 자리가 있어도 잡는다. shell.php5, x.php7 같은 옛 멀티버전 PHP 확장자 우회를 막는다.
  • ($|[/?#]) — 가장 중요한 경계. .php 가 파일 이름의 끝일 때만 매치한다. 끝이거나($), 바로 뒤에 /·?·# 가 오는 경우. 이게 없으면 블로그 슬러그에 들어간 php 글자까지 걸려 오탐이 난다.
  • transform: lowercase — 경로를 소문자로 내린 뒤 매칭한다. WP-LOGIN.PHP 같은 대소문자 우회를 무력화한다.

말로만 하면 안 믿기니, 정규식에 직접 여러 입력을 먹여 본다.

# regex_demo.py — no-php-execution 룰의 정규식이 무엇을 잡고 무엇을 놓치는지 직접 먹여본다.
# 룰: zones=URI, transform=lowercase, value='\.php[0-9]?($|[/?#])'
import re
RULE = re.compile(r'\.php[0-9]?($|[/?#])')
 
def test(uri):
    # 룰의 transform:lowercase 를 흉내 — 경로를 소문자로 내린 뒤 매칭
    return "차단" if RULE.search(uri.lower()) else "통과"
 
cases = [
    # 공격 — 잡혀야 한다
    "/wp-login.php",
    "/xmlrpc.php?rsd",
    "/admin.php/",
    "/shell.php5",
    "/WP-LOGIN.PHP",                        # 대문자 우회 → lowercase 로 무력화
    "/vendor/phpunit/phpunit/src/Util/PHP/eval-stdin.php",
    # 정상 — 통과해야 한다 (오탐 0 이 목표)
    "/blog/php-ide-vs-vscode",             # 슬러그에 'php' 가 들어가도
    "/research/phpstorm-tips",
    "/wp-content/uploads/2021/01/diagram.png",
    "/api/posts?tag=php",                  # 쿼리스트링의 php
    "/",
]
print(f"{'요청 URI':<52}{'판정'}")
print("-" * 60)
for u in cases:
    print(f"{u:<52}{test(u)}")
python3 regex_demo.py
regex_demo.py 실행 결과 — 공격 .php 변종 6개는 전부 차단, php 가 들어간 블로그 슬러그와 쿼리스트링은 전부 통과
regex_demo.py 실행 결과 — 공격 .php 변종 6개는 전부 차단, php 가 들어간 블로그 슬러그와 쿼리스트링은 전부 통과

공격 변종 6개는 전부 "차단", php 가 단어로 들어간 블로그 슬러그와 쿼리스트링은 전부 "통과". 경계 ($|[/?#]) 덕분에 /blog/php-ide-vs-vscode 는 안 걸린다 — php 뒤에 . 도 경계도 없으니 .php 파일이 아니다. CrowdSec 의 AppSec 룰 문법도 이 패턴을 그대로 지원한다.

CrowdSec 공식 문서 — AppSec 룰 문법. zones, transform, match 로 요청의 어느 부분을 어떻게 검사할지 정의한다
CrowdSec 공식 문서 — AppSec 룰 문법. zones, transform, match 로 요청의 어느 부분을 어떻게 검사할지 정의한다

Source: CrowdSec Docs — AppSec rules syntax


오탐 검증 — 정상은 통과, 공격은 403

설계가 맞는지는 살아있는 서버에 직접 쏴서 확인한다. 정상 경로는 403 이 아니어야 하고, .php 공격 경로는 403 이어야 한다. 테일스케일 IP 로 실제 nginx→WAF 경로를 그대로 탄다.

# fp_check.sh
UA='zinosec-lab/1.0 (fp-check)'
probe() { curl -s -o /dev/null -w '%{http_code}' --resolve zino.kr:443:100.84.130.6 -A "$UA" "https://zino.kr$1"; }
 
echo "── 정상 경로 (403 이면 안 된다) ──"
for p in "/" "/blog" "/research" "/playground/security" \
         "/research/log4shell-cve-2021-44228" "/api/posts?tag=php"; do
  printf "  %-42s %s\n" "$p" "$(probe "$p")"
done
 
echo "── 공격 경로 (.php → 403 이어야 한다) ──"
for p in "/wp-login.php" "/xmlrpc.php" "/admin.php" "/shell.php5" \
         "/WP-LOGIN.PHP" "/vendor/phpunit/phpunit/src/Util/PHP/eval-stdin.php"; do
  printf "  %-42s %s\n" "$p" "$(probe "$p")"
done
bash fp_check.sh
fp_check.sh 실행 결과 — 정상 경로 6개는 200 또는 404(403 아님), 공격 .php 경로 6개는 전부 403
fp_check.sh 실행 결과 — 정상 경로 6개는 200 또는 404(403 아님), 공격 .php 경로 6개는 전부 403

정상 경로는 전부 200(또는 존재하지 않는 API 는 404 — 어쨌든 403 이 아니다). 공격 경로는 대문자 우회(WP-LOGIN.PHP)와 숫자 확장자(shell.php5)까지 전부 403.

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

# fp_in_logs.py — "오탐이 정말 0인가"를 로그 전체에서 확인한다.
# no-php-execution 정규식에 걸린 요청 중 성공 응답(200/304)이 한 건이라도 있었는지 센다.
# 하나라도 있으면 정상 콘텐츠를 막았다는 뜻 → 반드시 0 이어야 한다.
import re, gzip, glob
from collections import Counter
RULE = re.compile(r'\.php[0-9]?($|[/?#])')
LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[[^\]]+\] "(?P<m>\S+) (?P<uri>\S+) [^"]*" (?P<st>\d{3}) ')
MINE = re.compile(r'^(100\.84\.130\.|100\.82\.133\.|127\.|::1|172\.30\.)')  # 자가점검 제외
 
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')):
            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"룰에 걸린 .php 요청 총 {total:,} 건의 최종 응답 코드:")
for code, n in sorted(st.items(), key=lambda x: -x[1]):
    note = {'403': 'WAF 차단', '301': 'HTTP→HTTPS 업그레이드(:80, WAF 도달 전)',
            '400': '잘못된 요청', '499': '클라이언트 연결 종료', '404': 'WAF 재시작 순간 passthrough → Next.js(PHP 없음)',
            '308': '리다이렉트', '307': '리다이렉트', '408': '타임아웃'}.get(code, '')
    print(f"  {code}  {n:>7,}   {note}")
print()
print(f"★ 정상 응답(200/304) = {len(served)} 건")
print("  → 88일 동안 이 룰이 '진짜 콘텐츠'를 내보낸 적은 한 번도 없다. 오탐 0.")
python3 fp_in_logs.py
fp_in_logs.py 실행 결과 — 룰에 걸린 4만4천 건의 응답 분포. 403 과 301 이 대부분이고 정상 응답 200/304 는 0건
fp_in_logs.py 실행 결과 — 룰에 걸린 4만4천 건의 응답 분포. 403 과 301 이 대부분이고 정상 응답 200/304 는 0건

정상 응답 0건. 88일 동안 이 룰이 진짜 콘텐츠를 막은 적은 한 번도 없다. 이게 무오탐 원칙의 실증이다 — 애초에 이 서버에 .php 가 없으니, .php 를 전부 막아도 잃을 게 없다.

404 가 242건 있는데, 이건 룰을 통과한 게 아니라 CrowdSec 이 재시작되는 찰나 AppSec 이 잠깐 끊겨(APPSEC_FAILURE_ACTION=passthrough) 요청이 Next.js 까지 갔다가, 거기에도 PHP 가 없어 404 가 난 경우다. WAF 가 깜빡여도 뒤에 PHP 가 없다.



.php 는 어디서 죽나 — 앱엔 흔적이 없다

이 룰은 5/22 에 만들었고 로그는 8/22 부터만 남아 있다. "룰 도입 전후 비교"는 데이터가 없어서 못 한다 — 지어내지 않는다. 대신 지금 이 순간 살아있는 WAF 가 .php 를 잡고 있다는 걸 메트릭으로 확인한다. 메트릭은 재시작 이후 누적분이라 절대값은 로그와 다르지만, 룰이 활발히 도는 건 분명하다.

sudo cscli metrics | grep -E 'Local API Alerts|Rules Metrics|zinosec/no-php-execution'
cscli metrics 에서 zinosec/no-php-execution 의 탐지 건수 — Local API Alerts 와 AppSec Rules Metrics 양쪽에 집계되어 재시작 이후로도 살아 도는 룰임을 보여준다
cscli metrics 에서 zinosec/no-php-execution 의 탐지 건수 — Local API Alerts 와 AppSec Rules Metrics 양쪽에 집계되어 재시작 이후로도 살아 도는 룰임을 보여준다

차단은 전부 nginx↔AppSec 사이에서 끝나므로, Next.js 애플리케이션 로그에는 이 .php 요청들의 흔적이 없다. 앱은 자기가 무슨 공격을 받았는지도 모른다 — 그게 WAF 가 할 일을 하고 있다는 뜻이다.


노출 규모 — 공격자 지형

마지막으로 공격이 어디서 오는지. 국가는 로그에 없고 CrowdSec 이 GeoIP 로 붙인 값이라, 경보(7일 창)에서 받아온다.

# php_country.py — no-php-execution 으로 찍힌 WAF 경보의 출신 국가를 센다.
# CrowdSec 경보 DB 는 7일만 보존하므로 이 집계는 '최근 7일 창'이다(88일 로그와 다름).
# 국가(source.cn)는 로그엔 없고 CrowdSec 이 GeoIP 로 붙인 값이라 cscli 에서 받는다.
import json, subprocess, collections
 
raw = subprocess.run(
    ["sudo", "-n", "cscli", "alerts", "list",
     "--scenario", "zinosec/no-php-execution", "-o", "json", "--limit", "5000"],
    capture_output=True, text=True).stdout
alerts = json.loads(raw)
 
cn = collections.Counter()
for a in alerts:
    cn[a.get("source", {}).get("cn") or "(미상)"] += 1
 
print(f"최근 7일 no-php-execution WAF 경보 : {len(alerts):,} 건")
print()
print("출신 국가 TOP 10:")
for c, n in cn.most_common(10):
    bar = "█" * round(n / max(cn.values()) * 24)
    print(f"  {c:<8}{n:>4}  {bar}")
python3 php_country.py
php_country.py 실행 결과 — 최근 7일 no-php-execution 경보 1천여 건의 출신 국가 막대그래프, 미국 일본 홍콩 순
php_country.py 실행 결과 — 최근 7일 no-php-execution 경보 1천여 건의 출신 국가 막대그래프, 미국 일본 홍콩 순

미국·일본·홍콩·네덜란드가 상위다. 다만 이건 "미국이 공격한다"가 아니라, 공격자가 값싼 클라우드·VPS 를 거쳐 들어온다는 뜻에 가깝다. 상위 AS 를 보면 구글 클라우드·텐센트·화웨이 같은 호스팅 사업자다. .php 정찰은 MITRE ATT&CK 의 T1595(Active Scanning)에 해당하는 전형적 자동화 스캐닝이다.

MITRE ATT&CK T1595 — Active Scanning. 표적의 인프라를 자동으로 긁어 취약한 서비스를 찾는 정찰 기법
MITRE ATT&CK T1595 — Active Scanning. 표적의 인프라를 자동으로 긁어 취약한 서비스를 찾는 정찰 기법

Source: MITRE ATT&CK — T1595 Active Scanning


탐지 — 방어자 시그니처

차단은 WAF 가 하지만, "지금 누가 .php 를 긁고 있나"를 보려면 로그 쪽 시그니처가 유용하다. 방어자 입장에서 쓸 만한 것 몇 가지.

  • 요청 경로: \.php[0-9]?($|[/?#]) — 이 글의 룰 그대로. nginx 액세스 로그에 걸면 실시간 정찰 탐지가 된다.
  • 응답 코드 상관: 한 IP 가 짧은 시간에 403 을 다발로 받으면(특히 서로 다른 .php 경로로) 웹셸 스캔이다. CrowdSec 이 이걸 결정으로 승격해 ban 한다.
  • UA 패턴: libredtail-http, 빈 UA(-), 또는 브라우저를 사칭하지만 Accept 헤더가 */* 하나뿐인 요청. 정상 브라우저는 이렇게 안 생겼다.
  • 옛 URL 되가리킴: wp-login.php?redirect_to= 에 이미 존재하지 않는 옛 경로가 담기면 봇넷의 낡은 타깃 목록이다. 사람은 이런 걸 안 친다.

이것들은 차단 룰이 아니라 "관찰용"이다. 이미 WAF 가 막고 있으니, 탐지는 추세를 보는 용도다.


한계 — 이 룰이 못 막는 것

솔직하게. 이 룰은 만능이 아니다.

  • 이중 인코딩: %2570hp(= %70hp → php) 처럼 인코딩을 겹치면 URI 정규화 단계에 따라 비껴갈 수 있다. nginx 가 한 번은 디코드하지만, AppSec 이 보는 문자열이 원본이냐 디코드본이냐에 따라 다르다. 다만 이렇게 들어온 요청은 Next.js 도 똑같이 못 찾아 404 라, 실행으로 이어지진 않는다(뒤에 PHP 가 없으니까).
  • 다른 확장자: .phtml, .phar, .php.jpg 같은 변종은 이 정규식이 안 잡는다. 하지만 이것도 PHP 가 없는 서버에선 실행 위험이 0 이다. 그래서 굳이 룰을 키우지 않았다 — 오탐 위험만 늘 뿐이다.
  • 쿼리스트링 안의 .php: 일부러 경로(쿼리 앞)만 본다. 쿼리의 ?file=x.php 같은 건 LFI 쪽(zinosec/lfi-traversal)이 담당한다. 룰마다 책임 범위를 좁게 나눠 오탐을 줄였다.
  • POST 본문: 이 룰은 URI 만 본다. eval-stdin.php 처럼 본문에 페이로드를 싣는 공격도 경로가 .php 라 어차피 URI 단계에서 잡히지만, 경로를 안 거치는 본문 공격은 다른 룰의 몫이다.

핵심은 "완벽한 룰"이 아니라 "오탐 0 으로 대부분을 막는 룰"이다. 못 막는 변종조차 이 서버에선 실행으로 이어지지 않는다 — PHP 자체가 없기 때문이다. 룰은 방어의 한 겹일 뿐, 진짜 안전은 "애초에 공격 표면이 없다"는 데서 온다.



마치며

4만4천 건, 3천 개 IP, 88일. 그리고 오탐 0. .php 를 노린 요청은 끊이지 않지만, 이 서버엔 PHP 가 없어서 전부 헛손질이다. no-php-execution 룰은 그 헛손질을 Next.js 에 닿기 전에 403 으로 끊는다.

설계는 단순해서 안전하다. \.php[0-9]?($|[/?#]) + lowercase, 그게 전부다. 복잡한 휴리스틱이 아니라 "이 서버에 존재할 수 없는 것"이라는 명확한 기준이라, 오탐 없이 공격적으로 막을 수 있다.

봇은 과거를 기억한다. 몇 년 전 지운 워드프레스 한글 슬러그를 아직도 되가리키는 요청을 보면, 한 번 긁힌 사이트맵이 얼마나 오래 떠도는지 실감한다. 그래서 옛 CMS 를 걷어내도 그 흔적(/wp-content/uploads/ 같은)은 신중히 다뤄야 한다.

다음 편은 .git·.env·.aws/credentials 를 노리는 zinosec/no-server-secrets 다. 비밀 파일을 긁어가려는 요청이 88일에 1만9천 건 들어왔다.

이 글이 도움이 됐나요?

Comments

댓글

0개

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

댓글 불러오는 중…

Related

관련 글

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

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 이었음을 실측한다. 방어자 시점 분석.
#security#waf#crowdsec+9
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