Copy & Run

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

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

실습 노트 · 2026-11-02 발행 · 2026-11-14 수정 · 22분 · 2026-11 확인

메일 인증 기록은 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
이 단계의 파일 내려받기:Dockerfilecheck_mail_dns.pydnsmasq.confshow_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를 조회합니다.

이 단계의 파일 내려받기:Dockerfilednsmasq.conf

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는 조각 1개, DKIM 공개키는 218자와 192자의 조각 2개, DMARC는 조각 1개로 조회되는 것을 확인합니다.
SPF는 조각 1개, DKIM 공개키는 218자와 192자의 조각 2개, DMARC는 조각 1개로 조회되는 것을 확인합니다.

기록의 위치는 정해져 있습니다. SPF는 도메인 자신의 TXT(v=spf1로 시작), DKIM은 선택자._domainkey.도메인(RFC 6376의 3.6.2 절), DMARC는 _dmarc.도메인(RFC 7489 6.1)입니다.

이 단계의 파일 내려받기:show_txt.py

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

good은 조회 1회에 -all로 문제가 없고 From이 같으면 정렬을 통과하며, 엄격 정렬에서 하위 도메인 From은 정렬 실패 오류로 나오고, loose는 조회 2회에 ~all이며 DKIM 테스트 키와 DMARC p=none 주의가 붙는 것을 확인합니다.
good은 조회 1회에 -all로 문제가 없고 From이 같으면 정렬을 통과하며, 엄격 정렬에서 하위 도메인 From은 정렬 실패 오류로 나오고, loose는 조회 2회에 ~all이며 DKIM 테스트 키와 DMARC p=none 주의가 붙는 것을 확인합니다.

이 단계의 파일 내려받기:check_mail_dns.py

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입니다.

이 단계의 파일 내려받기:check_mail_dns.py

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과 비교하지만, 스크립트는 메일을 보지 않으므로 두 경우 모두 조회한 도메인을 비교 대상으로 씁니다. 느슨 정렬은 한쪽이 다른 쪽과 같거나 하위 도메인이면 통과로 보고, 공개 접미사 목록은 쓰지 않습니다.

이 단계의 파일 내려받기:check_mail_dns.py

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 '^(==|조회|정책|  오류|  주의)'

many는 조회 11회로 10회 제한 초과, dup은 SPF 기록 2개 오류, mid는 quarantine 50% 정책이 요약되는 것을 확인합니다.
many는 조회 11회로 10회 제한 초과, dup은 SPF 기록 2개 오류, mid는 quarantine 50% 정책이 요약되는 것을 확인합니다.

다음은 문법 오류를 모은 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

SPF의 잘못된 접두어 길이와 알 수 없는 항목, DKIM 세 선택자의 서로 다른 오류, DMARC의 p, pct, rua 오류가 항목별로 지적되는 것을 확인합니다.
SPF의 잘못된 접두어 길이와 알 수 없는 항목, DKIM 세 선택자의 서로 다른 오류, DMARC의 p, pct, rua 오류가 항목별로 지적되는 것을 확인합니다.

이 단계의 파일 내려받기:check_mail_dns.py

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

loose.example.test의 TXT, MX, A 질의와 DKIM, DMARC 이름의 TXT 질의 5건이 모두 127.0.0.1에서 온 것으로 기록된 것을 확인합니다.
loose.example.test의 TXT, MX, A 질의와 DKIM, DMARC 이름의 TXT 질의 5건이 모두 127.0.0.1에서 온 것으로 기록된 것을 확인합니다.

이 단계의 파일 내려받기:dnsmasq.conf

결과 정리

  • 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}")
이 단계의 파일 내려받기:Dockerfilecheck_mail_dns.pydnsmasq.confshow_txt.py

자주 막히는 곳

  • 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 서비스는 입력 형식이 다를 수 있어 서비스 안내를 따릅니다.
이 단계의 파일 내려받기:show_txt.py

확인 범위

  • 확인한 것: 위의 모든 명령과 출력은 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 키 길이만 계산합니다. 수신 서버의 실제 판정과 다를 수 있으므로 점검 도구로 쓰고 최종 판단은 수신 결과 헤더로 합니다.
이 단계의 파일 내려받기:check_mail_dns.py

이 글은 스타트업·소규모 조직 보안 구축 로드맵의 한 단계입니다.

이 글의 다음 단계

  • 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

같은 카테고리의 글