TL;DR: Every technical control checks whether a message is forged. None of them checks whether the person who sent it was allowed to. A phishing mail from a real, authenticated mailbox passes SPF, DKIM and DMARC, looks exactly like the company it claims to be, and needs no exploit at all. The only control that survives this is the one that protects the login.
The scenario
I built a phishing mail that was not a phishing mail. It used a real mailbox, a real signature, a real domain and a real link. Every header check passed:
From: Service <service@example.tld>
Return-Path: <bounce@send.example.tld>
dkim=pass header.i=@example.tld header.s=esp
spf=pass ... @send.example.tld ...
dmarc=pass (p=REJECT sp=REJECT) header.from=example.tld
There is nothing to detect. The message is not forged. It is a genuine message from a genuine address that happens to say something false.
That is the class of phishing that survives every mail-security programme, and it starts with one credential.
Two questions, one answer
Mail authentication answers exactly one question: is this domain allowed to send?
It does not answer: was this person allowed to send?
That gap is not a bug in SPF, DKIM or DMARC. It is their scope. They were designed to stop forgery, and they do that well. They were never designed to notice that a legitimate account was used by the wrong person.
Once an attacker can send from a real mailbox, every downstream control agrees with them:
- the domain is correct — no lookalike needed;
- the signature is valid — the provider signed it;
- the thread is real — the attacker replies inside an existing conversation;
- the tone is right — the mail is written from inside the mailbox;
- the link is plausible — it points to a familiar host.
"Check the sender" is the advice that fails here, because the sender is correct.
Five doors, all of them credentials
The mailbox does not need to be hacked. It needs to be used. Five ordinary paths lead there:
- A reused password. One breach elsewhere, one identical password here.
- An app password. Created once, never expires, often forgotten.
- An OAuth grant. "Allow" on a consent screen that looked like a normal login.
- An API key. In a repository, a screenshot, a ticket, a chat message.
- A forwarding rule. Set once by someone with brief access; invisible afterwards.
Each one is enough to send as the domain. None of them trips an authentication check, because there is nothing wrong with the authentication.
What happens after the login
A quiet foothold looks like housekeeping:
- a forwarding rule that copies invoices to an external box;
- a filter that hides replies containing the word "payment";
- a new signature with a different bank account;
- a saved draft waiting for the right thread to reopen;
- an app password that survives the next password reset.
None of this needs malware. None of it touches the website. None of it appears in a mail filter, because every message is legitimate.
Findings
| Control | Answers | Blind to |
|---|---|---|
| SPF | was the envelope domain authorized | a real mailbox |
| DKIM | was the message signed by the domain | who pressed send |
| DMARC | does the visible domain align | a compromised account |
| Content filter | does the text look like phishing | a real conversation |
| Link scanner | is the destination known-bad | a clean, own host |
| 2SV / security key | who can log in | — |
The chain
Detection is in the account, not the mail
This is the part most teams miss: if the mail is clean, stop looking at the mail. The signals are in the account:
- a forwarding address nobody configured;
- a filter rule created at 03:14;
- a login from a country the user never visited;
- an app password created right after a password reset;
- a signature change without a ticket;
- a sudden burst of outbound mail from one mailbox.
All of these are user-account events. Most mail-security stacks do not look at them at all.
The control that survives
| Login factor | Phishing resistance |
|---|---|
| password only | one reused credential gives full sending |
| password + SMS | better, still phishable |
| password + TOTP | good; the secret can be phished live |
| password + security key | phishing-resistant — the key is bound to the origin |
The step from TOTP to a security key is the one that actually closes the realistic path. Everything below it can be relayed by a convincing page in real time.
And two configuration items matter as much as the factor:
- turn app passwords off where the workflow allows it;
- alert on new forwarding rules — that single rule catches a large share of mailbox takeovers.
Closing
The uncomfortable conclusion is that the two headlines everyone quotes — "phishing is getting better" and "authentication is the answer" — describe different problems.
Authentication stops forgery. It does nothing about impersonation with a real identity. The budget should follow the gap: less on another mail filter, more on protecting and watching the login.
Once an attacker gains access, they can perform the following actions: