なりすましメールを根絶する SPF (RFC 7208) / DKIM (RFC 6376) / DMARC (RFC 7489) / ARC
暗号検証パイプライン詳解

#![no_std]
#![forbid(unsafe_code)]

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AlignmentMode {
    Relaxed,
    Strict,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DmarcPolicy {
    None,
    Quarantine,
    Reject,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DmarcDisposition {
    AcceptAuthenticated { spf_aligned: bool, dkim_aligned: bool },
    RejectOrQuarantine(DmarcPolicy),
    SpfLookupLimitExceeded(u8),
}

/// Case-insensitive ASCII byte comparison for domain labels (RFC 4343).
#[inline]
pub const fn ascii_eq_ignore_case(a: &[u8], b: &[u8]) -> bool {
    if a.len() != b.len() {
        return false;
    }
    let mut i = 0;
    while i < a.len() {
        let ca = if a[i] >= b'A' && a[i] <= b'Z' { a[i] + 32 } else { a[i] };
        let cb = if b[i] >= b'A' && b[i] <= b'Z' { b[i] + 32 } else { b[i] };
        if ca != cb {
            return false;
        }
        i += 1;
    }
    true
}

/// Evaluates RFC 7489 Section 3.1 Identifier Alignment between `RFC5322.From` domain
/// and an authenticated SPF or DKIM (`d=`) domain.
pub const fn check_domain_alignment(
    header_from_domain: &[u8],
    auth_domain: &[u8],
    mode: AlignmentMode,
) -> bool {
    if ascii_eq_ignore_case(header_from_domain, auth_domain) {
        return true;
    }
    match mode {
        AlignmentMode::Strict => false,
        AlignmentMode::Relaxed => {
            // Relaxed alignment allows subdomain relationship if Organizational Domain matches
            if auth_domain.len() > header_from_domain.len() {
                let prefix_len = auth_domain.len() - header_from_domain.len();
                if auth_domain[prefix_len - 1] == b'.' {
                    let (_, tail) = auth_domain.split_at(prefix_len);
                    return ascii_eq_ignore_case(header_from_domain, tail);
                }
            }
            false
        }
    }
}

/// Evaluates full DMARC disposition given SPF lookup count (RFC 7208 max 10),
/// SPF verification result, DKIM verification result, and alignment modes.
pub const fn evaluate_dmarc_pipeline(
    header_from_domain: &[u8],
    spf_mailfrom_domain: &[u8],
    spf_passed: bool,
    spf_dns_lookups: u8,
    dkim_d_domain: &[u8],
    dkim_signature_valid: bool,
    aspf: AlignmentMode,
    adkim: AlignmentMode,
    policy: DmarcPolicy,
) -> DmarcDisposition {
    if spf_dns_lookups > 10 {
        return DmarcDisposition::SpfLookupLimitExceeded(spf_dns_lookups);
    }

    let spf_aligned = spf_passed
        && check_domain_alignment(header_from_domain, spf_mailfrom_domain, aspf);
    let dkim_aligned = dkim_signature_valid
        && check_domain_alignment(header_from_domain, dkim_d_domain, adkim);

    if spf_aligned || dkim_aligned {
        DmarcDisposition::AcceptAuthenticated {
            spf_aligned,
            dkim_aligned,
        }
    } else {
        DmarcDisposition::RejectOrQuarantine(policy)
    }
}

/// Implements RFC 6376 Section 3.4.2 DKIM `relaxed` header canonicalization into `out_buf`.
/// Converts header field name to lowercase, unfolds CRLF+WSP, and compresses WSP runs to single 0x20.
pub fn canonicalize_dkim_header_relaxed(raw_header: &[u8], out_buf: &mut [u8]) -> Option<usize> {
    let mut colon_pos: Option<usize> = None;
    for (i, &b) in raw_header.iter().enumerate() {
        if b == b':' {
            colon_pos = Some(i);
            break;
        }
    }
    let c_idx = colon_pos?;
    let mut w = 0usize;

    // 1. Lowercase field name, stripping any WSP before colon
    for &b in &raw_header[..c_idx] {
        if b == b' ' || b == b'\t' {
            continue;
        }
        if w >= out_buf.len() {
            return None;
        }
        out_buf[w] = if b >= b'A' && b <= b'Z' { b + 32 } else { b };
        w += 1;
    }
    if w >= out_buf.len() {
        return None;
    }
    out_buf[w] = b':';
    w += 1;

    // 2. Skip leading WSP after colon and collapse internal WSP sequences
    let mut in_wsp = false;
    let mut started = false;
    for &b in &raw_header[(c_idx + 1)..] {
        if b == b'\r' || b == b'\n' {
            continue;
        }
        if b == b' ' || b == b'\t' {
            if started {
                in_wsp = true;
            }
        } else {
            if in_wsp {
                if w >= out_buf.len() {
                    return None;
                }
                out_buf[w] = b' ';
                w += 1;
                in_wsp = false;
            }
            if w >= out_buf.len() {
                return None;
            }
            out_buf[w] = b;
            w += 1;
            started = true;
        }
    }
    Some(w)
}