OSINT Open Source Intelligence

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Introducción

OSINT está en todas partes. Cada publicación compartida públicamente en una red social, cada registro de dominio, cada versión anterior de un sitio web y cada respuesta de un servidor en una dirección IP abierta puede usarse para recopilar información. No es una aventura de espionaje, sino una disciplina estándar en ciberseguridad, inteligencia empresarial y análisis forense digital.

¿Por qué es importante este tema? Porque los ataques rara vez comienzan con exploits complejos. A menudo, la información pública es suficiente para obtener acceso, identificar identidades o mapear estructuras organizacionales. Quien entiende OSINT puede reconocer mejor los ataques y también reducir su propia huella digital.

En este artículo aprenderás qué es OSINT, cómo trabajan las autoridades con él, cómo construir tus propias herramientas y bases de datos, y cómo protegerte de la recopilación no deseada de información.

¿Qué es OSINT?

OSINT significa Open Source Intelligence, es decir, la obtención y análisis de información de fuentes públicamente accesibles. El término proviene originalmente del ámbito militar y de inteligencia, pero en los últimos años ha ganado importancia masiva en negocios, investigación de seguridad y ciberseguridad.

Accesible públicamente significa que la información está disponible para cualquiera sin necesidad de acceder a sistemas cerrados. Esto incluye:

• Motores de búsqueda: Google, Bing, Yandex y motores especializados como Shodan o Censys
• Redes sociales: LinkedIn, Twitter/X, Facebook, Instagram, Mastodon
• Registros públicos: Registros comerciales, extractos del registro de la propiedad, notificaciones de insolvencia, registros de asociaciones
• Información de dominios y redes: WHOIS, entradas DNS, registros de transparencia de certificados
• Plataformas de código: GitHub, GitLab, Bitbucket (commits, issues, secretos filtrados)
• Bases de datos y archivos: Wayback Machine, bases de datos de brechas, sitios de paste
• Publicaciones de autoridades: Leyes, regulaciones, licitaciones públicas

La idea central de OSINT es simple: si recopila suficientes puntos de datos públicos y los vincula entre sí, obtiene una imagen detallada de una persona, organización o sistema. Los puntos de datos individuales parecen inofensivos, pero la combinación es lo que hace que OSINT sea tan poderoso.

En Resumen

OSINT significa recopilar, estructurar y analizar información de fuentes públicas. Es legal mientras uses exclusivamente datos públicamente accesibles. Se vuelve ilegal cuando accedes a sistemas protegidos o procesas datos personales de manera indebida. Lo fundamental no es la técnica de hacking, sino la capacidad de conectar puntos de datos dispersos en una imagen coherente.

IRC-Security.de

Cybersecurity Artikel und Tutorials

Componentes Clave de OSINT

OSINT se puede desglosar en cuatro componentes. No necesitas dominarlos todos simultáneamente, pero cuanto mejor los combines, más valioso será tu trabajo.

1. Identificación de Fuentes

Encontrar la fuente correcta. Pueden ser motores de búsqueda, archivos, registros públicos, APIs o redes sociales. Cada fuente tiene reglas propias, límites de velocidad y marcos legales específicos.

2. Recopilación de Datos

Técnicamente, se trata de reunir datos de forma deliberada. Puede ser puntual (consulta WHOIS) o recurrente (monitoreo de una cuenta de Twitter). Scripts en Python o Bash automatizan este paso.

3. Estructuración de Datos

Los datos sin procesar carecen de valor sin estructura. Las bases de datos, gráfos o listas simples ayudan a identificar conexiones. Maltego funciona con gráfos precisamente porque las relaciones suelen ser más importantes que los datos individuales.

4. Análisis y Verificación

No todo lo público es verdadero o actual. Debes contrastar fuentes, prestar atención a marcas de tiempo e cotejar información. OSINT depende de la evaluación crítica de los datos.

Qué tan importante es OSINT en la Práctica

Algunos ejemplos de cuán rápidamente OSINT aparece en el trabajo diario de desarrollo:

• Respuesta a Incidentes: Una empresa detecta ataques en su infraestructura. OSINT muestra si la información del atacante ya aparece en paste-sites o bases de datos de amenazas.
• Diligencia Debida: Antes de colaborar con alguien, se verifica si hay reportes públicos sobre esa empresa que indiquen problemas ocultos.
• Bug Bounty y Pruebas de Penetración: El primer paso es generalmente reconocimiento. OSINT ayuda a encontrar subdominios, sistemas de prueba antiguos y credenciales filtradas.
• Seguridad Personal: Prácticamente cualquiera puede revisar su propio perfil digital y reducirlo.

Cómo Utilizan OSINT las Autoridades

Las autoridades han utilizado OSINT durante décadas. Sin embargo, los métodos se han expandido drásticamente con Internet.

Servicios de Inteligencia

El BND, la CIA y servicios equivalentes operan sus propias divisiones de OSINT. Por ejemplo, el BND evalúa sistemáticamente fuentes públicamente accesibles para crear cuadros situacionales. Esto incluye medios extranjeros, registros públicos, redes sociales y datos técnicos como imágenes de satélite. Los hallazgos se incorporan en reportes para el gobierno federal.

Aplicación de la Ley

Las autoridades policiales usan OSINT para investigaciones. Un ejemplo clásico: identificar a los autores de delitos basándose en fotos de redes sociales. Si alguien publica una foto de un delito, los investigadores pueden determinar la identidad usando metadatos, detalles de fondo e información del perfil. El análisis de transacciones criptográficas en blockchains públicos (Chainalysis) también cae dentro del ámbito de OSINT.

Militares y Defensa

Los militares usan OSINT para reconocer movimientos de tropas, analizar publicaciones públicas de fuerzas enemigas e investigar infraestructura. Las imágenes satelitales de código abierto (Sentinel, Planet Labs) han revolucionado el campo porque están disponibles para todos, no solo para agencias de inteligencia militar.

Autoridades Regulatorias

Reguladores financieros como la BaFin utilizan OSINT para detectar manipulación de mercados, comercio de información privilegiada y fraude. El análisis de posts públicos en Reddit, Twitter o foros puede revelar pistas de manipulaciones coordinadas, como ocurrió con el GameStop short squeeze de 2021.

Construir Tus Propias Herramientas y Bases de Datos OSINT

Como desarrollador, puedes crear tus propias herramientas OSINT. Aquí hay enfoques prácticos usando Python y Bash.

1. Reconocimiento de Dominios e IP con Python

Un script simple que recopila datos WHOIS, entradas DNS y subdominios para un dominio objetivo:

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": []
    }

    # Consulta WHOIS
    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)

    # Registros DNS
    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))

Este script utiliza las librerías python-whois y dnspython. Instálalas con pip install python-whois dnspython.

2. Enumeración de subdominios con Bash

Una solución sencilla en Bash que consulta múltiples fuentes públicas:

#!/bin/bash
DOMAIN=$1
echo "=== Subdomain Enumeration para $DOMAIN ==="

# crt.sh (Certificate Transparency)
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 con lista de palabras
echo "--- Brute Force ---"
while read word; do
    host "$word.$DOMAIN" &>/dev/null && echo "$word.$DOMAIN"
done < wordlist.txt

3. Base de datos OSINT para redes sociales

Para una base de datos OSINT estructurada, SQLite o PostgreSQL funcionan bien. Un esquema simple:

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. Integración con Shodan

Shodan es un buscador de dispositivos IoT y servidores. Con la librería de Python puedes buscar puertos abiertos, servicios y vulnerabilidades:

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"Error: {e}")

# Busca puertos RDP abiertos en Alemania
shodan_search("port:3389 country:DE")

5. Escáner de repositorios GitHub

Un script que busca secretos filtrados en repositorios públicos:

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]}...")

Herramientas OSINT importantes

No tienes que construir todo desde cero. Las siguientes herramientas están consolidadas y cubren las áreas OSINT más relevantes.

Estas herramientas complementan tus propios scripts. Están consolidadas y disponibles libremente:

• Maltego: Plataforma OSINT gráfica que visualiza relaciones entre puntos de datos. La Community Edition es gratuita.
• theHarvester: Recopila correos electrónicos, subdominios y hosts desde fuentes públicas.
• Recon-ng: Framework de recon modular en Python, similar a Metasploit pero para OSINT.
• SpiderFoot: Herramienta OSINT automatizada que consulta más de 200 fuentes de datos.
• Shodan: Buscador de dispositivos conectados y servidores.
• Censys: Similar a Shodan, con enfoque en certificados y hosts.
• Wayback Machine: Archivo de versiones históricas de sitios web.
• Have I Been Pwned: Verifica si una dirección de correo aparece en filtraciones conocidas.
• OSINT Framework: Directorio de herramientas OSINT, ordenado por tipo de fuente.
• Amass: Proyecto OWASP para enumeración de subdominios y mapeo de redes.

Cómo protegerte contra OSINT

OSINT se realiza por definición con datos públicos. Una protección completa es casi imposible, pero puedes reducir significativamente tu superficie de ataque digital.

1. Minimizar tus huellas digitales

Cada publicación, foto de perfil y comentario deja rastros. Revisa regularmente qué información compartes públicamente:

• Redes sociales: Establece tus perfiles como privados. Elimina información sensible como dirección, empleador y fecha de nacimiento de perfiles públicos.
• Foros y comunidades: Los posts antiguos en foros pueden encontrarse años después. Usa nombres de usuario diferentes en distintas plataformas.
• Imágenes: Las fotos contienen metadatos (EXIF). Elimina coordenadas GPS y marcas de tiempo antes de subirlas. En GitHub hay herramientas como exiftool que automatizan esto.

2. OpSec (Seguridad Operacional)

• Alias de correo: Usa direcciones de correo diferentes para distintos propósitos. Servicios como SimpleLogin o AnonAdday generan alias que reenvían a tu dirección real.
• Seudónimos: Separa tu nombre real de tus actividades en línea cuando sea posible y tenga sentido.
• VPN y Tor: Una VPN oculta tu dirección IP. Tor ofrece mayor anonimato, pero es más lento.
• Higiene del navegador: Usa navegadores como Brave o Firefox con protección contra rastreo robusta. Desactiva las cookies de terceros.

3. Filtraciones y Brechas de Datos

• Verifica regularmente tus direcciones de correo en Have I Been Pwned.
• Usa un gestor de contraseñas (Bitwarden, KeePass) y contraseñas únicas para cada servicio.
• Activa autenticación de dos factores en todos lados donde sea posible.

4. Privacidad de Dominios y WHOIS

Si posees dominios, tus datos de contacto son visibles públicamente en consultas WHOIS. Usa servicios de privacidad WHOIS (Domain Privacy) que reemplazan tus datos reales por los del registrador. La mayoría de registradores lo ofrecen de forma gratuita.

5. GitHub y Plataformas de Código

• Sin secretos en el código: Usa variables de entorno o gestores de secretos. Si ya has committeado secretos, no solo los elimines, sino que los rotas inmediatamente.
• Limpiar historial de Git: git filter-branch o BFG Repo-Cleaner eliminan datos sensibles del historial.
• Repositorios privados: Mantén proyectos sensibles privados hasta que estén listos para publicar.

6. Resistencia al Social Engineering

OSINT se usa frecuentemente como preparación para social engineering. Si un atacante conoce tu nombre, tu empleador y tus colegas de LinkedIn, puede elaborar correos de phishing convincentes. Sé escéptico con mensajes inesperados, incluso si parecen plausibles.

7. Script Práctico: Auditar tu Propia Huella Digital

Un script simple que verifica cuánta información sobre una dirección de correo está disponible públicamente:

import requests

def check_email_footprint(email):
    findings = []

    # Have I Been Pwned check
    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 encontrado en al menos una brecha de datos")
    except Exception:
        pass

    # GitHub user check
    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"Perfil GitHub encontrado: {data.get('html_url', 'N/A')}")
            if data.get("bio"):
                findings.append(f"Bio de GitHub: {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] Sin hallazgos públicos.")

IRC-Security.de

Cybersecurity Artikel und Tutorials

Aspectos Legales

OSINT se mueve en una zona gris legal. Los datos son públicos, pero la forma de recolectarlos y usarlos puede cruzar límites legales.

• RGPD: El procesamiento de datos personales sin consentimiento puede violar el RGPD, incluso si los datos son accesibles públicamente.
• BDSG: La Ley Federal Alemana de Protección de Datos limita el procesamiento de datos personales por actores privados.
• StGB Sección 202a: El espionaje de datos (preparación de fraude informático) se sanciona si accedes a datos que no están destinados a ti. OSINT utiliza solo datos públicos, pero el límite es difuso.
• Derechos de autor: Publicar resultados de OSINT puede violar derechos de autor, especialmente con fotos y documentos.

Si practicas OSINT, adhiérete a principios éticos. Usa OSINT solo para propósitos legítimos como investigación de seguridad, pruebas de penetración contratadas o auditar tu propia visibilidad digital.

OSINT en la Práctica: Un Flujo de Trabajo Típico

Un flujo de trabajo OSINT típico para una auditoría de seguridad se ve así:

1. Definición del objetivo: ¿Qué debe examinarse? ¿Un dominio, una persona, una organización?
2. Recolección pasiva: WHOIS, DNS, transparencia de certificados, motores de búsqueda, redes sociales.
3. Estructuración: Registra datos en una base de datos, documenta fuentes.
4. Análisis: Identifica patrones, establece conexiones entre puntos de datos.
5. Verificación: ¿La información encontrada es actual y correcta?
6. Informe: Presenta resultados de forma estructurada con recomendaciones de medidas de protección.

Resumen

• OSINT es la obtención sistemática de información a partir de fuentes accesibles públicamente.
• Agencias, empresas e investigadores de seguridad usan OSINT para análisis de situación, investigaciones, reconocimiento y análisis de amenazas.
• Puedes construir tus propias herramientas OSINT con Python, Bash y SQLite para auditar dominios, subdominios, repositorios de GitHub y filtraciones.
• Herramientas conocidas como Shodan, Maltego, theHarvester, SpiderFoot y Recon-ng cubren muchos casos estándar.
• La autoprotección significa: minimizar la huella digital, respetar OpSec, usar gestor de contraseñas, activar privacidad WHOIS y no dejar secretos en repositorios de código.
• OSINT está permitido legalmente con datos públicos, pero el procesamiento de datos personales está sujeto al RGPD.

FAQ: OSINT Open Source Intelligence

Fuentes

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/

Lecturas recomendadas: Cybersecurity e OSINT

Más artículos sobre Cybersecurity

La seguridad informática y la recopilación de información son aspectos fundamentales para proteger tus sistemas. Los siguientes artículos te ayudarán a comprender todos los aspectos de la seguridad IT.

• Fundamentos de Cybersecurity: Criptografía y Cifrado - Conceptos básicos de criptografía, funciones hash y firmas digitales
• Mejores prácticas de seguridad en APIs - Protección de APIs contra ataques
• Ataques de SQL Injection y medidas de protección - Prevención de ataques de SQL Injection
• OWASP Top 10: Riesgos de seguridad críticos - Los riesgos de seguridad más críticos en aplicaciones web

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert