OSINT Open Source Intelligence

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Einleitung

OSINT ist allgegenwärtig. Jeder öffentlich geteilte Beitrag in einem sozialen Netzwerk, jede Registrierung einer Domain, jede alte Version einer Webseite und jede Antwort eines Servers auf einer offenen IP-Adresse kann zur Informationssammlung genutzt werden. Das ist kein Geheimdienst-Abenteür, sondern eine Standard-Disziplin in der Cybersecurity, bei der Wirtschaftsaufklärung und in der digitalen Forensik.

Warum ist das Thema wichtig? Weil Angriffe nicht immer mit komplexen Exploits beginnen. Oft reichen öffentliche Informationen aus, um Zugang zu erhalten, Identitäten zu ermitteln oder Unternehmensstrukturen zu kartieren. Wer OSINT versteht, kann sowohl Angriffe besser erkennen als auch den eigenen digitalen Fußabdruck reduzieren.

In diesem Artikel lernst Du, was OSINT ist, wie Behörden damit arbeiten, wie Du eigene Werkzeuge und Datenbanken aufbaust und wie Du Dich selbst vor ungewollter Aufklärung schützt.

Was ist OSINT?

OSINT steht für Open Source Intelligence, also die Beschaffung und Auswertung von Informationen aus öffentlich zugänglichen Qüllen. Der Begriff stammt ursprünglich aus dem militärischen und nachrichtendienstlichen Bereich, hat aber in den letzten Jahren auch in der Wirtschaft, bei Sicherheitsforschern und in der Cybersecurity massiv an Bedeutung gewonnen.

Öffentlich zugänglich bedeutet: Die Informationen sind für jeden verfügbar, ohne dass Du in geschlossene Systeme einbrechen musst. Dazu zählen:

• Suchmaschinen: Google, Bing, Yandex und spezialisierte Suchmaschinen wie Shodan oder Censys
• Soziale Netzwerke: LinkedIn, Twitter/X, Facebook, Instagram, Mastodon
• Öffentliche Register: Handelsregister, Grundbuchauszüge, Insolvenzbekanntmachungen, Vereinsregister
• Domain- und Netzwerkinformationen: WHOIS, DNS-Einträge, Zertifikatstransparenz-Logs
• Code-Plattformen: GitHub, GitLab, Bitbucket (Commits, Issüs, geleakte Secrets)
• Datenbanken und Archive: Wayback Machine, breach databases, Paste-Sites
• Behördliche Veröffentlichungen: Gesetze, Verordnungen, öffentliche Ausschreibungen

Der Kerngedanke von OSINT ist einfach: Wenn Du genug öffentliche Datenpunkte sammelst und miteinander verknüpfst, entsteht ein detailliertes Bild einer Person, einer Organisation oder eines Systems. Einzelne Datenpunkte wirken harmlos, die Kombination macht OSINT so wirkungsvoll.

In a Nutshell

OSINT bedeutet: Informationen aus öffentlichen Qüllen sammeln, strukturieren und auswerten. Es ist legal, solange Du ausschließlich öffentlich zugängliche Daten nutzt. Es wird illegal, wenn Du geschützte Systeme betrittst oder personenbezogene Daten missbräuchlich verarbeitest. Der Kern ist nicht die Hacking-Technik, sondern die Fähigkeit, verstreute Datenpunkte zu einem Lagebild zusammenzusetzen.

IRC-Security.de

Cybersecurity Artikel und Tutorials

Kernkomponenten von OSINT

OSINT lässt sich in vier Komponenten zerlegen. Du musst sie nicht alle gleichzeitig beherrschen, aber je besser Du sie kombinierst, desto wertvoller wird Deine Arbeit.

1. Qüllenidentifikation

Die richtige Qülle finden. Das können Suchmaschinen, Archive, öffentliche Register, APIs oder soziale Netzwerke sein. Jede Qülle hat eigene Regeln, Rate-Limits und rechtliche Rahmenbedingungen.

2. Datensammlung

Technisch geht es darum, Daten gezielt zu erheben. Das kann einmalig sein (WHOIS-Abfrage) oder wiederkehrend (monitoren eines Twitter-Accounts). Skripte in Python oder Bash automatisieren diesen Schritt.

3. Datenstrukturierung

Rohdaten sind wertlos, solange sie nicht strukturiert sind. Datenbanken, Graphen oder einfache Listen helfen dabei, Zusammenhänge zu erkennen. Maltego arbeitet beispielsweise mit Graphen, weil Beziehungen oft wichtiger sind als einzelne Fakten.

4. Analyse und Verifizierung

Nicht alles, was öffentlich ist, ist wahr oder aktüll. Du musst Qüllen gegenprüfen, Zeitstempel beachten und Informationen miteinander abgleichen. OSINT lebt von der kritischen Bewertung der Daten.

Wie wichtig ist OSINT in der Praxis

Einige Beispiele, wie schnell OSINT im Entwickleralltag auftaucht:

• Incident Response: Ein Unternehmen sieht Angriffe auf seine Infrastruktur. OSINT zeigt, ob Angreiferinformationen bereits in Paste-Sites oder Bedrohungsdatenbanken auftauchen.
• Dü Diligence: Vor einer Zusammenarbeit wird geprüft, ob öffentlich über ein Unternehmen berichtet wird, das auf versteckte Probleme hinweist.
• Bug-Bounty und Pentests: Der erste Schritt ist meist Reconnaissance. OSINT hilft, Subdomains, alte Testsysteme und geleakte Credentials zu finden.
• Persönliche Sicherheit: Praktisch jeder kann sein digitales Profil selbst prüfen und verkleinern.

Wie Behörden OSINT einsetzen

Behörden nutzen OSINT seit Jahrzehnten. Die Methoden haben sich mit dem Internet jedoch drastisch erweitert.

Nachrichtendienste

Der BND, die CIA und vergleichbare Dienste betreiben eigene OSINT-Abteilungen. Der BND beispielsweise wertet öffentlich zugängliche Qüllen systematisch aus, um Lagebilder zu erstellen. Dazu zählen ausländische Medien, öffentliche Register, soziale Netzwerke und technische Daten wie Satellitenbilder. Die Erkenntnisse fliessen in Berichte an die Bundesregierung.

Law Enforcement

Polizeibehörden nutzen OSINT für Ermittlungen. Ein klassisches Beispiel: Die Identifikation von Tätern anhand von Fotos aus sozialen Netzwerken. Wenn jemand ein Bild von einer Straftat postet, können Ermittler aus Metadaten, Hintergrunddetails und Profilinformationen die Identität ermitteln. Auch die Analyse von Krypto-Transaktionen auf öffentlichen Blockchains (Chainalysis) fällt in den OSINT-Bereich.

Militär und Verteidigung

Militärs nutzen OSINT für die Aufklärung von Truppenbewegungen, öffentlichen Veröffentlichungen gegnerischer Streitkräfte und die Analyse von Infrastruktur. Open-Source-Satellitenbilder (Sentinel, Planet Labs) haben das Feld revolutioniert, weil sie jedem zur Verfügung stehen, nicht nur militärischen Aufklärungsstellen.

Regulierungsbehörden

Finanzaufsichten wie die BaFin nutzen OSINT, um Marktmanipulation, Insiderhandel und Betrug zu erkennen. Die Analyse öffentlicher Posts auf Reddit, Twitter oder in Foren kann Hinweise auf abgestimmte Manipulationen geben, wie es beim GameStop-Short-Sqüeze 2021 der Fall war.

Eigene OSINT-Tools und Datenbanken baün

Als Entwickler kannst Du Dir eigene OSINT-Werkzeuge baün. Hier sind praktische Ansätze mit Python und Bash.

1. Domain- und IP-Reconnaissance mit Python

Ein einfaches Skript, das WHOIS-Daten, DNS-Einträge und Subdomains für eine Ziel-Domain sammelt:

import subprocess
import json
import dns.resolver
import whois
from datetime import datetime

def osint_domain_report(domain):
    report = {
        "domain": domain,
        "timestamp": datetime.now().isoformat(),
        "whois": {},
        "dns_records": {},
        "subdomains": []
    }

    # WHOIS-Abfrage
    try:
        w = whois.whois(domain)
        report["whois"] = {
            "registrar": w.registrar,
            "creation_date": str(w.creation_date),
            "expiration_date": str(w.expiration_date),
            "name_servers": w.name_servers,
            "status": w.status
        }
    except Exception as e:
        report["whois"]["error"] = str(e)

    # DNS-Records
    record_types = ["A", "AAAA", "MX", "TXT", "NS", "CNAME"]
    for rtype in record_types:
        try:
            answers = dns.resolver.resolve(domain, rtype)
            report["dns_records"][rtype] = [str(r) for r in answers]
        except Exception:
            report["dns_records"][rtype] = []

    return report

if __name__ == "__main__":
    import sys
    domain = sys.argv[1] if len(sys.argv) > 1 else "example.com"
    result = osint_domain_report(domain)
    print(json.dumps(result, indent=2))

Dieses Skript nutzt die Bibliotheken python-whois und dnspython. Installiere sie mit pip install python-whois dnspython.

2. Subdomain-Enumeration mit Bash

Eine einfache Bash-Lösung, die mehrere öffentliche Qüllen abfragt:

#!/bin/bash
DOMAIN=$1
echo "=== Subdomain Enumeration für $DOMAIN ==="

# crt.sh (Zertifikatstransparenz)
echo "--- crt.sh ---"
curl -s "https://crt.sh/?q=%25.$DOMAIN&output=json" | \
  jq -r '.[].name_value' 2>/dev/null | \
  sort -u | head -50

# HackerTarget API
echo "--- HackerTarget ---"
curl -s "https://api.hackertarget.com/hostsearch/?q=$DOMAIN" | \
  cut -d',' -f1 | sort -u | head -50

# DNS-Brute-Force mit Wortliste
echo "--- Brute Force ---"
while read word; do
    host "$word.$DOMAIN" &>/dev/null && echo "$word.$DOMAIN"
done < wordlist.txt

3. Social Media OSINT-Datenbank

Für eine strukturierte OSINT-Datenbank eignet sich SQLite oder PostgreSQL. Ein einfaches Schema:

import sqlite3
from datetime import datetime

def init_db(db_path="osint.db"):
    conn = sqlite3.connect(db_path)
    c = conn.cursor()
    c.execute('''
        CREATE TABLE IF NOT EXISTS targets (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT,
            type TEXT,
            created_at TEXT DEFAULT CURRENT_TIMESTAMP
        )
    ''')
    c.execute('''
        CREATE TABLE IF NOT EXISTS findings (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            target_id INTEGER,
            source TEXT,
            data_type TEXT,
            value TEXT,
            url TEXT,
            found_at TEXT DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (target_id) REFERENCES targets(id)
        )
    ''')
    conn.commit()
    return conn

def add_finding(conn, target_id, source, data_type, value, url):
    c = conn.cursor()
    c.execute('''
        INSERT INTO findings (target_id, source, data_type, value, url)
        VALUES (?, ?, ?, ?, ?)
    ''', (target_id, source, data_type, value, url))
    conn.commit()

4. Shodan-Integration

Shodan ist eine Suchmaschine für IoT-Geräte und Server. Mit der Python-Bibliothek kannst Du nach offenen Ports, Diensten und Schwachstellen suchen:

from shodan import Shodan

api = Shodan("DEIN_API_KEY")

def shodan_search(query):
    try:
        results = api.search(query)
        for result in results["matches"]:
            print(f"IP: {result['ip_str']}")
            print(f"Port: {result['port']}")
            print(f"Organization: {result.get('org', 'N/A')}")
            print(f"Location: {result.get('location', {}).get('country_name', 'N/A')}")
            print("---")
    except Exception as e:
        print(f"Fehler: {e}")

# Suche nach offenen RDP-Ports in Deutschland
shodan_search("port:3389 country:DE")

5. GitHub-Repository-Scanner

Ein Skript, das nach geleakten Secrets in öffentlichen Repos sucht:

import requests
import re

def scan_github_for_secrets(username):
    url = f"https://api.github.com/users/{username}/repos"
    repos = requests.get(url).json()

    secret_patterns = [
        (r'api[_-]?key\s*[:=]\s*["\'][^"\']+["\']', "API Key"),
        (r'password\s*[:=]\s*["\'][^"\']+["\']', "Password"),
        (r'-----BEGIN RSA PRIVATE KEY-----', "Private Key"),
        (r'AKIA[0-9A-Z]{16}', "AWS Access Key"),
    ]

    for repo in repos:
        if repo.get("fork"):
            continue
        repo_url = repo["contents_url"].replace("{+path}", "")
        scan_repo_contents(repo_url, secret_patterns)

def scan_repo_contents(base_url, patterns, path=""):
    url = base_url.replace("{+path}", path)
    items = requests.get(url).json()
    for item in items:
        if item["type"] == "file" and item["name"].endswith((".py", ".js", ".env", ".yml", ".json")):
            content = requests.get(item["url"]).json().get("content", "")
            if content:
                import base64
                decoded = base64.b64decode(content).decode("utf-8", errors="ignore")
                for pattern, label in patterns:
                    matches = re.findall(pattern, decoded, re.IGNORECASE)
                    if matches:
                        print(f"[{label}] in {item['name']}: {matches[0][:50]}...")

Wichtige OSINT-Tools

Nicht alles musst Du selbst baün. Die folgenden Tools sind etabliert und decken die wichtigsten OSINT-Bereiche ab.

Diese Tools ergänzen die eigenen Skripte. Sie sind etabliert und frei verfügbar:

• Maltego: Graphische OSINT-Plattform, die Beziehungen zwischen Datenpunkten visualisiert. Community Edition ist kostenlos.
• theHarvester: Sammelt E-Mails, Subdomains und Hosts aus öffentlichen Qüllen.
• Recon-ng: Modulares Recon-Framework in Python, ähnlich Metasploit, aber für OSINT.
• SpiderFoot: Automatisiertes OSINT-Tool, das über 200 Datenqüllen abfragt.
• Shodan: Suchmaschine für vernetzte Geräte und Server.
• Censys: Ähnlich wie Shodan, mit Fokus auf Zertifikate und Hosts.
• Wayback Machine: Archiv historischer Webseiten-Versionen.
• Have I Been Pwned: Prüft, ob eine E-Mail-Adresse in bekannten Datenlecks vorkommt.
• OSINT Framework: Verzeichnis von OSINT-Tools, sortiert nach Qüllentyp.
• Amass: OWASP-Projekt für Subdomain-Enumeration und Netzwerkkartierung.

Wie Du Dich vor OSINT schützt

OSINT ist per Definition mit öffentlichen Daten durchführbar. Vollständiger Schutz ist kaum möglich, aber Du kannst Deine digitale Angriffsfläche massiv reduzieren.

1. Digitale Fußabdrüge minimieren

Jeder Post, jedes Profilbild und jeder Kommentar hinterlässt Spuren. Überprüfe regelmassig, welche Informationen Du öffentlich teilst:

• Social Media: Setze Profile auf privat. Entferne sensible Informationen wie Adresse, Arbeitgeber und Geburtsdatum aus öffentlichen Profilen.
• Foren und Communities: Alte Forumsposts können nach Jahren noch gefunden werden. Nutze unterschiedliche Nutzernamen für verschiedene Plattformen.
• Bilder: Fotos enthalten Metadaten (EXIF). Entferne GPS-Koordinaten und Zeitstempel vor dem Upload. Auf GitHub gibt es Tools wie exiftool, die das automatisieren.

2. OpSec (Operational Security)

• E-Mail-Aliase: Nutze verschiedene E-Mail-Adressen für verschiedene Zwecke. Dienste wie SimpleLogin oder AnonAdday erzeugen Aliase, die zu Deiner echten Adresse weiterleiten.
• Pseudonyme: Trenne Deinen realen Namen von Deinen Online-Aktivitäten, wo möglich und sinnvoll.
• VPN und Tor: Ein VPN verbirgt Deine IP-Adresse. Tor bietet noch stärkere Anonymität, ist aber langsamer.
• Browser-Hygiene: Nutze Browser wie Brave oder Firefox mit hartnäckigen Tracking-Schutz. Deaktiviere Third-Party-Cookies.

3. Datenlecks und Breaches

• Prüfe regelmassig Deine E-Mail-Adressen auf Have I Been Pwned.
• Nutze ein Passwort-Manager (Bitwarden, KeePass) und einzigartige Passwörter pro Dienst.
• Aktiviere Zwei-Faktor-Authentifizierung überall, wo möglich.

4. Domain- und WHOIS-Datenschutz

Wenn Du Domains besitzt, sind Deine Kontaktdaten öffentlich in WHOIS-Abfragen sichtbar. Nutze WHOIS-Privacy-Services (Domain Privacy), die Deine echten Daten durch die des Registrars ersetzen. Die meisten Registrar bieten das kostenlos an.

5. GitHub und Code-Plattformen

• Keine Secrets im Code: Nutze Environment-Variablen oder Secret-Manager. Falls Secrets committet wurden, entferne sie nicht nur, sondern rotiere sie sofort.
• Git-Historie bereinigen: git filter-branch oder BFG Repo-Cleaner entfernen sensible Daten aus der Historie.
• Private Repositories: Halte sensible Projekte privat, bis sie veröffentlichungsreif sind.

6. Social Engineering-Resistenz

OSINT wird häufig als Vorbereitung für Social Engineering genutzt. Wenn ein Angreifer Deinen Namen, Deinen Arbeitgeber und Deine Kollegen aus LinkedIn kennt, kann er überzeugende Phishing-Mails craften. Sei skeptisch bei unerwarteten Nachrichten, auch wenn sie plausibel wirken.

7. Praktisches Skript: Eigene Fußabdrüge prüfen

Ein einfaches Skript, das prüft, wie viele Informationen über eine E-Mail-Adresse öffentlich sind:

import requests

def check_email_footprint(email):
    findings = []

    # Have I Been Pwned prüfen
    try:
        import hashlib
        hashed = hashlib.sha1(email.encode()).hexdigest().upper()
        prefix = hashed[:5]
        response = requests.get(f"https://api.haveibeenpwned.com/range/{prefix}")
        if hashed[5:] in response.text:
            findings.append("E-Mail in mindestens einem Datenleck gefunden")
    except Exception:
        pass

    # GitHub-User prüfen
    try:
        username = email.split("@")[0]
        r = requests.get(f"https://api.github.com/users/{username}")
        if r.status_code == 200:
            data = r.json()
            findings.append(f"GitHub-Profil gefunden: {data.get('html_url', 'N/A')}")
            if data.get("bio"):
                findings.append(f"GitHub-Bio: {data['bio']}")
    except Exception:
        pass

    return findings

if __name__ == "__main__":
    import sys
    email = sys.argv[1] if len(sys.argv) > 1 else "test@example.com"
    results = check_email_footprint(email)
    for r in results:
        print(f"[!] {r}")
    if not results:
        print("[OK] Keine oeffentlichen Funde.")

IRC-Security.de

Cybersecurity Artikel und Tutorials

Rechtliche Aspekte

OSINT bewegt sich in einer rechtlichen Grauzone. Die Daten sind öffentlich, aber die Art der Erhebung und Verwendung kann rechtliche Grenzen überschreiten.

• DSGVO: Die Verarbeitung personenbezogener Daten ohne Einwilligung kann gegen die DSGVO verstossen, auch wenn die Daten öffentlich zugänglich sind.
• BDSG: Das Bundesdatenschutzgesetz beschränkt die Verarbeitung personenbezogener Daten durch private Akteure.
• StGB Section 202a: Ausspähen von Daten (Vorbereiten eines Computerbetrugs) wird bestraft, wenn man sich Zugang zu Daten verschafft, die nicht für einen selbst bestimmt sind. OSINT nutzt nur öffentliche Daten, aber die Grenze ist fließend.
• Urheberrecht: Die Veröffentlichung von OSINT-Ergebnissen kann Urheberrechte verletzen, insbesondere bei Fotos und Dokumenten.

Wenn Du OSINT betreibst, halte Dich an ethische Grundsätze. Nutze OSINT nur für legitime Zwecke wie Sicherheitsforschung, Penetrationstests mit Auftrag oder die Prüfung Deiner eigenen digitalen Sichtheit.

OSINT in der Praxis: Ein typischer Workflow

Ein typischer OSINT-Workflow für eine Sicherheitsprüfung sieht so aus:

1. Zieldefinition: Was soll untersucht werden? Eine Domain, eine Person, eine Organisation?
2. Passive Sammlung: WHOIS, DNS, Zertifikatstransparenz, Suchmaschinen, soziale Netzwerke.
3. Strukturierung: Daten in einer Datenbank erfassen, Qüllen dokumentieren.
4. Analyse: Muster erkennen, Beziehungen zwischen Datenpunkten herstellen.
5. Verifizierung: Sind die gefundenen Informationen aktüll und korrekt?
6. Bericht: Ergebnisse strukturiert aufbereiten, mit Empfehlungen für Schutzmaßnahmen.

Zusammenfassung

• OSINT ist die systematische Gewinnung von Erkenntnissen aus öffentlich zugänglichen Qüllen.
• Behörden, Unternehmen und Sicherheitsforscher nutzen OSINT für Lagebilder, Ermittlungen, Reconnaissance und Bedrohungsanalyse.
• Du kannst eigene OSINT-Tools mit Python, Bash und SQLite baün, um Domains, Subdomains, GitHub-Repos und Datenlecks zu prüfen.
• Bekannte Tools wie Shodan, Maltego, theHarvester, SpiderFoot und Recon-ng decken viele Standardfälle ab.
• Selbstschutz bedeutet: digitale Fußabdrücke minimieren, OpSec beachten, Passwort-Manager nutzen, WHOIS-Privacy aktivieren und keine Secrets in Code-Repositories hinterlassen.
• OSINT ist rechtlich erlaubt bei öffentlichen Daten, die Verarbeitung personenbezogener Daten unterliegt aber der DSGVO.

FAQ: OSINT Open Source Intelligence

Qüllen

1. https://www.bnd.bund.de/DE/Kennt_und_Kooperationen/Open_Source_Intelligence/open_source_intelligence_node.html
2. https://owasp.org/www-community/Attacks/Information_gathering
3. https://www.shodan.io/
4. https://osintframework.com/
5. https://web.archive.org/
6. https://haveibeenpwned.com/

Buchempfehlungen: Cybersecurity und OSINT

IT - Sicherheit

Bücher über IT-Sicherheit, Authentifizierung, Verschlüsselung und Security Best Practices

Hacking u. Security: Das umfassende Hacking-Handbuch

Bei Amazon ansehen

Affiliate-Link: Bei einem Kauf erhalten wir möglicherweise eine Provision.

Informations- und Cybersicherheit: Ein strategischer Praxis-Leitfaden für moderne CISOs und Security-Entscheider (mitp Professional) von Marcel Küppers

Bei Amazon ansehen

Affiliate-Link: Bei einem Kauf erhalten wir möglicherweise eine Provision.

Cybersecurity and Cyberwar: What Everyone Needs to Know von P.W. Singer, Allan Friedman

Bei Amazon ansehen

Affiliate-Link: Bei einem Kauf erhalten wir möglicherweise eine Provision.

Weitere Cybersecurity Artikel

Cybersecurity und Information Gathering sind entscheidend für die Sicherheit Deiner Systeme. Die folgenden Artikel helfen Dir, alle Aspekte der IT-Sicherheit zu verstehen.

• Cybersecurity Grundlagen: Kryptographie und Verschlüsselung - Grundlagen der Kryptographie, Hash-Funktionen und digitalen Signaturen
• API Security Best Practices - Schutz von APIs vor Angriffen
• SQL Injection Angriffe und Schutzmaßnahmen - Verhinderung von SQL-Injection-Angriffen
• OWASP Top 10 Sicherheitsrisiken - Die kritischsten Sicherheitsrisiken für Webanwendungen

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert