메일 인증 기록은 DNS TXT 한 줄이어서 글자 하나가 틀려도 알아채기 어렵습니다. 이 글은 시험용 DNS 서버에 정상 기록과 오류 기록을 직접 올려 두고, 스크립트로 SPF 조회 횟수, DKIM 공개키 형식, DMARC 정책을 읽어 어디가 문제인지 짚는 방법을 다룹니다.
Windows Git Bash에서 Docker Desktop으로 실행했습니다. 도메인은 예약 영역인 example.test만 쓰고 컨테이너 안의 dnsmasq가 응답하므로 외부 DNS 조회도 메일 발송도 없습니다. 서버 포트는 호스트 127.0.0.1에만 열었습니다. 기록 값은 연습용이고 키는 이 글을 위해 새로 만든 것입니다.
DKIM 서명을 실제로 만들어 메일에 붙이는 과정은 Postfix와 OpenDKIM으로 DKIM 서명하고 검증하기 글에서 이어서 다룹니다.
준비물
| 항목 | 확인한 값 |
|---|---|
| 실행 환경 | 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 컨테이너 띄우기
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 문법 오류 모음 |
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. 기록을 조각 단위로 읽기
TXT 기록은 255바이트 이하 문자열 조각의 모음입니다. DKIM 공개키는 2048비트면 400자 가까이 되어 조각 둘로 나뉘고, 수신 측은 조각을 공백 없이 이어 붙여 읽습니다. show_txt.py는 조각 개수와 길이를 보여 줍니다.
docker exec cr-e17-dns python3 /opt/show_txt.py good.example.test s2026._domainkey.good.example.test _dmarc.good.example.test

기록의 위치는 정해져 있습니다. SPF는 도메인 자신의 TXT(v=spf1로 시작), DKIM은 선택자._domainkey.도메인(RFC 6376의 3.6.2 절), DMARC는 _dmarc.도메인(RFC 7489 6.1)입니다.
3. SPF 읽기: 조회 횟수가 핵심
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는 기록을 따라 내려가며 이 횟수를 셉니다.
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

4. DKIM 읽기: 선택자와 공개키
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 읽기: 정책과 정렬
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. 오류 기록과 대조하기
조회 제한 초과, 기록 중복, 단계적 DMARC를 먼저 봅니다. 아래 명령은 출력을 grep으로 줄였고, DKIM 선택자가 없는 도메인은 "선택자 기록이 없습니다"가 함께 나옵니다.
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 '^(==|조회|정책| 오류| 주의)'

다음은 문법 오류를 모은 broken.example.test입니다. SPF에는 접두어 길이 /33, 모르는 항목 ipv4:, -all 뒤의 항목이 있고, DKIM 선택자 세 개는 각각 p가 비었거나 없거나 base64가 아닙니다. DMARC는 p=block, pct=150, mailto: 없는 rua입니다.
docker exec cr-e17-dns python3 /opt/check_mail_dns.py broken.example.test --selector s2026 --selector old --selector bad

7. 질의가 시험용 서버에서만 처리됐는지 확인
dnsmasq.conf의 log-queries와 log-facility=- 덕분에 질의가 컨테이너 로그에 남습니다. loose 점검을 한 번만 실행했다면 mx와 a 항목이 각각 MX, A 조회를 만든 것과 DKIM, DMARC 조회가 모두 127.0.0.1에서 온 것을 볼 수 있습니다. 같은 점검을 반복하면 줄 수가 늘어납니다.
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

결과 정리
- 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
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
"""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
"""이름마다 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 키 길이만 계산합니다. 수신 서버의 실제 판정과 다를 수 있으므로 점검 도구로 쓰고 최종 판단은 수신 결과 헤더로 합니다.
이 글은 스타트업·소규모 조직 보안 구축 로드맵의 한 단계입니다.
이 글의 다음 단계
- DMARC 집계 보고서 읽기: rua XML을 파이썬으로 파싱해 SPF, DKIM 보기DMARC 정책을 p=none으로 시작하면 수신 서버가 rua 주소로 XML 집계 보고서를 보냅니다. 이 XML을 Python 표준 라이브러리만으로 읽어 발신 IP별 SPF, DKIM, DMARC 통과 여부와 실패 비율을 요약하는 스크립트를 만들고 시험 보고서로 실행합니다.
- 피싱 메일 헤더 분석: Received, SPF·DKIM·DMARC를 파이썬으로 점검파이썬 표준 라이브러리 email 모듈로 .eml 파일을 읽어 Received 체인, Return-Path와 From 불일치, Reply-To 차이, Authentication-Results의 spf·dkim·dmarc 결과, 표시 이름 위장, 링크 표시 텍스트와 실제 주소 불일치를 점수 없이 항목별로 나열합니다. 직접 만든 시험 메일 3개(정상, 발신자 불일치형, 링크 위장형)로 결과를 대조하고 자동 점검의 한계도 정리합니다.
이 내용을 팀 교육으로 진행하고 싶으신가요?
인원, 수준, 일정에 맞춰 실습 환경까지 준비해 진행합니다. 대상과 기간을 알려 주시면 구성을 제안해 드립니다.
교육 문의하기메일로 보내실 수도 있습니다: fankh111@gmail.com