# SPF, DKIM, DMARC 기록 읽고 점검하기: 파이썬

> 컨테이너 안의 dnsmasq에 example.test 영역을 만들어 SPF, DKIM, DMARC 기록을 정상, 느슨함, 조회 10회 초과, 기록 중복, 문법 오류로 나눠 직접 올리고, dnspython 스크립트로 조회 횟수를 세고 오류를 짚어 정책을 요약합니다. 외부 DNS는 조회하지 않고 메일도 보내지 않습니다.

- 주소: https://copyandrun.com/blog/spf-dkim-dmarc-record-check-local-dns/
- 분야: 이메일·도메인 보안
- 발행일: 2026-11-02
- 태그: SPF, DKIM, DMARC, DNS, dnspython, 메일 보안

메일 인증 기록은 DNS TXT 한 줄이어서 글자 하나가 틀려도 알아채기 어렵습니다. 이 글은 시험용 DNS 서버에 정상 기록과 오류 기록을 직접 올려 두고, 스크립트로 SPF 조회 횟수, DKIM 공개키 형식, DMARC 정책을 읽어 어디가 문제인지 짚는 방법을 다룹니다.

Windows Git Bash에서 Docker Desktop으로 실행했습니다. 도메인은 예약 영역인 `example.test`만 쓰고 컨테이너 안의 dnsmasq가 응답하므로 외부 DNS 조회도 메일 발송도 없습니다. 서버 포트는 호스트 127.0.0.1에만 열었습니다. 기록 값은 연습용이고 키는 이 글을 위해 새로 만든 것입니다.

DKIM 서명을 실제로 만들어 메일에 붙이는 과정은 [Postfix와 OpenDKIM으로 DKIM 서명하고 검증하기](/blog/postfix-opendkim-sign-verify-local/) 글에서 이어서 다룹니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| 실행 환경 | Docker 컨테이너 1개, `debian:12-slim` 기반 |
| dnsmasq | 2.90 (TXT, MX, A 기록을 설정 파일로 직접 응답) |
| dnspython | 2.3.0 (`python3-dnspython` 패키지) |
| Python | 3.11.2 (컨테이너 안) |

작업 폴더는 아래 네 파일입니다. 전체 내용은 글 끝의 `## 전체 코드`에 있습니다.

```
Dockerfile
dnsmasq.conf
check_mail_dns.py
show_txt.py
```

## 1. 시험용 DNS 컨테이너 띄우기

<!-- files: Dockerfile, dnsmasq.conf -->

`dnsmasq.conf`는 `no-resolv`로 바깥 DNS를 보지 않게 하고 `local=/example.test/`로 이 영역을 직접 답하게 합니다. 그 아래에 시나리오별 도메인 일곱 개를 `txt-record`로 적었습니다.

| 도메인 | 시나리오 |
|---|---|
| `good.example.test` | 정상: SPF include와 ip4와 -all, DKIM 2048비트, DMARC reject |
| `loose.example.test` | 느슨함: mx와 a, ~all, DKIM 테스트 중, DMARC none |
| `mid.example.test` | 단계적 적용: quarantine 50%, 하위 도메인 reject |
| `many.example.test` | include 11개로 조회 제한 초과 |
| `dup.example.test` | SPF 기록 두 개 |
| `open.example.test` | `+all`, DMARC 없음 |
| `broken.example.test` | SPF, DKIM, DMARC 문법 오류 모음 |

```bash
docker build -q -t cr-e17-dns:latest . >/dev/null && echo built
docker network create cr-e17-net
docker run -d --name cr-e17-dns --network cr-e17-net -p 127.0.0.1:18120:53/udp -p 127.0.0.1:18120:53/tcp cr-e17-dns:latest
```

`docker network create`가 "already exists" 오류를 내면 이전 실습에서 남은 것이므로 `docker rm -f cr-e17-dns`와 `docker network rm cr-e17-net`으로 지운 뒤 다시 실행합니다.

`docker exec`에 `/opt/...` 경로를 넘길 때는 먼저 `export MSYS_NO_PATHCONV=1`을 실행합니다. `rua`의 메일 주소는 시험용 예약 도메인이라 받는 쪽이 없고, 스크립트는 형식만 점검합니다. 이 글의 점검 스크립트는 컨테이너 안에서 `127.0.0.1`의 dnsmasq를 조회합니다.

## 2. 기록을 조각 단위로 읽기

<!-- files: show_txt.py -->

TXT 기록은 255바이트 이하 문자열 조각의 모음입니다. DKIM 공개키는 2048비트면 400자 가까이 되어 조각 둘로 나뉘고, 수신 측은 조각을 공백 없이 이어 붙여 읽습니다. `show_txt.py`는 조각 개수와 길이를 보여 줍니다.

```bash
docker exec cr-e17-dns python3 /opt/show_txt.py good.example.test s2026._domainkey.good.example.test _dmarc.good.example.test
```

![SPF는 조각 1개, DKIM 공개키는 218자와 192자의 조각 2개, DMARC는 조각 1개로 조회되는 것을 확인합니다.](https://copyandrun.com/img/spf-dkim-dmarc-record-check-local-dns/01-local-dns-lab.png)

기록의 위치는 정해져 있습니다. SPF는 도메인 자신의 TXT(`v=spf1`로 시작), DKIM은 `선택자._domainkey.도메인`(RFC 6376의 3.6.2 절), DMARC는 `_dmarc.도메인`(RFC 7489 6.1)입니다.

## 3. SPF 읽기: 조회 횟수가 핵심

<!-- files: check_mail_dns.py -->

SPF는 `v=spf1` 뒤에 허용할 출처를 항목으로 나열하고 끝에 `all`로 나머지를 어떻게 볼지 적습니다.

| 항목 | 뜻 | DNS 조회 |
|---|---|---|
| `ip4:10.20.0.0/24` | 이 대역을 허용 | 없음 |
| `include:도메인` | 그 도메인의 SPF 기록을 포함 | 1회 + 안쪽 기록 |
| `a`, `mx` | 도메인의 A 또는 MX 기록에 나오는 주소 허용 | 각 1회 |
| `-all` | 나머지는 실패 | 없음 |
| `~all` | 나머지는 소프트 실패(표시만 하고 통과시키는 경우가 많음) | 없음 |

RFC 7208 4.6.4는 `include`, `a`, `mx`, `ptr`, `exists` 항목과 `redirect` 한정자를 합쳐 DNS 조회를 10회로 제한하라고 하고(`MUST`), 응답이 비어 있는 조회(void lookup)는 2회로 제한하기를 권고(`SHOULD`)합니다. 넘으면 `permerror`가 되어 SPF 판정 자체가 무효입니다. `check_mail_dns.py`는 기록을 따라 내려가며 이 횟수를 셉니다.

```bash
docker exec cr-e17-dns python3 /opt/check_mail_dns.py good.example.test --from good.example.test
docker exec cr-e17-dns python3 /opt/check_mail_dns.py good.example.test --from news.good.example.test | grep -E '^(==|From|  오류)'
docker exec cr-e17-dns python3 /opt/check_mail_dns.py loose.example.test --from news.loose.example.test
```

![good은 조회 1회에 -all로 문제가 없고 From이 같으면 정렬을 통과하며, 엄격 정렬에서 하위 도메인 From은 정렬 실패 오류로 나오고, loose는 조회 2회에 ~all이며 DKIM 테스트 키와 DMARC p=none 주의가 붙는 것을 확인합니다.](https://copyandrun.com/img/spf-dkim-dmarc-record-check-local-dns/02-good-vs-loose.png)

## 4. DKIM 읽기: 선택자와 공개키

<!-- files: check_mail_dns.py -->

DKIM 기록은 `v=DKIM1; k=rsa; p=공개키(base64)` 형식의 태그 목록입니다. RFC 6376 3.6.1에 따르면 `p`가 비어 있으면 폐기된 키이고, `t=y`는 도메인이 DKIM을 시험 중이라는 표시입니다. 서명하는 쪽은 장기 키로 RSA 1024비트 이상을 써야 하고(3.3.3) 검증하는 쪽은 512~2048비트를 처리해야 합니다. 스크립트는 `p`를 base64로 풀어 공개키 구조(DER)를 읽고 모듈러스 비트 수를 계산합니다. 위 화면에서 good과 loose의 키는 모두 2048비트로 나왔습니다. 선택자는 `--selector`로 지정하며 기본값은 `s2026`입니다.

## 5. DMARC 읽기: 정책과 정렬

<!-- files: check_mail_dns.py -->

DMARC는 SPF나 DKIM 통과 결과가 보낸 사람 주소(From)의 도메인과 정렬(alignment)될 때 인증으로 인정합니다. RFC 7489 6.3 기준으로 주요 태그는 다음과 같습니다.

| 태그 | 의미 | 기본값 |
|---|---|---|
| `p` | 실패 메일 요청 처리: `none`, `quarantine`, `reject` | 필수 |
| `sp` | 하위 도메인 정책 | `p`와 같음 |
| `pct` | 정책을 적용할 메일 비율 | 100 |
| `rua` | 집계 보고서를 받을 `mailto:` 주소 | 없음 |
| `adkim`, `aspf` | 정렬 방식 `r`(느슨) 또는 `s`(엄격) | `r` |

엄격 정렬은 도메인이 정확히 같아야 하고, 느슨 정렬은 같은 조직 도메인이면 됩니다. DMARC는 DKIM 정렬과 SPF 정렬 중 하나만 통과해도 인증으로 보므로(RFC 7489 3.1), 둘 다 실패해야 DMARC 실패입니다. 위 화면이 그 차이를 보여 줍니다. good은 엄격이라 From이 `good.example.test`이면 통과하고 하위 도메인 `news.good.example.test`이면 둘 다 실패해 오류가 나며, 이 기록의 `p=reject`가 적용되는 경우입니다. loose는 느슨이라 `news.loose.example.test`도 통과합니다.

스크립트의 정렬 판정은 근사입니다. 실제 DKIM 정렬은 서명의 `d=` 도메인, SPF 정렬은 봉투 발신자(MAIL FROM) 도메인을 From과 비교하지만, 스크립트는 메일을 보지 않으므로 두 경우 모두 조회한 도메인을 비교 대상으로 씁니다. 느슨 정렬은 한쪽이 다른 쪽과 같거나 하위 도메인이면 통과로 보고, 공개 접미사 목록은 쓰지 않습니다.

## 6. 오류 기록과 대조하기

<!-- files: check_mail_dns.py -->

조회 제한 초과, 기록 중복, 단계적 DMARC를 먼저 봅니다. 아래 명령은 출력을 `grep`으로 줄였고, DKIM 선택자가 없는 도메인은 "선택자 기록이 없습니다"가 함께 나옵니다.

```bash
docker exec cr-e17-dns python3 /opt/check_mail_dns.py many.example.test | grep -E '^(==|조회|  오류|  주의)'
docker exec cr-e17-dns python3 /opt/check_mail_dns.py dup.example.test | grep -E '^(==|조회|  오류|  주의)'
docker exec cr-e17-dns python3 /opt/check_mail_dns.py mid.example.test | grep -E '^(==|조회|정책|  오류|  주의)'
```

![many는 조회 11회로 10회 제한 초과, dup은 SPF 기록 2개 오류, mid는 quarantine 50% 정책이 요약되는 것을 확인합니다.](https://copyandrun.com/img/spf-dkim-dmarc-record-check-local-dns/03-spf-limit-dup-dmarc.png)

다음은 문법 오류를 모은 `broken.example.test`입니다. SPF에는 접두어 길이 `/33`, 모르는 항목 `ipv4:`, `-all` 뒤의 항목이 있고, DKIM 선택자 세 개는 각각 `p`가 비었거나 없거나 base64가 아닙니다. DMARC는 `p=block`, `pct=150`, `mailto:` 없는 `rua`입니다.

```bash
docker exec cr-e17-dns python3 /opt/check_mail_dns.py broken.example.test --selector s2026 --selector old --selector bad
```

![SPF의 잘못된 접두어 길이와 알 수 없는 항목, DKIM 세 선택자의 서로 다른 오류, DMARC의 p, pct, rua 오류가 항목별로 지적되는 것을 확인합니다.](https://copyandrun.com/img/spf-dkim-dmarc-record-check-local-dns/04-broken-records.png)

## 7. 질의가 시험용 서버에서만 처리됐는지 확인

<!-- files: dnsmasq.conf -->

`dnsmasq.conf`의 `log-queries`와 `log-facility=-` 덕분에 질의가 컨테이너 로그에 남습니다. loose 점검을 한 번만 실행했다면 `mx`와 `a` 항목이 각각 MX, A 조회를 만든 것과 DKIM, DMARC 조회가 모두 `127.0.0.1`에서 온 것을 볼 수 있습니다. 같은 점검을 반복하면 줄 수가 늘어납니다.

```bash
docker logs cr-e17-dns 2>&1 | grep -c 'query\[.*loose.example.test'
docker logs cr-e17-dns 2>&1 | grep 'query\[.*loose.example.test' | cut -c1-80
```

![loose.example.test의 TXT, MX, A 질의와 DKIM, DMARC 이름의 TXT 질의 5건이 모두 127.0.0.1에서 온 것으로 기록된 것을 확인합니다.](https://copyandrun.com/img/spf-dkim-dmarc-record-check-local-dns/05-dns-query-log.png)

## 결과 정리

- SPF는 `include`, `a`, `mx`, `ptr`, `exists`, `redirect`의 합이 10회를 넘으면 `permerror`이고, 기록은 도메인당 하나여야 합니다.
- DKIM은 `선택자._domainkey.도메인`의 `p` 값이 비어 있거나 base64가 아니거나 짧으면 점검 대상입니다.
- DMARC는 `p`만이 아니라 `pct`, `sp`, `rua`, 정렬 방식을 함께 읽습니다. `p=none`이나 `pct`가 낮은 기록은 아직 막지 않는 단계입니다.
- 실제 도메인에 적용하기 전에는 `p=none`과 `rua`로 보고서를 먼저 모으고 단계적으로 올립니다.

## 전체 코드

작업 폴더 구조는 아래와 같습니다.

```
Dockerfile
dnsmasq.conf
check_mail_dns.py
show_txt.py
```

### Dockerfile

```dockerfile
FROM debian:12-slim
RUN apt-get update \
 && apt-get install -y --no-install-recommends dnsmasq python3-dnspython \
 && rm -rf /var/lib/apt/lists/*
COPY dnsmasq.conf /etc/dnsmasq.conf
COPY check_mail_dns.py show_txt.py /opt/
CMD ["dnsmasq", "--keep-in-foreground", "--conf-file=/etc/dnsmasq.conf"]
```

### dnsmasq.conf

```
# 시험용 DNS 설정입니다. example.test 영역의 응답만 만들고 바깥으로는 묻지 않습니다.
port=53
bind-interfaces
listen-address=0.0.0.0
no-resolv
no-hosts
no-poll
local=/example.test/
log-queries
log-facility=-

# --- good.example.test: 정상 기록 (SPF include + ip4 + -all, DKIM 2048비트, DMARC reject) ---
txt-record=good.example.test,"v=spf1 ip4:10.20.0.0/24 include:_spf.mail.example.test -all"
txt-record=_spf.mail.example.test,"v=spf1 ip4:192.168.50.0/24 -all"
txt-record=s2026._domainkey.good.example.test,"v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmKfEYCdw5t8EOPbvEhUrHSpLKAu1L7a2nyFjJDArHL1SLYGZ6ZIWSpiolMGD/GxH9qOGAb/r8KM5+D7kkV6ri24LDLgNXpnI5Ety+D5J+NQbbvjInADSu759mXCeMUCYj1rq9ZH2QUpAWEk8VjyPwb0SWMqO","Upj1xfb5q5afMAAk9w8S0PajjU9yfCBDnWFiZKj0lTP5Z1DCUjsbw6kYR/GFWy7FunQ1zODHhPCTmx5QPRLAb+rNbIgBmHw8FhwxfbZRzyi+RlhlSgQl9GoILI2HNJE9wq9TTCOcfdB1dp2ddvdcec5jHvRsdMsWFIwsVIBFW9dVy3NtOtoeRYoYBQIDAQAB"
txt-record=_dmarc.good.example.test,"v=DMARC1; p=reject; rua=mailto:dmarc-reports@good.example.test; adkim=s; aspf=s; pct=100"

# --- loose.example.test: 느슨한 기록 (mx, a 사용, ~all, DKIM 테스트 중, DMARC none) ---
host-record=loose.example.test,10.20.0.30
host-record=mail.loose.example.test,10.20.0.25
mx-host=loose.example.test,mail.loose.example.test,10
txt-record=loose.example.test,"v=spf1 mx a ip4:10.20.0.0/24 ~all"
txt-record=s2026._domainkey.loose.example.test,"v=DKIM1; k=rsa; t=y; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmKfEYCdw5t8EOPbvEhUrHSpLKAu1L7a2nyFjJDArHL1SLYGZ6ZIWSpiolMGD/GxH9qOGAb/r8KM5+D7kkV6ri24LDLgNXpnI5Ety+D5J+NQbbvjInADSu759mXCeMUCYj1rq9ZH2QUpAWEk8VjyPwb0SWMqO","Upj1xfb5q5afMAAk9w8S0PajjU9yfCBDnWFiZKj0lTP5Z1DCUjsbw6kYR/GFWy7FunQ1zODHhPCTmx5QPRLAb+rNbIgBmHw8FhwxfbZRzyi+RlhlSgQl9GoILI2HNJE9wq9TTCOcfdB1dp2ddvdcec5jHvRsdMsWFIwsVIBFW9dVy3NtOtoeRYoYBQIDAQAB"
txt-record=_dmarc.loose.example.test,"v=DMARC1; p=none; rua=mailto:dmarc-reports@loose.example.test"

# --- mid.example.test: 단계적 적용 (quarantine 50%, 하위 도메인 reject) ---
txt-record=mid.example.test,"v=spf1 include:_spf.mail.example.test ~all"
txt-record=_dmarc.mid.example.test,"v=DMARC1; p=quarantine; sp=reject; pct=50; aspf=s; rua=mailto:dmarc-reports@mid.example.test"

# --- many.example.test: include 11개 (조회 10회 제한 초과) ---
txt-record=many.example.test,"v=spf1 include:i01.many.example.test include:i02.many.example.test include:i03.many.example.test include:i04.many.example.test include:i05.many.example.test include:i06.many.example.test include:i07.many.example.test include:i08.many.example.test include:i09.many.example.test include:i10.many.example.test include:i11.many.example.test -all"
txt-record=i01.many.example.test,"v=spf1 ip4:10.30.1.0/24 -all"
txt-record=i02.many.example.test,"v=spf1 ip4:10.30.2.0/24 -all"
txt-record=i03.many.example.test,"v=spf1 ip4:10.30.3.0/24 -all"
txt-record=i04.many.example.test,"v=spf1 ip4:10.30.4.0/24 -all"
txt-record=i05.many.example.test,"v=spf1 ip4:10.30.5.0/24 -all"
txt-record=i06.many.example.test,"v=spf1 ip4:10.30.6.0/24 -all"
txt-record=i07.many.example.test,"v=spf1 ip4:10.30.7.0/24 -all"
txt-record=i08.many.example.test,"v=spf1 ip4:10.30.8.0/24 -all"
txt-record=i09.many.example.test,"v=spf1 ip4:10.30.9.0/24 -all"
txt-record=i10.many.example.test,"v=spf1 ip4:10.30.10.0/24 -all"
txt-record=i11.many.example.test,"v=spf1 ip4:10.30.11.0/24 -all"

# --- dup.example.test: SPF 기록 두 개 ---
txt-record=dup.example.test,"v=spf1 ip4:10.20.0.0/24 -all"
txt-record=dup.example.test,"v=spf1 include:_spf.mail.example.test ~all"

# --- open.example.test: 모두 허용(+all), DMARC 없음 ---
txt-record=open.example.test,"v=spf1 +all"

# --- broken.example.test: 문법 오류 모음 ---
txt-record=broken.example.test,"v=spf1 ip4:10.20.0.0/33 ipv4:10.20.1.1 include:_spf.mail.example.test -all ip4:10.9.9.9"
txt-record=s2026._domainkey.broken.example.test,"v=DKIM1; k=rsa; p="
txt-record=old._domainkey.broken.example.test,"v=DKIM1; k=rsa"
txt-record=bad._domainkey.broken.example.test,"v=DKIM1; k=rsa; p=MIIBIjANBgkq-not-base64!"
txt-record=_dmarc.broken.example.test,"v=DMARC1; p=block; rua=dmarc-reports@broken.example.test; pct=150"
```

### check_mail_dns.py

```python
"""SPF, DKIM, DMARC 기록을 DNS 에서 읽어 문법을 점검하는 스크립트입니다.

사용법: python3 check_mail_dns.py 도메인 [--selector 선택자 ...] [--from 보낸사람도메인] [--server 127.0.0.1]
- SPF: v=spf1 문법, 기록 개수, DNS 조회 횟수(10회 제한), all 한정자 요약
- DKIM: 선택자별 공개키 TXT 의 태그, base64, RSA 키 길이
- DMARC: 정책 요약(p, sp, pct, rua, 정렬 방식), --from 을 주면 정렬 판정(둘 다 실패하면 오류)
"""
import argparse
import base64
import binascii
import ipaddress
import re
import sys

import dns.exception
import dns.resolver

TERM = re.compile(r"^([+\-~?])?(all|include|a|mx|ptr|ip4|ip6|exists)(?:[:/=](.*))?$|^(redirect|exp)=(.+)$", re.I)
RESOLVER = dns.resolver.Resolver(configure=False)


def txt(name):
    """이름의 TXT 기록을 문자열 목록으로 돌려줍니다. 255바이트씩 나뉜 조각은 공백 없이 이어 붙입니다."""
    try:
        ans = RESOLVER.resolve(name, "TXT")
    except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
        return []
    return ["".join(s.decode() for s in r.strings) for r in ans]


def exists(name, rtype):
    try:
        RESOLVER.resolve(name, rtype)
        return True
    except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
        return False


# ---------------------------------------------------------------- SPF
def spf_walk(domain, state, depth=0):
    """SPF 기록을 따라가며 DNS 조회 횟수를 세고 문제를 모읍니다."""
    pad = "  " * depth
    recs = [t for t in txt(domain) if t.lower().startswith("v=spf1")]
    if not recs:
        state["errors"].append(f"{domain}: SPF 기록이 없습니다")
        return
    if len(recs) > 1:
        state["errors"].append(f"{domain}: SPF 기록이 {len(recs)}개입니다 (permerror)")
        return
    rec = recs[0]
    print(f"{pad}{domain}: {rec}")
    terms = rec.split()[1:]
    seen_all = False
    for t in terms:
        m = TERM.match(t)
        if not m:
            state["errors"].append(f"{domain}: 알 수 없는 항목 '{t}'")
            continue
        qual, mech, arg = m.group(1), (m.group(2) or m.group(4)).lower(), m.group(3) or m.group(5)
        if seen_all:
            state["warns"].append(f"{domain}: all 뒤의 '{t}' 는 평가되지 않습니다")
            continue
        if mech in ("ip4", "ip6"):
            try:
                net = ipaddress.ip_network(arg, strict=False)
                if net.version != (4 if mech == "ip4" else 6):
                    raise ValueError
            except ValueError:
                state["errors"].append(f"{domain}: '{t}' 의 주소 또는 접두어 길이가 잘못됐습니다")
        elif mech == "all":
            seen_all = True
            state["all"] = (qual or "+") + "all"
        elif mech in ("include", "a", "mx", "ptr", "exists", "redirect"):
            state["lookups"] += 1
            if mech in ("include", "redirect"):
                if not arg:
                    state["errors"].append(f"{domain}: '{t}' 에 도메인이 없습니다")
                elif depth < 12:
                    spf_walk(arg, state, depth + 1)
            elif mech in ("a", "mx"):
                target = arg.split("/")[0] if arg and not arg.startswith("/") else domain
                if not exists(target, "A" if mech == "a" else "MX"):
                    state["voids"] += 1


def check_spf(domain):
    print("[SPF]")
    state = {"lookups": 0, "voids": 0, "errors": [], "warns": [], "all": None}
    spf_walk(domain, state)
    if state["lookups"] > 10:
        state["errors"].append(f"DNS 조회 {state['lookups']}회로 10회 제한을 넘습니다 (RFC 7208 4.6.4, permerror)")
    if state["voids"] > 2:
        state["warns"].append(f"빈 응답 조회가 {state['voids']}회입니다 (void lookup 2회 권고 초과)")
    if state["all"] == "+all":
        state["warns"].append("+all 은 모든 서버를 허용합니다")
    elif state["all"] == "?all":
        state["warns"].append("?all 은 판정을 하지 않겠다는 뜻입니다")
    elif state["all"] is None and not state["errors"]:
        state["warns"].append("끝맺는 all 또는 redirect 가 없습니다")
    print(f"조회 횟수 {state['lookups']}회 / 끝맺음 {state['all']}")
    report(state)


# ---------------------------------------------------------------- DKIM
def der(b, i):
    """DER 항목 하나를 읽어 (태그, 내용 시작, 내용 끝)을 돌려줍니다."""
    tag, ln = b[i], b[i + 1]
    j = i + 2
    if ln & 0x80:
        n = ln & 0x7F
        ln = int.from_bytes(b[j:j + n], "big")
        j += n
    return tag, j, j + ln


def rsa_bits(blob):
    """SubjectPublicKeyInfo 에서 RSA 모듈러스의 비트 수를 구합니다."""
    _, s, _ = der(blob, 0)                  # SEQUENCE
    _, _, e = der(blob, s)                  # AlgorithmIdentifier 건너뜀
    tag, s2, _ = der(blob, e)               # BIT STRING
    if tag != 0x03:
        raise ValueError("공개키 구조가 아닙니다")
    inner = blob[s2 + 1:]                   # 미사용 비트 수 1바이트 건너뜀
    _, s3, _ = der(inner, 0)                # RSAPublicKey SEQUENCE
    tag, s4, e4 = der(inner, s3)            # modulus INTEGER
    if tag != 0x02:
        raise ValueError("RSA 모듈러스를 찾지 못했습니다")
    return int.from_bytes(inner[s4:e4], "big").bit_length()


def parse_tags(text):
    tags, order = {}, []
    for part in text.split(";"):
        if "=" in part:
            k, v = part.split("=", 1)
            k = k.strip()
            tags.setdefault(k, v.strip())
            order.append(k)
    return tags, order


def check_dkim(domain, selector):
    name = f"{selector}._domainkey.{domain}"
    print(f"[DKIM] {name}")
    state = {"errors": [], "warns": []}
    recs = txt(name)
    if not recs:
        state["errors"].append("선택자 기록이 없습니다")
        return report(state)
    if len(recs) > 1:
        state["errors"].append(f"TXT 가 {len(recs)}개입니다")
    tags, order = parse_tags(recs[0])
    if "v" in tags and (order[0] != "v" or tags["v"] != "DKIM1"):
        state["errors"].append("v 태그는 첫 태그이고 값은 DKIM1 이어야 합니다")
    k = tags.get("k", "rsa")
    flags = [x.strip() for x in tags.get("t", "").split(":") if x.strip()]
    if "p" not in tags:
        state["errors"].append("p 태그(공개키)가 없습니다")
    elif tags["p"] == "":
        state["errors"].append("p 가 비어 있어 폐기된 키입니다 (RFC 6376 3.6.1)")
    else:
        try:
            raw = base64.b64decode(tags["p"].replace(" ", ""), validate=True)
            if k == "rsa":
                bits = rsa_bits(raw)
                print(f"키 종류 rsa / 길이 {bits}비트")
                if bits < 1024:
                    state["warns"].append("1024비트 미만입니다")
            else:
                print(f"키 종류 {k} / 공개키 {len(raw)}바이트")
        except binascii.Error:
            state["errors"].append("p 값이 올바른 base64 가 아닙니다")
        except (ValueError, IndexError):
            state["errors"].append("p 값이 공개키 구조(SubjectPublicKeyInfo)가 아닙니다")
    if "y" in flags:
        state["warns"].append("t=y: 테스트 중인 키라 검증 실패를 엄격히 다루지 않을 수 있습니다")
    report(state)


# ---------------------------------------------------------------- DMARC
def aligned(from_domain, auth_domain, mode):
    """정렬 판정입니다. 공개 접미사 목록 없이, 한쪽이 다른 쪽과 같거나 하위 도메인이면 같은 조직으로 보는 단순화입니다."""
    if mode == "s":
        return from_domain == auth_domain
    return (from_domain == auth_domain
            or from_domain.endswith("." + auth_domain)
            or auth_domain.endswith("." + from_domain))


def check_dmarc(domain, from_domain):
    name = f"_dmarc.{domain}"
    print(f"[DMARC] {name}")
    state = {"errors": [], "warns": []}
    recs = [t for t in txt(name) if t.lower().startswith("v=dmarc1")]
    if not recs:
        state["warns"].append("DMARC 기록이 없습니다")
        return report(state)
    if len(recs) > 1:
        state["errors"].append(f"DMARC 기록이 {len(recs)}개입니다")
    tags, order = parse_tags(recs[0])
    if order[:2] != ["v", "p"]:
        state["errors"].append("v, p 순서로 시작해야 합니다 (RFC 7489 6.3)")
    p = tags.get("p", "")
    if p not in ("none", "quarantine", "reject"):
        state["errors"].append(f"p={p or '(없음)'} 는 허용 값(none, quarantine, reject)이 아닙니다")
    sp = tags.get("sp", p)
    if "sp" in tags and sp not in ("none", "quarantine", "reject"):
        state["errors"].append(f"sp={sp} 는 허용 값이 아닙니다")
    try:
        pct = int(tags.get("pct", "100"))
        if not 0 <= pct <= 100:
            raise ValueError
    except ValueError:
        pct = None
        state["errors"].append(f"pct={tags.get('pct')} 는 0~100 정수가 아닙니다")
    rua = [x.strip() for x in tags.get("rua", "").split(",") if x.strip()]
    for u in rua:
        if not u.lower().startswith("mailto:"):
            state["errors"].append(f"rua '{u}' 는 mailto: 로 시작해야 합니다")
    adkim, aspf = tags.get("adkim", "r"), tags.get("aspf", "r")
    print(f"정책 p={p} / 하위 도메인 sp={sp} / 적용 비율 pct={pct if pct is not None else '?'}")
    print(f"정렬 DKIM={'엄격' if adkim == 's' else '느슨'} SPF={'엄격' if aspf == 's' else '느슨'} / 보고서 수신 {len(rua)}곳")
    if p == "none":
        state["warns"].append("p=none 은 관찰만 하고 막지 않습니다")
    if pct is not None and pct < 100 and p != "none":
        state["warns"].append(f"정책이 메일의 {pct}% 에만 적용됩니다")
    if not rua:
        state["warns"].append("rua 가 없어 집계 보고서를 받을 수 없습니다")
    if from_domain:
        dk_ok = aligned(from_domain, domain, adkim)
        spf_ok = aligned(from_domain, domain, aspf)
        print(f"From {from_domain}: DKIM 정렬 {'통과' if dk_ok else '실패'}, SPF 정렬 {'통과' if spf_ok else '실패'}")
        if not (dk_ok or spf_ok):
            state["errors"].append(f"From {from_domain} 은 DKIM, SPF 정렬이 모두 실패해 DMARC 가 실패합니다 "
                                   f"(RFC 7489 3.1, p={p} 대상)")
    report(state)


def report(state):
    for e in state["errors"]:
        print(f"  오류: {e}")
    for w in state["warns"]:
        print(f"  주의: {w}")
    if not state["errors"] and not state["warns"]:
        print("  문제 없음")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("domain")
    ap.add_argument("--selector", action="append", default=None)
    ap.add_argument("--from", dest="from_domain")
    ap.add_argument("--server", default="127.0.0.1")
    a = ap.parse_args()
    RESOLVER.nameservers = [a.server]
    RESOLVER.lifetime = 5
    print(f"== {a.domain} ==")
    check_spf(a.domain)
    for sel in a.selector or ["s2026"]:
        check_dkim(a.domain, sel)
    check_dmarc(a.domain, a.from_domain)


if __name__ == "__main__":
    sys.stdout.reconfigure(encoding="utf-8")
    main()
```

### show_txt.py

```python
"""이름마다 TXT 기록을 조각(문자열) 단위로 출력합니다. 사용법: python3 show_txt.py 이름 [이름 ...]"""
import sys

import dns.resolver

resolver = dns.resolver.Resolver(configure=False)
resolver.nameservers = ["127.0.0.1"]
for name in sys.argv[1:]:
    for rdata in resolver.resolve(name, "TXT"):
        print(f"{name}  (조각 {len(rdata.strings)}개)")
        for s in rdata.strings:
            text = s.decode()
            shown = text if len(text) <= 70 else text[:60] + "..." + text[-6:]
            print(f"  [{len(text):3}자] {shown}")
```

## 자주 막히는 곳

- **`docker exec`에 넘긴 `/opt/...` 경로가 바뀝니다.** Git Bash 경로 변환 때문에 `//C:/Program Files/Git/opt/show_txt.py`로 바뀌어 `can't open file` 오류가 났습니다. `export MSYS_NO_PATHCONV=1`을 먼저 실행합니다.
- **Windows의 `nslookup -type=TXT -port=18120 ... 127.0.0.1`이 시간 초과됩니다.** 같은 포트에 파이썬 소켓으로 UDP와 TCP 질의를 보냈을 때는 두 방식 모두 TXT 응답을 받았습니다. 이 글은 컨테이너 안에서 점검했고, 호스트에서 조회할 때는 파이썬으로 확인했습니다. `nslookup`이 실패한 원인은 확인하지 않았습니다.
- **선택자 이름이 다르면 DKIM이 "선택자 기록이 없습니다"로 나옵니다.** 이 글의 시험 선택자는 `s2026`이고 `--selector`를 생략하면 이 값을 조회합니다. 실제 메일 헤더의 `DKIM-Signature`에서 `s=` 값을 확인해 지정합니다.
- **긴 공개키는 따로 나누지 않아도 됩니다.** 설정 파일에서 400자 가까운 문자열 하나로 적은 기록으로 따로 띄워 보니 dnsmasq가 255자와 155자로 나눠 응답했습니다. 이 글의 설정은 조각 둘로 직접 나눠 적었습니다. 공개 DNS 서비스는 입력 형식이 다를 수 있어 서비스 안내를 따릅니다.

## 확인 범위

- **확인한 것:** 위의 모든 명령과 출력은 Docker 컨테이너에서 실제로 실행한 결과입니다. 수치와 규칙은 RFC 원문에서 확인했습니다. SPF 조회 10회와 void 2회, 기록 중복과 `permerror`는 RFC 7208 3.2, 4.5, 4.6.4(`https://www.rfc-editor.org/rfc/rfc7208.html`), DKIM 태그, 선택자 위치, 키 길이는 RFC 6376 3.3.3, 3.6.1, 3.6.2(`https://www.rfc-editor.org/rfc/rfc6376.html`), DMARC 태그와 기본값, 정렬, `_dmarc` 위치는 RFC 7489 3.1, 6.1, 6.3(`https://www.rfc-editor.org/rfc/rfc7489.html`)입니다. 세 문서 모두 앞부분 10만 자까지만 읽었고 나머지 부분은 확인하지 않았습니다.
- **하지 못한 것:** 실제 메일 발송과 수신 서버의 판정, 공개 DNS의 기록 조회, 서명 검증은 하지 않았습니다. Linux와 macOS에서는 같은 도커 명령을 쓰고 `MSYS_NO_PATHCONV` 줄만 빼면 되지만 실행해 보지 않았습니다.
- **범위의 한계:** 스크립트는 `rua` 값이 `mailto:`로 시작하는지만 봅니다. `sp`는 명시된 경우에만 값을 검사합니다. `check_mail_dns.py`는 `ptr`와 `exists`, `exp`를 조회 횟수나 문법에서 간략히 처리하고 `a`와 `mx`의 CIDR 접미사, MX 대상 주소 조회 10개 제한, DMARC의 `ruf`와 `ri`는 점검하지 않습니다. DMARC의 조직 도메인 판정과 정렬 비교 대상(DKIM의 `d=`, SPF의 MAIL FROM 대신 조회 도메인 사용)은 단순화했고, DKIM은 RSA 키 길이만 계산합니다. 수신 서버의 실제 판정과 다를 수 있으므로 점검 도구로 쓰고 최종 판단은 수신 결과 헤더로 합니다.
