A homograph attack registers a domain built from characters that look like the ones in a real domain but aren't. A Cyrillic "о" stands in for a Latin "o", and the address you read and the address a browser resolves become two different things. The trick travels as punycode: DNS only understands ASCII, so every non-ASCII name is converted into an xn-- label before it touches the network, and browsers convert it back for display. That conversion back is where the deception lives.
Modern browsers now catch the obvious cases and show raw punycode when a label mixes scripts suspiciously. But that protection stays inside the address bar. This post covers how the attack works, what the standards and browsers do about it, where they stop, and what a link scanner can and can't see. For the broader question of short links, are URL shorteners safe covers that ground; this one is about the domain underneath the link.
What Punycode Is and Why It Exists
DNS was built for ASCII. Full stop. It has no native way to store accented letters, Cyrillic, Arabic or Chinese, which became a problem the moment domain registration opened up outside English-speaking markets.
Punycode is the fix: a reversible encoding, standardised as RFC 3492, that converts a Unicode label into letters, digits and hyphens that DNS carries unchanged. A German bakery with an umlaut in its name or a Ukrainian retailer registering in Cyrillic gets a working internationalised domain that resolves like any other. The encoded label starts with xn--, which signals "decode before showing this to a human."
None of that is a flaw. Internationalised domains are a necessary feature.
The trouble starts a layer up, where software decides how to display the decoded name.
How a Homograph Attack Works
The attack exploits the gap between what a domain contains and what it looks like once rendered. Unicode's security report, UTS #39, gives the vocabulary (accessed 2026-10-25). Two strings are confusable when they reduce to the same "skeleton." It then separates a whole-script confusable, where a string written entirely in one script, such as Latin "scope", has a lookalike written entirely in another, here Cyrillic, from a mixed-script confusable, where the lookalike mixes scripts.
The whole-script version needs a name whose every letter has a counterpart in another script. It's rarer. Few real brands can be spelled that way. The mixed-script version needs one substitution. Take novacloud.com, swap the Latin "o" for the Cyrillic "о" (U+043E), and you get a domain of the same shape and length that encodes to xn--nvacloud-nbh.com. The eye has almost nothing to flag. That's the point.
Once the domain is registered, the rest is ordinary phishing. A copied login page, an urgent message, a target with no reason to doubt an address that looks right.
What Browsers Do About It
Browsers closed the easy version of this attack with rules about which scripts may share a label. Chrome's IDN policy decides per label and falls back to punycode in many cases (accessed 2026-10-25). It states that Latin, Cyrillic and Greek characters cannot be mixed with each other, and it also shows punycode for mixed-script confusables, for labels made up entirely of whole-script confusables unless the top-level domain is in that script's usual territory, and for labels whose skeleton matches a top domain. Firefox runs a comparable check, described in Mozilla's IDN display algorithm, and Safari has its own.
The result is that nоvacloud.com with one Cyrillic letter shows up as xn--nvacloud-nbh.com in Chrome. It isn't complete protection. Rules differ by browser, and a single-script lookalike that no list anticipates can still render as a readable, deceptive name.
Where That Protection Stops
The script-mixing check lives in the browser's address-bar rendering. It doesn't travel with the URL.
Email clients can show any anchor text over any destination. Many run no confusable check at all, and mobile mail apps are the weakest. Chat apps unfurl a link into a preview card built from page metadata. QR codes remove the text step, a gap we cover in are QR codes safe, and print has no software layer at all.
| Channel | Shows the real destination before you act | Typical exposure |
|---|---|---|
| Modern desktop browser | Usually, via script-mixing rules | Low, if kept current |
| Email client | Rarely, since anchor text can say anything | High, especially on mobile mail apps |
| Chat and messaging apps | Rarely, previews use page metadata | High, unfurled links look identical |
| QR code | No, nothing renders until after the scan | High, the decision takes a second |
| Printed material | Never, no software is involved | Highest, no technical check is possible |
What a Link Shortener Can Check
A shortener sits between the sender and the browser, so it can look at a destination before anyone clicks. How much it sees depends on the implementation, and here is what Elido does today, from the code.
The url-scanner heuristic adds 25 points when a destination host starts with, or contains a label starting with, xn--. It adds more for brand names in the host or path, for an @ that hides the real host, for raw IP hosts and for hyphen-stuffed hostnames. Heuristic scores are capped at 75, below the 80 needed to block, so a punycode host alone is flagged suspect, never blocked. Crossing the line takes a threat-feed match or a second signal. The scanner also queries threat feeds, which list lookalike domains once someone reports them.
There is a gap, and it's a real one. That xn-- test runs on the hostname as submitted, and I found no step in api-core or the scanner that converts a Unicode hostname to its ASCII form first. A destination pasted in Unicode form (the Cyrillic version) may therefore skip the punycode signal that its ASCII twin would trigger. The brand-lookalike check is also ASCII substring matching, so it won't match a Cyrillic "раураl" at all. We've logged both as backlog items. Until they're fixed, treat the heuristic as a cheap first filter, not a homograph detector.
On the other side, custom domains are stricter. The domain-add handler accepts only ASCII letters, digits and hyphens, so a workspace can't attach a raw Unicode hostname, though it can add an xn-- form.
Why a Branded Domain Helps You
A homograph attack needs a recognisable brand to counterfeit. That's no reason to avoid building one. A distinctive branded short link that your audience associates with you gives them something to compare a suspicious message against. A generic shared domain gives an attacker a template. Customers can't tell it from the real provider.
Setting up a custom domain means every link you send carries a name recipients know, which raises the bar for anyone counterfeiting it. See how custom domains work on Elido; you get one on Pro and five on Business. This is the opposite of link cloaking, which is a disclosed choice to route links through your own domain. A homograph attack hides the attacker's identity while imitating yours.
Registrar controls for domains you own
Registrar lock, often shown as clientTransferProhibited, blocks routine automated transfers. Turn it on. Registry lock engages the registry operator so any change, transfer or deletion needs manual out-of-band verification. Reserve it for the domains where an unauthorised change would be expensive.
Neither lock stops someone registering a lookalike next to yours. Only monitoring catches that: watch new registrations and certificate-transparency logs for names close to your brand, and keep a named owner and a path for reporting a lookalike to its registrar. The security checklist for choosing a link provider covers adjacent vendor controls.
A Verification Recipe Anyone Can Follow
You don't need to understand punycode. Four steps catch nearly everything this attack relies on.
- Expand the link first. How to see where a short URL goes lists the tools, and Elido's link checker is one of them. On an Elido short link, adding
+to the end shows a preview page with the destination instead of redirecting. - Read the registrable domain, the part just before the top-level domain. That's the part an attacker has to control.
- Look for an
xn--label in the expanded URL or the address bar. Where you expected a plain brand name, stop and treat it as a lookalike. - Check the certificate name on the destination. It reflects what was issued to the domain owner, which is harder to fake convincingly than a rendered label, though note that certificates are issued to lookalikes too, so a padlock proves nothing about honesty.
A homograph attack is a display problem, not a protocol bug. Punycode does what it was designed to do; the deception happens between what a domain is and what software shows you. Browsers have closed most of that gap in the address bar. Everywhere else it's open. Expanding a link and reading the registrable domain remains the habit that works whichever channel delivered it.
Related on the Blog
Frequently asked questions
What is an IDN homograph attack?
It registers a domain using characters from another script that look the same as the ones in a real domain, so a reader can't tell them apart. The classic case swaps one Latin letter for a Cyrillic or Greek lookalike. The two domains differ at the code point level, so different owners can hold them. The attack works on appearance alone, which is why it targets well-known brand names.
What is punycode and why does it exist?
Punycode, defined in RFC 3492, turns a non-ASCII domain label into an ASCII string that DNS can store and resolve. A domain written in Cyrillic, Arabic, Chinese or with accented Latin letters is converted this way before lookup, and the encoded label always starts with xn--. Browsers decode it back for display. That's a legitimate feature, not the vulnerability itself.
What does the xn-- prefix mean in a URL?
It marks a label as ASCII-compatible encoding of a name that contained non-ASCII characters. In the example here, xn--nvacloud-nbh.com decodes to a name that looks like novacloud.com with one Latin o replaced by a Cyrillic one. A plain ASCII domain never produces an xn-- label, so seeing one where you expected a familiar brand deserves a second look.
Do browsers protect against homograph attacks?
Largely, in the address bar. Chrome shows punycode instead of Unicode when a label mixes Latin, Cyrillic or Greek, when it is a mixed-script confusable, or when its skeleton matches a top domain. Firefox and Safari have their own rules. Attackers can still use single-script lookalikes that slip through, and the protection doesn't follow the link into email, chat or a QR code.
How can I tell if a link is a lookalike domain before I click it?
Expand the link so you see the real destination, read the registrable domain just before the top-level domain, and look for an xn-- label. If one appears where you expected a plain brand name, treat it as a lookalike until proven otherwise. Typing the address yourself or using a saved bookmark for banks and payment pages avoids the question entirely.
What is registry lock and does my domain need it?
Registry lock blocks any change, transfer or deletion of a domain until it is verified out of band, usually by phone or a passphrase, so even a compromised registrar account can't move it. It is stronger than a registrar lock, which only blocks routine automated transfers. It suits the domains whose hijacking would be costly, typically your primary brand domain. It won't stop someone registering a similar-looking domain next to yours; monitoring handles that.
Try Elido
Paste a URL, get a working short link
No signup. Link lives for 30 days. Sign up to keep it forever.
Free account required. The free plan includes 25 links in total. Already have an account? Log in
