Lookalike-Domain-Erkennung: Algorithmen und Methoden erklärt

Technischer Leitfaden zur Erkennung ähnlicher Domains: Damerau-Levenshtein, Homoglyphen und strukturelle Muster mit Python-Codebeispielen.

Eine Lookalike-Domain ist ein Domainname, der so gestaltet ist, dass er einer legitimen Domain visuell oder phonetisch ähnelt. Die systematische Erkennung solcher Domains basiert auf drei Methodenfamilien: Edit-Distanz-Algorithmen, Homoglyphen-Substitution und strukturelle Musteranalyse. Für eine Domain wie "acme.com" kann ein vollständiger Scan mehrere hundert Kandidatenvarianten erzeugen, bevor gefiltert wird. Dieser Artikel erklärt jede Methode mit konkreten Beispielen und Code und zeigt, wie Domain Sentinel sie zu einer kontinuierlichen Monitoring-Pipeline kombiniert.

Edit-Distanz: Levenshtein und Damerau-Levenshtein

Die Levenshtein-Distanz zwischen zwei Zeichenketten ist die Mindestanzahl von Einzelzeichen-Einfügungen, -Löschungen und -Ersetzungen, die nötig sind, um eine in die andere umzuwandeln. Die Damerau-Levenshtein-Variante ergänzt Transpositionen benachbarter Zeichen, die häufigsten realen Tippfehler.

Konkrete Beispiele für die Zeichenkette "acme":

"acme" vs "acmee": Distanz 1 (Einfügung eines Zeichens)
"acme" vs "acne": Distanz 1 (Ersetzung von "m" durch "n")
"acme" vs "amce": Damerau-Distanz 1 (Transposition), Levenshtein-Distanz 2

Für die Markenüberwachung wird typischerweise ein Distanzschwellenwert von 1 oder 2 verwendet, abhängig von der Namenslänge. Kurze Namen (4-5 Zeichen) brauchen einen Schwellenwert von 1, um falsche Treffer zu vermeiden; längere Namen können 2 tolerieren.

Python-Implementierung

def damerau_levenshtein(s1, s2):
    d = {}
    len1, len2 = len(s1), len(s2)
    for i in range(-1, len1 + 1):
        d[(i, -1)] = i + 1
    for j in range(-1, len2 + 1):
        d[(-1, j)] = j + 1
    for i in range(len1):
        for j in range(len2):
            cost = 0 if s1[i] == s2[j] else 1
            d[(i, j)] = min(
                d[(i - 1, j)] + 1,
                d[(i, j - 1)] + 1,
                d[(i - 1, j - 1)] + cost
            )
            if i > 0 and j > 0 and s1[i] == s2[j-1] and s1[i-1] == s2[j]:
                d[(i, j)] = min(d[(i, j)], d[(i-2, j-2)] + cost)
    return d[(len1 - 1, len2 - 1)]

def generate_varianten_distanz_1(name):
    alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789-'
    varianten = set()
    for i in range(len(name)):
        varianten.add(name[:i] + name[i+1:])
        for c in alphabet:
            varianten.add(name[:i] + c + name[i+1:])
            varianten.add(name[:i] + c + name[i:])
        if i < len(name) - 1:
            varianten.add(name[:i] + name[i+1] + name[i] + name[i+2:])
    return varianten - {name}

Generierung von Varianten mit Distanz 1

Die vier Modifikationskategorien und das Volumen, das sie für einen Namen der Länge n erzeugen:

Löschungen: n Varianten
Ersetzungen: n × 36 Varianten (26 Buchstaben + 10 Ziffern + Bindestrich)
Einfügungen: (n+1) × 36 Varianten
Transpositionen: (n-1) Varianten

Für einen 5-buchstabigen Namen produziert das rund 380-420 Rohvarianten, bevor DNS-ungültige Zeichenketten herausgefiltert und Duplikate entfernt werden.

Homoglyphen: der Unicode-Zeichensubstitutionsangriff

Ein Homoglyphe ist ein Unicode-Zeichen, das einem anderen visuell identisch aussieht. Homoglyph-Angriffe nutzen internationalisierte Domainnamen (IDNs), die Nicht-ASCII-Zeichen in Punycode-Kodierung erlauben. Das kyrillische "а" (U+0430) ist in nahezu allen Schriftarten vom lateinischen "a" (U+0061) nicht zu unterscheiden. Ein Angreifer kann "аpple.com" mit kyrillischem "а" registrieren und diese Domain erscheint in vielen Kontexten als "apple.com".

Häufig ausgenutzte Homoglyphen-Paare:

Original	Häufige Substitute
a	а (U+0430 Kyrillisch), ɑ (U+0251), α (U+03B1 Griechisch)
o	о (U+043E Kyrillisch), 0 (Null), ο (U+03BF Griechisch)
e	е (U+0435 Kyrillisch), ё (U+0451)
c	с (U+0441 Kyrillisch)
p	р (U+0440 Kyrillisch)
l	1 (Eins), I (großes i),
n	п (U+043F Kyrillisch)
i	í (U+00ED), ï (U+00EF), 1 (Eins)

Programmatische Homoglyphen-Erkennung

Das Unicode-Konsortium pflegt ein öffentliches "Confusables"-Dataset, das Zeichen ihren visuellen Äquivalenten zuordnet. Ein praktischer Python-Ansatz:

HOMOGLYPHEN = {
    'a': ['а', 'ɑ', 'α'],
    'o': ['о', '0', 'ο'],
    'e': ['е', 'ё'],
    'c': ['с'],
    'l': ['1', 'I'],
    'p': ['р'],
}

def generate_homoglyph_varianten(domain):
    name, tld = domain.rsplit('.', 1)
    varianten = set()

    def rekursion(index, aktuell):
        if index == len(name):
            if aktuell != name:
                varianten.add(f"{aktuell}.{tld}")
            return
        char = name[index]
        rekursion(index + 1, aktuell + char)
        for substitut in HOMOGLYPHEN.get(char, []):
            rekursion(index + 1, aktuell + substitut)

    rekursion(0, '')
    return varianten

Achtung vor kombinatorischer Explosion: Ein 6-Buchstaben-Name, bei dem jeder Buchstabe 3 mögliche Homoglyphen hat, erzeugt allein durch Homoglyphen bis zu 3^6 = 729 Varianten. In der Praxis begrenzt man die maximale Substitutionstiefe (typischerweise 2 Substitutionen pro Domain), um die Menge handhabbar zu halten.

Wie moderne Browser mit IDNs umgehen

Chrome und Firefox zeigen die Punycode-Darstellung (beginnend mit xn--) statt des Unicode-Domainnamens an, wenn eine Domain verschiedene Schriften mischt (z.B. Latein und Kyrillisch im selben Label). "аpple.com" mit kyrillischem "а" erscheint in der Browser-Adressleiste als xn--pple-43d.com. Rein kyrillische Domains hingegen können noch als Unicode angezeigt werden, weshalb die Homoglyphen-Erkennung relevant bleibt. Das Punycode für аcme.com (kyrillisches а) lautet xn--cme-9cd.com.

Strukturanalyse: TLD-Varianten und Präfix/Suffix-Muster

Die dritte Methodenfamilie manipuliert nicht einzelne Zeichen, sondern die Struktur der Domain selbst.

TLD-Tausch

Das Ersetzen der TLD ist die einfachste Variante und oft die kommerziell relevanteste. Für "acme.com" ergibt das acme.net, acme.io, acme.co, acme.app, acme.shop. TLDs, die am häufigsten für Missbrauch genutzt werden:

.co (sehr verbreitet: optisch nah an .com und legitimer ccTLD)
.net (etabliert, weit bekannt)
.io (Tech-Branchenstandard, wachsende Verwechslung mit .com)
.app (Mobile und SaaS)
.shop, .store (E-Commerce)
.xyz, .top, .tk, .ml, .ga (oft kostenlos; überproportional für Phishing genutzt)

Häufige Präfix- und Suffix-Muster

Diese Muster sind oft gefährlicher als reine Tippfehler, weil sie selbst erfahrene Nutzer täuschen können:

get{marke}.com        try{marke}.com        mein{marke}.com
{marke}app.com        {marke}hq.com         {marke}online.com
{marke}-login.com     {marke}-sicher.com    {marke}-konto.com
{marke}offiziell.com  {marke}support.com    {marke}-hilfe.com
{marke}pro.com        {marke}plus.com       {marke}portal.com
sign{marke}.com       {marke}-verifizierung.com

Wörter wie "login", "sicher", "konto" und "verifizierung" in einem Domainnamen sind Warnsignale, keine Vertrauenssignale. Legitime Dienste müssen diese Begriffe selten in ihrem primären Domainnamen unterbringen.

Trennzeichen und zusammengesetzte Varianten

Wenn Ihr Markenname aus mehreren Wörtern besteht ("Domain Sentinel"), überwachen Sie: domainsentinel.com, domain-sentinel.com, sentineldomain.com, sentinel-domain.com. Wenn Ihr Markenname einen Bindestrich enthält, überwachen Sie auch die Version ohne Bindestrich und umgekehrt.

Methoden kombinieren: die vollständige Erkennungspipeline

Domain Sentinel kombiniert alle drei Methodenfamilien in einer sequenziellen Pipeline:

Kandidaten generieren mit Damerau-Levenshtein-Varianten (Distanz 1-2), Homoglyphen-Substitutionen (bis zu 2 Substitutionen), TLD-Tauschen über eine kuratierte TLD-Liste und strukturellen Mustervarianten (Präfixe/Suffixe).
Deduplizieren und filtern, um DNS-ungültige Zeichenketten zu entfernen und den Kandidatensatz zu reduzieren.
Batch-RDAP-Verifizierung für jeden Kandidaten: registriert, verfügbar oder ausstehend/reserviert.
Ergebnisse klassifizieren: Neuregistrierungen lösen Alarme aus; verfügbare Domains können für eine mögliche Präventivregistrierung markiert werden.
Alarme priorisieren nach Risiko: Domains mit mehreren Ähnlichkeitssignalen (Tippfehler + verdächtiges Schlüsselwort + kürzlich registriert) werden höher eingestuft als einfache TLD-Tausche mit langer Registrierungsgeschichte.

Das "Rauschen"-Problem ist real: Erschöpfende Generierung kann Tausende von Kandidaten erzeugen. Die Priorisierung nach Edit-Distanz, TLD-Risikoniveau und Vorhandensein von Hochrisiko-Schlüsselwörtern (login, sicher, offiziell, verifizierung, support) hält die Alarmwarteschlange handhabbar.

Open-Source-Tools und APIs

Für Teams, die ihre eigene Pipeline aufbauen oder Ergebnisse validieren möchten:

dnstwist (Python, Open Source) ist das Referenz-Tool zur Generierung von Lookalike-Domain-Varianten. Es implementiert die meisten hier beschriebenen Methoden und enthält RDAP/WHOIS-Lookups.
urlcrazy ist ähnlich, mit Fokus auf Typosquatting-Variantengenerierung.
Der RDAP-Dienst der ICANN unter rdap.org verarbeitet individuelle RDAP-Lookups kostenlos und ohne Authentifizierung.
Domain Sentinel automatisiert die gesamte Pipeline kontinuierlich, sendet Alarme bei neuen Registrierungen und handhabt die Komplexität der RDAP-Abfragen und Rate-Limits.

Die wesentliche Einschränkung von Open-Source-Tools: Sie generieren Varianten, überwachen aber nicht kontinuierlich. dnstwist einmal auszuführen zeigt Ihnen, was heute registriert ist. Sie müssen es morgen und übermorgen erneut ausführen und darüber ein eigenes Benachrichtigungssystem aufbauen. Diese Lücke füllt Domain Sentinel.

In der Praxis liefern TLD-Tausche und strukturelle Muster das schnellste Signal mit dem geringsten Rauschen. Ergänzen Sie Damerau-Levenshtein-Varianten für umfassende Tippfehlerabdeckung, dann fügen Sie Homoglyphen-Erkennung für vollständige Abdeckung hinzu. Der vollständige Scan für einen 6-buchstabigen Markennamen über 20 TLDs und 30 Präfix/Suffix-Muster produziert rund 2.000-3.000 Kandidaten-Domains, die per RDAP geprüft werden sollten. Analysieren Sie Ihre Domain in Domain Sentinel, um zu sehen, welche davon bereits registriert sind.