Künstliche Intelligenz bezeichnet das breite Gebiet der Informatik, das sich mit der Entwicklung von Systemen befasst, die Aufgaben ausführen können, für die normalerweise menschliche Intelligenz erforderlich ist. Innerhalb dieses Bereichs sind große Sprachmodelle eine spezielle Klasse statistischer KI-Systeme, die anhand umfangreicher Textkorpora trainiert werden, um kohärente Sprache vorherzusagen und zu generieren. Bekannte Beispiele sind ChatGPT, Grok xAI, Claude und Gemini, die sich durch hervorragende Übersetzungs-, Zusammenfassungs- und Konversationsfunktionen auszeichnen, jedoch eher durch Mustererkennung als durch echtes Verständnis funktionieren.

Kritiker argumentieren, dass die Vermischung von KI und LLMs die Vielfalt der KI-Forschung übersieht, die auch Bereiche wie Computer Vision, Robotik, Expertensysteme und autonome Entscheidungsfindung umfasst.

Wir wollen hier nicht über die Wissenschaft der KI oder LLMs diskutieren, sondern uns darauf konzentrieren, wofür KI in der Cyberabwehr eingesetzt werden kann.

Die Themen dieses Abschnitts umfassen Folgendes:

  1. Verschiedene Arten der KI-Nutzung: Prompting, RAG und Fine-Tuning
  2. Einrichten einer KI-API
  3. KI-Prompting

Verschiedene Arten der KI-Nutzung: Prompting, RAG und Fine-Tuning

Kontext und Ziel

Unser Ziel ist es, Beiträge in Cybercrime-Foren zu analysieren, um diejenigen zu identifizieren, in denen über Initial Access Sales (IABs) diskutiert wird. Die Beiträge werden wie folgt klassifiziert:

  • Positive Beiträge: direkter Verkauf von unbefugtem Zugriff auf ein Unternehmen (z. B. „Initial Access to RBC Bank available“).
  • Neutrale Beiträge: allgemeine Angebote für Tools, Exploits oder Malware ohne Nennung eines bestimmten Ziels.
  • Negative Beiträge: themenfremde oder nicht relevante Dienstleistungen wie Hosting, Spam-Tools oder generischer VPS-Verkauf.

KI-Prompting

Beim Prompting werden vorab trainierte APIs (z. B. OpenAI, xAI, Anthropic) verwendet, indem speziell formulierte Prompts gesendet und unveränderte Antworten empfangen werden.

Kosten und technischer Aufwand

  • API-Aufrufe von Drittanbietern reichen von niedrig (GPT-3.5 bei ~0,002 $ pro 1.000 Tokens) bis mittel (GPT-4 bei ~0,03–0,06 $ pro 1.000 Tokens).

  • Selbsthosting verursacht Hardwarekosten (GPU-Server bei 2–3 $/Stunde) und Lizenzgebühren für offene Modelle.

  • Minimale Infrastruktur über die sichere Speicherung von Prompt-Protokollen und API-Schlüsseln hinaus.

Datenspeicherung Nur Prompt-Vorlagen, Protokolle und Metadaten zu Beiträgen; in der Regel wenige Megabyte pro Tag.

Datenschutz Das Senden sensibler Bedrohungsinformationen an externe APIs kann die Vertraulichkeit verletzen. Lokale Modelle verbessern den Datenschutz, erhöhen jedoch die Infrastruktur- und Schulungskosten.

Einfache Einführung Prompting ist der schnellste Weg, um mit CTI zu beginnen, da keine Modellschulung und nur minimale Einrichtung erforderlich sind.

Retrieval Augmented Generation (RAG)

RAG kombiniert einen Dokumentenspeicher für CTI-Daten mit einem LLM. Es ruft relevante Passagen (z. B. aus Malware-Berichten oder Leak-Archiven) ab, um den Prompt-Kontext zu ergänzen.

Kernkomponenten und Kosten

  1. Vektorspeicher (z. B. FAISS, Pinecone)

  2. Einbettungsmodell (OpenAI-Einbettungen oder Open-Source-Alternativen)

  3. LLM

  4. Führende Cloud-LLMs: GPT-4, Claude 2

  5. Selbst gehostete Modelle: Llama 2-70B, Mistral Instruct

Die Kosten für die Cloud-Inferenz umfassen Einbettungsaufrufe und Generierungsaufrufe (ähnlich wie bei Prompting). Für das Selbsthosting sind GPUs (A100 oder gleichwertig) mit 40–80 GB VRAM für große Modelle erforderlich.

Technischer Aufwand Die Einrichtung einer Abruf-Pipeline, die Indizierung von Dokumenten und die Pflege von Vektordatenbanken erfordern technische Kenntnisse.

Datenspeicherung Speicherplatz für den Korpus (zig bis hunderte Gigabyte) plus Vektorindizes (etwa 2-5-mal so groß wie der Korpus).

Rechenanforderungen

  • Einbettung: wenige Sekunden pro Dokument auf der GPU

  • Generierung: abhängig von der Modellgröße; GPT-4- oder 70-B-Parameter-Modelle benötigen High-End-GPUs für eine Inferenz mit geringer Latenz.

Feinabstimmung

Durch Feinabstimmung wird ein LLM an CTI angepasst, indem es anhand von beschrifteten Beispielen (z. B. Post-Klassifizierungen oder Zusammenfassungen von Bedrohungsberichten) trainiert wird.

Beste Reasoning-LLMs und Rechenanforderungen

  • Cloud†: Feinabstimmung von GPT-3.5 und GPT-4 (erfordert minimale Rechenleistung auf der Benutzerseite).
  • Selbst gehostet: Mistral 7B/13B, Llama 2-Varianten, Falcon-Serie.
  • Die Feinabstimmung großer Modelle (30 B+ Parameter) erfordert mehrere A100-GPUs und kann Stunden bis Tage dauern.

Kosten und technischer Aufwand

  • Cloud: tokenbasierte Feinabstimmungsgebühren (~0,03–0,12 USD pro 1.000 Token) zuzüglich Speicherplatz für das abgestimmte Modell.
  • Vor Ort: GPU-Cluster-Miete (3–10 USD/Stunde pro GPU), Pipelines für die Datenvorverarbeitung, Wartung der Trainingsinfrastruktur.

Datenspeicherung Trainingsdatensätze (bis zu mehreren Gigabyte) plus endgültige Modell-Checkpoints (10–200 GB, je nach Größe).

Um mit der Feinabstimmung zu beginnen, finden Sie hier einen Beispiel-Datensatz, den Sie verwenden können:

https://github.com/0xHamy/minimal_scraper/tree/main/datasets

Um weitere ähnliche Daten zu generieren, können Sie Paragraphing-APIs verwenden.

Vergleichende Zusammenfassung

| Aspekt | Prompting | RAG | Feinabstimmung | |----------------------|-------------------------------|---------------------------------------------|--------------------------------------| | Datenschutz | Gering (öffentliche API) oder hoch (lokal) | Mittel (lokaler Korpus, öffentliches LLM) | Hoch (lokales Modell) | | Einrichtungszeit | Minuten | Stunden bis Tage | Tage bis Wochen | | Infrastruktur | Minimal | Moderat (Vektor-DB, Abrufservrer) | Umfangreich (GPU-Flotte, Trainingsstack) | | Kostenprofil | Niedrig bis mittel | Mittel bis hoch | Hoch | | Datenspeicherung | Protokolle und Metadaten | Dokumente + Indizes | Trainingsdaten + Modell-Checkpoints | | Modellbegründung | Auf Prompt-Design beschränkt | Durch Kontextabruf verbessert | Beste Domänenanpassung | | Lernkurve | Am einfachsten | Mittel | Steil |

Einrichten einer KI-API

Wie bereits erwähnt, ist Prompting der einfachste Weg für den Einstieg. Aber wie wählen wir die richtigen Modelle für unsere Aufgaben aus?

Die unten aufgeführten KI-Anbieter bieten eine Reihe von Modellen an, die über die genannten hinausgehen. Ich empfehle Ihnen, sich mit ihren Angeboten vertraut zu machen und sich über ihre Funktionen zu informieren. Beachten Sie, dass KI-Abonnements (z. B. für ChatGPT oder Claude) sich von KI-APIs unterscheiden, für die API-Credits erworben werden müssen. Diese beginnen in der Regel bei 5 US-Dollar und haben eine beträchtliche Laufzeit.

Anthropic

Claude 3.5 Sonnet von Anthropic ist ein Modell, das ich häufig verwende. Es zeichnet sich durch hervorragende Schlussfolgerungsfähigkeiten und robuste Sicherheitsvorkehrungen aus und eignet sich daher ideal für die Identifizierung von Beiträgen im Zusammenhang mit Erstzugangsverkäufen, Hassreden oder Cybermobbing. Darüber hinaus liefert es gute Ergebnisse bei der optischen Zeichenerkennung (OCR), insbesondere bei der Lösung von CAPTCHAs durch effektive Extraktion von Text aus Bildern.

Erste Schritte:

https://www.anthropic.com/api

xAI

Grok 3 von xAI eignet sich hervorragend zum Schreiben und Analysieren großer Codebasen mit bis zu 2.000 Zeilen Code. Es eignet sich zwar für die Malware-Analyse, ist jedoch weniger effektiv bei Argumentationsaufgaben wie Debatten, bei denen es Schwierigkeiten hat, einzigartige Argumente zu generieren. Claude 3.5 Sonnet übertrifft Grok 3 in allgemeinen Argumentationen und Debatten, aber Grok 3 ist führend bei Codierungsaufgaben.

Erste Schritte:

https://x.ai/api

OpenAI

OpenAI bietet verschiedene Modelle an, wobei o1 sich besonders für die Fehlersuche in Code und die Behebung von Fehlern eignet. Dieses Modell ist für die Fehlerbehebung in großen Codebasen von unschätzbarem Wert. Bei der Entwicklung umfangreicher CTI-Plattformen werden Sie auf zahlreiche Fehler stoßen, und o1 ist ein zuverlässiges Werkzeug, um Lösungen zu finden.

Erste Schritte:

https://openai.com/api/

AI-Prompting

Die zuvor genannten AI-API-Anbieter bieten umfassende Dokumentationen, in denen detailliert beschrieben wird, wie Sie mit ihren APIs mithilfe von Programmiersprachen wie Python oder JavaScript interagieren können. In diesem Abschnitt werde ich näher darauf eingehen und erklären, wie Sie die KI von Anthropic für bestimmte Anwendungsfälle nutzen können, beispielsweise um Beiträge, in denen es um Erstzugangsverkäufe geht, von anderen Beiträgen zu unterscheiden.

Erstzugriffsverkauf mit Claude identifizieren

Um Erstzugriffsverkäufe mit Claude zu identifizieren, können wir die KI-Inferenz auffordern. Richten Sie zunächst eine virtuelle Python-Umgebung ein:

mkdir ai_prompting && cd ai_prompting
python3 -m venv venv
source venv/bin/activate
pip install anthropic
touch iab_identifier.py

Öffnen Sie iab_identifier.py und fügen Sie den folgenden Code ein:

from anthropic import Anthropic
import json


def claude_classify(
    api_key: str,
    model_name: str,
    post_content: str,
    max_tokens: int = 100,
    temperature: float = 0.1
) -> dict:
    """
    Classify a post using Claude (e.g., Sonnet) to determine if it discusses selling initial access,
    unrelated items, or warnings/complaints.

    Args:
        api_key (str): Anthropic API key.
        model_name (str): Claude model name (e.g., 'claude-3-5-sonnet-20241022').
        post_content (str): Post text to classify.
        max_tokens (int, optional): Max output tokens. Defaults to 100.
        temperature (float, optional): Sampling temperature. Defaults to 0.1.

    Returns:
        dict: JSON with classification, scores, and error (if any).
    """
    client = Anthropic(api_key=api_key)
    prompt_template = """
    Does this post discuss selling initial access to a company (e.g., RDP, VPN, admin access), selling unrelated items (e.g., accounts, tools), or warnings/complaints? Classify it as:
- Positive Posts: direct sale of unauthorized access to a company, this usually include the target's name.
- Neutral Posts: general offers for tools, exploits or malware without naming a specific target.
- Negative Posts: off-topic or unrelated services such as hosting, spam tools or generic VPS sales.

The content must be specifically about selling access to a company or business whose name is mentioned in the post. 

Return **only** a JSON object with:
- `classification`: "Positive", "Neutral", or "Negative".
- `scores`: Probabilities for `positive`, `neutral`, `negative` (summing to 1).

Wrap the JSON in ```json
{
  ...
}
``` to ensure proper formatting. Do not include any reasoning or extra text.

Post:
```markdown
{{POST}}
``` 
"""
    prompt = prompt_template.replace("{{POST}}", post_content)

    try:
        message = client.messages.create(
            model=model_name,
            max_tokens=max_tokens,
            temperature=temperature,
            messages=[
                {"role": "user", "content": prompt}
            ]
        )
        content = message.content[0].text
        # Extract JSON between ```json and ```
        start = content.index("```json\n") + 7
        end = content.index("\n```", start)
        result = json.loads(content[start:end])
        return result
    except Exception as e:
        return {"error": f"Failed to classify post: {str(e)}", "classification": None, "scores": None}


# Example usage 
if __name__ == "__main__":
    API_KEY = "" 
    MODEL_NAME = "claude-3-7-sonnet-20250219"

    sample_post = """Selling access to Horizon Logistics\nRevenue: $1.2B\nAccess: RDP with DA\nPrice: 0.8 BTC\nDM for details"""

    result = claude_classify(
        api_key=API_KEY,
        model_name=MODEL_NAME,
        post_content=sample_post,
        max_tokens=100,
        temperature=0.1
    )
    print("API response:")
    print(json.dumps(result, indent=4))

Dies wird als Funktions-Docstring bezeichnet:

    """
    Classify a post using Claude (e.g., Sonnet) to determine if it discusses selling initial access,
    unrelated items, or warnings/complaints.

    Args:
        api_key (str): Anthropic API key.
        model_name (str): Claude model name (e.g., 'claude-3-5-sonnet-20241022').
        post_content (str): Post text to classify.
        max_tokens (int, optional): Max output tokens. Defaults to 100.
        temperature (float, optional): Sampling temperature. Defaults to 0.1.

    Returns:
        dict: JSON with classification, scores, and error (if any).
    """

Docstrings werden verwendet, um die Funktionsweise von Code zu dokumentieren.

Dieser Code kann auch als Modul verwendet werden. Sie können beispielsweise claude_classify aus iab_identifier.py importieren, die erforderlichen Argumente übergeben und es verwenden.

Hier definieren wir eine bedingte Anweisung, if __name__ == „__main__“:, um zu überprüfen, ob das Programm als Skript ausgeführt wird. Ist dies der Fall, wird der Code innerhalb des bedingten Blocks ausgeführt.

Um dies zu verwenden, setzen Sie Ihren API-Schlüssel in der Variable API_KEY und geben Sie den Modellnamen in der Variable MODEL_NAME an. Für sample_post können Sie entweder einen einzelnen Beitrag oder eine Liste von Beiträgen angeben und diese durchlaufen.

Nachfolgend finden Sie ein Beispiel mit drei Beiträgen wie „positive“, „neutral“ und „negative“, die aus dem folgenden Datensatz stammen:

https://github.com/0xHamy/minimal_scraper/blob/main/datasets/base.csv

# Example usage 
if __name__ == "__main__":
    API_KEY = "sk-ant-apixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" 
    MODEL_NAME = "claude-3-5-sonnet-20241022"

    sample_posts = ["Selling access to Capital Freight Co. (Texas-based logistics) \nRevenue: ~$900M \nAccess: Full RDP, domain admin via svc_x backup creds \nExtras: Internal invoices, mapped drives, Outlook web creds \nEDR: minimal – Defender only \nPrice: 0.6 BTC firm, BTC only, DM me quick", 
	"Private obfuscator for Python tools \nRandom junk + encryption \nFUD for most stealers \n0.012 BTC",
	"Selling 150k+ Netflix logins from Latin America \nMost accounts active, pulled from private stealer logs \nNo warranty – buy at your own risk \n0.02 BTC per 1k – discounts on bulk \nDM for sample"
	]

    for idx, post in enumerate(sample_posts, start=1):
        result = claude_classify(
            api_key=API_KEY,
            model_name=MODEL_NAME,
            post_content=post,
            max_tokens=100,
            temperature=0.1
        )
        print(f"API response for post number {idx}:\n")
        print(json.dumps(result, indent=4))
        print(60 * '*')

Hier ist die Ausgabe:

-> % python3 iab_identifier.py
API response for post number 1:

{
    "classification": "Positive",
    "scores": {
        "positive": 0.95,
        "neutral": 0.04,
        "negative": 0.01
    }
}
************************************************************
API response for post number 2:

{
    "classification": "Neutral",
    "scores": {
        "positive": 0.05,
        "neutral": 0.85,
        "negative": 0.1
    }
}
************************************************************
API response for post number 3:

{
    "classification": "Negative",
    "scores": {
        "positive": 0.05,
        "neutral": 0.15,
        "negative": 0.8
    }
}
************************************************************

Dieser Ansatz ist sehr effektiv und führt die Aufgabe schnell aus. APIs können zwar gelegentlich „neutrale“ und „negative“ Beiträge falsch klassifizieren, aber sie identifizieren „positive“ Beiträge durchweg korrekt, was entscheidend ist. Allgemeine Cyberkriminalität fällt oft in die Kategorien „negativ“ oder „neutral“, aber Erstzugriffsverkäufe lassen sich immer zuverlässig unterscheiden.