10월 13일 하루 동안 이 블로그의 워드프레스 wp-login.php 로 POST 요청 1,895건이 들어왔다. nginx 에 IP 당 속도제한을 걸어 두어 대부분은 429 로 처리되었다(1,675건). 하지만 190건 정도가 속도제한을 통과해서 WordPress 에 아이디와 비밀번호를 확인하는 상태까지 들어갔다. 이전에도 9월 28일부터 10월 18일 새벽까지 20일 동안 IP 229개가 로그인 페이지에 POST 7,993건을 보냈고 그중 1,041건이 PHP 까지 들어오는 상태였다.
문고리 마음대로 잡는 행태를 막으려고 Cloudflare 사용자 지정 규칙을 하나 더 추가했다. 경로에 wp-login.php 가 사용되면 관리형 챌린지(Managed Challenge)를 거치도록 하는 한 줄짜리 조건이다. 적용 뒤 열흘 동안 퍼블릭에서 들어온 로그인 POST 는 1건이었고 다행히 그 1건마저도 문고리를 잡고 제끼지는 못했다.

이 글은 byitx.com 에 걸어 둔 Cloudflare 사용자 지정 규칙 4개를 하나씩 설명하는 시리즈의 세 번째 글이다. 첫 번째 글에서는 공격만 보내는 호스팅 회사의 ASN 을 차단하고, 두 번째 글은 정적 파일에 캐시 회피 쿼리를 붙여 원본까지 오는 요청 차단 방법을 정리했다.
이번 내용은 워드프레스 로그인 화면에 대한 추가적인 제한 규칙이다. 어떻게 하면 IP 속도 제한을 뚫고 비집고 들어올 수 있는지 실제 로그로 먼저 확인하고 속도제한 대신 무엇을 기준으로 하면 될지와 추가된 기준으로 무엇을 통과시킬지까지 정리해 보자. 글에 나오는 스크립트와 명령은 도메인과 API 토큰만 바꾸면 각자의 사이트에서 그대로 돌릴 수 있도록 했다.
목차
IP 당 속도 제한이 있었는데 어떻게 PHP 까지 올 수 있을까
이 블로그로 오는 요청은 Cloudflare 엣지 → Tunnel → Nginx → PHP-FPM(WordPress) 순서로 원본 서버에 들어온다. 이번 주제의 규칙을 걸기 전까지 wp-login.php 를 보호하는 역할은 Nginx 의 limit_req 하나였다. (아래)
# 방문자 IP 마다(IPv6 는 /64 단위) 분당 6회. $client_rl_key 는 CF-Connecting-IP 로 만든 키다.
limit_req_zone $client_rl_key zone=wp_login:10m rate=6r/m;
server {
location = /wp-login.php {
limit_req zone=wp_login burst=5 nodelay; # 한 번에 5건까지는 바로 받고, 그 이상이면 429 return
include /etc/nginx/snippets/php-fastcgi.conf;
}
}
Code language: Nginx (nginx)
Cloudflare 로그를 날짜별로 펼쳐 보면 이 제한이 얼마나 효과적인지 보인다. 아래는 글 끝에 전체 코드를 붙인 login_report.py 의 daily 명령 결과다. 운영자 PC 와 서버 자신의 IP 는 --exclude 로 뺐다. 서버의 헬스체크가 10분마다 가짜 로그인 POST 를 보내기 때문이다.

login_report.py daily 결과.① 10월 4일에는 IP 204개가 왔다.
② 10월 13일 1,895건 중 1,675건은 nginx 가 429 로 돌려보냈고 190건은 PHP 까지 갔다(원본 2xx).
③ 규칙이 시작된 10월 18일부터는 하루 0건
④ 적용 전 20.2일과 적용 뒤 9.8일 비교.
‘원본 2xx’ 는 WordPress 가 로그인 실패 화면을 보낸 응답이다. 로그인에 성공한 302 는 한 건도 없었다. ‘원본 3xx’ 는 apex 도메인(byitx.com)으로 온 요청에 대해 nginx 가 PHP 를 거치지 않고 301 을 리턴해준 것이다.

빠른 IP, 느린 IP, 넓게 퍼진 IP
Nginx의 IP 당 속도제한으로 차단되지 않은 요청들을 보려면 IP 별로 묶어 봐야 한다. ips 명령은 같은 기간의 POST 를 IP 별로 묶고 Team Cymru whois 로 ASN 을 붙인다. 조회 방법은 첫 번째 글에서 다뤘다.

login_report.py ips 결과.① AS215930 의 IP 들은 시간당 120건 안팎을 몰아서 보냈다.
대부분 429 였지만 IP 하나에서 200건 가까이가 PHP 까지 갔다.
② OVH 의 51.210.150.97 은 39시간 동안 시간당 5건씩 191건을 보냈다.
429 는 0건이고 191건 모두 PHP 까지 갔다.
③ ASN 으로 묶으면 AS215930 은 IP 5개로 5,733건, PHP 도달 489건이다.
④ 3xK Tech 은 IP 197개가 1건씩 보냈다.
요청하는 스타일이 IP 별로 다르다.
- 빠른 로그인 시도를 하는 IP들: AS215930(CIPHER OPERATIONS)의 IP 5개가 5,733건을 보냈다. 한 번에 몰아서 보내니 90% 넘게 429 로 차단됐다. 그래도 분당 6회와 버스트 5건만큼은 매번 통과해서 489건이 PHP 에 전달됐다. 첫 번째 글에서 ASN 째로 막은 바로 그 회사다. Oracle Cloud Worker 의 IP 7개(1,307건)도 같은 방식이었다.
- 느린 텀으로 로그인을 시도하는 IP들: OVH 의 51.210.150.97 은 39시간에 걸쳐 시간당 5건꼴로 보냈다. 분당 6회에 한 번도 닿지 않으니 nginx 는 한 건도 막지 않았다. 191건이 전부 PHP 까지 전달됐다.
- 다양한 IP로 로그인을 시도하는 IP들: 10월 4일 아침, 3xK Tech(AS200373)의 IP 197개가 1건씩 214건을 보냈다. IP 마다 1건이면 카운팅할 것이 없다. 이 요청들은 apex 도메인으로 와서 301 로 끝났다.

IP 당 속도제한은 하나의 IP 요청이 얼마나 찔러 보는지만 본다. 빠른 IP 에는 효과적이지만 보내는 주기가 느리거나, IP 를 늘리면 허용량이 그만큼 늘어난다. 계산해 보면 IP 하나에 하루 8,640번(분당 6회 × 1,440분)이 열려 있고 IP 가 229개면 하루 200만 번 가까이 된다. 제한을 더 낮추면 비밀번호를 몇 번 틀린 사람이 먼저 막힌다.
그런데 세 가지 유형 모두 로그인 화면을 브라우저로 열지 않았다는 것이다. 빠른 IP 두 개는 로그인 화면을 4,619번 GET 하는 동안 CSS·JS 같은 정적 파일은 8번 받아 갔다. 느린 IP 와 넓게 퍼진 IP 는 정적 파일 요청이 아예 없었다. 넓게 퍼진 IP 는 로그인 화면조차 열지 않고 POST 만 보냈다. User-Agent 는 7,993건 중 7,040건(88%)이 Mozilla/5.0 한 단어였다. 보내는 속도는 제각각이지만 세 녀석 모두 브라우저 없이 HTTP 요청만 던지고 있는 것이다.
서버 부하는 아니었다 — Grafana 로 본 A1의 당시 상태
막기 전에 서버가 얼마나 고통받았는지 확인해 봤다. 이 블로그는 Oracle Cloud 무료 A1 인스턴스 위에서 돌고 있다. 사양은 Neoverse-N1 2 OCPU, 메모리 12GB 인데 OS 에서는 10.6 GiB 로 보인다. 호스트 지표는 Grafana Alloy 가 테일스케일로 연결된 Local Mac 의 VictoriaMetrics 로 보내고 로컬 Grafana 로 모니터링이 가능하다. 이 글을 쓰면서 프로세스별 CPU 와 규칙 적용 시점을 보자면 아래와 같다.

① 2코어·10.6 GiB ② php-fpm 의 30일 평균 CPU 는 코어 2개 대비 0.07%
③ 빨간 점선이 10월 18일 03:31 적용 시점이다.
④ CPU 를 가장 많이 쓰는 프로세스는 자동화 파이프라인의 n8n(평균 0.80%)이고 postgres(0.60%)가 그다음이다.
⑤ php-fpm 은 평균 0.07%, 최대 1.63%.
적용 전과 뒤의 차이는 이 그래프에서 보이지 않는다. 로그인 POST 가 가장 많이 몰린 시간을 확대해도 마찬가지였다. 10월 14일 21시에는 한 시간 동안 POST 246건이 왔고 그중 25건이 PHP 까지 갔다.

① 로그인 POST 246건이 들어온 21~22시에도 최대 0.14% 였다.
② 6시간 평균은 0.078%.
WordPress 는 6.8 부터 비밀번호를 bcrypt 로 저장한다(WordPress 6.8 will use bcrypt for password hashing, 2025-02-17). A1 에서 bcrypt 대조 한 번에 걸리는 시간을 재 봤다.
# WordPress PHP — bcrypt(기본) 암호화 처리에 소요되는 시간
php -r '$h = password_hash("x", PASSWORD_BCRYPT); $t = microtime(true);
for ($i = 0; $i < 20; $i++) password_verify("y", $h);
printf("PHP %s · cost %d · password_verify %.1f ms\n", PHP_VERSION,
password_get_info($h)["options"]["cost"], (microtime(true) - $t) / 20 * 1000);'
# PHP 8.3.36 · cost 10 · password_verify 61.0 ms
Code language: Bash (bash)
한 시간에 25건일 때에도 CPU 점유시간은 2초가 채 되지 않는다. 솔직히 이 숫자를 처음 봤을 때는 좀 허무했다. 하지만, CPU 때문에 규칙을 필요로 하는 건 아니다. 진짜 문제는 1,041번의 시도에서 진짜 워드프레스 로그인 코드에서 아이디와 비밀번호를 대조했다는 점이다. 당시는 Google 로그인 방식과 비밀번호 로그인 방식이 둘 다 가능한 상태였고, IP 를 바꿔 가며 시도되는 Brute Force 공격을 막아 주는 대비책은 비밀번호 복잡도 하나였다. 또한, Brute Force 규모가 커질 경우 부하 문제로도 바뀔 수 있다. 존재하는 아이디로 무차별 대입 요청이 초당 30 정도 들어온다면 bcrypt 대조만으로 코어 2개 가까이를 쓸 수 있다(61 ms × 30 ≈ 1.8 코어).
결국 로그인 시도 요청을 속도제한으로 제한하는 것만으로는 부족해 보였다. 앞에서 본 공통점대로 브라우저가 아닌 요청을 걸러 내는 장치가 필요했다.
사람과 스크립트를 가르는 기준 — 관리형 챌린지
사람이 로그인할 때는 대부분 브라우저를 사용한다. 로그인 화면을 GET 으로 열고 화면의 자바스크립트가 돌고 쿠키를 받은 다음 POST 를 보낸다. 무차별 로그인을 시도하는 도구들은 이 과정을 건너뛰고 POST 요청으로만 이루어진다는 특징이 있다. Cloudflare 의 챌린지가 바로 이 차이를 이용해 방어할 수 있는 도구다.

① 비대화형 챌린지는 페이지에 넣은 자바스크립트로 브라우저 신호를 모아 자동화 여부를 판단하고
② 대개 5초 안에 끝난다.
③ 관리형 챌린지는 요청의 특성을 보고 Cloudflare 가 챌린지 종류를 고른다.
④ 사람은 대부분 자동으로 통과하고
⑤ Cloudflare 는 WAF 규칙에 관리형 챌린지를 쓰라고 권한다.
관리형 챌린지는 대부분의 방문자에게 클릭조차 요구하지 않는다. 브라우저가 챌린지 스크립트를 실행하면 Cloudflare 가 cf_clearance 쿠키를 준다. 쿠키가 살아 있는 동안에는 같은 사이트의 다른 주소에서도 챌린지가 다시 나오지 않는다. 기본 유효 시간은 30분이고 대시보드의 Security Settings > Challenge passage 에서 바꾼다. 이 존은 기본값(1,800초)을 그대로 쓴다.

① 챌린지를 통과하면
cf_clearance 쿠키를 준다.② 쿠키가 유효하면 챌린지를 다시 보여 주지 않는다.
③ XmlHTTP 요청에는 검증 시간을 1시간 더 준다.
④ 기본 유효 시간은 30분이다.
이 존의 설정은 대시보드의 보안 설정에 챌린지 패시지라는 이름으로 나온다. 같은 값을 API 로도 읽을 수 있고, modified_on 이 null 이면 한 번도 바꾸지 않은 기본값이다.

① 30분(기본값)
② 설정을 읽는 API
③ 설정을 바꾸는 API.
# 토큰 권한: Zone > Zone Settings > Read
curl -s -H "Authorization: Bearer $CF_API_TOKEN" \
"https://api.cloudflare.com/client/v4/zones/$CF_ZONE_ID/settings/challenge_ttl" | python3 -m json.tool
# "id": "challenge_ttl", "value": 1800, "modified_on": null, "editable": true
Code language: Bash (bash)


동작을 Block 이 아니라 Managed Challenge 로 고른 이유는 워드프레스 관리자도 이 주소로 로그인을 해야 하기 때문이다. Google OAuth 로그인도 wp-login.php 를 거친다. 구글 로그인 버튼은 wp-login.php?byitx_google=1 을 거쳐 브라우저를 Google 로 보낸다. Google OAuth는 인증 처리 후 code·state 를 붙여 다시 wp-login.php 로 브라우저를 돌려보낸다. 정상적인 접근은 브라우저의 일반 페이지 이동이라 Cloudflare 챌린지를 문제없이 통과할 수 있다.
Cloudflare 챌린지와 다른 방법들을 검토해 봤다.
| 방법 | 오리진 전달여부 | 로그인 영향 | 비고 |
|---|---|---|---|
| 허용 IP 만 받고 나머지 차단 | 안 온다 | 허용 IP 밖에서는 로그인 불가 | 로그인 위치가 대부분 유동 IP 이고 편집자 IP도 추가해야 한다 |
| Cloudflare Access(Zero Trust) | 안 온다 | Access 로그인을 한 번 더 한다 | Zero Trust 정책을 관리해야 하고, Google 로그인+웹서버 인증 (두 번 로그인) |
| 로그인 주소를 바꾸는 플러그인 | 온다(PHP 가 판단) | 없음 | 요청은 여전히 PHP 를 탄다. 주소가 새면 원래대로다 |
| 관리형 챌린지 | 스크립트는 안 온다 | 대부분 아무것도 느끼지 못한다 | – |
규칙 한 줄 — 조건·순서·Terraform
조건은 이것뿐이다.
ends_with(http.request.uri.path, "/wp-login.php")
Code language: plaintext (plaintext)
경로가 /wp-login.php 로 끝나는 요청으로 잡은 데는 이유가 있다. 스캐너는 /wordpress/wp-login.php·/blog/wp-login.php 처럼 설치 위치를 바꿔 가며 요청을 찔러 본다. 이 조건이면 그런 경로도 걸러내면서 존 안의 모든 호스트(멀티사이트의 서브도메인 포함)에도 한 번에 적용이 가능하다. 쿼리는 보지 않는다. ?action=lostpassword 나 ?byitx_google=1 같은 변형도 경로가 같으니 챌린지 대상에 모두 포함된다.
순서는 세 번째다. 사용자 지정 규칙은 위에서부터 평가되고 Block 이나 챌린지에 걸리면 거기서 평가가 끝난다. 첫 번째 규칙(ASN 차단)에 걸리는 회사는 챌린지까지 오지도 못하고 403 수준에서 걸러낼 수 있다.

① 사용자 지정 규칙은 5개 중 4개를 쓰고 있다.
② 이 글의 규칙이 세 번째다.
③ CSR(Challenge Solve Rate)은 챌린지 중 통과한 비율이다.
④ 규칙별 이벤트 수와 추이.
CSR 은 Cloudflare 문서(Challenge solve rate)에서 “통과한 챌린지 수 ÷ 요청된 챌린지 수” 로 정의하고 규칙이 사용된 비율을 가늠하기 위한 지표로 사용한다. 값이 높으면 사람이 챌린지를 많이 받고 있다는 뜻이다. 화면의 10.95% 를 최근 24시간 이벤트로 다시 계산해 보니 10% 안팎이 나왔다. 분모에는 우리 헬스체크 POST 가 들어 있었다. 하루 280건 안팎이고 한 번도 통과시키지 않았다. 단순히 요청만 계산하면 24시간 17.7%, 10일 11.4% 다.

① 규칙 이름
② 조건식(49자/4,000자 중)
③ 동작은 관리 챌린지 — 클라이언트에 대화형 또는 비대화형 챌린지를 낸다.
④ 두 번째 규칙(정적 파일 + 캐시 회피 쿼리 차단) 다음에 실행된다.
Cloudflare 설정은 Terraform 으로 관리하는 것이 편리하다. 한 Zone의 사용자 지정 규칙은 규칙 묶음(ruleset) 하나로 관리되어 규칙이 한 리소스의 rules 목록에서 ④번과 같이 순서에 맞춰 적용된다. Apply 한 번에 전체에 적용할 수 있어 여러 Zone에 적용되어 있어도 번거롭게 따로 수정할 필요가 없어진다.
# terraform/cloudflare/prod/waf_custom.tf (발췌)
locals {
waf_wp_login = "ends_with(http.request.uri.path, \"/wp-login.php\")"
}
resource "cloudflare_ruleset" "waf_custom" {
zone_id = var.zone_id
name = "blog-platform custom rules"
kind = "zone"
phase = "http_request_firewall_custom"
rules = [
# ① asn_block, ② uploads_query_block 이 먼저 온다
{
ref = "wp_login_challenge"
description = "wp-login.php 관리형 챌린지 (분산 로그인 대입)"
enabled = true
expression = local.waf_wp_login
action = "managed_challenge"
},
# ④ junk_block 이 그다음
]
}
Code language: plaintext (plaintext)
대시보드에서 직접 만든다면 Security > Security rules 에서 사용자 지정 규칙을 새로 만들고 표현식 편집 화면에 위의 한 줄을 넣은 뒤 동작으로 Managed Challenge(관리 챌린지) 를 선택하면 된다. 무료 플랜에서도 이 동작을 쓸 수 있고 무료 플랜 사용자 지정 규칙에서 적용되지 않는 동작은 Log 하나뿐이다.

① 무료(free) 플랜 존이다.
② 이 규칙의 동작은 관리 챌린지
③ 무료 플랜 동작은 관리 챌린지·차단·비대화형 챌린지·건너뛰기·대화형 챌린지이고 로그(Log)는 목록에 없다.
검증 — curl 과 헤드리스 크롬
규칙이 잘 걸렸는지 curl 로 바로 확인할 수 있다. 아래 스크립트에서 SITE 만 자기 워드프레스 사이트로 바꿔 사용해보자.
SITE=https://example.com
# ① 쿠키 없이 로그인 POST — 403 과 cf-mitigated: challenge 가 나와야 한다
curl -s -o /dev/null -D - -X POST -d "log=test&pwd=test" "$SITE/wp-login.php" \
| grep -iE "^(HTTP|cf-mitigated|content-type)"
# ② 스크립트가 받는 본문
curl -s "$SITE/wp-login.php" | grep -oE "<title>[^<]*|Enable JavaScript and cookies to continue"
# ③ 다른 페이지는 그대로
curl -s -o /dev/null -w "%{http_code} %{content_type}\n" "$SITE/"
Code language: Bash (bash)

① 로그인 POST 는 403
②
cf-mitigated: challenge 헤더가 붙는다.③ 스크립트가 받는 것은 “Just a moment…” 페이지다.
④ 홈은 200 그대로.
Cloudflare 문서(Detect a Challenge Page response)에 따르면 챌린지 응답에는 챌린지 종류와 상관없이 cf-mitigated: challenge 가 붙고 content-type 은 늘 text/html 이다. 우리 헬스체크도 이 헤더로 규칙이 살아 있는지 10분마다 확인한다.
브라우저 쪽은 빈 프로필의 헤드리스 크롬으로 시험했다. 아래 스크립트는 네 가지 경우를 차례로 돌리고 페이지 이동마다 상태 코드와 cf-mitigated 헤더를 찍는다(Node 22 이상, Chrome 필요).
// wp-login.php 의 Cloudflare 챌린지를 빈 프로필 헤드리스 크롬으로 시험한다. Node 22 이상, Chrome 필요.
// node chal_check.mjs https://example.com/wp-login.php
// ① 브라우저로 GET ② 같은 브라우저로 다시 GET ③ 쿠키 없이 폼 POST ④ 자바스크립트를 끈 GET
// 사람의 브라우저처럼 보이도록 일반 Chrome UA 를 쓴다. HEADLESS_UA=1 이면 기본값(HeadlessChrome)으로 비교해 볼 수 있다.
import { spawn } from 'node:child_process';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const TARGET = process.argv[2];
const CHROME = process.env.CHROME || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36';
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
async function browser(port, fn) {
const dir = mkdtempSync(join(tmpdir(), 'chal-'));
const args = ['--headless=new', '--no-first-run', `--remote-debugging-port=${port}`, `--user-data-dir=${dir}`];
if (!process.env.HEADLESS_UA) args.push(`--user-agent=${UA}`);
const ch = spawn(CHROME, [...args, 'about:blank'], { stdio: 'ignore' });
try {
let url;
for (let i = 0; i < 60 && !url; i++) {
try { url = (await (await fetch(`http://127.0.0.1:${port}/json/version`)).json()).webSocketDebuggerUrl; } catch { await sleep(200); }
}
const ws = new WebSocket(url);
await new Promise((r) => ws.addEventListener('open', r));
let id = 0; const pend = new Map(); const log = [];
ws.addEventListener('message', (e) => {
const m = JSON.parse(e.data);
if (m.id && pend.has(m.id)) { pend.get(m.id)(m.result); pend.delete(m.id); return; }
if (m.params?.type !== 'Document' || !(m.params.request || m.params.response).url.startsWith('http')) return; // 페이지 이동만 본다
if (m.method === 'Network.requestWillBeSent') log.push(` ${m.params.request.method} ${new URL(m.params.request.url).host}`);
if (m.method === 'Network.responseReceived') {
const h = m.params.response.headers;
log.push(` → ${m.params.response.status}${h['cf-mitigated'] ? ' cf-mitigated: ' + h['cf-mitigated'] : ''}`);
}
});
const send = (method, params = {}, sessionId) => new Promise((r) => { const i = ++id; pend.set(i, r); ws.send(JSON.stringify({ id: i, method, params, sessionId })); });
const { targetId } = await send('Target.createTarget', { url: 'about:blank' });
const { sessionId } = await send('Target.attachToTarget', { targetId, flatten: true });
const page = {
send: (m, p) => send(m, p, sessionId),
eval: async (js) => (await send('Runtime.evaluate', { expression: js, returnByValue: true }, sessionId)).result.value,
cookies: async () => (await send('Network.getCookies', { urls: [TARGET] }, sessionId)).cookies.map((c) => c.name), // 이름만
log,
};
await page.send('Network.enable');
await fn(page);
ws.close();
} finally { ch.kill(); await sleep(500); rmSync(dir, { recursive: true, force: true }); }
}
async function report(title, p) {
const err = await p.eval('(document.querySelector("#login_error") || {}).innerText || ""');
console.log(`\n${title}\n${p.log.join('\n')}`);
console.log(` 제목: ${await p.eval('document.title')} · 쿠키: ${(await p.cookies()).join(', ') || '없음'}${err ? ' · 오류: ' + err.trim() : ''}`);
p.log.length = 0;
}
await browser(9351, async (p) => {
await p.send('Page.navigate', { url: TARGET }); await sleep(12000);
await report('① 브라우저로 GET', p);
await p.send('Page.navigate', { url: TARGET }); await sleep(5000);
await report('② 같은 브라우저로 다시 GET', p);
});
await browser(9352, async (p) => {
const form = `<form id=f method=POST action="${TARGET}"><input name=log value=test><input name=pwd value=test></form><script>f.submit()</script>`;
await p.send('Page.navigate', { url: 'data:text/html,' + encodeURIComponent(form) }); await sleep(15000);
await report('③ 쿠키 없이 폼 POST', p);
});
await browser(9353, async (p) => {
await p.send('Emulation.setScriptExecutionDisabled', { value: true });
await p.send('Page.navigate', { url: TARGET }); await sleep(6000);
await report('④ 자바스크립트를 끈 GET', p);
});
Code language: JavaScript (javascript)
$ node chal_check.mjs https://axgo.byitx.com/wp-login.php
① 브라우저로 GET
GET axgo.byitx.com
GET axgo.byitx.com
→ 403 cf-mitigated: challenge
GET challenges.cloudflare.com
→ 200
POST axgo.byitx.com
→ 200
제목: 로그인 ‹ 앜쓰고 — 워드프레스 · 쿠키: cf_clearance, wordpress_test_cookie
② 같은 브라우저로 다시 GET
GET axgo.byitx.com
→ 200
제목: 로그인 ‹ 앜쓰고 — 워드프레스 · 쿠키: cf_clearance, wordpress_test_cookie
③ 쿠키 없이 폼 POST
POST axgo.byitx.com
→ 403 cf-mitigated: challenge
GET challenges.cloudflare.com
→ 200
POST axgo.byitx.com
→ 200
제목: 로그인 ‹ 앜쓰고 — 워드프레스 · 쿠키: wordpress_test_cookie, cf_clearance · 오류: 오류: 이 사이트는 Google 로그인만 씁니다.
④ 자바스크립트를 끈 GET
GET axgo.byitx.com
GET axgo.byitx.com
→ 403 cf-mitigated: challenge
제목: Just a moment... · 쿠키: 없음
Code language: plaintext (plaintext)
| 테스트 | 첫 응답 | 그다음 | 결과 |
|---|---|---|---|
| ① 브라우저로 GET | 403 cf-mitigated: challenge | challenges.cloudflare.com 스크립트가 돌고 같은 주소로 다시 요청 | 200 로그인 화면, cf_clearance 쿠키 생김 |
| ② 같은 브라우저로 다시 GET | 200 | — | 쿠키가 있어 챌린지 없음 |
| ③ 쿠키 없이 폼 POST | 403 cf-mitigated: challenge | 통과 뒤 POST 를 본문째 다시 보냄 | WordPress 가 받아서 “이 사이트는 Google 로그인만 씁니다” |
| ④ 자바스크립트를 끈 브라우저 | 403 cf-mitigated: challenge | 더 진행하지 못함 | “Enable JavaScript and cookies to continue” |
③이 실제 운영에서 중요하다. 통과 쿠키가 없는 상태에서 보낸 POST 도 챌린지를 통과하면 입력한 값이 그대로 전달됐다(Chrome 기준). 로그인 화면을 30분 넘게 열어 두었다가 버튼을 누르는 경우가 이렇다. 또 하나 눈에 띈 것은 User-Agent 다. 스크립트에서 --user-agent 를 빼고 기본 헤드리스 UA(HeadlessChrome)로 돌리면 ①~③ 모두 “잠시만 기다리십시오…” 화면에서 넘어가지 못했다. HEADLESS_UA=1 을 주면 그 경우를 볼 수 있다.

보안 이벤트에는 챌린지를 통과한 요청이 남는다. 같은 Ray ID 로 managed_challenge_non_interactive_solved(클릭 없이 통과, 클릭이 필요했으면 interactive_solved)와 managed_challenge_bypassed 가 함께 찍힌다. 그 뒤 쿠키를 들고 다시 오면 bypassed 한 줄만 남는다. 시험 ①·② 의 이벤트가 정확히 그렇게 남았다. 원본까지 간 요청 수를 알고 싶으면 bypassed 를 카운팅하면 된다.
대시보드의 보안 이벤트 목록에는 solved·bypassed 가 나오지 않는다. 통과한 요청은 Security Analytics 에서 보안 작업을 관리 챌린지 바이패스됨으로 거르면 보인다(주소에 ?mitigation-action=managed_challenge_bypassed 를 붙여도 된다). 30일 동안 220건이 모두 원본에서 제공됐고 전부 Chrome 데스크톱의 GET 이었다. 경로는 모두 /wp-login.php 다.

① 보안 소스는 사용자 지정 규칙, 운영자 PC·서버 IP 는 빼고, 보안 작업은 관리 챌린지 바이패스됨
② 지난 30일 ③ 220건 모두 원본에서 제공됐다.
④ 캐시를 거치지 않는 동적 요청이고 전부 Chrome 의 GET 이다.
⑤ 표본 로그의 경로는 모두
/wp-login.php 다. 소스 IP 는 가렸다.적용 전후 — 엣지 기록과 A1 로그

| 항목(운영자·서버 IP 제외) | 적용 전 20일간 | 적용 뒤 열흘 동안 |
|---|---|---|
| 퍼블릭 로그인 POST | 7,993건 (하루 396) | 1건 |
| PHP 까지 간 로그인 POST | 1,041건 (하루 51.6) | 0건 |
| 원본에 전달된 wp-login 요청 (All Method) | 하루 893건 | 하루 29건 (모두 챌린지를 통과한 GET) |
| nginx 의 wp-login 429 | 하루 661건 | 0건 |
다만 이것이 공격자가 챌린지로 완전히 차단되었다는 뜻은 아니다. 마지막 대입은 적용 27시간 전인 10월 17일 0시였고 그전 20일 동안에도 40시간 동안 로그인 대입 시도가 없었다. 적용 뒤 10일 동안 예전에 대입 공격 IP 는 wp-login.php 에 한 번도 다시 오지 않았다.(포기한 건가?) 다시 오더라도 원본까지 오지 못할 것은 확실하다. A1 과 로컬 Mac 의 헬스체크는 10일 동안 가짜 로그인 POST 2,840건을 보냈고 전부 엣지에서 403 챌린지로 끝났다. (헬스체크는 HTTP 응답이 있으면 ‘OK’ 다)
Zone 대시보드 Security Analytics 에서도 같은 흐름을 확인할 수 있다. 무료 플랜의 Analytics 필터에는 경로 항목이 없어서 wp-login.php 만 따로 고를 수는 없다. 대신 보안 소스를 사용자 지정 규칙으로 좁히고 운영자 PC·서버 IP 를 뺀 뒤 보안 작업별로 묶었다. 사용자 지정 규칙 4개 가운데 관리 챌린지를 쓰는 것은 이 규칙 하나라서 파란 선을 곧 이 규칙의 기록으로 가정할 수 있다.

① 필터에서 사용자 지정 규칙, 소스 IP 제외 (관리IP·서버IP 2개)
② 지난 30일 ③ 관리 챌린지 2.28k, 쿠키로 통과된 챌린지 바이패스 220건. 차단된 460건은 나머지 규칙이다.
④ 규칙을 건 10월 18일 전에는 관리 챌린지가 없었다.
⑤ 10월 26일 밤 Meta 크롤러가 로그인 링크를 열면서 스파이크가 발생했다.
원본 쪽도 봤다. A1 의 nginx 로그는 journald 에 남아 있다. 해당 기간 wp-login.php 줄을 메서드·상태별로 그룹핑했다.

①
wp-login.php 요청 111건이 모두 GET 이다(200 21건, 302 90건). POST 는 0건② IP 106개, IP 하나에 1건꼴
③
wp_login 경로 속도제한에 걸린 요청은 0건이다.111건 중 4건은 나의 로그인 기록이다. 같은 기간 Cloudflare 이벤트의 bypassed 는 115건이었다. 엣지가 통과시켰다고 기록한 수와 원본이 받은 수가 거의 같다. 302 90건은 로그인 창의 Google 로그인 링크(?byitx_google=1)가 Google 로 보낸 것이다.
일반 nginx 의 combined 로그를 쓰는 서버라면 아래처럼 확인 가능하다.
LOG=/var/log/nginx/access.log
# wp-login.php 요청을 메서드·상태별로
awk '$7 ~ /wp-login\.php/ {print $6, $9}' "$LOG" | tr -d '"' | sort | uniq -c
# limit_req 에 걸린 요청 수(error.log)
grep -c 'limiting requests' /var/log/nginx/error.log
# 이 블로그처럼 journald 로 모으고 로그 형식이 다르면 필드 번호만 맞춘다
J="sudo journalctl -t blog-prod-nginx --since 2026-10-24T06:00 --until 2026-10-28T00:00 --no-pager -o cat"
$J | grep -F "/wp-login.php" | awk "{print substr(\$7,2), \$10}" | sort | uniq -c
Code language: Bash (bash)
대시보드의 보안 이벤트에서 규칙 ID 로 필터링하면 개별 요청의 세부 내용을 볼 수 있다.

① 규칙 ID 필터 ② 지난 24시간 ③ 자메이카 IP로 들어온 요청을 열었다
④ ASN 은 현지 통신사(AS30689 FLOW)다.
⑤ 쿼리가
?byitx_google=1&redirect_to=… 로, 블로그 태그 페이지의 로그인 창 링크를 따라왔다.챌린지를 통과하는 요청 — 로그인 링크를 따라온 크롤러
적용 뒤 10일의 이벤트를 events 명령으로 묶었다.

login_report.py events 결과.① GET 2,125건이 챌린지에서 멈췄다. Meta(AS32934)와 Tencent(AS132203)가 많았다.
② 챌린지 285건이 통과됐다. 자동 통과된 요청은 241건, 체크 상자로 푼 것이 36건이다.
③ POST 는 1건이었고 엣지에서 차단되었다.
④ 쿼리의 첫 인자는 대부분
byitx_google 로, 로그인 창의 Google 로그인 링크다.챌린지에 걸린 요청은 대부분 대입이 아닌 크롤러였다. 모든 페이지 머리글의 사람 아이콘에 로그인 창을 달아 두었고 그 안에 wp-login.php?byitx_google=1&redirect_to=<지금 보는 글> 링크가 있다. 크롤러가 이 링크를 따라온 것으로 보인다. 10월 26일 하루에만 Meta 의 크롤러가 490건의 챌린지를 요청했다. AdSense 크롤러(Mediapartners-Google)도 10일 동안 165건이 이 링크로 왔다가 챌린지에서 차단됐다. 규칙 전에는 이런 요청이 매번 PHP 로 로그인 화면으로 이동하거나 Google OAuth 인증화면으로 302 를 응답해 줬다. 규칙 적용 전에 20일간 PHP 까지 간 GET 요청은 2,814건이었다(로그인 대입 공격(GET)과 크롤러가 섞여 있다).
통과한 285건은 Comcast·Charter·T-Mobile·Verizon 같은 미국 가정·모바일 회선이 대부분이었다. 미국 가정집에서 한국어 블로그의 로그인 버튼을 하루 수십 번씩 누를 일이 있을까? 어쨌든 IP 하나에 1건씩, 통과하자마자 Google 로 넘어가고 블로그로 인증 정보를 가지고 돌아오지 못했다. 진짜 브라우저를 사용하는 크롤러가 가정용 프록시를 타는 것으로 추정할 수 있었다. 이런 유형은 챌린지로 막을 수 없다. 관리형 챌린지는 브라우저인지만 판정하기 때문이다.
이 때문에 어쩔 수 없이 워드프레스 자체 로그인도 Off 시켰다. WordPress 코어의 아이디·비밀번호 확인(authenticate 필터의 wp_authenticate_username_password·wp_authenticate_email_password)을 빼고 Google 로그인만 남겼다. 지금 로그인 화면에는 Google 버튼만 남아 있다. 시험 ③처럼 챌린지를 통과한 브라우저가 비밀번호를 보내도 WordPress 가 거부한다.


단점과 주의할 점
브라우저가 아닌 로그인은 모두 막힌다. curl 이나 스크립트 방식으로 wp-login.php 에 로그인하던 자동화, 로그인 화면이 200 인지 보는 외부 모니터링, wp-login 쿠키 인증을 이용하는 어플리케이션들과 플러그인이 이에 해당한다. 이런 방식 외에도 XML-RPC를 이용한 공격 시도 등은 네 번째 WAF 사용자 정의 규칙에서 막을 수 있도록 했다.
모니터링은 403 을 ‘OK’ 로 봐야 한다. 이 블로그의 헬스체크는 거꾸로 cf-mitigated: challenge 가 없으면 알람이 발생하도록 했다. 규칙이 꺼지거나 순서가 바뀌는 사고를 잡기 위해서다.
로그인을 fetch 로 보내면 깨진다. 챌린지는 HTML 페이지를 돌려주므로 HTML 이 아닌 응답을 기대하는 AJAX·fetch 요청은 정상 동작할 수 없다. 테마나 플러그인이 팝업 로그인 창에서 wp-login.php 로 fetch POST 를 보낸다면 통과 쿠키가 없을 때 로그인이 실패한다. 때문에 블로그의 로그인 창은 링크만 두고 있다.

① HTML 이 아닌 응답을 기대하는 AJAX·XHR(fetch) 요청에서는 이 방식이 실패한다.
크롤러와 검증된 봇도 챌린지를 받는다. 무료 플랜의 사용자 지정 규칙은 검증된 봇 예외 필드를 쓸 수 없다(첫 번째 글 참고). wp-login.php 는 색인될 페이지가 아니기 때문에 문제가 없지만 같은 표현식을 글 주소에까지 사용하면 검색 엔진에서도 챌린지를 받게 된다.
챌린지는 인증이 아니다. 실제 브라우저를 돌리는 봇은 챌린지를 통과한다. 앞에서 본 가정 회선 IP를 이용하는 크롤러가 해당한다. 강한 비밀번호, 2단계 인증, 소셜 로그인 같은 애플리케이션 쪽 장치가 같이 있어야 한다.
자바스크립트나 쿠키를 끈 사람은 로그인하지 못한다. TEST ④의 화면과 같이 더 이상 진행할 수 없다.
원본을 직접 부를 수 있으면 소용이 없다. 엣지 규칙은 Cloudflare 를 거치는 요청에만 걸린다. 하지만, 현재 공개 포트 없이 Cloudflare Tunnel 을 통해서만 원본에 접근이 가능하다(Cloudflare Tunnel과 무료 CDN 구성기). 원본 IP 가 열려 있다면 방화벽에서 Cloudflare 대역만 받도록 먼저 막아야 한다.
무료 규칙 5개 중 하나를 사용하게 된다. 이 규칙으로 4개를 채웠다. (규칙 4/5 사용)
워드프레스 wp-login 요청만 정리해서 보는 스크립트
포스팅에 사용된 카운팅은 아래 스크립트를 분석 자료로 사용했다. GraphQL 을 urllib 로 부르는 방식과 표본 데이터를 처리하는 방식은 표준 라이브러리로 만든 Cloudflare 로그 분석 CLI에서 더 자세히 다뤘다.
daily: 날짜별 로그인 요청을 “엣지에서 끝남 / 원본 429 / 원본 3xx / 원본 2xx” 로 나눈다.--mark에 규칙을 건 시각을 주면 앞뒤 하루 평균을 비교할 수 있다.ips: 같은 요청을 IP 별로 묶고 활동한 시간 수와 시간당 건수를 보여 준다. ASN 은 Team Cymru bulk whois 로 붙인다.events: 규칙 ID 로 보안 이벤트를 받아 결과(멈춤·자동 통과·체크 상자 통과·통과 쿠키)와 많이 온 ASN 을 보여 준다.
API 토큰은 Cloudflare 대시보드의 My Profile > API Tokens 에서 Zone > Analytics > Read 권한 하나면 된다. Zone ID 는 존 개요 화면의 API 영역에서 복사한다.
export CF_API_TOKEN=... # Zone > Analytics > Read
export CF_ZONE_ID=...
export MY_IPS=1.2.3.4,5.6.7.8 # 내 PC·서버·모니터링 IP
python3 login_report.py daily --since 2026-09-28T00:00 --mark 2026-10-18T03:31 --exclude "$MY_IPS"
python3 login_report.py ips --until 2026-10-18T03:31 --exclude "$MY_IPS"
python3 login_report.py events --rule <규칙 ID> --since 2026-10-18T03:31 --exclude "$MY_IPS"
Code language: Bash (bash)
스크립트에서 신경 쓴 부분은 이렇다.
- 경로는
clientRequestPath_like: "%/wp-login.php"로 필터링한다./wordpress/wp-login.php같은 경로도 함께 잡힌다. - 내 IP 는 받은 뒤 빼지 않고
clientIP_notin으로 요청 단계에서 제외한다. - 무료 플랜의 요청 집계(
httpRequestsAdaptiveGroups)에는 쿼리 문자열과 ASN 이 없다. 쿼리는 보안 이벤트(firewallEventsAdaptive)에서만 볼 수 있어서events만 쿼리를 쓴다. 그중에서도 첫 인자 이름만 본다. 값에는 주소와 토큰이 들어 있다. - 보안 이벤트는 표본이라
sampleInterval을 곱해서 카운팅해야 한다. - 원본 상태가 ‘0’ 이면 엣지에서 끝난 요청이다(챌린지·차단·엣지 리다이렉트 등).
#!/usr/bin/env python3
"""Cloudflare 무료 플랜 요청 로그에서 로그인 경로(/wp-login.php)만 대상으로 한다.
export CF_API_TOKEN=... # Zone > Analytics > Read 권한
export CF_ZONE_ID=... # 대시보드 개요 화면 오른쪽 아래의 Zone ID
python3 login_report.py daily [--days 30] [--mark 2026-10-18T03:31]
python3 login_report.py ips [--until 2026-10-18T03:31] [--top 12]
python3 login_report.py events --rule <규칙 ID> [--since 2026-10-18T03:31]
공통 옵션: --path /wp-login.php(경로 끝이 이것이면 모두) --method POST --exclude "내 로컬IP,서버 IP"
"""
import argparse
import collections
import concurrent.futures
import datetime as dt
import json
import os
import socket
import unicodedata
import urllib.request
API = 'https://api.cloudflare.com/client/v4/graphql'
Q_REQ = '''query($z: String!, $f: ZoneHttpRequestsAdaptiveGroupsFilter_InputObject!) {
viewer { zones(filter: {zoneTag: $z}) {
rows: httpRequestsAdaptiveGroups(limit: 10000, filter: $f) { count dimensions { %s } } } } }'''
Q_EVT = '''query($z: String!, $f: FirewallEventsAdaptiveFilter_InputObject!) {
viewer { zones(filter: {zoneTag: $z}) {
rows: firewallEventsAdaptive(limit: 10000, filter: $f) { %s } } } }'''
LOCAL = dt.datetime.now().astimezone().tzinfo
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(query, flt):
body = json.dumps({'query': query, '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]['rows']
def fetch(query, a, **flt):
"""기간을 하루씩 나눠 4개씩 동시에 받는다. 한 구간이 10,000행을 채우면 반으로 다시 나눈다."""
iso = lambda t: t.astimezone(dt.timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
flt['clientRequestPath_like'] = '%' + a.path
if a.exclude:
flt['clientIP_notin'] = a.exclude.split(',')
def span(t, e):
got = gql(query, dict(flt, datetime_geq=iso(t), datetime_lt=iso(e)))
if len(got) < 10000 or e - t <= dt.timedelta(minutes=10):
return got
mid = t + (e - t) / 2
return span(t, mid) + span(mid, e)
spans, t = [], a.since
while t < a.until:
spans.append((t, min(t + dt.timedelta(days=1), a.until)))
t = spans[-1][1]
with concurrent.futures.ThreadPoolExecutor(4) as ex:
for part in ex.map(lambda s: span(*s), spans):
yield from part
def requests(a, dims):
q = Q_REQ % ('datetimeHour clientIP clientRequestHTTPMethodName originResponseStatus ' + dims)
return fetch(q, a, requestSource='eyeball', clientRequestHTTPMethodName=a.method)
def local(s):
return dt.datetime.fromisoformat(s.replace('Z', '+00:00')).astimezone(LOCAL)
def outcome(d):
"""요청이 처리된 위치. 원본 상태가 0 이면 엣지(챌린지·차단)에서 끝난 요청이다."""
o = d['originResponseStatus']
return 'edge' if o == 0 else 'o429' if o == 429 else 'o3xx' if 300 <= o < 400 else 'o2xx' if o < 300 else 'oerr'
def cymru(ips):
"""IP → (ASN, AS 이름). 'end' 를 보낸 뒤 종료하지 않고 모두 받을 때까지 계속한다."""
out, ips = {}, sorted(ips)
for i in range(0, len(ips), 2000):
q = 'begin\nverbose\n' + '\n'.join(ips[i:i + 2000]) + '\nend\n'
with socket.create_connection(('whois.cymru.com', 43), timeout=120) as s:
s.sendall(q.encode())
raw = b''.join(iter(lambda: s.recv(65536), b''))
for line in raw.decode('utf-8', 'replace').splitlines():
p = [x.strip() for x in line.split('|')]
if len(p) == 7 and p[0].isdigit():
out[p[1]] = (int(p[0]), p[6].split(' - ', 1)[-1].rsplit(',', 1)[0])
return out
def cmd_daily(a):
rows = list(requests(a, ''))
day = collections.defaultdict(collections.Counter)
ips = collections.defaultdict(set)
for r in rows:
d = r['dimensions']
k = local(d['datetimeHour']).strftime('%m-%d')
day[k]['req'] += r['count']
day[k][outcome(d)] += r['count']
ips[k].add(d['clientIP'])
head = [('날짜', 5), ('요청', 7), ('엣지에서 끝남', 13), ('원본 429', 9), ('원본 3xx', 9), ('원본 2xx', 9), ('IP', 5)]
print(f'{a.method} *{a.path} · {a.since:%m-%d %H시} ~ {a.until:%m-%d %H시}')
print(' '.join(col(h, w, i == 0) for i, (h, w) in enumerate(head)))
t, keys = a.since, []
while t < a.until: # 요청이 없던 날도 0 으로 보인다
keys.append(t.strftime('%m-%d')); t += dt.timedelta(days=1)
for k in keys:
c = day[k]
vals = [k, f"{c['req']:,}", f"{c['edge']:,}", f"{c['o429']:,}", f"{c['o3xx']:,}", f"{c['o2xx']:,}", len(ips[k])]
print(' '.join(col(v, w, i == 0) for i, (v, (_, w)) in enumerate(zip(vals, head))))
if a.mark: # 규칙을 건 시각 앞뒤를 하루 평균으로 비교한다(그 시각이 든 한 시간은 앞쪽으로 센다)
cut = a.mark.replace(minute=0, second=0, microsecond=0) + dt.timedelta(hours=1)
for name, sel, span in (('적용 전', [r for r in rows if local(r['dimensions']['datetimeHour']) < cut], cut - a.since),
('적용 뒤', [r for r in rows if local(r['dimensions']['datetimeHour']) >= cut], a.until - cut)):
days = span.total_seconds() / 86400
c = collections.Counter()
for r in sel:
c['req'] += r['count']; c[outcome(r['dimensions'])] += r['count']
print(f"{name} {days:4.1f}일 · 요청 {c['req']:,}(하루 {c['req'] / days:,.0f}) · 원본 2xx {c['o2xx']:,}"
f"(하루 {c['o2xx'] / days:,.1f}) · IP {len({r['dimensions']['clientIP'] for r in sel})}개")
def cmd_ips(a):
ip = collections.defaultdict(lambda: {'req': 0, 'o2xx': 0, 'o429': 0, 'hours': set()})
for r in requests(a, ''):
d, g = r['dimensions'], ip[r['dimensions']['clientIP']]
g['req'] += r['count']; g['hours'].add(d['datetimeHour'])
g[outcome(d)] = g.get(outcome(d), 0) + r['count']
if not ip:
return print('요청 없음')
asn = cymru(ip)
print(f'{a.method} *{a.path} · {a.since:%m-%d %H시} ~ {a.until:%m-%d %H시} · '
f'IP {len(ip)}개 · 요청 {sum(g["req"] for g in ip.values()):,} · 원본 2xx {sum(g["o2xx"] for g in ip.values()):,}')
print(col('IP', 16, True), col('요청', 6), col('429', 6), col('2xx', 5), col('활동', 5), col('시간당', 6), ' ASN')
for k, g in sorted(ip.items(), key=lambda kv: -kv[1]['req'])[:a.top]:
n, name = asn.get(k, (0, '?'))
h = len(g['hours'])
print(col(k, 16, True), col(f"{g['req']:,}", 6), col(f"{g['o429']:,}", 6), col(g['o2xx'], 5),
col(f'{h}h', 5), col(f"{g['req'] / h:.0f}", 6), '', f'AS{n} {name[:22].rstrip()}')
agg = collections.defaultdict(lambda: collections.Counter())
for k, g in ip.items():
n, name = asn.get(k, (0, '?'))
agg[(n, name)]['ip'] += 1; agg[(n, name)]['req'] += g['req']; agg[(n, name)]['o2xx'] += g['o2xx']
print()
print(col('ASN', 8), col('AS 이름', 25, True), col('IP', 4), col('요청', 6), col('2xx', 5), col('IP당', 5))
for (n, name), c in sorted(agg.items(), key=lambda kv: -kv[1]['req'])[:a.top // 2]:
print(col(n, 8), col(name[:24], 25, True), col(c['ip'], 4), col(f"{c['req']:,}", 6), col(c['o2xx'], 5),
col(f"{c['req'] / c['ip']:.0f}", 5))
ACTIONS = {
'managed_challenge': '챌린지를 받고 멈춤',
'managed_challenge_non_interactive_solved': '자동으로 통과',
'managed_challenge_interactive_solved': '체크 상자로 통과',
'managed_challenge_bypassed': '통과 쿠키로 지나감',
}
def cmd_events(a):
fields = 'action clientIP clientAsn clientASNDescription clientRequestHTTPMethodName clientRequestQuery sampleInterval'
flt = {'ruleId': a.rule} if a.rule else {}
ev = list(fetch(Q_EVT % fields, a, **flt))
if not ev:
return print('이벤트 없음')
w = lambda e: e['sampleInterval'] # 표본 하나에 카운팅된 요청 수
by = collections.Counter()
for e in ev:
by[(e['action'], e['clientRequestHTTPMethodName'])] += w(e)
print(f'규칙 {a.rule or "(전체)"} · {a.since:%m-%d %H시} ~ {a.until:%m-%d %H시} · 이벤트 {sum(map(w, ev)):,}건 · '
f'IP {len({e["clientIP"] for e in ev}):,}개')
print(col('결과', 20, True), col('메서드', 6, True), col('건수', 6), ' 많이 온 ASN')
for (act, m), n in by.most_common():
top = collections.Counter()
for e in ev:
if e['action'] == act and e['clientRequestHTTPMethodName'] == m:
top[f"AS{e['clientAsn']} {e['clientASNDescription'].split(',')[0][:14]}"] += w(e)
print(col(ACTIONS.get(act, act), 20, True), col(m, 6, True), col(f'{n:,}', 6), ' ',
' · '.join(f'{k} {v}' for k, v in top.most_common(2)))
keys = collections.Counter()
for e in ev: # 쿼리 문자열의 첫 인자 이름만 본다(값에는 주소·토큰이 들어 있다)
first = e['clientRequestQuery'].lstrip('?').split('&')[0].split('=')[0]
keys[first or '(쿼리 없음)'] += w(e)
print('쿼리 첫 인자:', ' · '.join(f'{k} {v:,}' for k, v in keys.most_common(4)))
def when(s):
t = dt.datetime.fromisoformat(s)
return t if t.tzinfo else t.replace(tzinfo=LOCAL)
def main():
ap = argparse.ArgumentParser(description='Cloudflare 요청 로그에서 워드프레스 로그인 경로만 확인')
sub = ap.add_subparsers(dest='cmd', required=True)
for name in ('daily', 'ips', 'events'):
p = sub.add_parser(name)
p.add_argument('--days', type=int, default=30, help='--since 가 없을 때 최근 며칠(무료 플랜은 30일까지)')
p.add_argument('--since', type=when)
p.add_argument('--until', type=when)
p.add_argument('--path', default='/wp-login.php')
p.add_argument('--method', default='POST')
p.add_argument('--exclude', help='뺄 IP(쉼표) — 내 PC·서버·모니터링')
p.add_argument('--top', type=int, default=12)
if name == 'daily':
p.add_argument('--mark', type=when, help='규칙을 건 시각 — 앞뒤 하루 평균을 비교한다')
if name == 'events':
p.add_argument('--rule', help='사용자 지정 규칙 ID(대시보드 규칙 편집 화면 · API)')
a = ap.parse_args()
now = dt.datetime.now(LOCAL).replace(minute=0, second=0, microsecond=0)
a.until = a.until or now
a.since = a.since or a.until - dt.timedelta(days=a.days)
{'daily': cmd_daily, 'ips': cmd_ips, 'events': cmd_events}[a.cmd](a)
if __name__ == '__main__':
main()
Code language: Python (python)
정리와 다음 글
- IP 당 제한은 얼마나 자주 요청하는지만 보면 된다. 20일 동안 IP 229개가 보낸 로그인 POST 7,993건 중 1,041건이 nginx 의 분당 6회 제한을 받지 않고 WordPress 로그인까지 왔다. 느리게 보내는 IP 와 여러 IP 를 동시에 이용한 로그인 시도는 Nginx의 속도 제한에 걸리지도 않았다. (ㅜㅜ)
- 공격이 몰린 시간에도 php-fpm CPU 는 0.14% 였으니 서버 부하 때문만은 아니다. 비밀번호 추측이 실제 워드프레스 인증 코드에 대입되는 것을 막고 싶었다.
- 로그인 대입 도구는 브라우저를 이용한 시도가 아니라는 공통점이 있다.
ends_with(http.request.uri.path, "/wp-login.php")에 관리형 챌린지를 걸자 10일 동안 서버에 들어온 로그인 시도는 0건이 됐다. 내가 설정한 헬스체크 요청 2,840건도 엣지에서 처리되었다. - 정상적인 브라우저 로그인은 영향이 없다. 바이패스 쿠키가 없는 POST 도 챌린지를 통과하면 본문 그대로 서버에 전달됐다.
- 챌린지는 인증이 아니다. 진짜 브라우저를 사용하는 크롤러들은 통과한다. 때문에 WordPress 쪽에서 비밀번호 로그인을 끄고 Google 로그인만 남겼다.
다음 글은 이 시리즈의 마지막인 네 번째 규칙이다. xmlrpc.php, 설치 화면(install.php·setup-config.php), 댓글·트랙백 접수, 로그인 쿠키 없는 REST batch, 80·443 이 아닌 엣지 포트, WordPress 호스트로 온 n8n 전용 경로. 쓰는 사람이 없는데 원본까지는 들어오는 여섯 가지를 규칙 하나로 묶어 엣지에서 차단했다. 정말 사용되지 않는지 로그로 확인하고, 규칙 하나에 or 로 묶는 방법을 정리해 보겠다.