.de-Domainliste

Domainagentur schrieb:
Mit Adressen wäre interessant, aber so leider nutzlos.

Abfragen usw… gibts ja bereits die bekannten Systeme/Tools.
Zum Vergrößern anklicken....
Das ist alles andere als nutzlos wenn man dafür einen usecase hat. Es gibt keine Zonefiles von .de und die Dienste, die Martin ansprach, sind nicht vollständig. Ich will nicht mutmaßen wo diese Liste herkommt. Ich hätte die zu gerne, aber werde dafür nicht someK ausgeben.
 
kann dir ne list mit 1000 .com domains verkaufen. Mit Garantie das 95% noch registriet sind. Gibt da in Excel so ein super feature das einfach hochzählt. Und da angeblich alle 1-3 zeicher besetzt sind sollte das passen🤯
 
Liebeg schrieb:
kann dir ne list mit 1000 .com domains verkaufen. Mit Garantie das 95% noch registriet sind. Gibt da in Excel so ein super feature das einfach hochzählt. Und da angeblich alle 1-3 zeicher besetzt sind sollte das passen🤯
Zum Vergrößern anklicken....
1000 .com Domains? Die 2 Zeichen Kombinationen alleine sind doch schon knapp 700 Kombinationen.
 
Pearly schrieb:
Biete eine .de-Domainliste mit 17,53 Mio aktuell registrierten Domains an.
Zum Vergrößern anklicken....

Ich steh' hier voll auf'm Schlauch.... hilft mir jemand?

Ich meine, wären Inhaber- und Kontaktdaten dabei, wäre die Liste auch den doppelten Betrag wert.

Aber so sehe ich überhaupt keine Möglichkeit, mit der Liste auch nur 1€ zu verdienen...

oder fehlt mir hier einfach was?

Sehe ich was nicht?

---

@OP: Ich rate mal: Du bist an irgendeiner Forschungs-Uni? KIT KA oder IW Köln oder sowas. Die kriegen schon mal Zugriff auf die Zonendaten für Ihre Studien.

---

Ich finde, "Forschen" sollte nicht den Universitäten vorbehalten sein.

Wir sind alle als Forscher geboren. Als Kinder sind wir so neugierig, dass wir "nerven".
Wir wollen alles wissen, alles verstehen (Jaja.. Kinder heute sind anders).

Irgendwann auf dem Weg scheinen wir das alle, mehr oder weniger, zu verlieren.

Vermutlich auch deshalb, weil wir eine Schulzeit lang mit Müll bombardiert werden, an dem wir nicht das geringste Interesse haben, erscheint uns unser "Forschen", was im Grunde immer eine Art "Suche nach einer Wahrheit" ist, immer aussichtsloser und unsere Neugier verkümmert langsam, wie ein Muskel, den wir nicht benutzen.

Neugier, Kreativität, Imagination, Muskelkraft, Liebe, das alles sind einige von vielen Dingen, von denen wir paradoxerweise MEHR haben, je MEHR wir davon geben - und die wir verlieren, wenn wir sie nicht nutzen. Wir nutzen diese Fähigkeiten nicht, weil uns die Möglichkeiten dazu immer weniger gegeben werden, weil uns Daten, Fakten und Wahrheiten vorenthalten werden.

Wir haben uns daran gewöhnt, dass wir nur BS finden, wenn wir nach der Wahrheit suchen, deswegen suchen wir erst gar nicht mehr.

Für Jeden, der an der Wahrheit interessiert ist - und neugierig und mutig genug ist, nachzuforschen, sollten die notwendigen Informationen, die er dafür braucht, frei und möglichst leicht zugänglich sein.

Deshalb, für die Researcher unter euch, hier mal ein Bruteforce-Script für Whois-Abfragen. Hat genau 10 Minuten gedauert, es zu schreiben (Props an Claude und ChatGPT).

Ich habe es allerdings nicht getestet und rate ausdrücklich davon ab, es zu benutzen, wenn man nicht zu 100% weiß, was man da macht.



Domain Checker: Automatische Überprüfung und Analyse von Domains​


Funktionen:

- Domainüberprüfung: Prüft automatisch den Registrierungsstatus und das Ablaufdatum von Domains.
- Flexible Domainerzeugung: Generiert Domains mit einstellbarer Länge und Top-Level-Domain (TLD).
- Asynchrone Verarbeitung: Nutzt moderne asynchrone Technologien für hohe Effizienz.
- Fortschrittsanzeige: Zeigt den aktuellen Stand der Überprüfung in Echtzeit an.
- CSV-Export: Speichert die Ergebnisse übersichtlich in CSV-Dateien.

Technische Highlights:

- Geschrieben in Python 3.7+
- Verwendet `asyncio` und `aiohttp` für parallele Verarbeitung
- Robuste Fehlerbehandlung und detailliertes Logging
- Konfigurierbar über Kommandozeilenargumente

Anwendungsmöglichkeiten:

- Marktanalyse für verfügbare Domainnamen
- Überwachung von Domainablaufdaten
- Recherche für Domainportfolios

Hinweis:

Dieses Skript ist für Bildungs- und Forschungszwecke gedacht. Bitte beachte die Nutzungsbedingungen von Domainregistraren und verwenden es verantwortungsvoll.



Python: 
Domain Checker Script
Version: 1.0
Author: Christopher Hüneke
Date: 13.08.2024

Description:
This script checks the registration status and expiration date of domains
with a specified length and top-level domain (TLD). It uses asynchronous
processing for improved performance and saves the results to CSV files.

Usage:
python domain_checker.py [options]

Options:
  --length INT         Length of the domain name (default: 2)
  --tld STRING         Top-level domain (default: 'de')
  --max-records INT    Maximum number of entries per CSV file (default: 99999)
  --output-dir PATH    Directory for output files (default: 'output')
  --max-concurrent INT Maximum number of concurrent requests (default: 10)

Requirements:
- Python 3.7+
- whois
- aiohttp
- tqdm

Disclaimer:
This script is for educational and research purposes only. Use responsibly and in accordance
with all applicable laws and terms of service of domain registrars. USE AT YOUR OWN RISK.


# Script
import whois
import itertools
import time
import csv
import logging
import asyncio
import aiohttp
from typing import Optional, Tuple, List
from tqdm import tqdm
import argparse
from pathlib import Path

# Konfiguration des Loggings
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

async def check_domain(domain: str, session: aiohttp.ClientSession) -> Optional[Tuple[str, str]]:
    """
    Überprüft eine Domain asynchron auf ihren Registrierungsstatus und Ablaufdatum.
 
    :param domain: Die zu überprüfende Domain
    :param session: Eine aiohttp ClientSession für HTTP-Anfragen
    :return: Ein Tupel mit Domain und Ablaufdatum oder None bei Fehlern
    """
    try:
        # Verwendung von python-whois für robustere WHOIS-Abfragen
        w = whois.whois(domain)
        if w.domain_name:
            expiration_date = w.expiration_date
            if isinstance(expiration_date, list):
                expiration_date = expiration_date[0]
            logger.info(f"Domain registriert: {domain}, Ablaufdatum: {expiration_date}")
            return domain, str(expiration_date)
        else:
            return None
    except (whois.parser.PywhoisError, Exception) as e:
        logger.error(f"Fehler bei der Abfrage von {domain}: {e}")
        return None

def generate_domains(length: int, tld: str) -> str:
    """
    Generiert Domains mit der angegebenen Länge und TLD.
 
    :param length: Länge des Domainnamens (ohne TLD)
    :param tld: Top-Level-Domain (z.B. 'de')
    :yield: Generierte Domainnamen
    """
    characters = 'abcdefghijklmnopqrstuvwxyz'
    for combo in itertools.product(characters, repeat=length):
        yield ''.join(combo) + f'.{tld}'

async def save_to_csv(data: List[Tuple[str, str]], file_index: int, output_dir: Path):
    """
    Speichert die gefundenen Domains und ihre Ablaufdaten in einer CSV-Datei.
 
    :param data: Liste von Tupeln (Domain, Ablaufdatum)
    :param file_index: Index für den Dateinamen
    :param output_dir: Verzeichnis zum Speichern der CSV-Dateien
    """
    filename = output_dir / f'domains{file_index:07d}.csv'
    with open(filename, mode='w', newline='', encoding='utf-8') as file:
        writer = csv.writer(file)
        writer.writerow(['Domain', 'Ablaufdatum'])
        writer.writerows(data)
    logger.info(f"Datei {filename} gespeichert mit {len(data)} Einträgen.")

async def main(length: int, tld: str, max_records: int, output_dir: Path, max_concurrent: int):
    """
    Hauptfunktion zum Überprüfen von Domains und Speichern der Ergebnisse.
 
    :param length: Länge des Domainnamens (ohne TLD)
    :param tld: Top-Level-Domain (z.B. 'de')
    :param max_records: Maximale Anzahl von Einträgen pro CSV-Datei
    :param output_dir: Verzeichnis zum Speichern der CSV-Dateien
    :param max_concurrent: Maximale Anzahl gleichzeitiger Anfragen
    """
    output_dir.mkdir(parents=True, exist_ok=True)
    found_domains = []
    file_index = 1
    semaphore = asyncio.Semaphore(max_concurrent)

    async with aiohttp.ClientSession() as session:
        tasks = []
        for domain in tqdm(generate_domains(length, tld)):
            async with semaphore:
                task = asyncio.create_task(check_domain(domain, session))
                tasks.append(task)

            if len(tasks) >= max_records:
                for completed_task in asyncio.as_completed(tasks):
                    result = await completed_task
                    if result:
                        found_domains.append(result)

                await save_to_csv(found_domains, file_index, output_dir)
                found_domains = []
                file_index += 1
                tasks = []

        # Verarbeitung der restlichen Tasks
        for completed_task in asyncio.as_completed(tasks):
            result = await completed_task
            if result:
                found_domains.append(result)

        # Speichern der restlichen Domains
        if found_domains:
            await save_to_csv(found_domains, file_index, output_dir)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Domain-Checker")
    parser.add_argument("--length", type=int, default=2, help="Länge des Domainnamens")
    parser.add_argument("--tld", type=str, default="de", help="Top-Level-Domain")
    parser.add_argument("--max-records", type=int, default=99999, help="Maximale Anzahl von Einträgen pro CSV-Datei")
    parser.add_argument("--output-dir", type=Path, default=Path("output"), help="Verzeichnis für die Ausgabedateien")
    parser.add_argument("--max-concurrent", type=int, default=10, help="Maximale Anzahl gleichzeitiger Anfragen")
    args = parser.parse_args()

    asyncio.run(main(args.length, args.tld, args.max_records, args.output_dir, args.max_concurrent))


Code: 
pip install aiohttp tqdm

Code: 
python script.py --length 3 --tld com --max-records 50000 --output-dir ./domain_results --max-concurrent 20
 
Das wird nicht funktionieren.
Forsche mal in Richtung Ratelimiting.

Und hacke mal 37pow10 in deinen Taschenrechner, das ist die Anzahl der möglichen Domainnamen für 10 Stellen.

Bruteforce macht wirklich nur sehr sehr bedingt Sinn.
 
dododude schrieb:
Das wird nicht funktionieren.
Forsche mal in Richtung Ratelimiting.

Und hacke mal 37pow10 in deinen Taschenrechner, das ist die Anzahl der möglichen Domainnamen für 10 Stellen.

Bruteforce macht wirklich nur sehr sehr bedingt Sinn.
Zum Vergrößern anklicken....

Und? Kannst du auch konkret sagen, warum das nicht funktionieren sollte?

Ratelimiting gibt dir ein timeout nach 1000 Abfragen, wenn du zu schnell abfragst. musst halt den korrekten delay reinhauen und notfalls nach 999 URLs die Proxy wechseln.

Wo genau ist das Problem?

Deine Liste macht in 6 Monaten keinen Sinn mehr, weil die Daten der letzten 6 Monate fehlen.

Das Script kann in 6 Monaten immernoch Whois Abfragen automatisieren.
 
chueneke schrieb:
Ratelimiting gibt dir ein timeout nach 1000 Abfragen, wenn du zu schnell abfragst. musst halt den korrekten delay reinhauen und notfalls nach 999 URLs die Proxy wechseln.
Zum Vergrößern anklicken....

Du kannst ja mal mehr als 4 Abfragen pro Sekunde gegen den .de whois fahren. Oder gegen .ch

chueneke schrieb:
Deine Liste macht in 6 Monaten keinen Sinn mehr, weil die Daten der letzten 6 Monate fehlen.
Zum Vergrößern anklicken....
Das ist nicht meine Liste.

Ich bin hier soweit fertig.
Bitte arbeiten Sie an Ihrem Ego.
 
Du musst dich einloggen oder registrieren, um hier zu antworten.

Zurzeit aktive Besucher

Gesamt: 50 (Mitglieder: 3, Gäste: 47)

Neueste Beiträge

Domain Forum Friends

Wir empfehlen weltweit diese befreundeten Domain Foren:

Neueste Themen

Statistik des Forums

Themen
5.273
Beiträge
44.650
Mitglieder
916
Neuestes Mitglied
JosephyOrAbs

Sharing is Caring

Oben