이미지 요청은 Cloudflare 캐시를 타야 하는 요청인데 초당 602건이 CDN 캐시를 타지 못하고 원본 서버로 전달되어 오는 것을 확인했다. 블로그 이미지에 ?x=<난수> 를 붙인 요청들은 CDN 엣지 캐시에서 매번 MISS 였고 속도 제한은 이 요청을 제한하지 못했다. 같은 이미지를 쿼리 없이 보내면 1만 8천 건이 전부 CDN 캐시로 응답이 처리되고 있었지만, 쿼리를 넣은 요청들은 내 서버의 CPU에 계속 부담을 주고 있는 상태였다. 이제 이미지 쿼리에 대한 CDN 규칙을 하나 더 추가해보자.

이 글은 byitx.com 에 걸어 둔 Cloudflare 사용자 지정 규칙 4개를 하나씩 설명하는 시리즈의 두 번째 편이다. 첫 편은 공격만 오는 호스팅 ASN 을 막는 규칙이었다. 이번 규칙은 이미지·CSS·JS 같은 정적 파일 주소에 캐시를 피하려는 쿼리가 붙어 오면 엣지에서 403 으로 막도록 했다(내가 만들어둔 쿼리도 아니다). 이 증상이 왜 생기는지와 30일간의 Cloudflare Analytics 지표와 A1 서버 지표로 실제 이 증상이 공격에 활용되는지도 확인해야만 했다. 이어서 WordPress 의 ?ver= 는 살리면서 차단하는 조건식과 적용 전후의 지표, 주의할 점을 다뤄보자. 스크립트는 Python 표준 라이브러리와 curl을 활용하고 지정한 사이트 주소나 API 토큰만 넣으면 그대로 활용 가능하다.
목차
정적 파일은 캐시가 받아 준다는 착각 — 캐시 키에 쿼리가 들어갔을때
Cloudflare 가 캐시에서 파일을 찾을 때 쓰는 이름을 캐시 키라고 한다. 기본 캐시 키는 scheme·호스트·경로에 쿼리 문자열까지 포함한다. 문서에 나온 예시는 /logo.jpg?utm_source=newsletter 다.

① 기본 캐시 키에는 쿼리 문자열이 들어간다.
② 무료 플랜에서도 ‘Ignore query string’(쿼리를 빼는 캐시 레벨)은 쓸 수 있지만
③ 어떤 쿼리를 키에 넣고 뺄지 고르는 설정은 Enterprise 전용이다.
동일한 이미지라도 쿼리가 다르면 Cloudflare 는 캐시 키가 다른 것으로 간주하고, 일단 Origin에서 가져오려는 시도를 한다. a.webp 가 1년짜리 캐시로 엣지에 있어도 a.webp?x=7c7ba837 은 캐시에 없으니 원본에 다시 물어보는 것이다. 쿼리 값을 매번 바꾸면 요청마다 원본까지 요청이 전달된다.

?ver= 는 WordPress 가 새 파일을 내보낼 때 쓰는 방식이다.직접 확인하는 방법은 간단하다. 아래 스크립트는 정적 파일 하나를 쿼리 없이 두 번, 매번 다른 쿼리를 붙여 두 번 요청하고 응답 코드와 cf-cache-status 헤더를 보여 준다. 자기 사이트의 이미지 주소를 넣어 보면 된다.
#!/usr/bin/env bash
# 정적 파일 하나로 Cloudflare 캐시 키가 쿼리에 따라 갈리는지 본다.
# 쿼리 없이 두 번, 매번 다른 쿼리 값으로 두 번 요청하고 응답 코드와 cf-cache-status 를 찍는다.
# ./cache_key_check.sh <정적 파일 주소> [쿼리 이름(기본 x)]
set -euo pipefail
url=${1:?정적 파일 주소를 주세요}
key=${2:-x}
probe() {
curl -s -o /dev/null -D - -H 'Accept-Encoding: gzip' "$1" | tr -d '\r' |
awk -v u="…/${1##*/}" 'NR == 1 { code = $2 }
tolower($1) == "cf-cache-status:" { c = $2 }
END { printf "%-4s %-8s %s\n", code, (c ? c : "-"), u }'
}
printf '%-4s %-8s %s\n' HTTP CACHE 요청
probe "$url"
probe "$url"
for _ in 1 2; do
probe "$url?$key=$(od -An -N4 -tx4 /dev/urandom | tr -d ' ')"
done
Code language: Bash (bash)
chmod +x cache_key_check.sh
./cache_key_check.sh https://blog.example.com/wp-content/uploads/2026/10/a.webp
./cache_key_check.sh https://blog.example.com/wp-content/themes/<테마>/assets/js/menu.min.js ver
Code language: Bash (bash)
규칙이 없는 사이트라면 쿼리를 붙인 두 줄이 200 MISS 로 나온다. 아래는 지금(규칙을 적용한 뒤) axgo 에서 돌린 결과다.

① 쿼리 없는 요청은 엣지 캐시가 응답한다.
② 동일한 이미지에 쿼리를 붙이면 지금은 엣지가 403 으로 처리한다.
③ JS 의
?ver=<임의 값> 은 일부러 통과시킨다 — 매번 MISS 라 원본까지 간다.④
?_= 처럼 흔한 캐시 회피 쿼리는 403 으로 처리한다.③이 남아 있는 이유는 WordPress 에 있다. wp_enqueue_style()·wp_enqueue_script() 의 $ver 인자는 캐시를 깨기 위해 주소 뒤에 쿼리를 붙인다. 버전을 주지 않으면 WordPress 버전이 대신 붙는다.

$ver 설명.① 버전 번호는 캐시를 사용하지 않기 위해 URL 에 쿼리로 넣는다.
② 값을 주지 않으면 설치된 WordPress 버전이 자동으로 사용된다.
테마를 업데이트하면 menu.min.js?ver=3.6.1 이 ?ver=3.6.2 로 바뀌고 캐시 키가 달라지니 엣지가 새 파일을 받아 온다. 무료 플랜의 ‘Ignore query string’ 을 켜면 이 신호까지 사라진다. 이 캐시 레벨은 존 전체 설정이고 정적 파일 확장자에서 쿼리를 통째로 무시한다. 테마를 고쳐도 캐시가 끝날 때까지(이 블로그는 CSS·JS 30일) 옛 파일이 나간다. 쿼리를 통째로 무시하지 않고 무쓸모 쿼리만 골라 막아야 하는 것이 이것 때문이다.
속도 제한은 왜 이 요청을 막을 수 없을까
이 블로그의 속도 제한 규칙은 IP 당 10초 100건이다. 그런데 정적 경로(/wp-content/·/wp-includes/)는 이 규칙에서 뺐다. 무료 플랜 속도 제한의 제약 때문이다.

① 무료 플랜 조건식에 쓸 수 있는 필드는 경로와 검증된 봇뿐이다.
② 캐시된 요청을 셈에서 빼는 옵션이 없다.
③ “원본으로 간 요청만 카운팅한다” 같은 카운팅 조건(counting expression)도 Business 부터다.
무료 플랜에서는 캐시가 응답한 요청도 똑같이 카운팅된다. 글 한 편을 열면 블로그의 호스트 이름으로 이미지·CSS·JS 요청이 25~41건 발생한다. 정적 경로 기준으로 속도 제한을 걸면 글 서너 편만 읽으려 해도 429 를 응답해야 하는 상태다. 때문에 정적 경로를 속도 제한에서 제외시켰다. 그런데 이 제한은 “캐시가 받아 주니 괜찮다”는 가정을 두고 걸어둔 것이다. 이 상태에서 쿼리만 빼고 속도 제한을 걸기가 까다롭기 때문이다.

* 쿼리가 없으면 엣지 캐시에서 처리된다.
* 쿼리를 붙이면 속도 제한에 걸리지 않고 캐시에서는 MISS가 되어 원본까지 전달된다.
* 현재 – 규칙을 넣은 뒤로는 사용자 지정 규칙 단계에서 403 으로 처리된다.
문제는 Cloudflare와 워드프레스를 위한 설정이 겹치는 곳에서 발생한다. (양쪽 다 문제가 되는 상태는 아니다)
- 정적 경로는 속도 제한이 없다. (Cloudflare)
- 쿼리가 붙으면 캐시를 타지 않는다. (WordPress)
부하 테스트
이 문제는 공격 로그가 아니라 부하 테스트 중 확인했다. 10월 17일 A1 에서 블로그 이미지(54 KB) 하나에 매번 다른 쿼리를 붙여 동시 접속 20개로 보내봤다. 같은 방식으로 10월 18일에는 쿼리 없이 보냈다. Cloudflare Analytics(GraphQL httpRequestsAdaptiveGroups)에 남은 두 시험은 이렇다.
| 시험 | 요청 | 캐시 | 원본 응답 | 엣지가 내보낸 바이트 |
|---|---|---|---|---|
| 10-17 쿼리 붙임 | 4,852건 | 전부 MISS | 전부 200 | 268 MB |
| 10-18 쿼리 없음 | 18,318건 | 전부 HIT | 0건 | 192 MB |
요청 수는 Cloudflare 무료 분석의 표본 추정값이다. 쿼리를 붙인 쪽은 요청이 4분의 1인데도 268 MB 를 모두 원본에서 받아 왔다. 쿼리 없는 쪽은 1만 8천 건을 Cloudflare 엣지가 모두 처리했다.
원본 서버 쪽은 A1 에 붙여 둔 모니터링(Alloy → VictoriaMetrics → Grafana)으로 확인해봤다. 컨테이너별 네트워크 패널에서 Cloudflare Tunnel 을 맡는 cloudflared 의 네트워크 지표다 (터널 구성은 Cloudflare Tunnel과 무료 CDN 구성기에 적었다).

① 서비스를 cloudflared 로 필터링
② 10월 17일 부하 테스트 시간
③ 부하 테스트 간 터널이 받고 보낸 양이 1분 평균 2.5 MB/s 까지 올라갔다.
④ 범례의 최댓값.
앞뒤 5분 동안 cloudflared 가 보낸 바이트를 VictoriaMetrics 에서 더하면 302.9 MB 다. 같은 시험을 쿼리 없이 돌린 앞뒤 5분은 1.2 MB 로 평소 트래픽과 차이가 없었다. 같은 날 (OCI A1 Flex 2코어로 워드프레스 RPS 최적화) 측정값으로 cloudflared 는 54 KB 응답 하나를 터널로 넘기는 데 CPU 0.70 ms 정도의 사용량을 보였다. 초당 602건이면 터널 프로세스 하나가 2코어 가운데 0.4코어를 가져간다. IP 하나, curl 반복문 하나로 충분히 만들 수 있는 부하였다.
원본 로그로는 이 상태를 확인하기 어려웠다. 서버의 journald 에 남은 nginx 로그 나흘치(10월 24~27일)를 확인해 봤을 때 /wp-content/·/wp-includes/ 로 시작하는 요청은 83줄이었고 정적 파일 확장자는 5줄뿐이었다. 그 5줄도 모두 apex 도메인(byitx.com)이 301 로 돌려보낸 줄이다. 블로그 호스트의 이미지·CSS·JS 요청은 한 줄도 없다. nginx 의 정적 파일 location 에 access_log off 를 걸어 두었기 때문이다. 정적 파일을 대상으로 들어오는 공격이었다면 Cloudflare Analytics 와 컨테이너 지표로만 어느 정도의 볼륨만 보인다.
30일 Cloudflare Analytics — 공격자도 이 빈틈을 봤을까
빈틈이 있다는 것과 실제로 악용되었다는 것은 다른 이야기다. 9월 28일부터 10월 27일까지(KST) 정적 경로 요청을 Cloudflare GraphQL API 로 모두 받아 요청자별로 분류해 봤다.
| 요청자 | 요청 | 원본까지 | 비율 |
|---|---|---|---|
| 운영자(글 편집·부하 시험) | 50,264 | 21,331 | 42% |
| 검증된 봇(검색·광고 크롤러) | 15,028 | 5,646 | 38% |
| 방문자·기타 | 7,858 | 2,220 | 28% |
| apex·www 리다이렉트 | 3,030 | 1,189 | 39% |
| 스캐너(없는 파일 탐색·차단) | 1,247 | 1,192 | 96% |
| 합계 | 77,427 | 31,578 | 41% |
검증된 봇과 방문자의 원본 요청은 대부분 엣지에 처음 들어온 파일의 첫 MISS 다. 스캐너 1,247건은 IP 164개가 플러그인 폴더의 웹셸 이름(hellopress/wp_filemanager.php)·debug.log·.env·readme.txt 를 찔러 본 요청이다. 정적 파일이 아니라 없는 파일 이름이라 nginx 가 PHP 없이 404·403 으로 끝냈다. 이쪽은 첫 편의 ASN 차단과 네 번째 규칙에서 처리하고 있다.
쿼리 문자열은 무료 플랜의 요청 데이터셋에 없다. 대신 이렇게 추정했다. 같은 IP 가 같은 PoP 에서 같은 파일을 한 시간에 여러 번 MISS 로 받았다면 캐시 키가 매번 달랐다는 뜻이고 그 차이는 거의 쿼리다. 여기서 빈틈이 하나 있었다. 처음 숫자로만 카운팅했을 때 Google Cloud IP 하나가 1분 동안 underscore.min.js 를 100번 MISS 로 받은 것처럼 보였다. 확인해 보니 표본 1건에 가중치(sampleInterval) 100이 붙은 값이었다. 그 IP 는 같은 1분에 .env·config.js 같은 경로를 수백 개 훑던 스캐너라 Cloudflare 가 표본을 크게 줄였던 것이다. 무료 분석에서 ‘몇 번 반복됐나’를 볼 때는 count 대신 count ÷ avg.sampleInterval, 즉 샘플링 수로 세야 한다.
아래 static_cache_report.py 로 Cloudflare 지표를 계산하도록 했다.
daily: 정적 파일 요청을 날짜별로 ‘엣지에서 끝남·원본까지 감’으로 나눈다.busters: 같은 IP·PoP·파일이 한 시간에 N번 이상 MISS 난 경우를 표본 수로 찾는다.events: 사용자 지정 규칙 하나에 걸린 요청을 쿼리 이름까지 묶어 보여 준다. 보안 이벤트(firewallEventsAdaptive)에는 쿼리가 남는다.
export CF_API_TOKEN='...' # Zone > Analytics > Read
export CF_ZONE_ID='...'
python3 static_cache_report.py busters --min 3
python3 static_cache_report.py events --rule <규칙 ID>
Code language: Bash (bash)
#!/usr/bin/env python3
"""Cloudflare 무료 플랜에서 정적 파일(/wp-content/·/wp-includes/) 요청이 캐시를 피해 원본까지 갔는지 본다.
export CF_API_TOKEN=... # Zone > Analytics > Read 권한
export CF_ZONE_ID=... # 대시보드 개요 화면 오른쪽 아래의 Zone ID
python3 static_cache_report.py daily [--days 30]
python3 static_cache_report.py busters [--days 30] [--min 3]
python3 static_cache_report.py events --rule <규칙 ID> [--days 30]
daily : 하루별 정적 파일 요청을 '엣지 캐시가 받음'과 '원본까지 감'으로 나눈다.
busters : 같은 IP 가 같은 PoP 에서 같은 파일을 한 시간에 여러 번 MISS 로 받은 경우를 찾는다.
캐시 키가 매번 달랐다는 뜻이다(대개 쿼리 문자열). 무료 로그에는 쿼리가 없어 이렇게 추정한다.
events : 사용자 지정 규칙 하나에 걸린 요청을 쿼리 문자열까지 보여 준다(보안 이벤트에는 쿼리가 남는다).
"""
import argparse
import collections
import concurrent.futures
import datetime as dt
import json
import os
import unicodedata
import urllib.request
API = 'https://api.cloudflare.com/client/v4/graphql'
PREFIXES = ('/wp-content/%', '/wp-includes/%')
KST = dt.timezone(dt.timedelta(hours=9))
def col(s, n, left=False):
"""한글은 터미널에서 두 칸을 차지한다 — 화면 폭으로 맞춘다."""
s = str(s)
pad = ' ' * max(0, n - sum(2 if unicodedata.east_asian_width(ch) in 'WF' else 1 for ch in s))
return s + pad if left else pad + s
def gql(dataset, fields, flt, limit=10000):
q = ('query($z: String!, $f: Zone%sFilter_InputObject!) { viewer { zones(filter: {zoneTag: $z}) { '
'%s(limit: %d, filter: $f) { %s } } } }') % (dataset[0].upper() + dataset[1:], dataset, limit, fields)
body = json.dumps({'query': q, 'variables': {'z': os.environ['CF_ZONE_ID'], 'f': flt}}).encode()
req = urllib.request.Request(API, body, {'Authorization': 'Bearer ' + os.environ['CF_API_TOKEN'],
'Content-Type': 'application/json'})
with urllib.request.urlopen(req, timeout=60) as r:
data = json.load(r)
if data.get('errors'): # GraphQL 오류는 HTTP 200 으로 온다
raise SystemExit('GraphQL 오류: ' + data['errors'][0]['message'])
return data['data']['viewer']['zones'][0][dataset]
def windows(days):
end = dt.datetime.now(dt.timezone.utc).replace(minute=0, second=0, microsecond=0)
return [(end - dt.timedelta(days=i + 1), end - dt.timedelta(days=i)) for i in range(days)]
def groups(dims, days, **flt):
"""정적 경로 두 갈래 × 하루씩 4개 동시에. 10,000행을 채운 구간은 반으로 나눈다.
count 는 표본에 가중치(sampleInterval)를 곱한 추정값이라, 표본 수도 같이 받아야한다."""
iso = lambda t: t.strftime('%Y-%m-%dT%H:%M:%SZ')
fields = 'count avg { sampleInterval } dimensions { %s }' % dims
def span(t, e, like):
got = gql('httpRequestsAdaptiveGroups', fields, dict(
flt, datetime_geq=iso(t), datetime_lt=iso(e), requestSource='eyeball', clientRequestPath_like=like))
if len(got) < 10000 or e - t <= dt.timedelta(hours=1):
return got
mid = t + (e - t) / 2
return span(t, mid, like) + span(mid, e, like)
jobs = [(t, e, p) for t, e in windows(days) for p in PREFIXES]
with concurrent.futures.ThreadPoolExecutor(4) as ex:
for part in ex.map(lambda j: span(*j), jobs):
for r in part:
r['samples'] = round(r['count'] / (r['avg']['sampleInterval'] or 1))
yield r
def cmd_daily(a):
day = collections.defaultdict(collections.Counter)
for r in groups('date cacheStatus originResponseStatus', a.days):
d = r['dimensions']
c = day[d['date']]
c['req'] += r['count']
c['org' if d['originResponseStatus'] > 0 else 'edge'] += r['count']
c['miss'] += r['count'] if d['cacheStatus'] in ('miss', 'expired') else 0
print(col('날짜', 10, True), col('요청', 8), col('엣지에서 끝남', 14), col('원본까지', 9), col('MISS', 7), col('원본 비율', 10))
for k in sorted(day):
c = day[k]
print(col(k, 10, True), col(f"{c['req']:,}", 8), col(f"{c['edge']:,}", 14), col(f"{c['org']:,}", 9),
col(f"{c['miss']:,}", 7), col(f"{c['org'] / c['req']:.1%}", 10))
def cmd_busters(a):
dims = 'datetimeHour clientIP coloCode clientRequestHTTPHost clientRequestPath userAgent'
hit = collections.Counter()
for r in groups(dims, a.days, cacheStatus='miss', originResponseStatus_gt=0):
d = r['dimensions']
# 표본 수로 센다 — count 는 표본 1건이 100 으로 부풀려질 수 있다
hit[(d['datetimeHour'], d['clientIP'], d['coloCode'], d['clientRequestHTTPHost'], d['clientRequestPath'], d['userAgent'][:40])] += r['samples']
rows = sorted(((n, k) for k, n in hit.items() if n >= a.min), reverse=True)
if not rows:
return print(f'최근 {a.days}일 · 같은 PoP 에서 한 시간에 {a.min}번 이상 MISS 난 파일 없음')
print(f'최근 {a.days}일 · 같은 IP·PoP·파일이 한 시간에 {a.min}번 이상 MISS (표본 기준)')
print(col('MISS', 5), col('시각(KST)', 12, True), col('IP', 16, True), col('PoP', 4, True), ' 경로')
for n, (hour, ip, colo, host, path, ua) in rows[:a.top]:
t = dt.datetime.fromisoformat(hour.replace('Z', '+00:00')).astimezone(KST).strftime('%m-%d %H시')
short = path if len(path) <= 52 else path[:51] + '…'
print(col(n, 5), col(t, 12, True), col(ip, 16, True), col(colo, 4, True), '', host + short, f'[{ua[:18]}]')
def cmd_events(a):
fields = ('datetime clientIP clientASNDescription clientRequestHTTPHost clientRequestPath clientRequestQuery '
'userAgent sampleInterval')
iso = lambda t: t.strftime('%Y-%m-%dT%H:%M:%SZ')
ev = []
for t, e in windows(a.days):
ev += gql('firewallEventsAdaptive', fields, {'datetime_geq': iso(t), 'datetime_lt': iso(e), 'ruleId': a.rule})
# 날짜·IP·호스트·파일·쿼리 이름으로 묶는다(쿼리 값은 매번 다르니 이름만)
g = collections.Counter()
for x in ev:
t = dt.datetime.fromisoformat(x['datetime'].replace('Z', '+00:00')).astimezone(KST).strftime('%m-%d')
qname = x['clientRequestQuery'].lstrip('?').split('=', 1)[0]
g[(t, x['clientIP'], x['clientRequestHTTPHost'], x['clientRequestPath'].rsplit('/', 1)[-1][:34], qname, x['userAgent'][:14])] += x['sampleInterval']
ips = {k[1] for k in g}
print(f'규칙 {a.rule[:8]}… 최근 {a.days}일 · 이벤트 {sum(g.values()):,}건 · IP {len(ips)}개')
print(col('건수', 6), col('날짜', 6, True), col('IP', 16, True), col('쿼리', 5, True), ' 호스트·파일 [User-Agent]')
for (t, ip, host, name, q, ua), n in sorted(g.items())[:a.top]:
print(col(f'{n:,}', 6), col(t, 6, True), col(ip, 16, True), col(q + '=', 5, True), '', f'{host} …/{name} [{ua}]')
def main():
ap = argparse.ArgumentParser(description='정적 파일 요청의 캐시·원본 도달을 본다')
sub = ap.add_subparsers(dest='cmd', required=True)
for name in ('daily', 'busters', 'events'):
p = sub.add_parser(name)
p.add_argument('--days', type=int, default=30, help='최근 며칠(무료 플랜은 30일까지)')
p.add_argument('--top', type=int, default=20)
if name == 'busters':
p.add_argument('--min', type=int, default=3, help='한 시간에 몇 번 이상 MISS 면 표시')
if name == 'events':
p.add_argument('--rule', required=True, help='대시보드 보안 규칙의 규칙 ID')
a = ap.parse_args()
{'daily': cmd_daily, 'busters': cmd_busters, 'events': cmd_events}[a.cmd](a)
if __name__ == '__main__':
main()
Code language: Python (python)

① 한 시간에 세 번 넘게 MISS 난 파일은 30일 동안 딱 1건, 10월 17일 22시 내 A1 부하 시험이다.
② 2번 규칙의 30일 이벤트는 1,480건이고 IP 는 하나다.
③ 10월 18일 규칙을 넣으며 시험한 8건
④ 10월 28일 적용 후 비교 시험.
지난 30일 동안 이 부분을 이용한 공격성 트래픽은 없었다. 다행히 규칙에 걸린 1,480건도 모두 내 시험이고 그 밖의 방문자·봇이 막힌 사례(오탐)도 열흘 동안 없었다.
그래도 규칙을 남겨 둔 이유는 공격하는 쪽과 받는 쪽의 비용 차이가 커서다. 공격하는 쪽은 이미지 주소 하나와 난수만 있으면 된다. 받는 쪽은 요청마다 터널 대역폭과 내 서버의 CPU 를 낭비하게 되고 그 요청은 속도 제한에도 걸리지 않는 상태다. 그리고 표에서 보듯 스캐너는 이미 정적 경로를 들여다보고 있다. 아직 공격 같은 것은 없지만 규칙 하나 만들어 두고 있어 나쁠 것은 없다.
대비 방법과 차단을 선택한 이유
무료 플랜에서 고를 수 있는 방법은 셋이었다.
| 방법 | 무료 플랜 | 결과 | 걸리는 점 |
|---|---|---|---|
| 캐시 레벨 Ignore query string | 가능 | 쿼리를 무시하고 HIT | 존 전체에 걸린다. CSS·JS 의 ?ver= 도 무시돼 업데이트가 늦게 나간다 |
| URL 재작성(Transform Rules)으로 쿼리 지우기 | 가능(Transform Rules 10개, 정규식 없음) | 쿼리를 지운 주소로 HIT | 요청이 정상 응답으로 끝나 누가 시도했는지 남지 않는다 |
| 사용자 지정 규칙으로 차단 | 가능(5개 중 1개) | 엣지 403 | 쿼리가 붙은 정상 요청도 막아버린다 |
Cloudflare에서 URL 재작성을 이용하면 엣지에 들어오자마자 실행되어 뒤쪽(캐시 포함)은 바뀐 주소로 전달된다.(Cloudflare 블로그, Transform Rules 소개). 그래서 두 번째 방법도 쓸 수 있다. Client 입장에서 볼 때 이쪽이 더 유연한 동작을 구현할 수 있다. 하지만 정상 요청 중 쿼리가 붙은 업로드 주소가 없다는 것을 먼저 확인하고 403 차단하는 방향으로 진행했다. 차단하면 보안 이벤트에 쿼리까지 남아서 누가 이런 시도를 하고 있는지 바로 확인할 수 있다. 재작성은 그 요청을 평범한 HIT 로 바꿔 로그로 확인할 수가 없기 때문이다.
규칙 하나로 막기 — ?ver= 는 살린다
두 조건을 or 로 처리하도록 했다.
- 업로드 파일(
/wp-content/uploads/)에 쿼리가 붙어 있으면 막는다. WordPress 는 같은 이름으로 파일을 다시 올리면foo-1.webp처럼 이름을 바꾼다. 업로드 주소에는 쿼리가 필요 없다. - 테마·플러그인·코어(
/wp-content/themes/·/wp-content/plugins/·/wp-includes/)의 CSS·JS(css·js·mjs·map)에 쿼리가 붙어 있고 그 쿼리가ver=나wp-mce-로 시작하지 않으면 막는다.

matches)을 쓸 수 없어 starts_with·in·ne 을 사용한다.두 번째 조건을 CSS·JS 로 좁힌 데는 이유가 있다. 테마 CSS 가 부르는 폰트·이미지는 자기만의 쿼리를 쓴다. 사용 중인 테마는 star.woff2?gmcsp2 를, Font Awesome 은 fontawesome-webfont.eot?v=4.7.0 같은 주소를 쓴다. 확장자를 넓히면 이런 요청이 403 을 받고 아이콘이 깨진다. wp-mce- 는 워드프레스 클래식 편집기의 TinyMCE 가 플러그인·스킨 파일 뒤에 붙이는 캐시 접미사(cache_suffix)다.
http.request.uri.query 는 ? 를 뺀 쿼리 문자열 전체이고 http.request.uri.path.extension 은 경로의 확장자를 소문자로 돌려준다. /foo.JS 도 js 로 잡힌다. 대시보드에서 만든다면 보안 > 보안 규칙(Security rules)에서 사용자 지정 규칙을 만들고 Edit expression 에 아래 식을 넣는다. 동작은 차단(Block), 순서는 ASN 차단 다음이다.
(starts_with(http.request.uri.path, "/wp-content/uploads/") and http.request.uri.query ne "")
or ((starts_with(http.request.uri.path, "/wp-content/themes/")
or starts_with(http.request.uri.path, "/wp-content/plugins/")
or starts_with(http.request.uri.path, "/wp-includes/"))
and http.request.uri.path.extension in {"css" "js" "mjs" "map"}
and http.request.uri.query ne ""
and not starts_with(http.request.uri.query, "ver=")
and not starts_with(http.request.uri.query, "wp-mce-"))
Code language: plaintext (plaintext)

① 위 식이 그대로 들어가 있다(479자).
② 동작은 차단
③ 실행 순서는 1번 ASN 차단 다음이다.
저장하면 사용자 지정 규칙 목록의 두 번째 줄에 들어간다. (같은 화면 아래의 속도 제한 규칙도 있다)

① 2번 규칙
② 이벤트 열의 1.49k 는 모두 내 시험이고 대부분 10월 28일 비교 시험이다.
③ 속도 제한 규칙은 이름 그대로 정적 자원을 카운팅에서 제외한다.
이 블로그는 Terraform 으로 관리한다. 조건식을 locals 에 조각으로 나눠 두었다. 다음에 경로를 하나 더 쓴다면 하나 더 추가하고 Apply 하면 된다.
locals {
waf_wp_static = ["/wp-content/themes/", "/wp-content/plugins/", "/wp-includes/"]
waf_static_query = join(" or ", [
# 업로드 파일 + 쿼리 — WordPress 는 이름을 바꿔 새 파일을 만들므로 쿼리가 필요 없다
"(starts_with(http.request.uri.path, \"/wp-content/uploads/\") and http.request.uri.query ne \"\")",
# 테마·플러그인·코어의 CSS·JS + ver=·wp-mce- 가 아닌 쿼리
format("((%s) and %s)",
join(" or ", [for p in local.waf_wp_static : "starts_with(http.request.uri.path, \"${p}\")"]),
join(" and ", [
"http.request.uri.path.extension in {\"css\" \"js\" \"mjs\" \"map\"}",
"http.request.uri.query ne \"\"",
"not starts_with(http.request.uri.query, \"ver=\")",
"not starts_with(http.request.uri.query, \"wp-mce-\")",
])),
])
}
resource "cloudflare_ruleset" "waf_custom" {
zone_id = var.zone_id
name = "blog-platform custom rules"
kind = "zone"
phase = "http_request_firewall_custom"
rules = [
# 1번 asn_block 은 첫 편
{
ref = "uploads_query_block"
description = "정적 파일 + 캐시 회피 쿼리 차단 (업로드 전부·CSS/JS 의 ver= 외)"
expression = local.waf_static_query
action = "block"
enabled = true
},
# 3번 wp_login_challenge, 4번 junk_block 은 다음 글부터
]
}
Code language: plaintext (plaintext)
무료 플랜에는 Log 동작이 없어서 규칙을 거는 순간 바로 차단된다. 넣기 전에 내 페이지가 쿼리 붙은 정적 파일을 부르는지 먼저 확인했다. 아래 스크립트는 페이지 HTML 에서 같은 호스트의 정적 파일 주소(src·href·srcset)를 모두 꺼내 위 조건식과 같은 판정을 돌린다.
#!/usr/bin/env python3
"""규칙을 넣기 전에, 내 페이지가 부르는 같은 호스트 정적 파일 중 이 규칙에 걸릴 주소가 있는지 본다.
무료 플랜 사용자 지정 규칙에는 Log 동작이 없어서 걸면 바로 차단이다.
python3 static_query_audit.py https://blog.example.com/ https://blog.example.com/some-post/
"""
import html.parser
import sys
import urllib.parse
import urllib.request
THEME = ('/wp-content/themes/', '/wp-content/plugins/', '/wp-includes/')
CODE_EXT = ('css', 'js', 'mjs', 'map')
def blocked(path, query):
"""Cloudflare 규칙 식을 그대로 옮긴 것 — True 면 403."""
if path.startswith('/wp-content/uploads/') and query != '':
return True
ext = path.rsplit('/', 1)[-1].rpartition('.')[2].lower() if '.' in path.rsplit('/', 1)[-1] else ''
return (path.startswith(THEME) and ext in CODE_EXT and query != ''
and not query.startswith('ver=') and not query.startswith('wp-mce-'))
class Assets(html.parser.HTMLParser):
def __init__(self):
super().__init__()
self.urls = []
def handle_starttag(self, tag, attrs):
for k, v in attrs:
if not v:
continue
if k in ('src', 'href', 'data-src', 'poster'):
self.urls.append(v)
elif k in ('srcset', 'data-srcset', 'imagesrcset'):
self.urls += [c.strip().split(' ')[0] for c in v.split(',') if c.strip()]
def main():
seen, n_query, hits = set(), 0, []
for page in sys.argv[1:]:
req = urllib.request.Request(page, headers={'User-Agent': 'static-query-audit'})
with urllib.request.urlopen(req, timeout=20) as r:
p = Assets(); p.feed(r.read().decode('utf-8', 'replace'))
host = urllib.parse.urlsplit(page).hostname
for raw in p.urls:
u = urllib.parse.urlsplit(urllib.parse.urljoin(page, raw))
if u.hostname != host or not u.path.startswith(('/wp-content/', '/wp-includes/')) or u.geturl() in seen:
continue
seen.add(u.geturl())
if u.query:
n_query += 1
if blocked(u.path, u.query):
hits.append(u.geturl())
print(f'페이지 {len(sys.argv) - 1}개 · 같은 호스트 정적 파일 {len(seen)}개 · 쿼리 붙은 것 {n_query}개 · 규칙에 걸리는 것 {len(hits)}개')
for h in hits:
print(' 차단 대상:', h)
if __name__ == '__main__':
main()
Code language: Python (python)
python3 static_query_audit.py https://blog.example.com/ https://blog.example.com/<글 주소>/
Code language: Bash (bash)

① 같은 호스트 정적 파일 277개 중 쿼리가 붙은 16개는 모두
?ver= 다.② 규칙에 걸리는 주소는 0개.
글 본문에 쿼리 붙은 업로드 주소가 있는지도 DB 에서 따로 찾았다. byitx.com 네 사이트의 발행 글 119편에서 0건이었다. 홈 몇 장만 보면 놓치는 페이지가 있으니 카테고리·글·페이지를 한 장씩 섞어 넣는 편이 안전하다.
적용 전후 — 같은 시험을 다시 돌려 보니
적용 뒤 같은 이미지에 같은 동시 접속 20개를 로컬 Mac 에서 스크립트를 돌려 10초씩 다시 보냈다. 엣지에서 판정하기 때문에 클라이언트가 어디 있든 결과는 같다. 아래 edge_burst.py 는 쿼리 없이 또는 매번 다른 쿼리를 붙여 정해진 시간 동안 보내고 응답 코드와 cf-cache-status 별로 센다.
#!/usr/bin/env python3
"""정적 파일 하나에 쿼리를 바꿔 가며 동시에 요청하고, 응답 코드·cf-cache-status 를 센다. 표준 라이브러리만 쓴다.
자기 사이트에서만 쓴다.
python3 edge_burst.py https://blog.example.com/wp-content/uploads/a.webp --query random -c 20 -t 10
--query none 쿼리 없이(같은 캐시 키)
--query random 매번 다른 ?x=<난수>(매번 다른 캐시 키)
"""
import argparse
import collections
import http.client
import os
import threading
import time
import urllib.parse
ap = argparse.ArgumentParser()
ap.add_argument('url')
ap.add_argument('--query', choices=('none', 'random'), default='random')
ap.add_argument('-c', type=int, default=20, help='동시 연결 수')
ap.add_argument('-t', type=float, default=10, help='초')
a = ap.parse_args()
u = urllib.parse.urlsplit(a.url)
stat, size, lock = collections.Counter(), collections.Counter(), threading.Lock()
stop = time.time() + a.t
def worker():
conn = http.client.HTTPSConnection(u.hostname, timeout=10)
while time.time() < stop:
path = u.path + (f'?x={os.urandom(6).hex()}' if a.query == 'random' else '')
try:
conn.request('GET', path, headers={'User-Agent': 'edge-burst', 'Accept-Encoding': 'gzip'})
r = conn.getresponse()
body = r.read()
key, n = (r.status, r.getheader('cf-cache-status', '-')), len(body)
except Exception as e: # 연결이 끊기면 새로 연다
conn.close(); conn = http.client.HTTPSConnection(u.hostname, timeout=10)
key, n = ('ERR', type(e).__name__), 0
with lock:
stat[key] += 1; size[key] += n
t0 = time.time()
ts = [threading.Thread(target=worker) for _ in range(a.c)]
for t in ts: t.start()
for t in ts: t.join()
sec = time.time() - t0
n = sum(stat.values())
print(f'{u.hostname} · 쿼리 {a.query} · 동시 {a.c} · {sec:.1f}초 · 요청 {n:,}건 · 초당 {n / sec:,.0f}건')
for (code, cache), k in stat.most_common():
print(f' {k:6,}건 HTTP {code} cf-cache-status {cache:<8} 평균 응답 {size[code, cache] // k:,} 바이트')
Code language: Python (python)

① 쿼리 없이 보낸 495건은 모두 엣지 캐시가 응답했다(평균 54 KB).
② 매번 다른 쿼리를 붙인 764건은 모두 엣지에서 403(평균 1.7 KB)으로 끝났다.
Cloudflare Analytics 에 남은 기록도 같다. 그 10분 동안 쿼리를 붙인 요청 1,368건(표본 추정)이 전부 엣지 403 이었고 원본 응답은 0건이다. Mac 이 A1 보다 엣지와 멀어 초당 요청 수는 40~70건으로 낮았다. 비교해야 하는 부분은 요청 수가 아니라 원본까지 간 비율과 터널을 지난 바이트다.
대시보드에서도 같은 장면이 보인다. 보안 > Analytics 의 Traffic 탭은 필터에 규칙 ID 가 없어서 소스 IP 로 거르고 캐시 상태로 묶었다. 같은 10분을 GraphQL 로 캐시 상태와 보안 작업에 나눠 보면 ‘없음’으로 잡힌 요청은 사용자 지정 규칙이 막은 1,368건이 거의 전부다.

① 소스 IP 를 Mac 으로 거른 지난 6시간
② 캐시 상태로 묶었다.
③ 15:55 UTC(한국 시각 00:55) 비교 시험. 파란 ‘없음’은 캐시까지 가지 않고 엣지에서 끝난 차단이고 노란 ‘적중’은 쿼리 없이 보내 엣지 캐시가 응답한 요청이다.
④ 6시간 합계

① cloudflared 필터링
② 10월 28일 00:40~01:00
③ 00:54~00:55 시험 구간 — 평소와 구분되지 않는다.
④ 이 20분의 최댓값은 1.56 kB/s 다.

| 시험 | 원본까지 간 비율 | 터널 송신량(앞뒤 5분) |
|---|---|---|
| 적용 전 · 쿼리 붙임 | 100% | 302.9 MB |
| 적용 전 · 쿼리 없음 | 0% | 1.2 MB |
| 적용 후 · 쿼리 붙임 | 0% | 0.23 MB |
이 규칙으로 얻은 효과는 이렇다.
- 캐시를 피하는 정적 파일 요청이 원본 대신 엣지에서 처리된다. 같은 시험 기준으로 터널 트래픽이 302.9 MB 에서 평소 수준으로 낮아졌다.
- 속도 제한의 면제 경로를 그대로 둘 수 있다. 정적 경로를 세지 않아도 그 경로로 원본을 찔러댈 방법이 줄었다.
- 누가 이 구멍을 쓰는지 보안 이벤트로 보인다. 규칙 ID 로 거르면 쿼리까지 나온다.

① 규칙 ID 와 User-Agent 로 걸렀다. 주소 뒤에
?rule-id=<규칙 ID>&user-agent=<값> 을 붙여도 된다.② 걸린 규칙의 이름과 ID
③ 막힌 요청의 경로와 쿼리 문자열이 그대로 남는다.
④
edge_burst.py 가 보낸 User-Agent(UA)막지 않고 둔 것, 그리고 주의할 점
이 규칙이 모든 캐시 회피를 막지는 않는다. 일부러 남긴 것과 적용 전에 확인할 것을 정리해 보면 아래와 같다.
?ver=<임의 값> 은 그대로 원본까지 간다. 앞의 curl 결과 ③이 그 경우다. WordPress 의 캐시 갱신이 이 쿼리에 의존하고 있어서 막으면 테마·플러그인 업데이트를 할 수 없다. 이 요청은 nginx 가 정적 파일로 바로 응답한다. CPU 부담이 거의 없어서 유지하는 것으로 했다.
없는 파일 이름도 원본까지 간다. /wp-content/uploads/<난수>.webp 는 쿼리가 없으니 통과하고 캐시에 없으니 원본에 가서 nginx 404 로 끝난다. PHP 까지는 가지 않는다. 무료 속도 제한은 캐시 상태로 확인할 수 없어서 이 경우는 Cloudflare 의 L7 DDoS 방어와 원본 nginx 에서 대응해야 한다.
업로드 폴더에 CSS·JS 를 만드는 플러그인들은 제외해야 한다. 페이지 빌더나 테마 확장 중에는 생성한 CSS 를 업로드 폴더에 파일로 쓰고 ?ver= 를 붙여 부르는 것이 있다. Elementor 의 uploads/elementor/css/, GeneratePress Premium 의 동적 CSS 외부 파일 같은 경우다. 이 규칙을 그대로 사용하면 해당 CSS는 403 을 받아 브라우저에서 화면이 깨진다. 위 감사 스크립트로 먼저 확인하고 걸리는 폴더는 and not starts_with(http.request.uri.path, "/wp-content/uploads/elementor/") 처럼 제외해야 한다.
쿼리가 붙은 채 퍼진 이미지 링크는 깨진다. 뉴스레터 도구나 SNS 가 이미지 주소에 ?utm_source= 같은 추적 쿼리를 붙이면 그 주소는 403 이다. 이미지 리사이즈 서비스가 원본을 ?w=600 같은 쿼리로 가져오는 구성의 경우도 마찬가지다. 외부에 이미지를 많이 퍼뜨리는 사이트라면 차단 대신 URL 재작성으로 쿼리를 제거하는 방향이 좋을 것 같다.
막힌 요청은 원본 로그에 남지 않는다. 원래도 정적 파일은 nginx 로그에 남지 않는다. 오탐이 생겨도 서버에서는 모른다. 보안 이벤트에서 이 규칙 ID 로 거른 목록을 가끔 보고 정상적인 브라우저의 User-Agent 가 보이면 다시 판단해봐야 할 것 같다.
무료 규칙 5개 중 하나를 쓴다. 같은 이유로 막고 싶은 조건이 생기면 새 규칙을 만들지 말고 이 규칙에 or 로 더하는 편이 무료 규칙 5개 제한을 아낄 수 있다.
정리와 다음 글
- Cloudflare 기본 캐시 키에는 쿼리가 들어간다. 정적 파일이라도 매번 다른 쿼리를 붙이면 매번 원본까지 간다.
- 무료 속도 제한은 캐시된 요청도 세기 때문에 정적 경로를 제외할 수밖에 없다. 제외된 경로와 캐시 회피가 겹쳐 생기는 문제였다.
- 10월 17일 내 부하 시험으로 초당 602건, 5분 동안 302.9 MB 가 원본 서버에 전달되었다. 하지만, 30일 Analytics 에서 확인했을 때 공격 시도 같은 것은 없었다.
- 업로드 파일 + 쿼리, 테마·플러그인·코어 CSS·JS +
ver=·wp-mce-가 아닌 쿼리를 규칙 하나로 차단했다. WordPress 의 캐시 갱신은 그대로 동작한다. - 같은 시험을 다시 돌리니 원본 도달이 100% 에서 0% 로, 터널 송신량은 평소 수준으로 내려왔다. 아직까지 오탐은 없었다.
다음 글은 세 번째 규칙인 wp-login.php 관리형 챌린지다. 9월 18일부터 30일 동안 바깥에서 온 POST /wp-login.php 는 1만 700건쯤이었고(마이 묵었다 아이가) 그중 IP 53개가 보낸 2,032건은 nginx 의 속도 제한을 지나 PHP 까지 전달되었다. 로그인 화면을 열 때 챌린지를 한 번 통과하고 화면 없이 POST로만 찔러보는 시도들은 Cloudflare 엣지에서 차단하는 규칙을 정리해볼 예정이다.