Schutzregel: API-Schlüssel und Passwörter maskieren

Schutzregel, die API-Schlüssel, Tokens, Passwörter, private Schlüssel und Verbindungszeichenfolgen maskiert, bevor ein Text, eine Datei oder ein Export an eine KI geht. Regeln, 14 Testfälle, Code.

Regeln

Vor dem Senden an die KI jedes Geheimnis maskieren, das Zugang zu einem Konto oder Dienst gibt:
- API-Schlüssel (OpenAI, Anthropic, Mistral, Stripe, AWS…) und Zugriffstokens (GitHub, JWT);
- Passwörter im Klartext (passwort=…, password: …);
- private Schlüssel (-----BEGIN … PRIVATE KEY-----);
- Zugangsdaten in einer Adresse (postgres://nutzer:passwort@server).
Durchlassen: Platzhalter (IHR_API_SCHLUESSEL, xxx, <schlüssel>), Adressen ohne Zugangsdaten, Bestell- oder Commit-Nummern, Text über Passwörter ohne ein Passwort.
Anwenden, bevor eine .env-Datei, ein Datenbankexport oder Logs in einen Assistenten kopiert werden.

Testfälle

Code

import re

PATTERNS = {
    "private_key": r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----",
    "aws_key": r"\bAKIA[0-9A-Z]{16}\b",
    "github_token": r"\bgh[pousr]_[A-Za-z0-9]{36,}\b",
    "llm_api_key": r"\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}\b",
    "stripe_key": r"\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b",
    "jwt": r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b",
    "url_credentials": r"\b[a-z][a-z0-9+.-]*://[^\s:/@]+:[^\s@/]+@",
    "password_assignment": r"(?i)\b(?:password|passwd|pwd|secret|api_?key|token|passwort|kennwort)\s*[:=]\s*[\"']?[^\s\"']{6,}",
}
PLACEHOLDERS = ("xxx", "...", "<", "your", "ihr_", "example_value")

def mask_secrets(text: str) -> tuple[str, bool]:
    """Ersetzt Geheimnisse durch [Typ maskiert]; gibt den Text und True zurück, wenn etwas maskiert wurde."""
    found = False
    for name, pattern in PATTERNS.items():
        def repl(m):
            nonlocal found
            if any(p in m.group(0).lower() for p in PLACEHOLDERS):
                return m.group(0)
            found = True
            return f"[{name} maskiert]"
        text = re.sub(pattern, repl, text)
    return text, found

Kennung

contextetech--geheimnisse-api-schluessel-maskieren

Datei

geheimnisse-api-schluessel-maskieren.guardrail.json

Format

JSON (application/json)

Größe

2.651 Bytes (2,6 KB)

Kodierung

UTF-8

Geschätzte Tokens

≈ 731

Kommerzielle Nutzung

Erlaubt

Personenbezogene Daten

Keine

Version

1.0

Veröffentlicht am

10. Oktober 2026 um 04:24

Aktualisiert am

16. Oktober 2026 um 23:20

Speicherung

in der Datenbank

Geschätzte Kosten

Eingabe-Tokens pro Aufruf

≈ 1.072

Nur Eingabekosten, ohne die Antwort des Modells. Öffentliche Standardpreise der Anbieter (Mistral AI, DeepSeek, OpenAI, Anthropic) von USD in Euro umgerechnet zum EZB-Kurs vom 13. Oktober 2026. Schätzung: 1 Token ≈ 3,6 Zeichen.

geheimnisse-api-schluessel-maskieren.guardrail.json

{
  "format": "contextetech/guardrail/v1",
  "id": "contextetech/geheimnisse-api-schluessel-maskieren",
  "description": "Schutzregel, die API-Schlüssel, Tokens, Passwörter, private Schlüssel und Verbindungszeichenfolgen maskiert, bevor ein Text, eine Datei oder ein Export an eine KI geht. Regeln, 14 Testfälle, Code.",
  "license": "MIT",
  "language": "de",
  "type": "other",
  "action": "mask",
  "rules": "Vor dem Senden an die KI jedes Geheimnis maskieren, das Zugang zu einem Konto oder Dienst gibt:\n- API-Schlüssel (OpenAI, Anthropic, Mistral, Stripe, AWS…) und Zugriffstokens (GitHub, JWT);\n- Passwörter im Klartext (passwort=…, password: …);\n- private Schlüssel (-----BEGIN … PRIVATE KEY-----);\n- Zugangsdaten in einer Adresse (postgres://nutzer:passwort@server).\nDurchlassen: Platzhalter (IHR_API_SCHLUESSEL, xxx, <schlüssel>), Adressen ohne Zugangsdaten, Bestell- oder Commit-Nummern, Text über Passwörter ohne ein Passwort.\nAnwenden, bevor eine .env-Datei, ein Datenbankexport oder Logs in einen Assistenten kopiert werden.",
  "cases": [
    {
      "input": "AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE",
      "expected": "block"
    },
    {
      "input": "token: ghp_000000000000000000000000000000000000",
      "expected": "block"
    },
    {
      "input": "ANTHROPIC_API_KEY=sk-ant-00000000000000000000000000000000",
      "expected": "block"
    },
    {
      "input": "STRIPE_SECRET=sk_live_0000000000000000000000",
      "expected": "block"
    },
    {
      "input": "DATABASE_URL=postgres://admin:S3cretPass@db.internal:5432/app",
      "expected": "block"
    },
    {
      "input": "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA0000000000000000\n-----END RSA PRIVATE KEY-----",
      "expected": "block"
    },
    {
      "input": "Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIwMDAwMDAifQ.0000000000000000000000",
      "expected": "block"
    },
    {
      "input": "passwort = Sommer2026!",
      "expected": "block"
    },
    {
      "input": "Das Passwort muss mindestens 12 Zeichen lang sein.",
      "expected": "allow"
    },
    {
      "input": "Ersetzen Sie IHR_API_SCHLUESSEL durch den Schlüssel Ihres Kontos.",
      "expected": "allow"
    },
    {
      "input": "Die Dokumentation steht unter https://docs.beispiel.de/api.",
      "expected": "allow"
    },
    {
      "input": "Commit a1b2c3d behebt den Anmeldefehler.",
      "expected": "allow"
    },
    {
      "input": "Bestellung Nr. 2026-10-458712 wurde versandt.",
      "expected": "allow"
    },
    {
      "input": "Melden Sie sich mit Ihrem üblichen Konto an.",
      "expected": "allow"
    }
  ]
}

Text prüfen (Python)

import re

PATTERNS = {
    "private_key": r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----",
    "aws_key": r"\bAKIA[0-9A-Z]{16}\b",
    "github_token": r"\bgh[pousr]_[A-Za-z0-9]{36,}\b",
    "llm_api_key": r"\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}\b",
    "stripe_key": r"\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b",
    "jwt": r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b",
    "url_credentials": r"\b[a-z][a-z0-9+.-]*://[^\s:/@]+:[^\s@/]+@",
    "password_assignment": r"(?i)\b(?:password|passwd|pwd|secret|api_?key|token|passwort|kennwort)\s*[:=]\s*[\"']?[^\s\"']{6,}",
}
PLACEHOLDERS = ("xxx", "...", "<", "your", "ihr_", "example_value")

def mask_secrets(text: str) -> tuple[str, bool]:
    """Ersetzt Geheimnisse durch [Typ maskiert]; gibt den Text und True zurück, wenn etwas maskiert wurde."""
    found = False
    for name, pattern in PATTERNS.items():
        def repl(m):
            nonlocal found
            if any(p in m.group(0).lower() for p in PLACEHOLDERS):
                return m.group(0)
            found = True
            return f"[{name} maskiert]"
        text = re.sub(pattern, repl, text)
    return text, found