Punycode & IDN Converter
Convert Internationalized Domain Names (IDN) with foreign characters into ASCII Punycode (xn--) and vice versa.
Unlike conventional calculator sites that send your financial numbers, payload data, or code snippets across remote web servers, Affi-Chain processes all mathematical derivations, algorithms, and data parsing 100% locally within your browser sandbox. No tracking cookies, no server-side retention, and zero transmission lag.
What is Punycode?
Punycode is a specialized encoding syntax defined by the Internet Engineering Task Force (IETF) in RFC 3492 designed to translate arbitrary Unicode strings into unique, reversible ASCII character sequences containing exclusively letters (a-z), digits (0-9), and hyphens (-).
Punycode was engineered specifically to solve the architectural conflict between global human languages and the legacy Domain Name System (DNS). Defined in 1987 under RFC 1034 and RFC 1035, the global DNS protocol strictly permits only LDH (Letters, Digits, Hyphen) ASCII characters in hostname labels. When the international community introduced Internationalized Domain Names (IDNs) to allow web addresses in non-Latin scripts (such as Arabic, Chinese, Cyrillic, Hebrew, Hindi, and Japanese) and diacritic Latin alphabets (such as French, German, and Spanish), replacing the entire global DNS infrastructure was physically impossible.
Instead, the IDNA (Internationalizing Domain Names in Applications) standard uses Punycode as an application-layer translation bridge. Every internationalized domain is prefixed with the four-character ASCII Compatible Encoding (ACE) token xn--, allowing legacy DNS root servers, authoritative name servers, and recursive resolvers to route international domains without modifying a single line of low-level networking protocol code.
The IDNA Translation Architecture
When a user enters an international web address into a modern browser, the user agent executes the IDNA ToASCII workflow before initiating DNS resolution:
flowchart TD
UserInput["User Inputs Internationalized URL: https://münchen.de"] --> IDNAEngine["Client Browser IDNA Engine (UTS #46)"]
IDNAEngine --> CheckScript{Does label contain non-ASCII code points?}
CheckScript -- No --> StandardDNS["Standard DNS Resolution: Query A/AAAA"]
CheckScript -- Yes --> Normalize["Unicode Normalization (NFC) & Mapping"]
Normalize --> PunycodeEncode["Execute RFC 3492 Bootstring Algorithm"]
PunycodeEncode --> PrependPrefix["Prepend ACE Prefix: 'xn--'"]
PrependPrefix --> CompleteDomain["Canonical ASCII Hostname: xn--mnchen-3ya.de"]
CompleteDomain --> RootDNS["Query Root DNS Nameservers via UDP Port 53"]
Transformation Walkthrough: münchen.de $\to$ xn--mnchen-3ya.de
- The domain label
münchencontains the Unicode characterü(code pointU+00FC). - The Bootstring algorithm extracts all basic ASCII characters:
m,n,c,h,e,n$\to$"mnchen". - A delimiter hyphen (
-) is appended:"mnchen-". - The delta-encoded offset for
üis calculated and serialized in base-36:"3ya". - Combining the elements yields
"mnchen-3ya". - Prepending the ACE flag yields the final DNS label:
xn--mnchen-3ya, resolving toxn--mnchen-3ya.de.
Canonical Internationalized Domain Name Translation Matrix
| Unicode Domain Name | Primary Language / Script | Punycode ACE Encoded Domain | ACE Label Breakdown |
|---|---|---|---|
münchen.de | German (Umlaut) | xn--mnchen-3ya.de | mnchen (ASCII) + - + 3ya (encoded ü) |
café.com | French (Acute accent) | xn--caf-dma.com | caf (ASCII) + - + dma (encoded é) |
bücher.de | German (Umlaut) | xn--bcher-kva.de | bcher (ASCII) + - + kva (encoded ü) |
españa.es | Spanish (Tilde) | xn--espaa-rta.es | espaa (ASCII) + - + rta (encoded ñ) |
интернет.рф | Russian (Cyrillic) | xn--e1afmkfd.xn--p1ai | Fully non-ASCII; domain and TLD are both ACE-encoded |
北京大学.cn | Chinese (Simplified Han) | xn--1lq90ic7f1rc.cn | Delimiter omitted when zero basic ASCII characters exist |
東京.jp | Japanese (Kanji) | xn--1lqs71d.jp | Maps code points U+6771 (東) and U+4EAC (京) |
سورية.sy | Arabic (Right-to-Left) | xn--ogb4ce7e.sy | RTL bidirectional text processed under RFC 5893 |
भारत.in | Hindi (Devanagari) | xn--h2brj9c.in | Devanagari script representing national name |
Cybersecurity Architecture: IDN Homograph Phishing Attacks
While Punycode provides global linguistic accessibility, it also introduces a severe attack vector: the IDN Homograph Phishing Attack.
The Homoglyph Vulnerability
A homoglyph is a character whose visual appearance is virtually identical or indistinguishable from a character in a different alphabet. Malicious actors register domain names using lookalike Unicode glyphs to impersonate financial institutions, technology platforms, and government agencies:
flowchart LR
A["Target Target: apple.com (Latin ASCII)"]
B["Phishing Domain: аpple.com (Cyrillic 'а' U+0430)"]
A -->|DNS Lookups| IP1["Valid Apple Origin IP: 17.253.144.10"]
B -->|Punycode Translation| ACE["xn--pple-43d.com"]
ACE -->|DNS Lookups| IP2["Attacker Exploitation Server IP: 198.51.100.42"]
Because Cyrillic small letter а (Unicode code point U+0430) renders identically to Latin small letter a (ASCII code point U+0061) in standard fonts (Helvetica, Arial, Roboto), a user inspecting the address bar cannot visually detect the fraud.
Browser Defensive Mechanisms (UTS #46 & Mixed-Script Profiles)
To combat homograph attacks, modern web browsers (Chrome, Firefox, Safari) implement strict IDN Display Algorithms defined by Unicode Technical Standard #46:
- Single-Script Enforcement: If a domain label mixes Cyrillic and Latin characters (e.g.,
аpple.comwith one Cyrillicаand four Latin letterspple), the browser detects an illegitimate mixed-script attack and forces display of the raw Punycode stringxn--pple-43d.comin the address bar. - Allowed Script Whitelists: Top-Level Domain (TLD) registries enforce strict script rules (e.g.,
.deregistries reject Cyrillic characters to prevent cross-language homoglyphs).
Practical Implementation Examples
Node.js (JavaScript) Production Encoding & Decoding
Node.js provides native URL parsing conforming to RFC 5891 / UTS #46 via the standard library:
const url = require('node:url');
function convertDomainToPunycode(domainName) {
try {
// Constructing a WHATWG URL automatically triggers UTS #46 ToASCII
const parsedUrl = new url.URL(`https://${domainName}`);
return {
original: domainName,
punycode: parsedUrl.hostname,
isIdn: parsedUrl.hostname.startsWith('xn--') || parsedUrl.hostname.includes('.xn--')
};
} catch (err) {
throw new Error(`Invalid hostname: ${err.message}`);
}
}
function decodePunycodeToUnicode(punycodeDomain) {
// URL parser translates ACE to Unicode when formatted for display
const parsed = new url.URL(`https://${punycodeDomain}`);
return {
punycode: punycodeDomain,
unicode: url.domainToUnicode(parsed.hostname)
};
}
// Verification
const encoded = convertDomainToPunycode('münchen.de');
console.log('ToASCII:', encoded);
// Output: { original: 'münchen.de', punycode: 'xn--mnchen-3ya.de', isIdn: true }
const decoded = decodePunycodeToUnicode('xn--pple-43d.com');
console.log('ToUnicode (Homoglyph detected):', decoded);
// Output: { punycode: 'xn--pple-43d.com', unicode: 'аpple.com' }
Python: Robust IDNA & RFC 3492 Translation
Python's built-in idna codec and external idna library implement standard IDNA2008:
import idna
def process_international_domain(domain_str: str) -> dict:
try:
# IDNA ToASCII encoding
encoded_bytes = idna.encode(domain_str, uts46=True)
punycode_str = encoded_bytes.decode('ascii')
# IDNA ToUnicode decoding
decoded_unicode = idna.decode(encoded_bytes)
return {
"input_domain": domain_str,
"punycode_ascii": punycode_str,
"roundtrip_verified": domain_str.lower() == decoded_unicode.lower()
}
except idna.IDNAError as exc:
return {"error": f"IDNA encoding failure: {str(exc)}"}
print(process_international_domain("café.com"))
# Output: {'input_domain': 'café.com', 'punycode_ascii': 'xn--caf-dma.com', 'roundtrip_verified': True}
print(process_international_domain("интернет.рф"))
# Output: {'input_domain': 'интернет.рф', 'punycode_ascii': 'xn--e1afmkfd.xn--p1ai', 'roundtrip_verified': True}
Critical Edge Cases & Common Implementation Traps
1. The DNS 63-Octet Label Length Limit
RFC 1035 §2.3.4 dictates that individual DNS domain labels must not exceed 63 octets (bytes). In complex Unicode scripts (such as Hindi or Thai), a short 20-character Unicode word may expand significantly during Bootstring encoding. If the resulting ACE string (xn--...) exceeds 63 characters, authoritative DNS servers reject the zone file, causing domain registration failure.
2. IDNA2003 vs. IDNA2008 Specification Conflict
In IDNA2003, the German sharp S (ß, Eszett) was normalized to lowercase ss. Under IDNA2008, ß is preserved as an independent character:
- Under IDNA2003:
faß.demapped tofass.de. - Under IDNA2008:
faß.demaps toxn--fa-hia.de.
This divergence caused legal disputes and website hijacking during the transitional period. Production systems must utilize Unicode Technical Standard #46 (UTS #46) compatibility processing to handle transitional mappings safely.
3. Bidirectional (Bidi) Text in Right-to-Left (RTL) Scripts
Domains containing Hebrew or Arabic text are subject to RFC 5893 Bidi rules. If a domain mistakenly mixes Left-to-Right digits with RTL letters without valid trailing character directionality, IDN encoders reject the string to prevent UI spoofing in browser address bars.