# auth.log로 SSH 침입 흔적 읽기: 실패 반복, 성공 로그인, 직후 sudo를 시간순으로

> 컨테이너에 openssh-server와 rsyslog를 띄우고 ssh 명령 몇 번으로 실패 로그인 7번과 성공 로그인 1번을 만든 뒤, 실제 auth.log에서 실패 반복, 실패 뒤 첫 성공, 성공 세션의 sudo와 계정 생성 기록을 파이썬 스크립트로 시간순 타임라인으로 읽습니다. 키 인증 전환과 로그 보존 점검표도 함께 봅니다.

- 주소: https://copyandrun.com/blog/linux-auth-log-ssh-intrusion-triage/
- 분야: 침해사고·포렌식
- 발행일: 2026-11-02
- 태그: auth.log, SSH, sudo, 침해 사고 분석, 키 인증

SSH 서버가 뚫렸는지 의심될 때 가장 먼저 열어 보는 기록이 `/var/log/auth.log`입니다. 이 글은 같은 서버에 남은 실패 로그인, 실패 뒤의 첫 성공 로그인, 그 세션 안에서 일어난 sudo 명령을 하나의 시간순 타임라인으로 엮어 읽는 방법을 다룹니다.

Windows Git Bash에서 Docker Desktop으로 실행했고, 모든 컨테이너는 전용 bridge 네트워크(사설 대역 10.89.40.0/24)에만 연결했습니다. 로그는 `ssh` 명령 여덟 번(실패 7번, 성공 1번)으로 직접 만든 소량이며, 반복 시도 도구는 쓰지 않았습니다. 시험 계정과 비밀번호는 연습용이므로 실제 서버에 그대로 쓰지 않습니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| 실행 환경 | Docker 컨테이너 3개(서버 1, 접속하는 쪽 2), `debian:12-slim` 기반 |
| OpenSSH | OpenSSH_9.2p1 Debian-2+deb12u10 (서버와 클라이언트) |
| sudo | 1.9.13p3 |
| rsyslog | 8.2302.0 |
| Python | 3.11.2 (표준 라이브러리만 사용) |
| 보조 도구 | `sshpass`(틀린 비밀번호를 명령행으로 넘기는 용도, 호출마다 한 번만 시도) |

작업 폴더는 아래 여섯 파일입니다. 전체 내용은 글 끝의 `## 전체 코드`에 있습니다.

```
Dockerfile
start.sh
triage.py
make_logs.sh
harden.sh
hardening.conf
```

## 1. 서버와 접속 쪽 컨테이너 준비

<!-- files: Dockerfile, start.sh, triage.py -->

`Dockerfile`은 OpenSSH 서버, rsyslog, sudo, 파이썬을 설치하고 `start.sh`와 `triage.py`를 `/opt`에 넣습니다. `start.sh`는 시험 계정 `deploy`를 만들고(sudo 그룹 포함) rsyslog를 띄운 뒤 sshd를 실행합니다. 컨테이너에는 systemd가 없어서 rsyslog가 `/var/log/auth.log`를 쓰도록 직접 띄우는 부분이 필요합니다.

서버(`cr-f9-sshd`)는 10.89.40.10, 접속하는 쪽은 `cr-f9-a`(10.89.40.21)와 `cr-f9-b`(10.89.40.22)입니다. 서버의 22번 포트는 호스트 127.0.0.1에만 연결합니다.

```bash
docker build -q -t cr-f9-ssh:latest . >/dev/null && echo built
docker network create --subnet 10.89.40.0/24 cr-f9-net
docker run -d --name cr-f9-sshd --network cr-f9-net --ip 10.89.40.10 -p 127.0.0.1:18040:22 cr-f9-ssh:latest
docker run -d --name cr-f9-a --network cr-f9-net --ip 10.89.40.21 cr-f9-ssh:latest sleep 3600
docker run -d --name cr-f9-b --network cr-f9-net --ip 10.89.40.22 cr-f9-ssh:latest sleep 3600
```

Git Bash에서 `docker exec`에 `/`로 시작하는 경로를 넘길 때는 먼저 `export MSYS_NO_PATHCONV=1`을 실행합니다. 그렇지 않으면 경로가 Windows 경로로 바뀝니다.

![서버 컨테이너 한 개와 접속용 컨테이너 두 개가 전용 네트워크에서 올라오고, 서버의 22번 포트가 127.0.0.1:18040에만 연결된 것을 확인합니다.](https://copyandrun.com/img/linux-auth-log-ssh-intrusion-triage/01-lab-environment.png)

## 2. 시험 로그 만들기

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

`make_logs.sh`는 시나리오를 만듭니다. 접속하는 쪽 A는 계정을 바꿔 가며 4번 실패하고 끝납니다. B는 `deploy` 계정으로 3번 실패한 뒤 올바른 비밀번호로 로그인해서 sudo 명령 세 개를 실행합니다. 세 명령은 `id`, `cat /etc/shadow`(출력은 버립니다), `useradd -m svc-backup`입니다.

```bash
sh make_logs.sh
```

`ssh`가 `Permission denied, please try again.`을 찍는 일곱 번이 실패 시도이고, `uid=0(root)...` 한 줄이 B의 `sudo id` 결과입니다.

## 3. 실패 로그인 읽기

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

`auth.log`의 실패는 두 모양으로 남습니다. 존재하는 계정은 `Failed password for 계정 from IP`, 없는 계정은 `Invalid user 계정 from IP`가 먼저 나오고 이어서 `Failed password for invalid user 계정 ...`가 나옵니다.

```bash
docker exec cr-f9-sshd grep -cE 'Failed password' /var/log/auth.log
docker exec cr-f9-sshd grep -E 'Invalid user|Failed password' /var/log/auth.log | cut -c1-140
```

```
7
2026-11-01T15:17:26.377529+00:00 04687bc17846 sshd[43]: Failed password for deploy from 10.89.40.21 port 44738 ssh2
2026-11-01T15:17:28.850418+00:00 04687bc17846 sshd[45]: Failed password for deploy from 10.89.40.21 port 36870 ssh2
2026-11-01T15:17:29.625219+00:00 04687bc17846 sshd[47]: Invalid user admin from 10.89.40.21 port 36872
2026-11-01T15:17:31.349633+00:00 04687bc17846 sshd[47]: Failed password for invalid user admin from 10.89.40.21 port 36872 ssh2
2026-11-01T15:17:34.236062+00:00 04687bc17846 sshd[49]: Failed password for root from 10.89.40.21 port 36880 ssh2
2026-11-01T15:17:37.031574+00:00 04687bc17846 sshd[51]: Failed password for deploy from 10.89.40.22 port 51804 ssh2
2026-11-01T15:17:39.628979+00:00 04687bc17846 sshd[53]: Failed password for deploy from 10.89.40.22 port 51814 ssh2
2026-11-01T15:17:42.979579+00:00 04687bc17846 sshd[55]: Failed password for deploy from 10.89.40.22 port 51828 ssh2
```

![실패 7건이 10.89.40.21의 4건과 10.89.40.22의 3건으로 나뉘고, 없는 계정 admin은 Invalid user로 먼저 기록되는 것을 확인합니다.](https://copyandrun.com/img/linux-auth-log-ssh-intrusion-triage/02-failed-logins-raw.png)

읽을 때 보는 곳은 세 군데입니다. 출처 IP, 시도한 계정 이름(`admin`, `root`처럼 흔한 이름이 섞였는지), 시각 간격입니다. 이 시험에서는 로그인 실패마다 PAM(`pam_unix`)이 약 2초씩 지연을 두기 때문에 간격이 2~5초입니다. 시각이 빽빽한 실제 로그와는 다를 수 있습니다.

## 4. 성공 로그인과 직후 sudo 읽기

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

성공은 `Accepted password for 계정 from IP`(키 인증이면 `Accepted publickey`) 한 줄로 남고, 같은 `sshd[PID]`의 `session opened`와 `session closed`가 세션의 시작과 끝입니다. sudo는 `sudo:` 뒤에 계정, 작업 폴더, 대상 계정, 실행한 명령을 한 줄에 적습니다. 새 계정은 `useradd[PID]: new user:` 줄로 남습니다.

```bash
docker exec cr-f9-sshd grep -E 'Accepted|session opened|sudo|new user|session closed' /var/log/auth.log | grep -v pam_limits | cut -c12-
```

![Accepted 한 줄 뒤에 sudo 세 줄과 new user 한 줄이 이어지고 같은 sshd PID의 session closed로 끝나는 순서를 확인합니다.](https://copyandrun.com/img/linux-auth-log-ssh-intrusion-triage/03-accepted-and-sudo-raw.png)

두 가지를 알아 두면 좋습니다. sudo 줄에는 sshd의 PID가 없어서 어느 로그인 세션에서 나왔는지 로그만으로는 바로 이어지지 않습니다. 그래서 같은 계정이 로그인 세션이 열려 있던 시간 안에 실행한 sudo 줄을 그 세션의 것으로 봅니다. 다른 터미널에서 같은 계정으로 동시에 로그인했다면 구분할 수 없으므로 후보로만 봅니다. 또 `pam_limits ... Could not set limit for 'core'` 줄은 컨테이너 제약 때문에 나오는 경고라 위 명령에서 걸러 냈습니다.

## 5. 타임라인 스크립트

<!-- files: triage.py -->

`triage.py`는 로그를 한 번 읽어 세 가지를 출력합니다.

- IP별 실패 횟수와 시도한 계정, 첫 시각과 마지막 시각
- 성공 로그인마다 같은 IP의 직전 실패 횟수(이전 성공 이후만 셉니다). 기준 이상이면 "의심"
- 의심 세션의 실패, 성공, sudo, 계정 생성, 세션 종료를 시간순으로

```bash
docker exec cr-f9-sshd python3 /opt/triage.py /var/log/auth.log
```

```
[1] IP별 실패 횟수
IP              실패  시도한 계정                첫 시각 ~ 마지막 시각
10.89.40.21      4  admin,deploy,root     15:17:26 ~ 15:17:34
10.89.40.22      3  deploy                15:17:37 ~ 15:17:42

[2] 실패 뒤 첫 성공 로그인 (기준: 실패 3회 이상)
의심  15:17:45  deploy 출처 10.89.40.22  password  직전 실패 3회

[3] 의심 세션의 시간순 타임라인
세션 sshd[57] 출처 10.89.40.22
  15:17:37  실패 deploy
  15:17:39  실패 deploy
  15:17:42  실패 deploy
  15:17:45  성공 로그인 deploy (password)
  15:17:45  sudo root: /usr/bin/id
  15:17:45  sudo root: /usr/bin/cat /etc/shadow
  15:17:45  sudo root: /usr/sbin/useradd -m svc-backup
  15:17:45  계정 생성 svc-backup
  15:17:45  세션 종료
```

![10.89.40.21은 실패 4건으로 끝났고 10.89.40.22는 실패 3건 뒤 성공해서 sudo 세 개와 계정 생성이 이어지는 타임라인을 확인합니다.](https://copyandrun.com/img/linux-auth-log-ssh-intrusion-triage/04-triage-timeline.png)

해석은 이렇게 합니다. 실패가 더 많은 쪽은 A지만 로그인에 성공하지 못했습니다. 눈여겨볼 쪽은 실패 뒤 성공한 B이고, 성공 직후 `/etc/shadow`를 읽고 새 계정을 만든 행동이 이어집니다. 실제 사고에서는 이런 패턴만으로 침입이라고 단정하지 않고, 정당한 사용자가 비밀번호를 몇 번 틀린 것인지 출처 IP와 평소 접속 기록으로 확인합니다. 기준 횟수 3은 이 시험용 값이며 `--threshold`로 바꿉니다.

## 6. 대응: 키 인증 전환과 점검표

<!-- files: harden.sh, hardening.conf -->

`harden.sh`는 접속하는 쪽 B에서 ed25519 키를 만들어 서버 `deploy` 계정에 등록하고, 먼저 키로 접속되는지 확인하고(성공하면 출력이 없고, 실패하면 메시지를 찍고 멈춥니다), 그다음 `hardening.conf`를 `sshd_config.d`에 넣어 `sshd -t`로 문법을 확인한 뒤 sshd에 SIGHUP을 보내 다시 읽게 합니다. 이 컨테이너에서는 sshd가 PID 1이라 `kill -HUP 1`을 썼습니다. 설정 네 줄의 기본값은 OpenSSH 공식 문서 기준으로 `PasswordAuthentication yes`, `PermitRootLogin prohibit-password`, `MaxAuthTries 6`, `LoginGraceTime 120`입니다.

```bash
sh harden.sh
```

![비밀번호 로그인은 Permission denied (publickey)로 거절되고 키 로그인은 성공하며, 로그에 Accepted publickey가 남는 것을 확인합니다.](https://copyandrun.com/img/linux-auth-log-ssh-intrusion-triage/05-key-auth-hardening.png)

대응 점검표입니다. 표의 마지막 열은 이 글에서 실행한 범위입니다.

| 항목 | 할 일 | 이 글에서 확인 |
|---|---|---|
| 키 인증 전환 | 키 등록 확인 뒤 `PasswordAuthentication no`, `PermitRootLogin no` | 실행함 |
| 시도 횟수 제한 | `MaxAuthTries`, `LoginGraceTime` 줄이기 | 값 적용만 확인, 효과는 측정 안 함 |
| 반복 실패 차단 | fail2ban 같은 도구로 IP 제한 | 실행하지 않음 |
| 로그 보존 | auth.log를 로그 서버로 복사, 회전 주기 점검 | 실행하지 않음 |
| 성공 직후 점검 | 새 계정, sudo 명령, `authorized_keys` 변경 확인 | triage.py로 계정 생성과 sudo만 확인 |

비밀번호 로그인을 끄기 전에 키로 접속되는지 다른 창에서 먼저 확인합니다. 순서를 거꾸로 하면 서버에 들어가지 못합니다.

## 결과 정리

- 실패는 IP, 계정, 시각으로 묶어 보고, 실패 뒤 성공한 IP를 의심 대상으로 봅니다.
- 성공 로그인은 `Accepted` 줄의 PID로 세션 시작과 끝을 잡고, 그 안의 sudo와 `new user` 줄을 이어 봅니다.
- sudo 줄은 세션 PID가 없어서 계정과 시간 범위로 연결하며, 동시 접속이 있으면 후보로만 봅니다.
- 키 인증으로 전환할 때는 키로 접속되는지 확인한 뒤에 비밀번호 로그인을 끕니다.

## 전체 코드

작업 폴더 구조는 아래와 같습니다.

```
Dockerfile
start.sh
triage.py
make_logs.sh
harden.sh
hardening.conf
```

### Dockerfile

```dockerfile
FROM debian:12-slim
RUN apt-get update \
 && apt-get install -y --no-install-recommends openssh-server openssh-client sshpass sudo rsyslog python3 \
 && rm -rf /var/lib/apt/lists/*
COPY start.sh triage.py /opt/
RUN chmod +x /opt/start.sh
CMD ["/opt/start.sh"]
```

### start.sh

```bash
#!/bin/sh
# 연습용 서버를 띄웁니다. 시험 계정 deploy 의 비밀번호는 연습용 값입니다.
useradd -m -s /bin/bash deploy
echo 'deploy:Lab-Pass-2026' | chpasswd
usermod -aG sudo deploy
mkdir -p /run/sshd
rsyslogd
exec /usr/sbin/sshd -D
```

### make_logs.sh

```bash
#!/bin/sh
# 시험 로그를 만듭니다. 비밀번호 틀린 시도 몇 번과 올바른 로그인 1번뿐이며 반복 도구는 쓰지 않습니다.
SERVER=10.89.40.10
SSH="ssh -o StrictHostKeyChecking=no -o PubkeyAuthentication=no -o LogLevel=ERROR"

# A(10.89.40.21): 계정을 바꿔 가며 4번 실패, 성공 없음
docker exec cr-f9-a sshpass -p wrong1 $SSH deploy@$SERVER true
docker exec cr-f9-a sshpass -p wrong2 $SSH deploy@$SERVER true
docker exec cr-f9-a sshpass -p wrong3 $SSH admin@$SERVER true
docker exec cr-f9-a sshpass -p wrong4 $SSH root@$SERVER true

# B(10.89.40.22): deploy 계정으로 3번 실패한 뒤 올바른 비밀번호로 로그인하고 명령 3개 실행
docker exec cr-f9-b sshpass -p guess1 $SSH deploy@$SERVER true
docker exec cr-f9-b sshpass -p guess2 $SSH deploy@$SERVER true
docker exec cr-f9-b sshpass -p guess3 $SSH deploy@$SERVER true
docker exec cr-f9-b sshpass -p Lab-Pass-2026 $SSH deploy@$SERVER \
  'echo Lab-Pass-2026 | sudo -S -p "" id; echo Lab-Pass-2026 | sudo -S -p "" cat /etc/shadow > /dev/null; echo Lab-Pass-2026 | sudo -S -p "" useradd -m svc-backup'
```

### triage.py

```python
"""auth.log 에서 SSH 침입 흔적을 시간순으로 읽는 분석 스크립트입니다.

사용법: python3 triage.py /var/log/auth.log [--threshold 3]
1) IP별 실패 횟수  2) 실패 뒤 첫 성공 로그인  3) 성공한 세션 안의 sudo 와 계정 생성 기록
"""
import re
import sys
from collections import defaultdict
from datetime import datetime

LINE = re.compile(r"^(\S+) (\S+) ([\w.-]+)(?:\[(\d+)\])?: (.*)$")
FAILED = re.compile(r"Failed password for (?:invalid user )?(\S+) from (\S+) port \d+")
ACCEPT = re.compile(r"Accepted (\w+) for (\S+) from (\S+) port \d+")
CLOSED = re.compile(r"session closed for user (\S+)")
SUDO = re.compile(r"^\s*(\S+) : .*?USER=(\S+) ; COMMAND=(.*)$")
NEWUSER = re.compile(r"new user: name=([^,]+)")


def parse(path):
    fails = defaultdict(list)      # IP -> [(시각, 계정)]
    sessions = {}                  # sshd PID -> 세션 정보
    sudos, adds = [], []
    with open(path, encoding="utf-8", errors="replace") as f:
        for raw in f:
            m = LINE.match(raw.rstrip("\n"))
            if not m:
                continue
            ts = datetime.fromisoformat(m.group(1))
            proc, pid, msg = m.group(3), m.group(4), m.group(5)
            if proc == "sshd":
                if (x := FAILED.search(msg)):
                    fails[x.group(2)].append((ts, x.group(1)))
                elif (x := ACCEPT.search(msg)):
                    sessions[pid] = {"start": ts, "end": None, "method": x.group(1),
                                     "user": x.group(2), "ip": x.group(3)}
                elif (x := CLOSED.search(msg)) and pid in sessions:
                    sessions[pid]["end"] = ts
            elif proc == "sudo" and (x := SUDO.match(msg)):
                sudos.append((ts, x.group(1), x.group(2), x.group(3)))
            elif proc == "useradd" and (x := NEWUSER.search(msg)):
                adds.append((ts, x.group(1)))
    return fails, sessions, sudos, adds


def hms(ts):
    return ts.strftime("%H:%M:%S")


def main():
    path = sys.argv[1]
    threshold = int(sys.argv[sys.argv.index("--threshold") + 1]) if "--threshold" in sys.argv else 3
    fails, sessions, sudos, adds = parse(path)

    print("[1] IP별 실패 횟수")
    print(f"{'IP':<14}{'실패':>4}  {'시도한 계정':<22}첫 시각 ~ 마지막 시각")
    for ip, items in sorted(fails.items(), key=lambda kv: -len(kv[1])):
        users = sorted({u for _, u in items})
        print(f"{ip:<14}{len(items):>4}  {','.join(users):<22}{hms(items[0][0])} ~ {hms(items[-1][0])}")

    print(f"\n[2] 실패 뒤 첫 성공 로그인 (기준: 실패 {threshold}회 이상)")
    hits, last_ok = [], {}
    for pid, s in sorted(sessions.items(), key=lambda kv: kv[1]["start"]):
        floor = last_ok.get(s["ip"], datetime.min.replace(tzinfo=s["start"].tzinfo))
        before = [t for t, _ in fails.get(s["ip"], []) if floor < t < s["start"]]
        last_ok[s["ip"]] = s["start"]
        flag = "의심" if len(before) >= threshold else "참고"
        print(f"{flag}  {hms(s['start'])}  {s['user']} 출처 {s['ip']}  {s['method']}  직전 실패 {len(before)}회")
        if flag == "의심":
            hits.append((pid, s, floor))

    print("\n[3] 의심 세션의 시간순 타임라인")
    for pid, s, floor in hits:
        end = s["end"] or datetime.max.replace(tzinfo=s["start"].tzinfo)
        events = [(t, f"실패 {u}") for t, u in fails[s["ip"]] if floor < t < s["start"]]
        events.append((s["start"], f"성공 로그인 {s['user']} ({s['method']})"))
        events += [(t, f"sudo {tgt}: {cmd}") for t, who, tgt, cmd in sudos
                   if who == s["user"] and s["start"] <= t <= end]
        events += [(t, f"계정 생성 {name}") for t, name in adds if s["start"] <= t <= end]
        if s["end"]:
            events.append((s["end"], "세션 종료"))
        print(f"세션 sshd[{pid}] 출처 {s['ip']}")
        for t, text in sorted(events):
            print(f"  {hms(t)}  {text}")


if __name__ == "__main__":
    main()
```

### harden.sh

```bash
#!/bin/sh
# 키 인증으로 전환합니다. B(10.89.40.22)에서 키를 만들어 서버 deploy 계정에 등록합니다.
SERVER=10.89.40.10
docker exec cr-f9-b ssh-keygen -q -t ed25519 -N '' -f /root/.ssh/id_ed25519
docker exec cr-f9-b cat /root/.ssh/id_ed25519.pub \
  | docker exec -i cr-f9-sshd sh -c 'install -d -m 700 -o deploy -g deploy /home/deploy/.ssh && cat > /home/deploy/.ssh/authorized_keys && chown deploy:deploy /home/deploy/.ssh/authorized_keys && chmod 600 /home/deploy/.ssh/authorized_keys'

# 설정을 적용하기 전에 키로 접속되는지 먼저 확인합니다. 실패하면 여기서 멈춥니다(성공하면 출력이 없습니다).
docker exec cr-f9-b ssh -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o LogLevel=ERROR deploy@$SERVER true   || { echo '키 로그인에 실패해 설정을 적용하지 않았습니다.'; exit 1; }

# 서버 설정을 바꾸고 문법 확인 뒤 다시 읽게 합니다(PID 1 이 sshd 입니다).
docker cp hardening.conf cr-f9-sshd:/etc/ssh/sshd_config.d/10-hardening.conf
docker exec cr-f9-sshd sh -c 'sshd -t && kill -HUP 1'
sleep 1
docker exec cr-f9-sshd sshd -T | grep -E '^(passwordauthentication|permitrootlogin|maxauthtries|logingracetime) '

# 비밀번호 로그인은 거절되고 키 로그인은 됩니다.
echo '--- 비밀번호 로그인'
docker exec cr-f9-b sshpass -p Lab-Pass-2026 ssh -o StrictHostKeyChecking=no -o PubkeyAuthentication=no -o LogLevel=ERROR deploy@$SERVER true 2>&1
echo '--- 키 로그인'
docker exec cr-f9-b ssh -o StrictHostKeyChecking=no -o LogLevel=ERROR deploy@$SERVER 'echo 키 로그인 성공' 2>&1
```

### hardening.conf

```
PasswordAuthentication no
PermitRootLogin no
MaxAuthTries 3
LoginGraceTime 20
```

## 자주 막히는 곳

- **`sshd -E 파일`로 로그를 파일에 보냈는데 시각이 없습니다.** rsyslog 없이 `/usr/sbin/sshd -D -E /var/log/sshd.log`로 띄워 보니 `Failed password for deploy from ... port ... ssh2`처럼 시각과 PID가 없는 줄만 남았습니다. 시간순 분석이 안 되므로 rsyslog를 함께 띄웠습니다. sudo는 `Defaults logfile="/var/log/sudo.log"`를 `/etc/sudoers.d/`에 두면 파일로 남지만 `Nov  1 15:11:15 : deploy : ...`처럼 연도 없는 형식이었습니다.
- **`docker exec`에 넘긴 경로가 이상하게 바뀝니다.** Git Bash의 경로 변환 때문입니다. `export MSYS_NO_PATHCONV=1`을 먼저 실행합니다.
- **한글 출력에서 파이썬이 인코딩 오류를 냅니다.** Windows 쪽에서 출력을 받는 도구가 cp1252로 쓰다가 난 오류였고, `PYTHONUTF8=1`을 주면 해결됩니다. 컨테이너 안에서 직접 실행할 때는 필요 없었습니다.
- **root로 비밀번호 로그인을 시도하면 거절될 수 있습니다.** OpenSSH의 `PermitRootLogin` 기본값이 `prohibit-password`라서 root는 비밀번호가 맞아도 거절됩니다. 이 글의 root 시도는 틀린 비밀번호로 한 것이라 이 설정과 상관없이 실패했습니다.

## 확인 범위

- **확인한 것:** 위의 모든 명령과 출력은 Docker 컨테이너에서 실제로 실행한 결과입니다. 시각은 컨테이너의 UTC 기준입니다. OpenSSH 옵션은 `https://man.openbsd.org/sshd.8`과 `https://man.openbsd.org/sshd_config.5`에서 확인했습니다(`-E`, `-t`, SIGHUP, 네 설정의 기본값, 처음 얻은 값이 쓰이는 규칙).
- **하지 못한 것:** fail2ban, logrotate, 로그 서버 전송은 실행하지 않았습니다. 다중 요소 인증, 실제 인터넷 환경의 대량 시도 로그, 배포판별 auth.log 위치 차이(RHEL 계열은 `/var/log/secure`)는 다루지 않았습니다.
- **범위의 한계:** `triage.py`는 rsyslog 기본 시각 형식(ISO 8601)과 password, publickey 로그인을 기준으로 만들었습니다. 다른 형식의 로그는 수정이 필요합니다. 실패 횟수 기준은 판정 근거가 아니라 점검을 시작하는 계기입니다.
