Zabezpieczenie: maskowanie kluczy API i haseł

Zabezpieczenie, które maskuje klucze API, tokeny, hasła, klucze prywatne i ciągi połączeń, zanim tekst, plik lub eksport trafi do AI. Reguły, 14 przypadków testowych, kod.

Reguły

Przed wysłaniem do AI zamaskuj każdy sekret, który daje dostęp do konta lub usługi:
- klucze API (OpenAI, Anthropic, Mistral, Stripe, AWS…) i tokeny dostępu (GitHub, JWT);
- hasła zapisane jawnym tekstem (haslo=…, password: …);
- klucze prywatne (-----BEGIN … PRIVATE KEY-----);
- dane logowania w adresie (postgres://uzytkownik:haslo@serwer).
Przepuszczaj: wartości przykładowe (TWOJ_KLUCZ_API, xxx, <klucz>), adresy bez danych logowania, numery zamówień lub commitów, tekst o hasłach, który żadnego nie zawiera.
Stosuj przed wklejeniem pliku .env, eksportu bazy danych lub logów do asystenta.

Przypadki testowe

Kod

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|haslo)\s*[:=]\s*[\"']?[^\s\"']{6,}",
}
PLACEHOLDERS = ("xxx", "...", "<", "your", "twoj_", "example_value")

def mask_secrets(text: str) -> tuple[str, bool]:
    """Zastępuje sekrety przez [typ zamaskowany]; zwraca tekst i True, jeśli coś zamaskowano."""
    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} zamaskowany]"
        text = re.sub(pattern, repl, text)
    return text, found

Identyfikator

contextetech--maskowanie-sekretow-kluczy-api

Plik

maskowanie-sekretow-kluczy-api.guardrail.json

Format

JSON (application/json)

Rozmiar

2566 bajtów (2,5 KB)

Kodowanie

UTF-8

Szacowane tokeny

≈ 701

Użycie komercyjne

Dozwolone

Dane osobowe

Brak

Wersja

1.0

Opublikowano

10 października 2026 04:24

Zaktualizowano

16 października 2026 23:20

Przechowywanie

w bazie danych

Szacowany koszt

Tokeny wejściowe na wywołanie

≈ 1044

Tylko koszt wejścia, bez odpowiedzi modelu. Publiczne standardowe ceny dostawców (Mistral AI, DeepSeek, OpenAI, Anthropic) przeliczone z USD na euro po kursie EBC z 13 października 2026. Szacunek: 1 token ≈ 3,6 znaku.

maskowanie-sekretow-kluczy-api.guardrail.json

{
  "format": "contextetech/guardrail/v1",
  "id": "contextetech/maskowanie-sekretow-kluczy-api",
  "description": "Zabezpieczenie, które maskuje klucze API, tokeny, hasła, klucze prywatne i ciągi połączeń, zanim tekst, plik lub eksport trafi do AI. Reguły, 14 przypadków testowych, kod.",
  "license": "MIT",
  "language": "pl",
  "type": "other",
  "action": "mask",
  "rules": "Przed wysłaniem do AI zamaskuj każdy sekret, który daje dostęp do konta lub usługi:\n- klucze API (OpenAI, Anthropic, Mistral, Stripe, AWS…) i tokeny dostępu (GitHub, JWT);\n- hasła zapisane jawnym tekstem (haslo=…, password: …);\n- klucze prywatne (-----BEGIN … PRIVATE KEY-----);\n- dane logowania w adresie (postgres://uzytkownik:haslo@serwer).\nPrzepuszczaj: wartości przykładowe (TWOJ_KLUCZ_API, xxx, <klucz>), adresy bez danych logowania, numery zamówień lub commitów, tekst o hasłach, który żadnego nie zawiera.\nStosuj przed wklejeniem pliku .env, eksportu bazy danych lub logów do asystenta.",
  "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": "haslo = Lato2026!",
      "expected": "block"
    },
    {
      "input": "Hasło musi mieć co najmniej 12 znaków.",
      "expected": "allow"
    },
    {
      "input": "Zastąp TWOJ_KLUCZ_API kluczem ze swojego konta.",
      "expected": "allow"
    },
    {
      "input": "Dokumentacja jest pod adresem https://docs.przyklad.pl/api.",
      "expected": "allow"
    },
    {
      "input": "Commit a1b2c3d naprawia błąd logowania.",
      "expected": "allow"
    },
    {
      "input": "Zamówienie nr 2026-10-458712 zostało wysłane.",
      "expected": "allow"
    },
    {
      "input": "Zaloguj się na swoje zwykłe konto.",
      "expected": "allow"
    }
  ]
}

Sprawdź tekst (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|haslo)\s*[:=]\s*[\"']?[^\s\"']{6,}",
}
PLACEHOLDERS = ("xxx", "...", "<", "your", "twoj_", "example_value")

def mask_secrets(text: str) -> tuple[str, bool]:
    """Zastępuje sekrety przez [typ zamaskowany]; zwraca tekst i True, jeśli coś zamaskowano."""
    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} zamaskowany]"
        text = re.sub(pattern, repl, text)
    return text, found