# 생성형 AI가 짜 줄 법한 Flask 로그인 코드를 Semgrep으로 점검하기

> 프롬프트 세 가지(간단한 로그인, 비밀번호 저장 포함, 세션과 토큰 포함)에 AI가 내놓기 쉬운 형태로 직접 쓴 Flask 로그인 코드 세 벌을 Semgrep 레지스트리 규칙과 직접 쓴 규칙 세 개로 점검합니다. 변형별 결과 표, 수정 뒤 재점검, 도구가 잡지 못한 인증 논리 결함 두 가지를 직접 실행해 확인합니다.

- 주소: https://copyandrun.com/blog/ai-generated-login-code-semgrep-review/
- 분야: 시큐어코딩
- 발행일: 2026-11-02
- 태그: Semgrep, Flask, 생성형 AI, 로그인, SAST

생성형 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
```

![작업 폴더의 파일 열한 개와 Semgrep 1.182.1, Python 3.12.16 버전이 출력된 것을 확인합니다.](https://copyandrun.com/img/ai-generated-login-code-semgrep-review/01-tool-versions.png)

## 1. 점검할 로그인 코드 세 벌

<!-- files: login_a.py, login_b.py, login_c.py -->

세 파일에는 일부러 서로 다른 문제를 넣었습니다.

| 파일 | 프롬프트 | 들어 있는 문제 |
|---|---|---|
| `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으로 점검

<!-- files: scan.sh, summarize.py, login-extra.yml -->

`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`, 비밀번호 열의 직접 비교입니다.

```bash
sh scan.sh login_a.py login_b.py login_c.py
```

![세 파일에서 모두 16건이 나오고, custom 표시가 붙은 세 건은 직접 쓴 규칙이 잡은 것임을 확인합니다.](https://copyandrun.com/img/ai-generated-login-code-semgrep-review/02-scan-three-variants.png)

변형별 결과를 문제 종류로 묶으면 아래와 같습니다.

| 문제 | A | B | C |
|---|---|---|---|
| SQL 문자열 결합 | 탐지 | 탐지 | 해당 없음 |
| 평문 비밀번호 | 직접 규칙만 탐지 | 해당 없음 | 해당 없음 |
| MD5 | 해당 없음 | 탐지 | 탐지(토큰 생성) |
| 코드에 적은 `secret_key` | 해당 없음 | 직접 규칙만 탐지 | 해당 없음 |
| `debug=True` | 탐지 | 해당 없음 | 탐지 |
| 쿠키 플래그 누락 | 해당 없음 | 해당 없음 | 직접 규칙만 탐지 |

## 3. 레지스트리 규칙만 쓰면

<!-- files: scan.sh -->

같은 파일을 `login-extra.yml` 없이 점검하면 건수가 줄어듭니다.

```bash
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_'
```

![레지스트리 규칙만 쓴 점검은 13건이며, 16건에서 직접 규칙 세 건이 빠진 것임을 확인합니다.](https://copyandrun.com/img/ai-generated-login-code-semgrep-review/03-registry-only-count.png)

직접 쓴 규칙 `login-plaintext-password-compare`는 이름과 달리 평문 저장 자체를 보지 않고, SQL 문장 안에 `password = '`로 비밀번호 열을 직접 비교하는 글자 모양을 찾는 정규식 규칙입니다(규칙 이름은 코드에 쓴 그대로 두었습니다). 그래서 비교 방식이 다른 코드는 놓칠 수 있습니다.

이 실행에서 평문 비밀번호, 코드에 적은 `secret_key`, 쿠키 플래그 누락은 `p/python`과 `p/flask`에서 나오지 않았습니다. 레지스트리 규칙은 계속 바뀌므로 다른 시점에는 결과가 다를 수 있습니다. 또 `login_c.py`의 MD5는 토큰 생성에 쓰였는데 도구는 "MD5는 약한 해시"라고만 알려 줄 뿐, 토큰이 예측 가능하다는 점은 알려 주지 않았습니다. `/admin?admin=1` 문제도 탐지되지 않았습니다.

## 4. 고친 뒤 다시 점검

<!-- files: fixed_a.py, fixed_b.py, fixed_c.py -->

수정본에는 매개변수 바인딩, `werkzeug.security`의 해시 함수(B는 scrypt), 환경 변수의 `secret_key`, `secrets.token_urlsafe`로 만든 토큰, `secure`와 `httponly`와 `samesite`를 지정한 쿠키, 로컬 바인딩과 디버그 끄기를 적용했습니다.

```bash
sh scan.sh fixed_a.py fixed_b.py fixed_c.py
```

![수정본 세 파일의 점검 결과가 0건으로 나오는 것을 확인합니다.](https://copyandrun.com/img/ai-generated-login-code-semgrep-review/04-rescan-fixed.png)

0건은 규칙에 걸리는 모양이 없다는 뜻이고, 코드가 안전하다는 뜻은 아닙니다.

## 5. 도구가 잡지 못하는 것

<!-- files: Dockerfile, logic_check.py -->

수정 과정에서 새로 생기거나 고치지 않고 넘어간, 사람이 읽어야 찾는 결함이 있습니다. `logic_check.py`가 Flask 테스트 클라이언트로 아래 세 가지를 확인합니다.

- **계정 존재 여부 노출**: 수정본 B는 없는 계정과 틀린 비밀번호에 다른 메시지를 돌려줍니다. 원본 `login_b.py`는 두 경우 모두 `로그인 실패`였으므로, 이 결함은 수정하면서 새로 생긴 것입니다.
- **시도 횟수 제한 없음**: 30번 연속 실패해도 잠금이나 지연이 없고 곧바로 올바른 비밀번호가 통과합니다.
- **권한 확인 누락**: 수정본 C의 `/admin`은 토큰이 있는지만 보고 `role`을 보지 않아 일반 사용자 guest가 들어갑니다.

```bash
docker build -q -t cr-a29-app . && docker run --rm --name cr-a29-run cr-a29-app
```

![B의 두 메시지가 서로 다르고 30회 실패 뒤에도 로그인되며, 일반 사용자 guest의 /admin 응답이 200인 것을 확인합니다.](https://copyandrun.com/img/ai-generated-login-code-semgrep-review/05-logic-gap-check.png)

이 결과는 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

```yaml
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

```bash
#!/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

```python
"""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

```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

```python
"""수정본 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`는 실행 시점의 내용이라 결과가 달라질 수 있습니다. 직접 쓴 규칙 세 개는 이 글의 코드 모양에 맞춘 것이라 다른 코드에서는 놓치거나 과하게 잡을 수 있습니다.
