logo svg
logo

November 1, 2025

Updated: November 4, 2026

What Is a Homoglyph Attack? Unicode Spoofing in 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

Mohammed Khalil

Featured Image

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).

The quick answer

QuestionShort 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.

What is a homoglyph attack?

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.

How homoglyph attacks work

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.

Homoglyph vs typosquatting vs slopsquatting

These lookalike techniques are often confused. The differences matter for defense.

TechniqueHow it fools youExample
Homoglyph / IDN homographLook-alike characters; the name appears correctpаypal.com (Cyrillic "а")
TyposquattingRelies on a typing mistakegooogle.com, paypall.com
CombosquattingAdds real words around the brandpaypal-secure-login.com
SlopsquattingNames that AI coding tools hallucinate, then attackers registera 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.

Where homoglyph attacks appear now

Homoglyphs started as a domain trick. In 2026 they span four surfaces.

Why homoglyph attacks matter in 2026

Three forces make this more dangerous, not less.

Real-world homoglyph examples

CaseWhat 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.

How to test for homoglyph attacks

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:

  1. Inventory the targets. List your critical domains, login URLs, sender addresses, brand names, and key software dependencies, the things worth spoofing.
  2. Generate lookalikes. Use tools like dnstwist and the Unicode confusables data (UTS #39) to enumerate homoglyph and typosquatted variants of each target.
  3. Simulate safely. Register test domains in a controlled environment or simulate them via lab DNS/hosts entries to see how browsers and mail clients render them (often as punycode, sometimes not).
  4. Run controlled phishing and access tests. Send sanctioned phishing using the lookalikes and check whether filters catch them, whether users notice, and whether password managers correctly refuse to autofill on the wrong domain (a strong, underrated signal).
  5. Analyze and report. Document which lookalikes were most convincing and which controls failed, then recommend blocks, filter updates, monitoring rules, and MFA on affected accounts.

Testing separately measures the control and the human, because a homoglyph attack can defeat either one alone.

How to defend against homoglyph attacks

Defense has to be layered, because no single control catches every case.

ControlWhat it does
Force punycode displayConfigure 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 monitoringWatch for newly registered lookalikes of your brand and take them down early; defensively register common variants
Confusable-detection toolingGateways/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 lintingDetect bidi/homoglyph characters in code (Trojan Source defenses, anti-bidi linters, compiler warnings)
Dependency pinning + package verificationPin versions, verify names, and scan dependencies to counter typosquatted/homoglyph packages
User training with real examplesTeach 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

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.

Four sources that reveal lookalike domains

No single feed sees every lookalike. Combine sources that catch a domain at different points in its life:

SourceWhat it catchesWhen you see itMain limit
Certificate Transparency logsPublicly trusted TLS certificates issued for lookalike names, including hostnames such as login.yourbrand-secure.comNo later than the moment the HTTPS site works, because browsers reject unlogged certificatesMisses sites without a publicly trusted certificate; wildcard certificates hide individual hostnames
New-registration and zone-file feedsNewly 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 additionsMost country-code TLDs don't share zone files; a registration alone doesn't prove intent
Permutation scanningWhich likely variants of your names (homoglyph, typo, hyphen, TLD swaps) are registered, resolve, or have mail serversWhenever you run it; schedule it daily or weeklyFinds only the variants its algorithms and dictionaries generate; arbitrary combosquats slip through
Reports and mail telemetryLookalikes already used against you: user-reported phish, email gateway detections, customer complaintsAfter the attack startsLate 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: generate the lookalikes before attackers do

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:

Diagram: lookalike domain monitoring pipeline from collecting signals to normalizing, triaging and taking action

Takedown workflow for a malicious lookalike

When a lookalike is live and malicious, speed matters more than legal perfection. A workable sequence:

  1. Preserve evidence. Capture a screenshot, the full URL, DNS and certificate details, registration data, and timestamps. ICANN's guidance on DNS abuse obligations cites a screenshot of what the page impersonates and the complete URL as examples of evidence that helps a registrar act.
  2. Protect your users first. Block the domain at the email gateway, DNS filter, and web proxy, warn staff or customers if the lure is circulating, and reset credentials for anyone who entered them.
  3. Report to the registrar and the host. ICANN-accredited registrars must publish an abuse contact and investigate reports, and since the contract amendments of 5 April 2024 they must act promptly to stop or disrupt phishing on a generic-TLD domain once they have actionable evidence. Send the same evidence to the hosting provider's abuse desk.
  4. Report to blocklists. Submit the URL to Google Safe Browsing and to Microsoft's unsafe-site reporting so browsers start warning users, and forward the phishing email to the Anti-Phishing Working Group at reportphishing@apwg.org.
  5. Use legal routes for the rest. For lookalikes that infringe your trademark without obvious phishing, the Uniform Domain Name Dispute Resolution Policy (UDRP) lets a trademark owner seek transfer of the domain by showing trademark rights, no rights or legitimate interest on the registrant's side, and registration and use in bad faith. It is slower than an abuse report, so keep it for persistent cases.
  6. Keep watching. Leave the domain on your watch list in case it is re-registered or the campaign moves to a close variant, and add the pattern to your permutation dictionaries.

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 and lookalike domains: what it does and doesn't do

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:

Where domain monitoring fits in your security program

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.

Conclusion

Digital illustration showing a cybersecurity expert activating a glowing holographic defense sphere labeled with “Phishing Simulation,” “Homoglyph Detection,” and “Continuous Testing,” symbolizing DeepStrike’s readiness-driven penetration testing approach.

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.

FAQ

What is a homoglyph (homograph) attack?

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.

How is a homoglyph attack different from typosquatting?

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.

Can browsers block homoglyph attacks automatically?

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.

Can homoglyphs appear in source code, not just domains?

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.

What are homoglyph attacks in software packages?

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.

Why are homoglyph attacks dangerous even with email security in place?

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.

How can penetration testing find homoglyph weaknesses?

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.

What is domain monitoring?

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.

How do I find lookalike domains of my brand?

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.

Does DMARC stop lookalike domain attacks?

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.

background
Let's hack you before real hackers do

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

Contact Us