생성형 AI에게 로그인 코드를 부탁하면 돌아가기는 하지만 보안 점검을 거치지 않은 코드가 나오기 쉽습니다. 이 글에서는 그런 코드를 Semgrep으로 점검하고 고친 뒤, 도구가 잡지 못하는 부분이 무엇인지 직접 확인합니다.
외부 AI API는 호출하지 않았습니다. 프롬프트 A(간단한 로그인), B(비밀번호 저장 포함), C(세션과 토큰 포함)에 AI가 내놓기 쉬운 형태의 Flask 코드는 제가 직접 작성한 것이고, 특정 모델이 실제로 출력한 결과가 아닙니다. 변형마다 문제가 다르게 들어 있으며, 연습용 취약 코드이므로 실제 서비스에 쓰지 않고 이 글의 실습 환경에서만 실행합니다. Windows Git Bash에서 Docker Desktop으로 실행했습니다.
준비물
| 항목 | 확인한 값 |
|---|---|
| Semgrep | 1.182.1 (공식 이미지 semgrep/semgrep:latest) |
| 레지스트리 규칙 | p/python, p/flask (실행 시점에 내려받음) |
| Python | 3.12.16 (python:3.12-slim) |
| Flask | 3.0.3 (논리 확인 단계에서만 사용) |
| 셸 | Windows Git Bash (Linux와 macOS 명령은 실행하지 않았습니다) |
아래 열한 개 파일을 한 폴더에 만듭니다. 전체 내용은 글 끝의 ## 전체 코드에 있습니다.
login_a.py
login_b.py
login_c.py
login-extra.yml
scan.sh
summarize.py
fixed_a.py
fixed_b.py
fixed_c.py
Dockerfile
logic_check.py

1. 점검할 로그인 코드 세 벌
세 파일에는 일부러 서로 다른 문제를 넣었습니다.
| 파일 | 프롬프트 | 들어 있는 문제 |
|---|---|---|
login_a.py |
간단한 로그인 | SQL 문자열 결합, 비밀번호 평문 저장과 비교, debug=True, 0.0.0.0 바인딩 |
login_b.py |
비밀번호 저장 포함 | MD5 비밀번호 해시, f-string SQL, 코드에 적은 secret_key |
login_c.py |
세션과 토큰 포함 | MD5로 만든 예측 가능한 토큰, 쿠키 플래그 누락, debug=True, 쿼리 문자열만 보는 /admin |
2. Semgrep으로 점검
scan.sh는 공식 이미지로 p/python, p/flask와 직접 쓴 login-extra.yml을 함께 적용하고, summarize.py가 JSON 결과를 한 줄씩 요약합니다. 공식 문서에 따르면 --config는 규칙 파일, 디렉터리, URL, 레지스트리 이름을 받고 여러 번 쓸 수 있습니다. --metrics off는 사용 통계 전송을 끕니다. 종료 코드는 기본적으로 탐지가 있어도 0이고, --error를 붙여야 1이 됩니다.
login-extra.yml에는 레지스트리 규칙이 잡지 못한 세 가지를 직접 규칙으로 썼습니다. 하드코딩된 secret_key, 플래그 없는 set_cookie, 비밀번호 열의 직접 비교입니다.
sh scan.sh login_a.py login_b.py login_c.py

변형별 결과를 문제 종류로 묶으면 아래와 같습니다.
| 문제 | A | B | C |
|---|---|---|---|
| SQL 문자열 결합 | 탐지 | 탐지 | 해당 없음 |
| 평문 비밀번호 | 직접 규칙만 탐지 | 해당 없음 | 해당 없음 |
| MD5 | 해당 없음 | 탐지 | 탐지(토큰 생성) |
코드에 적은 secret_key |
해당 없음 | 직접 규칙만 탐지 | 해당 없음 |
debug=True |
탐지 | 해당 없음 | 탐지 |
| 쿠키 플래그 누락 | 해당 없음 | 해당 없음 | 직접 규칙만 탐지 |
3. 레지스트리 규칙만 쓰면
같은 파일을 login-extra.yml 없이 점검하면 건수가 줄어듭니다.
MSYS_NO_PATHCONV=1 docker run --rm -v "$(pwd -W):/src" -w /src semgrep/semgrep:latest semgrep scan --config p/python --config p/flask --metrics off --disable-version-check --quiet login_a.py login_b.py login_c.py | grep -E 'Code Findings|login_'

직접 쓴 규칙 login-plaintext-password-compare는 이름과 달리 평문 저장 자체를 보지 않고, SQL 문장 안에 password = '로 비밀번호 열을 직접 비교하는 글자 모양을 찾는 정규식 규칙입니다(규칙 이름은 코드에 쓴 그대로 두었습니다). 그래서 비교 방식이 다른 코드는 놓칠 수 있습니다.
이 실행에서 평문 비밀번호, 코드에 적은 secret_key, 쿠키 플래그 누락은 p/python과 p/flask에서 나오지 않았습니다. 레지스트리 규칙은 계속 바뀌므로 다른 시점에는 결과가 다를 수 있습니다. 또 login_c.py의 MD5는 토큰 생성에 쓰였는데 도구는 "MD5는 약한 해시"라고만 알려 줄 뿐, 토큰이 예측 가능하다는 점은 알려 주지 않았습니다. /admin?admin=1 문제도 탐지되지 않았습니다.
4. 고친 뒤 다시 점검
수정본에는 매개변수 바인딩, werkzeug.security의 해시 함수(B는 scrypt), 환경 변수의 secret_key, secrets.token_urlsafe로 만든 토큰, secure와 httponly와 samesite를 지정한 쿠키, 로컬 바인딩과 디버그 끄기를 적용했습니다.
sh scan.sh fixed_a.py fixed_b.py fixed_c.py

0건은 규칙에 걸리는 모양이 없다는 뜻이고, 코드가 안전하다는 뜻은 아닙니다.
5. 도구가 잡지 못하는 것
수정 과정에서 새로 생기거나 고치지 않고 넘어간, 사람이 읽어야 찾는 결함이 있습니다. logic_check.py가 Flask 테스트 클라이언트로 아래 세 가지를 확인합니다.
- 계정 존재 여부 노출: 수정본 B는 없는 계정과 틀린 비밀번호에 다른 메시지를 돌려줍니다. 원본
login_b.py는 두 경우 모두로그인 실패였으므로, 이 결함은 수정하면서 새로 생긴 것입니다. - 시도 횟수 제한 없음: 30번 연속 실패해도 잠금이나 지연이 없고 곧바로 올바른 비밀번호가 통과합니다.
- 권한 확인 누락: 수정본 C의
/admin은 토큰이 있는지만 보고role을 보지 않아 일반 사용자 guest가 들어갑니다.
docker build -q -t cr-a29-app . && docker run --rm --name cr-a29-run cr-a29-app

이 결과는 Semgrep에 규칙을 더 쓰면 해결되는 문제와 다릅니다. 무엇을 보호해야 하는지 아는 사람이 인증 절차를 읽고 시험해야 합니다. 토큰이 서버에 저장되기만 하고 만료되지 않는 점도 같은 종류입니다.
결과 정리
- AI가 짜 준 로그인 코드에서는 SQL 결합, 약한 해시, 하드코딩 비밀값, 디버그 설정, 쿠키 플래그를 먼저 의심하고 Semgrep으로 걸러 냅니다.
- 레지스트리 규칙만으로는 평문 비밀번호, 하드코딩
secret_key, 쿠키 플래그가 빠졌고, 직접 규칙 세 개로 메웠습니다. - 탐지 0건은 안전하다는 증거가 아닙니다. 인증 논리(메시지, 횟수 제한, 권한 확인)는 사람이 시험합니다.
전체 코드
작업 폴더 구조는 아래와 같습니다.
login_a.py
login_b.py
login_c.py
login-extra.yml
scan.sh
summarize.py
fixed_a.py
fixed_b.py
fixed_c.py
Dockerfile
logic_check.py
login_a.py
# 프롬프트 A 변형: "Flask로 간단한 로그인 만들어 줘" (직접 작성한 연습용 코드, 실제 서비스에 쓰지 않습니다)
import sqlite3
from flask import Flask, request
app = Flask(__name__)
DB = "users_a.db"
def init_db():
con = sqlite3.connect(DB)
con.execute("CREATE TABLE IF NOT EXISTS users (username TEXT, password TEXT)")
con.execute("INSERT INTO users VALUES ('alice', 'alice-pw-1')")
con.commit()
con.close()
@app.route("/login", methods=["POST"])
def login():
username = request.form["username"]
password = request.form["password"]
con = sqlite3.connect(DB)
query = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "'"
row = con.execute(query).fetchone()
con.close()
if row:
return "로그인 성공"
return "로그인 실패", 401
if __name__ == "__main__":
init_db()
app.run(host="0.0.0.0", port=5000, debug=True)
login_b.py
# 프롬프트 B 변형: "비밀번호 저장까지 포함한 Flask 로그인" (직접 작성한 연습용 코드)
import hashlib
import sqlite3
from flask import Flask, request, session
app = Flask(__name__)
app.secret_key = "super-secret-key-1234"
DB = "users_b.db"
def init_db():
con = sqlite3.connect(DB)
con.execute("CREATE TABLE IF NOT EXISTS users (username TEXT, pw_hash TEXT)")
con.commit()
con.close()
@app.route("/register", methods=["POST"])
def register():
pw_hash = hashlib.md5(request.form["password"].encode()).hexdigest()
con = sqlite3.connect(DB)
con.execute("INSERT INTO users VALUES (?, ?)", (request.form["username"], pw_hash))
con.commit()
con.close()
return "가입 완료"
@app.route("/login", methods=["POST"])
def login():
username = request.form["username"]
pw_hash = hashlib.md5(request.form["password"].encode()).hexdigest()
con = sqlite3.connect(DB)
row = con.execute(f"SELECT username FROM users WHERE username = '{username}' AND pw_hash = '{pw_hash}'").fetchone()
con.close()
if row:
session["user"] = row[0]
return "로그인 성공"
return "로그인 실패", 401
if __name__ == "__main__":
init_db()
app.run(host="0.0.0.0", port=5000)
login_c.py
# 프롬프트 C 변형: "세션과 토큰까지 쓰는 Flask 로그인" (직접 작성한 연습용 코드)
import hashlib
import sqlite3
import time
from flask import Flask, make_response, request
app = Flask(__name__)
DB = "users_c.db"
def init_db():
con = sqlite3.connect(DB)
con.execute("CREATE TABLE IF NOT EXISTS users (username TEXT, pw_hash TEXT)")
con.execute("INSERT INTO users VALUES ('alice', ?)", (hashlib.sha256(b"alice-pw-1").hexdigest(),))
con.commit()
con.close()
@app.route("/login", methods=["POST"])
def login():
username = request.form["username"]
pw_hash = hashlib.sha256(request.form["password"].encode()).hexdigest()
con = sqlite3.connect(DB)
row = con.execute("SELECT username FROM users WHERE username = ? AND pw_hash = ?", (username, pw_hash)).fetchone()
con.close()
if not row:
return "로그인 실패", 401
token = hashlib.md5(f"{username}{int(time.time())}".encode()).hexdigest()
resp = make_response("로그인 성공")
resp.set_cookie("auth_token", token)
return resp
@app.route("/admin")
def admin():
if request.args.get("admin") == "1":
return "관리자 화면"
return "권한 없음", 403
if __name__ == "__main__":
init_db()
app.run(host="0.0.0.0", port=5000, debug=True)
login-extra.yml
rules:
- id: login-hardcoded-secret-key
languages: [python]
severity: ERROR
message: Flask secret_key 가 코드에 문자열로 들어 있습니다. 환경 변수나 비밀 저장소에서 읽으십시오.
patterns:
- pattern-either:
- pattern: $APP.secret_key = "..."
- pattern: $APP.config["SECRET_KEY"] = "..."
- id: login-cookie-missing-flags
languages: [python]
severity: WARNING
message: set_cookie 에 secure, httponly, samesite 가 모두 지정되어 있지 않습니다.
patterns:
- pattern: $R.set_cookie(...)
- pattern-not: $R.set_cookie(..., secure=True, httponly=True, samesite=..., ...)
- id: login-plaintext-password-compare
languages: [python]
severity: WARNING
message: 비밀번호 열을 SQL 조건에 직접 비교하고 있습니다. 해시 열을 두고 검증 함수로 비교하십시오.
pattern-regex: password\s*=\s*['"]
scan.sh
#!/bin/sh
# 사용법: sh scan.sh 파일... (Semgrep 공식 이미지로 레지스트리 규칙과 직접 쓴 규칙을 함께 적용)
# Git Bash 에서 -w /src 의 경로가 바뀌지 않게 합니다.
export MSYS_NO_PATHCONV=1
docker run --rm -v "$(pwd -W 2>/dev/null || pwd):/src" -w /src semgrep/semgrep:latest \
semgrep scan --config p/python --config p/flask --config login-extra.yml \
--metrics off --disable-version-check --json --quiet "$@" > result.json
python -X utf8 summarize.py result.json
summarize.py
"""Semgrep JSON 결과를 파일, 줄, 규칙 이름으로 요약합니다. 직접 쓴 규칙은 custom, 레지스트리 규칙은 registry 로 표시합니다."""
import json
import sys
from collections import Counter
data = json.load(open(sys.argv[1], encoding="utf-8"))
rows = []
for r in data["results"]:
rule = r["check_id"].split(".")[-1]
rows.append((r["path"], r["start"]["line"], "custom" if rule.startswith("login-") else "registry", rule))
rows.sort()
for path, line, src, rule in rows:
print(f"{path:<12}{line:>4} {src:<10}{rule}")
if not rows:
print("탐지 0건")
print()
for path, n in sorted(Counter(r[0] for r in rows).items()):
print(f"{path}: {n}건")
print(f"합계: {len(rows)}건")
fixed_a.py
# 변형 A 수정본: 매개변수 바인딩, 해시 비교, 로컬 바인딩, 디버그 끄기
import os
import sqlite3
from flask import Flask, request
from werkzeug.security import check_password_hash, generate_password_hash
app = Flask(__name__)
DB = "users_a.db"
def init_db():
con = sqlite3.connect(DB)
con.execute("CREATE TABLE IF NOT EXISTS users (username TEXT, pw_hash TEXT)")
con.execute("INSERT INTO users VALUES ('alice', ?)", (generate_password_hash("alice-pw-1"),))
con.commit()
con.close()
@app.route("/login", methods=["POST"])
def login():
con = sqlite3.connect(DB)
row = con.execute("SELECT pw_hash FROM users WHERE username = ?", (request.form["username"],)).fetchone()
con.close()
if row and check_password_hash(row[0], request.form["password"]):
return "로그인 성공"
return "로그인 실패", 401
if __name__ == "__main__":
init_db()
app.run(host="127.0.0.1", port=5000, debug=os.environ.get("FLASK_DEBUG") == "1")
fixed_b.py
# 변형 B 수정본: scrypt 해시, 매개변수 바인딩, 환경 변수의 secret_key
import os
import sqlite3
from flask import Flask, request, session
from werkzeug.security import check_password_hash, generate_password_hash
app = Flask(__name__)
app.secret_key = os.environ["SECRET_KEY"]
DB = "users_b.db"
def init_db():
con = sqlite3.connect(DB)
con.execute("CREATE TABLE IF NOT EXISTS users (username TEXT, pw_hash TEXT)")
con.commit()
con.close()
@app.route("/register", methods=["POST"])
def register():
pw_hash = generate_password_hash(request.form["password"], method="scrypt")
con = sqlite3.connect(DB)
con.execute("INSERT INTO users VALUES (?, ?)", (request.form["username"], pw_hash))
con.commit()
con.close()
return "가입 완료"
@app.route("/login", methods=["POST"])
def login():
con = sqlite3.connect(DB)
row = con.execute("SELECT pw_hash FROM users WHERE username = ?", (request.form["username"],)).fetchone()
con.close()
if row is None:
return "존재하지 않는 계정입니다", 401
if not check_password_hash(row[0], request.form["password"]):
return "비밀번호가 틀렸습니다", 401
session["user"] = request.form["username"]
return "로그인 성공"
if __name__ == "__main__":
init_db()
app.run(host="127.0.0.1", port=5000)
fixed_c.py
# 변형 C 수정본: 무작위 토큰, 쿠키 플래그, 서버에 저장한 토큰으로 /admin 확인
import secrets
import sqlite3
from flask import Flask, make_response, request
from werkzeug.security import check_password_hash, generate_password_hash
app = Flask(__name__)
DB = "users_c.db"
TOKENS = {} # 토큰 -> 사용자 이름
def init_db():
con = sqlite3.connect(DB)
con.execute("CREATE TABLE IF NOT EXISTS users (username TEXT, pw_hash TEXT, role TEXT)")
con.execute("INSERT INTO users VALUES ('alice', ?, 'admin')", (generate_password_hash("alice-pw-1"),))
con.execute("INSERT INTO users VALUES ('guest', ?, 'user')", (generate_password_hash("guest-pw-1"),))
con.commit()
con.close()
@app.route("/login", methods=["POST"])
def login():
username = request.form["username"]
con = sqlite3.connect(DB)
row = con.execute("SELECT pw_hash FROM users WHERE username = ?", (username,)).fetchone()
con.close()
if not row or not check_password_hash(row[0], request.form["password"]):
return "로그인 실패", 401
token = secrets.token_urlsafe(32)
TOKENS[token] = username
resp = make_response("로그인 성공")
resp.set_cookie("auth_token", token, secure=True, httponly=True, samesite="Strict")
return resp
@app.route("/admin")
def admin():
if request.cookies.get("auth_token") in TOKENS:
return "관리자 화면"
return "권한 없음", 403
if __name__ == "__main__":
init_db()
app.run(host="127.0.0.1", port=5000)
Dockerfile
FROM python:3.12-slim
RUN pip install --no-cache-dir flask==3.0.3
WORKDIR /app
COPY fixed_a.py fixed_b.py fixed_c.py logic_check.py /app/
CMD ["python", "logic_check.py"]
logic_check.py
"""수정본 B와 C에서 Semgrep이 보지 못하는 논리 결함을 Flask 테스트 클라이언트로 직접 확인합니다."""
import os
import tempfile
os.environ["SECRET_KEY"] = "test-only-key"
os.chdir(tempfile.mkdtemp())
import fixed_b
import fixed_c
fixed_b.init_db()
cb = fixed_b.app.test_client()
cb.post("/register", data={"username": "alice", "password": "alice-pw-1"})
print("[B] 없는 계정 :", cb.post("/login", data={"username": "nobody", "password": "x"}).get_data(as_text=True))
print("[B] 틀린 비밀번호 :", cb.post("/login", data={"username": "alice", "password": "x"}).get_data(as_text=True))
codes = [cb.post("/login", data={"username": "alice", "password": f"guess{i}"}).status_code for i in range(30)]
print("[B] 연속 30회 실패 :", set(codes), "(잠금이나 지연 없이 계속 401)")
print("[B] 그 뒤 올바른 비밀번호:", cb.post("/login", data={"username": "alice", "password": "alice-pw-1"}).get_data(as_text=True))
fixed_c.init_db()
cc = fixed_c.app.test_client()
cc.post("/login", data={"username": "guest", "password": "guest-pw-1"}, base_url="https://localhost")
r = cc.get("/admin", base_url="https://localhost")
print("[C] 일반 사용자 guest 의 /admin :", r.status_code, r.get_data(as_text=True))
자주 막히는 곳
docker run -w /src가C:/Program Files/Git/src로 바뀌어 실패합니다. 오류는the working directory 'C:/Program Files/Git/src' is invalid였습니다. Git Bash의 경로 변환 때문이며export MSYS_NO_PATHCONV=1을 먼저 실행하면 됩니다.scan.sh에는 이 줄을 넣었습니다.- 표 열이 붙어서 나옵니다. 처음에는 출처 열 너비를 8로 해서
registrytainted-sql-string처럼 붙었습니다.summarize.py의 열 너비를 10으로 늘렸습니다.
이어서 해 볼 것
semgrep scan --error로 종료 코드 1을 받아 CI 게이트로 연결합니다.- 수정본 C에
role확인과 토큰 만료를 넣고logic_check.py로 다시 확인합니다. login-extra.yml에 직접 쓴 규칙을 더하고, 규칙마다 일부러 걸리는 코드와 걸리지 않는 코드를 한 쌍씩 만들어 시험합니다.
확인 범위
- 확인한 것: 위의 모든 명령과 출력은 Docker Desktop에서 실제로 실행한 결과입니다. 옵션은
https://docs.semgrep.dev/cli-reference(--config,--error,--metrics, 종료 코드)와https://docs.semgrep.dev/getting-started/cli(--error없이는 종료 코드 0)에서 확인했습니다. - 하지 못한 것: 실제 생성형 AI 모델에 같은 프롬프트를 넣어 비교하지 않았으므로 세 변형은 대표 사례로 쓴 것이며 AI 출력의 통계가 아닙니다. 서버를 띄워 실제 HTTP로 공격해 보지 않았고, Flask 테스트 클라이언트로만 확인했습니다. Linux와 macOS 셸, Semgrep 유료 규칙은 다루지 않았습니다.
- 범위의 한계: 레지스트리 규칙
p/python과p/flask는 실행 시점의 내용이라 결과가 달라질 수 있습니다. 직접 쓴 규칙 세 개는 이 글의 코드 모양에 맞춘 것이라 다른 코드에서는 놓치거나 과하게 잡을 수 있습니다.
이 글의 다음 단계
- Keycloak 로컬 구성과 OIDC PKCE 로그인: 코드 가로채기 방어 확인Docker로 Keycloak을 띄워 realm, client, 테스트 사용자를 구성하고, Flask 클라이언트가 Authorization Code와 PKCE로 로그인해 ID 토큰의 iss, aud, exp, nonce를 검증합니다. PKCE를 요구하지 않는 client에서는 가로챈 인가 코드가 토큰으로 교환되는 것을 재현하고, PKCE S256을 필수로 켜서 code_verifier 없는 교환이 거부되는 것을 확인합니다.
- Node.js JWT alg none 점검: jsonwebtoken verify 옵션 확인jsonwebtoken 9.0.3의 jwt.verify에 헤더가 alg none이고 서명이 빈 토큰을 넣어 실제 결과와 에러 메시지를 봅니다. algorithms 옵션을 고정해야 하는 이유를 RS256과 HS256 혼동으로 설명합니다. 헤더의 alg를 믿는 검증 코드가 뚫리는 과정도 고친 코드와 함께 실행해 확인합니다.