Authenticated Received Chain (ARC) is an email authentication protocol, defined in RFC 8617, that lets intermediaries such as forwarders, mailing lists and security gateways record the SPF, DKIM and DMARC results they saw and cryptographically seal them into the message. A later receiver can then trust those results even after forwarding has broken SPF or DKIM.
With Microsoft, Google and Yahoo now enforcing DMARC on inbound mail, ARC is what stops legitimate forwarded mail from being rejected or quarantined. This post explains how ARC works, walks through a real three-hop ARC chain, and gives you a PowerShell function to decode ARC headers from any message.
Why Forwarding Breaks SPF, DKIM and DMARC
Indirect mail flow means the message doesn't travel straight from the sender's server to the recipient's server. Common examples:
- Mailbox or account forwarding (for example Microsoft 365 → Gmail → Zoho)
- Mailing lists that add a footer or
[List]subject tag - Third-party email security gateways that rewrite URLs or add banners
Each of these can break authentication:
| Check | Why it fails after forwarding |
|---|---|
| SPF | The forwarder sends from its own IP, which isn't in the original domain's SPF record (unless the forwarder rewrites the envelope sender with SRS) |
| DKIM | Changing the subject, body or footer invalidates the original signature |
| DMARC | DMARC needs SPF or DKIM to pass and align with the From: domain. If both break, DMARC fails and p=reject causes a bounce |
How ARC Solves It
- SPF, DKIM, DMARC =
pass - Seals results,
cv=none(first in chain)
- Validates the i=1 seal:
arc=pass - Adds its own seal,
cv=pass
- Validates the full chain i=1 → i=2
- Trusts the original DMARC pass, delivers to Inbox
Every ARC-participating server adds one ARC set, made of three headers that share the same instance number i=:
| Header | Purpose | Key tags |
|---|---|---|
| ARC-Authentication-Results (AAR) | A snapshot of the SPF / DKIM / DMARC / ARC results this hop saw | i=, spf=, dkim=, dmarc=, arc= |
| ARC-Message-Signature (AMS) | A DKIM-like signature over the message as this hop received it | i=, d=, s=, h=, bh=, b= |
| ARC-Seal (AS) | Signs all previous ARC sets, so nobody can tamper with the chain | i=, d=, s=, cv=, b= |
cv= (chain validation) tag in each ARC-Seal holds that hop's verdict on the chain before it:
cv=none— no earlier ARC sets (always the case fori=1)cv=pass— all earlier ARC sets validatedcv=fail— the chain is broken. Every later hop must also recordfail, and receivers should ignore the chain
Important: ARC does not override DMARC on its own. It gives the receiver evidence. The receiver decides whether to trust the sealer, based on its own reputation data or an admin-configured list of trusted ARC sealers.
Walking Through a Real 3-Hop ARC Chain
I sent a test message from Microsoft 365 (lab365.in) to Gmail, which auto-forwarded it to Zoho Mail. The final message contained three ARC sets.
Instance 1: Microsoft 365 seals the original results
ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none;
b=hHKv1LH/q7QPDa9zHQkK7AsDZpH527MaIpo6cdQbnsxr6NWp9ywYAPruYV78nEgl...
ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com;
s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version;
bh=JLqRj4hQ3j4my5ikpnsfqaeCAL5Ne00fEMqbrTD4h/4=;
b=BD5niXEk/wUbcitOLIbm9Kec7nYro0e2lbK+3aQOdlxeIPrMdRNXttekUbcV/...
ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass
smtp.mailfrom=lab365.in; dmarc=pass action=none header.from=lab365.in;
dkim=pass header.d=lab365.in; arc=none
mx.microsoft.com recorded SPF, DKIM and DMARC as pass. Because it's the first hop, both cv=none and arc=none.
Instance 2: Gmail validates hop 1 and adds its own seal
ARC-Seal: i=2; a=rsa-sha256; t=1640770738; cv=pass; d=google.com;
s=arc-20160816; b=aygLwXdcqgcZtrtMEuqeytWxoiLDaym+Pw80j2czWjCLs1KxzNHerpc63DqjL5YcGY...
ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com;
s=arc-20160816; h=mime-version:content-language:accept-language...;
b=EJbx2vp+QM/n+eRHI802OkM6wgqurzmpChmBVGEIyOw3T7dm8GnN8W5E4hPBbGehxS...
ARC-Authentication-Results: i=2; mx.google.com;
dkim=pass [email protected] header.s=selector2 header.b=pCmfPmVw;
spf=pass (google.com: domain of [email protected] designates
2a01:111:f400:fea4::61f as permitted sender) [email protected];
dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=lab365.in;
arc=pass (i=1 spf=pass spfdomain=lab365.in dkim=pass dkdomain=lab365.in
dmarc=pass fromdomain=lab365.in)
Gmail verified the i=1 seal (arc=pass (i=1 ...)) and sealed the chain with cv=pass.
Instance 3: Zoho validates the whole chain
ARC-Seal: i=3; a=rsa-sha256; t=1640770739; cv=pass; d=zohomail.com; s=zohoarc;
b=aT7DKuzcGg5Gi1vT/M1EoehU0ehCFT8RxaX3XXLCFAU9Qgtqhexqw+UGWnsMtIm/...
ARC-Message-Signature: i=3; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com;
s=zohoarc; t=1640770739; h=Content-Type:Date:From:MIME-Version:Message-ID:Subject:To;
bh=JLqRj4hQ3j4my5ikpnsfqaeCAL5Ne00fEMqbrTD4h/4=;
b=XHq/OSi0+YHUBPYZ38XRKZD481b91YY+J8srIOOaSc9gCRTXmWkiSqaamICWb5KoM...
ARC-Authentication-Results: i=3; mx.zohomail.com; dkim=pass;
spf=pass (zohomail.com: domain of _spf.google.com designates 209.85.160.178
as permitted sender) [email protected];
dmarc=pass header.from=<[email protected]> (p=quarantine dis=none);
arc=pass (i=2 dmarc=pass fromdomain=lab365.in)
Look at the smtp.mailfrom in instance 3. Gmail rewrote the envelope sender (the P1 / MAIL FROM address) to a gmail.com address, so SPF passed against Google's IPs. Microsoft 365 does the same thing with the Sender Rewriting Scheme (SRS). The header.from (the P2 address the user sees) stays lab365.in, and DMARC alignment is always checked against that header.
In this test DKIM also survived, so DMARC passed anyway. If Gmail had changed the body and broken DKIM, the i=2 ARC set would be the only proof that the message originally passed DMARC.
Decode Any ARC Chain with PowerShell
Copy the full message headers (Outlook: File → Properties → Internet headers; Outlook on the web: ⋯ → View → View message details) into a text file and run:
function Get-ArcTag([string]$Text, [string]$Name) {
if ($Text -match "(?:^|[;\s])$Name=([^;\s]+)") { $Matches[1] }
}
function Get-ArcChain {
[CmdletBinding()]
param (
[Parameter(Mandatory, ValueFromPipeline)] [string]$HeaderText
)
# Unfold folded header lines (RFC 5322: continuation lines start with whitespace)
$unfolded = $HeaderText -replace "`r?`n[ `t]+", ' '
$sets = @{}
foreach ($line in ($unfolded -split "`r?`n")) {
if ($line -match '^(ARC-Seal|ARC-Message-Signature|ARC-Authentication-Results):\s*(.+)%%%CODEBLOCK_4%%%#39;) {
$name = $Matches[1]
$value = $Matches[2]
if ($value -match '\bi=\s*(\d+)') {
$i = [int]$Matches[1]
if (-not $sets.ContainsKey($i)) { $sets[$i] = @{} }
$sets[$i][$name] = $value
}
}
}
foreach ($i in ($sets.Keys | Sort-Object)) {
$seal = $sets[$i]['ARC-Seal']
$aar = $sets[$i]['ARC-Authentication-Results']
$ams = $sets[$i]['ARC-Message-Signature']
[PSCustomObject]@{
Instance = $i
SealedBy = (Get-ArcTag $seal 'd')
Selector = (Get-ArcTag $seal 's')
ChainStatus = (Get-ArcTag $seal 'cv')
AuthServ = (if ($aar -match '^\s*i=\d+;\s*([^;\s]+)') { $Matches[1] })
SPF = (Get-ArcTag $aar 'spf')
DKIM = (Get-ArcTag $aar 'dkim')
DMARC = (Get-ArcTag $aar 'dmarc')
PriorARC = (Get-ArcTag $aar 'arc')
CompleteSet = [bool]($seal -and $aar -and $ams)
}
}
}
Get-Content .\headers.txt -Raw | Get-ArcChain | Format-Table -AutoSize
Output for the test message above (tested in Windows PowerShell 5.1 and PowerShell 7):
Instance SealedBy Selector ChainStatus AuthServ SPF DKIM DMARC PriorARC CompleteSet
1 microsoft.com arcselector9901 none mx.microsoft.com pass pass pass none True
2 google.com arc-20160816 pass mx.google.com pass pass pass pass True
3 zohomail.com zohoarc pass mx.zohomail.com pass pass pass pass True
How to read it:
ChainStatus = failat any instance → the chain was broken before that hop, so the receiver won't use it.CompleteSet = False→ one of the three headers is missing, which also breaks the chain.- The first instance where
DMARC = passshows the hop that saw the message before it was changed.
Note: This function reads ARC results. It doesn't re-verify the RSA signatures. To verify cryptographically, use a library such as Python'sdkimpy(arcverify) or check the receiver's ownAuthentication-Resultsheader, which contains itsarc=pass/failverdict.
ARC in Exchange Online (Microsoft 365)
- Outbound: Exchange Online ARC-seals messages it relays, using
d=microsoft.comwith selectors likearcselector9901/arcselector10001. - Inbound: Microsoft Defender for Office 365 / EOP validates ARC chains automatically. When DMARC fails but a trusted sealer's ARC set shows a pass, composite authentication can still pass the message. In the receiving
Authentication-Resultsheader this shows ascompauth=pass reason=130. - Trusted ARC sealers: if a third-party gateway (Mimecast, Proofpoint, Barracuda and so on) sits in front of Exchange Online and modifies messages, add its sealing domain as a trusted ARC sealer. Otherwise legitimate mail can fail DMARC. See my step-by-step guide: Configure Trusted ARC Sealers in Exchange Online with Set-ArcConfig.
Connect-ExchangeOnline
Get-ArcConfig | Format-List ArcTrustedSealers