К основному содержанию
скилл CX Codex

analyzing-typosquatting-domains-with-dnstwist — скилл для Claude Code

Скилл analyzing-typosquatting-domains-with-dnstwist генерирует домены-двойники для вашего имени, проверяет их через DNS и оценивает риск по схожести страницы и свежести регистрации.

Apache-2.0 278 установок ★ 36 511 обновлён 2026-08-31

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill analyzing-typosquatting-domains-with-dnstwist -a claude-code
Открыть на GitHub

Что делает analyzing-typosquatting-domains-with-dnstwist

Скилл гоняет dnstwist по вашему домену и собирает похожие имена: замену символов на соседние клавиши, перестановку, вставку, пропуск букв, омоглифы вроде rn вместо m, битсквоттинг и словарные приставки. Дальше проверяет, что из этого реально зарегистрировано: записи A, AAAA, NS и MX. Домен с MX-записью умеет принимать почту, значит фишинг с него возможен.

Внутри — Python-обёртка над CLI: запускает dnstwist --registered --format json с --mxcheck, --ssdeep и --geoip, складывает найденное в JSON и считает риск. Баллы дают схожесть HTML по ssdeep выше 50, свежая регистрация (меньше 30 дней добавляют 30, до 90 добавляют 15) и тип перестановки: омоглифы идут с надбавкой 25, а addition, replacement и transposition дают 10.

Нужен Python 3.9+ и pip install dnstwist[full], плюс сетевой доступ для DNS-запросов. Без сети скилл не проверит ни одного имени. GeoIP-база и ключ Shodan — по желанию, для обогащения. На обычный корпоративный домен приходится от 5,000 до 10,000 перестановок, так что прогон долгий: в примере кода стоит таймаут 600 секунд.

Какие задачи решает

  • проверить, не занял ли кто-то домен-двойник вашего бренда
  • найти омоглиф-домен, который читается как ваш
  • отличить клон фишинговой страницы по схожести HTML
  • расставить найденные домены по уровню риска
  • собрать список имён под запрос на блокировку

Примеры запросов агенту

  • Прогони dnstwist по example.com, оставь только зарегистрированные домены и сохрани результат в JSON.
  • У каких из этих двойников есть MX-записи? Отсортируй их по риску.
  • Сравни HTML подозрительного домена с нашим сайтом через ssdeep и скажи, клон ли это.

Как установить analyzing-typosquatting-domains-with-dnstwist

1Через Skills CLI (Vercel)

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill analyzing-typosquatting-domains-with-dnstwist -a claude-code

2Вручную: положить файлы

~/.claude/skills/analyzing-typosquatting-domains-with-dnstwist/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/analyzing-typosquatting-domains-with-dnstwist/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы об analyzing-typosquatting-domains-with-dnstwist

Как установить скилл в Claude Code?

Выполните npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill analyzing-typosquatting-domains-with-dnstwist -a claude-code. Файл появится по пути ~/.claude/skills/analyzing-typosquatting-domains-with-dnstwist/SKILL.md.

Что делает analyzing-typosquatting-domains-with-dnstwist?

Строит перестановки вашего домена, проверяет DNS-записи у каждой и считает риск по схожести страницы, наличию MX и дате регистрации. На выходе — список зарегистрированных двойников с оценкой.

Что нужно для работы?

Python 3.9+ с пакетом dnstwist[full] и сетевой доступ для DNS-запросов. GeoIP-база и ключ Shodan добавляют обогащение, но не обязательны.

Исходный текст

SKILL.md · Apache-2.0
---
name: analyzing-typosquatting-domains-with-dnstwist
description: Generate domain permutations with dnstwist and check DNS resolution
  to detect typosquatting, homograph phishing, and brand impersonation domains registered
  against your organization. Use when asked to monitor for lookalike domains, investigate
  a phishing domain, or assess brand-impersonation risk.
domain: cybersecurity
subdomain: threat-intelligence
tags:
- dnstwist
- typosquatting
- phishing
- domain-monitoring
- brand-protection
- homograph
- dns
- threat-intelligence
version: '1.0'
author: mahipal
license: Apache-2.0
atlas_techniques:
- AML.T0073
- AML.T0052
nist_csf:
- ID.RA-01
- ID.RA-05
- DE.CM-01
- DE.AE-02
mitre_attack:
- T1583.001
- T1566.002
- T1598.003
- T1583.006
mitre_f3:
  version: '1.1'
  tactics:
  - resource-development
  - reconnaissance
  - initial-access
  techniques:
  - id: T1583.001
    name: 'Acquire Infrastructure: Domains'
    tactic: resource-development
    source: attack
  - id: F1020.002
    name: 'Create Fake Materials: Fake Website'
    tactic: resource-development
    source: f3
  - id: T1598
    name: Phishing for Information
    tactic: reconnaissance
    source: attack
  - id: T1593
    name: Search Open Websites/Domains
    tactic: reconnaissance
    source: attack
  - id: T1660
    name: Phishing
    tactic: initial-access
    source: attack
---
# Analyzing Typosquatting Domains with DNSTwist

## Overview

DNSTwist is a domain name permutation engine that generates similar-looking domain names to detect typosquatting, homograph phishing attacks, and brand impersonation. It creates thousands of domain permutations using techniques like character substitution, transposition, insertion, omission, and homoglyph replacement, then checks DNS records (A, AAAA, NS, MX), calculates web page similarity using fuzzy hashing (ssdeep) and perceptual hashing (pHash), and identifies potentially malicious registered domains.


## When to Use

- When investigating security incidents that require analyzing typosquatting domains with dnstwist
- When building detection rules or threat hunting queries for this domain
- When SOC analysts need structured procedures for this analysis type
- When validating security monitoring coverage for related attack techniques

## Prerequisites

- Python 3.9+ with `dnstwist` installed (`pip install dnstwist[full]`)
- Optional: GeoIP database for IP geolocation
- Optional: Shodan API key for enrichment
- Network access to perform DNS queries
- Understanding of DNS record types and domain registration

## Key Concepts

### Domain Permutation Techniques

DNSTwist generates permutations using: addition (appending characters), bitsquatting (bit-flip errors), homoglyph (visually similar Unicode characters like rn vs m), hyphenation (adding hyphens), insertion (inserting characters), omission (removing characters), repetition (repeating characters), replacement (replacing with adjacent keyboard keys), subdomain (inserting dots), transposition (swapping adjacent characters), vowel-swap (swapping vowels), and dictionary-based (appending common words).

### Fuzzy Hashing and Visual Similarity

DNSTwist uses ssdeep (locality-sensitive hash) to compare HTML content and pHash (perceptual hash) to compare screenshots of web pages. This helps identify cloned phishing sites that visually mimic the legitimate site. A high similarity score indicates a likely phishing page.

### Detection Workflow

The typical workflow is: generate domain permutations -> resolve DNS records -> check for registered domains -> compare web page similarity -> flag suspicious domains -> alert security team -> request takedown. For a typical corporate domain, dnstwist generates 5,000-10,000 permutations.

## Workflow

### Step 1: Basic Domain Permutation Scan

```python
import subprocess
import json
import csv
from datetime import datetime

def run_dnstwist_scan(domain, output_file=None):
    """Run dnstwist scan against a target domain."""
    cmd = [
        "dnstwist",
        "--registered",     # Only show registered domains
        "--format", "json", # Output in JSON
        "--nameservers", "8.8.8.8,1.1.1.1",
        "--threads", "50",
        "--mxcheck",        # Check MX records
        "--ssdeep",         # Fuzzy hash comparison
        "--geoip",          # GeoIP lookup
        domain,
    ]

    print(f"[*] Scanning permutations for: {domain}")
    result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)

    if result.returncode == 0:
        results = json.loads(result.stdout)
        registered = [r for r in results if r.get("dns_a") or r.get("dns_aaaa")]
        print(f"[+] Found {len(registered)} registered lookalike domains")

        if output_file:
            with open(output_file, "w") as f:
                json.dump(registered, f, indent=2)
            print(f"[+] Results saved to {output_file}")

        return registered
    else:
        print(f"[-] dnstwist error: {result.stderr}")
        return []

results = run_dnstwist_scan("example.com", "typosquat_results.json")
```

### Step 2: Analyze and Prioritize Results

```python
def analyze_results(results, legitimate_ips=None):
    """Analyze dnstwist results and prioritize threats."""
    legitimate_ips = legitimate_ips or set()
    high_risk = []
    medium_risk = []
    low_risk = []

    for entry in results:
        domain = entry.get("domain", "")
        fuzzer = entry.get("fuzzer", "")
        dns_a = entry.get("dns_a", [])
        dns_mx = entry.get("dns_mx", [])
        ssdeep_score = entry.get("ssdeep_score", 0)

        risk_score = 0
        risk_factors = []

        # High similarity to legitimate site
        if ssdeep_score and ssdeep_score > 50:
            risk_score += 40
            risk_factors.append(f"high web similarity ({ssdeep_score}%)")

        # Has MX records (can receive email / phishing)
        if dns_mx:
            risk_score += 20
            risk_factors.append("has MX records (email capable)")

        # Recently registered (if whois data available)
        whois_created = entry.get("whois_created", "")
        if whois_created:
            try:
                created = datetime.fromisoformat(whois_created.replace("Z", "+00:00"))
                age_days = (datetime.now(created.tzinfo) - created).days
                if age_days < 30:
                    risk_score += 30
                    risk_factors.append(f"recently registered ({age_days} days)")
                elif age_days < 90:
                    risk_score += 15
                    risk_factors.append(f"registered {age_days} days ago")
            except (ValueError, TypeError):
                pass

        # Homoglyph attacks are highest risk
        if fuzzer == "homoglyph":
            risk_score += 25
            risk_factors.append("homoglyph (visually identical)")
        elif fuzzer in ("addition", "replacement", "transposition"):
            risk_score += 10
            risk_factors.append(f"permutation type: {fuzzer}")

        # Not pointing to legitimate infrastructure
        if dns_a and not set(dns_a).intersection(legitimate_ips):
            risk_score += 10
            risk_factors.append("different IP from legitimate")

        entry["risk_score"] = risk_score
        entry["risk_factors"] = risk_factors

        if risk_score >= 50:
            high_risk.append(entry)
        elif risk_score >= 25:
            medium_risk.append(entry)
        else:
            low_risk.append(entry)

    high_risk.sort(key=lambda x: x["risk_score"], reverse=True)
    medium_risk.sort(key=lambda x: x["risk_score"], reverse=True)

    print(f"\n=== Typosquatting Analysis ===")
    print(f"High Risk: {len(high_risk)}")
    print(f"Medium Risk: {len(medium_risk)}")
    print(f"Low Risk: {len(low_risk)}")

    if high_risk:
        print(f"\n--- High Risk Domains ---")
        for entry in high_risk[:10]:
            print(f"  {entry['domain']} (score: {entry['risk_score']})")
            for factor in entry['risk_factors']:
                print(f"    - {factor}")

    return {"high": high_risk, "medium": medium_risk, "low": low_risk}

analysis = analyze_results(results, legitimate_ips={"93.184.216.34"})
```

### Step 3: Continuous Monitoring Pipeline

```python
import time
import hashlib

class TyposquatMonitor:
    def __init__(self, domains, known_domains_file="known_typosquats.json"):
        self.domains = domains
        self.known_file = known_domains_file
        self.known_domains = self._load_known()

    def _load_known(self):
        try:
            with open(self.known_file, "r") as f:
                return json.load(f)
        except FileNotFoundError:
            return {}

    def _save_known(self):
        with open(self.known_file, "w") as f:
            json.dump(self.known_domains, f, indent=2)

    def scan_all_domains(self):
        """Scan all monitored domains for new typosquats."""
        new_findings = []
        for domain in self.domains:
            results = run_dnstwist_scan(domain)
            for entry in results:
                domain_key = entry.get("domain", "")
                if domain_key not in self.known_domains:
                    entry["first_seen"] = datetime.now().isoformat()
                    entry["monitored_domain"] = domain
                    self.known_domains[domain_key] = entry
                    new_findings.append(entry)
                    print(f"  [NEW] {domain_key} ({entry.get('fuzzer', '')})")

        self._save_known()
        print(f"\n[+] New typosquatting domains found: {len(new_findings)}")
        return new_findings

    def generate_alert(self, findings):
        """Generate alert for new high-risk typosquatting domains."""
        analysis = analyze_results(findings)
        alerts = []
        for entry in analysis["high"]:
            alerts.append({
                "severity": "HIGH",
                "domain": entry["domain"],
                "target": entry.get("monitored_domain", ""),
                "risk_score": entry["risk_score"],
                "risk_factors": entry["risk_factors"],
                "dns_a": entry.get("dns_a", []),
                "dns_mx": entry.get("dns_mx", []),
                "timestamp": datetime.now().isoformat(),
            })
        return alerts

monitor = TyposquatMonitor(["mycompany.com", "mycompany.org"])
new_findings = monitor.scan_all_domains()
alerts = monitor.generate_alert(new_findings)
```

### Step 4: Export for Blocklist and Takedown

```python
def export_blocklist(analysis, output_file="blocklist.txt"):
    """Export high-risk domains as blocklist for firewall/proxy."""
    domains = []
    for entry in analysis["high"] + analysis["medium"]:
        domain = entry.get("domain", "")
        if domain:
            domains.append(domain)

    with open(output_file, "w") as f:
        f.write(f"# Typosquatting blocklist generated {datetime.now().isoformat()}\n")
        for d in sorted(set(domains)):
            f.write(f"{d}\n")

    print(f"[+] Blocklist saved: {len(domains)} domains -> {output_file}")
    return domains

def generate_takedown_report(high_risk_domains):
    """Generate takedown request report."""
    report = f"""# Domain Takedown Request
Generated: {datetime.now().isoformat()}

## Summary
{len(high_risk_domains)} domains identified as potential typosquatting/phishing.

## Domains Requiring Takedown
"""
    for entry in high_risk_domains:
        report += f"""
### {entry['domain']}
- **Permutation Type**: {entry.get('fuzzer', 'unknown')}
- **IP Address**: {', '.join(entry.get('dns_a', ['N/A']))}
- **MX Records**: {', '.join(entry.get('dns_mx', ['N/A']))}
- **Risk Score**: {entry.get('risk_score', 0)}
- **Risk Factors**: {'; '.join(entry.get('risk_factors', []))}
- **Web Similarity**: {entry.get('ssdeep_score', 'N/A')}%
"""
    with open("takedown_report.md", "w") as f:
        f.write(report)
    print("[+] Takedown report generated: takedown_report.md")

export_blocklist(analysis)
generate_takedown_report(analysis["high"])
```

## Validation Criteria

- DNSTwist generates domain permutations for target domain
- DNS resolution identifies registered lookalike domains
- Web similarity scoring detects cloned phishing pages
- Risk scoring prioritizes domains by threat level
- Continuous monitoring detects newly registered typosquats
- Blocklist and takedown reports generated correctly

## References

- [dnstwist GitHub Repository](https://github.com/elceef/dnstwist)
- [dnstwister Online Service](https://dnstwister.report/)
- [HawkEye: Detect Typosquatting with DNSTwist](https://hawk-eye.io/2022/11/how-to-detect-typosquatting-using-dnstwist/)
- [Darktrace: Monitoring Typosquatting Domains](https://www.darktrace.com/blog/vigilance-in-action-monitoring-typosquatting-domains)
- [Security Risk Advisors: Domain Monitoring](https://sra.io/blog/domain-monitoring-fast-and-cheap/)
- [Conscia: How to Detect Typosquatting](https://conscia.com/blog/diving-deep-how-to-detect-typosquatting/)

© mahipal · Apache-2.0 · mukul975/Anthropic-Cybersecurity-Skills

Похожие скиллы

Все скиллы по теме «Безопасность» →
dnstwist w0h1v Подключает dnstwist к агенту: тот перебирает похожие на ваш домены и проверяет, какие из них уже зарегистрированы. CX Codex +1 ★ 51звёзд репо brand-protection kostja94 Скилл brand-protection для борьбы с поддельными сайтами, фишингом и кражей бренда. Помогает собрать доказательства, подать жалобы и закрыть мошеннические ресурсы. CX Codex +1 1 100установок phishing-operator 0xSteph Субагент phishing-operator помогает разбирать инфраструктуру фишинговых симуляций, домены-двойники и кампании GoPhish в рамках авторизованных red team работ. CX Codex ★ 2 482звёзд репо skill-auditor UseAI-pro Скилл skill-auditor проверяет безопасность скилла OpenClaw до установки: тайпсквоттинг, опасные разрешения, промпт-инъекции, цепочки поставок и утечки данных. CX Codex +1 699установок supply-chain-auditor 0xSteph Субагент supply-chain-auditor для Claude Code проверяет риски в цепи поставок: ищет dependency confusion и typosquatting, анализирует скрипты установки, проверяет целостность lockfile и провенанс артефактов. CX Codex ★ 2 482звёзд репо DomainKits ABTdomain MCP-сервер DomainKits для поиска свободных или просроченных доменов, проверки записей DNS и данных WHOIS прямо в интерфейсе ассистента. CX Codex +1 ★ 7звёзд репо

Из того же набора152

Весь набор →
implementing-api-schema-validation-security Скилл implementing-api-schema-validation-security настраивает проверку контрактов API через OpenAPI и JSON Schema на шлюзе и в коде. Защищает от инъекций, массового присвоения и утечек данных. CX Codex +1 280установок detecting-ai-model-prompt-injection-attacks Скилл detecting-ai-model-prompt-injection-attacks выявляет попытки инъекции в запросы к ИИ-моделям через регулярные выражения, анализ структуры и трансформатор DeBERTa. CX Codex +1 280установок analyzing-tls-certificate-transparency-logs Скилл analyzing-tls-certificate-transparency-logs ищет фишинговые домены и теневые TLS-сертификаты через логи Certificate Transparency и crt.sh. Помогает SOC выявлять тайпосквоттинг по расстоянию Левенштейна. CX Codex +1 280установок auditing-terraform-infrastructure-for-security Скилл auditing-terraform-infrastructure-for-security настраивает аудит Terraform-кода через Checkov, tfsec, Terrascan и OPA. Он помогает закрыть открытые порты, избыточные права IAM и отсутствие шифрования до деплоя в облако. CX Codex +1 279установок analyzing-security-logs-with-splunk Скилл analyzing-security-logs-with-splunk помогает расследовать инциденты безопасности в Splunk через SPL. Связывает логи Windows, Sysmon, прокси и сетевых экранов в единый таймлайн. CX Codex +1 278установок performing-ssrf-vulnerability-exploitation Скилл performing-ssrf-vulnerability-exploitation для Claude Code проверяет URL-параметры веб-приложений на SSRF, зондируя облачные метаданные, внутренние сервисы и обработчики протоколов. Используется для авторизованного пентеста. CX Codex +1 277установок testing-mobile-api-authentication Скилл testing-mobile-api-authentication для Claude Code проверяет аутентификацию и авторизацию мобильных API: JWT, OAuth, токены, сессии и IDOR. Помогает проводить разрешённые API-аудиты. CX Codex +1 276установок analyzing-threat-actor-ttps-with-mitre-navigator Скилл analyzing-threat-actor-ttps-with-mitre-navigator для картирования техник угроз (TTP) группы APT к фреймворку MITRE ATT&CK с помощью библиотеки attackcti и создания визуализаций в ATT&CK Navigator. CX Codex +1 275установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой