Postmortem: Our BIMI SVG Was Public, But the CDN Blocked Gmail
You bought the VMC and reached DMARC reject, but Gmail still serves up a generic initial instead of your logo. Your CDN might be the quiet culprit.

Dropping a significant chunk of budget on a Verified Mark Certificate only to stare at a generic gray placeholder in your inbox is a distinct kind of operational pain. You did the grueling architectural work. You spent months hunting down shadow IT, configuring SPF for every SaaS vendor, and ensuring DKIM cryptographic alignment across your sprawling corporate infrastructure. You finally flipped your DMARC policy to absolute enforcement. You converted your corporate logo into the hyper-specific vector format required by the standard. You published the DNS record and verified the syntax.
But when you send a test email to your personal Gmail account, the brand logo is conspicuously missing. You are staring down the classic bimi svg not showing scenario, and the most frustrating part is that every diagnostic tool on the internet claims your configuration is flawless. The AuthIndicators Working Group inspector gives you a green light. Your DNS resolves instantly.
Email security engineering often feels like trying to perfectly align a dozen moving parts across disparate networks. When authentication protocols rely on external web assets, the troubleshooting boundary extends past your mail transfer agents and straight into your web perimeter. This postmortem will tear down exactly why a perfectly compliant visual asset failed to render, entirely due to an overzealous security rule living at the CDN edge.
The Symptom and the Silent Fetch Failure
The initial triage of any email display issue begins with the raw message source. The authentication headers tell a story of total cryptographic success. The originating IP is authorized by the sender policy framework. The DKIM body hash perfectly matches the transmitted payload, proving no intermediate forwarder rewrote the message boundaries. DMARC evaluates to a strict enforcement state, which is the foundational prerequisite for Brand Indicators for Message Identification.
Authentication-Results: mx.google.com; dkim=pass header.i=@example.com header.s=core; spf=pass (google.com: domain of admin@example.com designates 192.0.2.100 as permitted sender); dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=example.com; bimi=skipped (fetcher timeout) — Gmail Authentication-Results Header Excerpt
That final directive in the header is the quiet killer. The receiving mailbox provider attempted to evaluate the record. It queried DNS for the default selector, successfully parsed the text record, extracted the location of the hosted image, but completely failed to retrieve the actual payload over the network.
The Illusion of Public Accessibility
When an engineer drops the image URL into a browser address bar or initiates a terminal curl request, the server returns an immediate HTTP 200 OK. The image renders perfectly on screen. The MIME type correctly broadcasts as image/svg+xml. To human eyes and standard testing scripts, the asset is entirely public and ready for consumption. The disconnect happens because your local workstation is fundamentally different from a headless backend crawler operating from a massive cloud data center.
Verifying the Strict Asset Syntax Limits
The standard dictates an incredibly rigid structure for a reason. Mailbox providers are inherently paranoid about parsing complex file types. A standard scalable vector graphic is essentially just an XML document, which historically carries immense risk. If a webmail client blindly renders an untrusted XML file, it opens the door to cross-site scripting, server-side request forgery, and XML external entity injection attacks directly inside the user interface.
To mitigate this blast radius, the standard mandates the SVG Tiny Portable Secure profile. This stripped-down specification disables external references, prevents embedded base64 raster images, and strictly limits animation tags. Before blaming network conditions, a competent defender must re-verify the asset against these strict schema limitations. A single rogue metadata tag injected by graphic design software can silently invalidate the entire file during the mailbox provider parsing stage.
Ruling Out Certificate Hash Mismatches
If your organization requires a Verified Mark Certificate to display logos in strict clients, the PEM-encoded certificate chain adds another layer of fragility. The certificate authority cryptographically binds the exact file hash of your logo into the certificate itself. We pulled the certificate entity from the hosting endpoint, ran a cryptographic hash on our hosted file, and confirmed total alignment. The math was correct. The asset was structurally sound. The problem was not the file itself, nor the DNS record pointing to it.
Hunting for Anomalies in Edge Network Logs
If the file is valid, the certificate hash aligns, and the DNS is correct, the failure must occur at the transport layer during the initial fetch attempt by the mailbox provider. It was time to stop looking at SMTP headers and start looking at the edge network processing the incoming HTTP requests.
We pulled the access logs from the Content Delivery Network responsible for terminating TLS for the domain hosting the brand assets. Filtering the immense stream of internet background radiation down to the exact URI path of the logo over a narrow twenty-four hour window revealed a very clear pattern of targeted rejection.
{"timestamp": "2023-11-14T09:42:11Z", "client_ip": "74.125.212.44", "user_agent": "Google-BIMI-Fetcher", "method": "GET", "uri": "/brand/logo.svg", "status": 403, "tls_cipher": "TLS_AES_128_GCM_SHA256", "waf_rule_id": "managed_bot_defense_strict"}
The smoking gun was sitting right in the standard output. An edge node had returned a forbidden error to the exact IP address attempting to cache our logo. The firewall was doing exactly what we paid it to do by blocking an unrecognized, automated scraper requesting resources from a known data center IP block.
Why Web Application Firewalls Hate Mailbox Crawlers
Modern Web Application Firewalls and automated bot management features no longer rely solely on static blocklists. They utilize complex behavioral heuristics, TLS fingerprinting, and strict parsing of request headers to drop malicious traffic before it ever hits the origin server. They are highly tuned to intercept headless browsers and generic Python scripts attempting to scrape your primary web properties or hammer your authentication endpoints.
The Fetcher Disconnect
The core issue is that mailbox providers do not fetch these visual assets using standard consumer browsers. When a major provider decides to cache your logo for their respective webmail interfaces, they dispatch a background crawler. These specific crawlers run entirely from massive data center IP ranges that are already heavily scrutinized by bot mitigation engines due to the sheer volume of abuse originating from those same hosting providers.
Unlike the primary search indexers which firewall vendors universally whitelist by default in their managed rulesets, niche fetchers built for email security protocols are frequently categorized as anomalous automated traffic. The crawler fails to present a typical consumer TLS fingerprint. It operates without a standard session cookie. If your edge protection is set to a high enforcement threshold, it will silently drop these requests. The mailbox provider registers a timeout, aborts the rendering process, falls back to the default initial letter, and refuses to try again for days.
Punching a Safe Hole in the Edge Perimeter
Upon identifying the block, the immediate temptation for many operations teams is to globally lower the bot protection sensitivity on the entire domain just to get the project shipped. This is a catastrophic architectural choice. You do not weaken your entire web security posture and invite credential stuffing attacks just to display a corporate logo.
The correct fix requires deploying a highly scoped firewall bypass rule specifically tailored to the fetcher behavior. We needed to allow the mailbox provider through the perimeter without exposing the origin server to generalized scraping abuse from the wider internet.
Scoping the Bypass Logic
We authored a custom edge rule that matched a GET request specifically and exclusively to the exact URI path of the visual asset. We did not rely on whitelisting the user-agent string alone, as headers are trivially spoofed by attackers attempting to evade basic defenses. Instead, we added a secondary logical condition checking the Autonomous System Number of the incoming requester.
By restricting the bypass logic to known mailbox provider networks, we constrained the attack surface to a mathematically insignificant window. Once the targeted rule was deployed and propagated across the edge nodes, we monitored the live traffic logs. Within a few hours, a fresh request from the fetcher hit the endpoint, successfully returned an HTTP 200 OK, and the logo instantly populated in the next wave of inbound test messages.
The takeaway
Email security does not exist in a vacuum. It intersects heavily with web infrastructure, edge configurations, and perimeter defense systems. When an email standard relies on cross-domain asset retrieval over HTTPS, your web firewall automatically becomes an involuntary participant in your delivery pipeline. Ignoring the network layer while troubleshooting mail configuration is a guaranteed recipe for prolonged outages.
The next time you deploy a strict domain authentication policy and your brand assets absolutely refuse to render in the client, stop staring obsessively at your DNS records. Fire up MailSleuth.AI to confirm your underlying alignment is genuinely flawless, then immediately go check your firewall access logs. The network layer never lies, and the call is almost always coming from inside your own perimeter.
We dissect phishing campaigns and email infrastructure so you don't have to.


