November 1, 2025
Updated: November 4, 2026
Homoglyph attacks exploit look-alike Unicode characters to spoof domains, trick users, and bypass filters. Learn how they work, see real examples, and discover proven defenses.
Mohammed Khalil

A homoglyph attack (also called a homograph or IDN homograph attack) is visual spoofing: an attacker swaps one or more letters in a domain, email address, filename, or even source code for a near-identical character from another script, so the text looks legitimate but points somewhere else. To your eye, example.com with a Cyrillic "а" is indistinguishable from the real example.com with a Latin "a", yet they are entirely different strings that resolve to different places. This guide explains how homoglyph attacks work, where they now appear (including code and software packages), real 2026 examples, how to test for them, how to defend, and how to run domain monitoring for lookalike domains, at a time when no major browser reliably stops them.
Updated: November 2026. Adds domain monitoring for lookalike domains: Certificate Transparency, new-registration feeds, permutation tools, a takedown workflow, and what DMARC does and doesn't cover. Reflects the 2026 threat picture (no unified browser IDN defense, and homoglyph/Unicode attacks spreading into source code and package registries).
| Question | Short answer |
|---|---|
| What is it? | Spoofing that replaces letters with look-alike Unicode characters from another script |
| Why does it work? | Many characters are visually confusable (Latin "a" vs Cyrillic "а"), and IDNs make them valid in DNS |
| Where does it show up? | Fake domains, phishing emails, filenames, source code, and malicious software packages |
| Can browsers stop it? | Not reliably. In 2026 the three major browsers each have partial, bypassable defenses |
| Why care? | In IBM's 2025 Cost of a Data Breach report, phishing was the most common initial attack vector (16% of breaches), and homoglyphs slip past filters and trained users alike |
The one line to remember: a homoglyph attack hides a malicious name in plain sight, so the string you read is not the string the computer resolves.
A homoglyph is a character that looks like another. Unicode contains about 160,000 characters across more than 170 scripts, and many are visually identical or nearly so: the Latin "o" (U+006F) and the Cyrillic "о" (U+043E) render the same on virtually every screen. A homoglyph attack weaponizes that overlap: the attacker composes a name that looks like a trusted one but contains one or more characters from a different script.
The enabling technology is the Internationalized Domain Name (IDN) system, which lets domains use non-ASCII characters (encoded behind the scenes as "punycode," an xn-- string). IDNs exist for a good reason (so the world can have domains in Arabic, Chinese, Cyrillic, and every other script), but they also mean a fully Cyrillic аррӏе.com can be registered and will resolve completely independently of the Latin apple.com. To a human, and to many filters, the two look the same.
This is why homoglyph attacks are a favorite of phishers and, increasingly, supply-chain attackers: the deception happens at the level of perception, before any security control gets a clean string to inspect.
The mechanics are consistent whether the target is a domain, an email, or a line of code.
The classic proof of concept came from security researcher Xudong Zheng in 2017, who registered аррӏе.com using Cyrillic characters, which punycode-encodes to xn--80ak6aa92e.com, and demonstrated that Chrome and Firefox at the time displayed it as apple.com. The visual was perfect; the destination was not.
These lookalike techniques are often confused. The differences matter for defense.
| Technique | How it fools you | Example |
|---|---|---|
| Homoglyph / IDN homograph | Look-alike characters; the name appears correct | pаypal.com (Cyrillic "а") |
| Typosquatting | Relies on a typing mistake | gooogle.com, paypall.com |
| Combosquatting | Adds real words around the brand | paypal-secure-login.com |
| Slopsquatting | Names that AI coding tools hallucinate, then attackers register | a plausible-sounding package an LLM invented |
The key distinction: typosquatting needs you to make a mistake; a homoglyph attack works even when you read carefully or copy and paste, because the string genuinely looks right. Slopsquatting is the newest twist: attackers register the fake package names that AI assistants confidently suggest but that never existed, catching developers who trust the AI's output.
Homoglyphs started as a domain trick. In 2026 they span four surfaces.
Three forces make this more dangerous, not less.
| Case | What happened |
|---|---|
| PayPal "PayPaI" (early 2000s) | An ASCII trick using capital "I" for lowercase "l" to spoof PayPal and steal credentials |
| Adobe "adoḅe" (2017) | A dotted-b homoglyph domain served a fake Flash update carrying the Betabot trojan |
| Apple PoC (2017) | Xudong Zheng's аррӏе.com (xn--80ak6aa92e.com) rendered as apple.com in major browsers |
| BEC campaigns (2020s) | Cyrillic/Greek homoglyphs in DocuSign and Spotify-style sender names to bypass filters |
| Trojan Source (2021) | Unicode homoglyph and bidi tricks that hide malicious behavior in source code from reviewers |
| npm/PyPI lookalikes (2024-2026) | Homoglyph and typosquatted package names that imitate popular libraries |
The common thread: the top-level domain or the surrounding structure stays familiar, only the characters change, so the fake blends seamlessly into whatever interface displays it. This is also why many brands register similar domains early, before an attacker can.
Include homoglyph scenarios in phishing, red-team, and supply-chain assessments, alongside the core stages of what penetration testing covers. A practical sequence, which slots into a standard external penetration test:
Testing separately measures the control and the human, because a homoglyph attack can defeat either one alone.
Defense has to be layered, because no single control catches every case.
| Control | What it does |
|---|---|
| Force punycode display | Configure browsers/mail clients to reveal xn-- for mixed-script domains (e.g. Firefox network.IDN_show_punycode) |
| Email authentication (DMARC, DKIM, SPF) | Won't stop a lookalike domain, but flags spoofed senders and hardens your own domain |
| Domain and brand monitoring | Watch for newly registered lookalikes of your brand and take them down early; defensively register common variants |
| Confusable-detection tooling | Gateways/DNS filters that map a string to its ASCII "skeleton" (UTS #39) and flag confusables regex misses |
| Phishing-resistant MFA (FIDO2/passkeys) | Even if credentials are phished, passkeys are bound to the real domain and won't authenticate on the fake |
| Source-code Unicode linting | Detect bidi/homoglyph characters in code (Trojan Source defenses, anti-bidi linters, compiler warnings) |
| Dependency pinning + package verification | Pin versions, verify names, and scan dependencies to counter typosquatted/homoglyph packages |
| User training with real examples | Teach hovering, URL checking, and skepticism of urgency, tested with homoglyph samples |
Two controls do the heaviest lifting. Phishing-resistant MFA neutralizes the payoff of a successful homoglyph phish, because a passkey simply won't work on the wrong domain. And automated confusable detection plus monitoring catches at machine speed what human eyes cannot, while the human side is quantified in our social engineering statistics. Pair those with a tested incident response plan so a reported lookalike triggers fast takedown and account protection.
Domain monitoring for lookalike domains is the continuous search for newly registered, newly certified, or newly activated domain names that imitate yours, including homoglyph, typosquatted, and combosquatted variants, so you can investigate them and get the malicious ones taken down before they reach your staff or customers. It is not the same as monitoring your own domains for expiry or DNS changes, although many products sell both under one name. For homoglyph attacks it is the earliest control you have: an attacker must register the lookalike, and usually obtain a certificate for it, before the first phishing email goes out.
Homoglyphs make this harder than a keyword search. An IDN lookalike appears in registration data and certificate logs in its punycode form (xn--...), so a watch rule for "paypal" never matches the Cyrillic pаypal.com. Effective monitoring decodes punycode back to Unicode, maps each name to its confusable "skeleton" using the Unicode confusables data, and compares that skeleton with your list of protected names. Registries narrow the field a little: as the dnstwist documentation notes, most TLD authorities reject labels that mix scripts or use characters outside their approved sets. Whole-script lookalikes such as the all-Cyrillic аррӏе.com still get through, so the realistic homoglyph space is smaller than all of Unicode, but it is not empty.
No single feed sees every lookalike. Combine sources that catch a domain at different points in its life:
| Source | What it catches | When you see it | Main limit |
|---|---|---|---|
| Certificate Transparency logs | Publicly trusted TLS certificates issued for lookalike names, including hostnames such as login.yourbrand-secure.com | No later than the moment the HTTPS site works, because browsers reject unlogged certificates | Misses sites without a publicly trusted certificate; wildcard certificates hide individual hostnames |
| New-registration and zone-file feeds | Newly registered domains in TLDs that share zone files (for example gTLDs through ICANN's CZDS) | When the next zone file is published; compare successive files to find additions | Most country-code TLDs don't share zone files; a registration alone doesn't prove intent |
| Permutation scanning | Which likely variants of your names (homoglyph, typo, hyphen, TLD swaps) are registered, resolve, or have mail servers | Whenever you run it; schedule it daily or weekly | Finds only the variants its algorithms and dictionaries generate; arbitrary combosquats slip through |
| Reports and mail telemetry | Lookalikes already used against you: user-reported phish, email gateway detections, customer complaints | After the attack starts | Late by definition, but confirms which lookalikes are active |
Certificate Transparency is the most useful early signal. RFC 9162 describes it as a way of publicly logging TLS server certificates as they are issued or observed, so anyone can audit what certificate authorities have signed. Because Chrome's Certificate Transparency policy and Apple's treat publicly trusted certificates as invalid unless they are logged, an attacker who wants a padlock on a lookalike login page has to put that name in a public log. You can query the logs through public search interfaces such as crt.sh or stream new entries into your own tooling, then apply the punycode and skeleton matching described above.
Registration data covers the lookalikes that never get a certificate, such as domains bought only to send email. ICANN's Centralized Zone Data Service lets any interested party request zone files from participating generic TLDs, and comparing one file with the next shows new registrations. Commercial newly registered domain feeds extend coverage beyond gTLDs, and RDAP or WHOIS lookups add registration dates and registrar names for triage. Expect noise: many lookalikes are parked by domain investors or registered defensively by brand owners, so a new registration is a lead, not a verdict.
Permutation tools turn the problem around. Instead of waiting for a lookalike to appear, they generate the variants an attacker is most likely to register and check which ones already exist. The best-known open-source option is dnstwist. It runs a domain through a set of fuzzing algorithms, including a homoglyph fuzzer built on Unicode characters that can actually be registered, plus typo, hyphenation, and dictionary-based variants, and reports DNS records for each result. It can also flag rogue mail servers on lookalikes and compare a lookalike's web page with your real site using fuzzy hashes (ssdeep or TLSH) or screenshot perceptual hashes (pHash).
A lab-safe way to start is to run it against a domain you own, show only registered results, and limit it to the homoglyph fuzzer, for example dnstwist --registered --fuzzers homoglyph yourdomain.com. Run page-similarity checks only on domains you are investigating, keep lookup rates reasonable, and don't log in to, probe, or otherwise interact with a suspected phishing site beyond what you need to document it.
Then triage each registered lookalike by what it can do today:

When a lookalike is live and malicious, speed matters more than legal perfection. A workable sequence:
Track the time from detection to takedown for every case. It is the clearest single measure of whether your domain monitoring program is working.
DMARC is essential, but it protects only the exact domain in a message's From header. The current specification, RFC 9989, which obsoletes the original RFC 7489, states that DMARC does not address the use of visually similar domain names. A p=reject policy on yourbrand.com stops attackers from sending as yourbrand.com, which is exactly why they move to a homoglyph of it: a lookalike domain they own can pass SPF, DKIM, and DMARC for itself.
Use DMARC for what it does well, and pair it with monitoring for what it can't do:
Lookalike domains are part of your external attack surface even though you don't own them, so domain monitoring belongs alongside the discovery work described in our guide to attack surface management. The other end of the chain is stolen data: credentials phished through a lookalike can end up traded on criminal forums and markets, which is where dark web monitoring tools come in. Together, the two show you both the lure and its payoff.
DeepStrike's Premium plan, continuous penetration testing, includes Dark Web Monitoring and Attack Surface Management alongside weekly automated vulnerability scanning and two comprehensive penetration tests a year, as listed on our pricing page. Our phishing and social-engineering assessments can then use the lookalikes that monitoring finds to test whether your filters, browsers, and people actually catch them.

Homoglyph attacks are a small trick with an outsized reach: by swapping a single character for a look-alike, an attacker can turn a trusted domain, email, code review, or dependency into a weapon, and in 2026 no browser reliably stops them. The defense is visibility and layering: force punycode, monitor for lookalikes, detect confusables automatically, lint your code and dependencies, and deploy phishing-resistant MFA so a convincing fake still fails. Above all, remember that the name you read is not always the name the machine resolves, and test for the difference before an attacker exploits it.
DeepStrike's penetration testing includes phishing and social-engineering assessments that use homoglyph and lookalike-domain scenarios to validate whether your filters, browsers, and people actually catch them. To scope an engagement, see our penetration testing services.
It is a spoofing attack that makes a domain, email, filename, or piece of code look identical to a legitimate one by replacing characters with visually similar glyphs, often from another alphabet. For example, using a Cyrillic "а" instead of a Latin "a" in a URL creates a lookalike that resolves to a different, attacker-controlled destination.
Typosquatting relies on you making a typing mistake, like gooogle.com. A homoglyph attack uses characters that look identical to the real ones, so it fools you even when you read carefully or copy and paste, because the text genuinely appears correct. Homoglyphs deceive perception; typosquatting exploits error.
Not reliably. As of 2026 there is no unified defense: Chrome, Firefox, and Safari each apply their own heuristics that show punycode (xn--...) for suspicious mixed-script domains, but each has known bypasses, and a carefully built homoglyph domain can still render as its target. Browser display helps but cannot be your only control.
Yes. The 2021 "Trojan Source" research (CVE-2021-42574 and CVE-2021-42694) showed that Unicode homoglyph and bidirectional-override characters can make source code look benign to a human reviewer while the compiler interprets it maliciously, for instance calling a homoglyph-named function. Anti-bidi linters and Unicode code scanning defend against it.
Attackers publish malicious packages to registries like npm and PyPI using homoglyph or typosquatted names of popular libraries, so developers install the fake by mistake. A related 2025-2026 twist is "slopsquatting," registering the plausible package names that AI coding assistants hallucinate. Dependency pinning, name verification, and scanning are the defenses.
Because a homoglyph URL or sender looks legitimate, so simple filters that match on paypal.com miss pаypal.com with a Cyrillic character. The malicious string is a different string entirely. That is why defense must be layered (punycode display, confusable detection, DMARC, and phishing-resistant MFA) rather than any single filter.
Testers generate homoglyph and typosquatted variants of your domains with tools like dnstwist and the Unicode confusables data, then use them in sanctioned phishing and access tests to see whether email filters catch them, whether users notice, and whether controls like password-manager autofill correctly refuse the fake domain. The gaps found drive filter, monitoring, and training fixes.
Domain monitoring is the continuous watch for domain names that could be used against your organization. In security it usually means finding newly registered or newly certified lookalike domains, including homoglyph and typosquatted variants of your brand, through Certificate Transparency logs, new-registration feeds, and permutation scans, then triaging them and getting the malicious ones taken down. Some vendors also use the term for watching your own domains' expiry and DNS records.
Combine three methods: search Certificate Transparency logs for certificates whose decoded names resemble yours, watch new-registration and zone-file feeds, and run a permutation tool such as dnstwist against your own domains to see which homoglyph and typo variants are registered. Decode punycode (xn--) names before matching, or homoglyph lookalikes will slip past keyword rules.
No. DMARC protects only the exact domain in the From header, and the current specification, RFC 9989, says it does not address visually similar domain names. A lookalike domain the attacker owns can pass its own SPF, DKIM, and DMARC checks. DMARC still matters because it stops exact-domain spoofing, but lookalikes need monitoring, gateway detection, and takedowns.

Stay secure with DeepStrike penetration testing services. Reach out for a quote or customized technical proposal today
Contact Us