Guardrail: mask API keys and passwords

Guardrail that masks API keys, tokens, passwords, private keys and connection strings before a text, file or export is sent to an AI. Rules, 14 test cases, code.

Rules

Mask before sending to the AI any secret that gives access to an account or a service:
- API keys (OpenAI, Anthropic, Mistral, Stripe, AWS…) and access tokens (GitHub, JWT);
- passwords written in clear text (password=…, pwd: …);
- private keys (-----BEGIN … PRIVATE KEY-----);
- credentials inside a URL (postgres://user:password@host).
Let through: placeholder values (YOUR_API_KEY, xxx, <key>), URLs without credentials, order or commit IDs, text about passwords that contains none.
Apply it before pasting a .env file, a database export or logs into an assistant.

Test cases

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

def mask_secrets(text: str) -> tuple[str, bool]:
    """Replaces secrets with [type masked]; returns the text and True if anything was masked."""
    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} masked]"
        text = re.sub(pattern, repl, text)
    return text, found

Identifier

contextetech--mask-secrets-api-keys

File

mask-secrets-api-keys.guardrail.json

Format

JSON (application/json)

Size

2,474 bytes (2.4 KB)

Encoding

UTF-8

Estimated tokens

≈ 685

Commercial use

Allowed

Personal data

None

Version

1.0

Published on

October 10, 2026 at 4:24 AM

Updated on

October 16, 2026 at 11:20 PM

Storage

in database

Estimated cost

Input tokens per call

≈ 1,031

Input cost only, excluding the model's answer. Providers' public standard prices (Mistral AI, DeepSeek, OpenAI, Anthropic) converted from USD to euros at the ECB rate of October 13, 2026. Estimate: 1 token ≈ 3.6 characters.

mask-secrets-api-keys.guardrail.json

{
  "format": "contextetech/guardrail/v1",
  "id": "contextetech/mask-secrets-api-keys",
  "description": "Guardrail that masks API keys, tokens, passwords, private keys and connection strings before a text, file or export is sent to an AI. Rules, 14 test cases, code.",
  "license": "MIT",
  "language": "en",
  "type": "other",
  "action": "mask",
  "rules": "Mask before sending to the AI any secret that gives access to an account or a service:\n- API keys (OpenAI, Anthropic, Mistral, Stripe, AWS…) and access tokens (GitHub, JWT);\n- passwords written in clear text (password=…, pwd: …);\n- private keys (-----BEGIN … PRIVATE KEY-----);\n- credentials inside a URL (postgres://user:password@host).\nLet through: placeholder values (YOUR_API_KEY, xxx, <key>), URLs without credentials, order or commit IDs, text about passwords that contains none.\nApply it before pasting a .env file, a database export or logs into an assistant.",
  "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": "password = Sunshine2026!",
      "expected": "block"
    },
    {
      "input": "Passwords must be at least 12 characters long.",
      "expected": "allow"
    },
    {
      "input": "Replace YOUR_API_KEY with the key from your account.",
      "expected": "allow"
    },
    {
      "input": "The docs are at https://docs.example.com/api.",
      "expected": "allow"
    },
    {
      "input": "Commit a1b2c3d fixes the login bug.",
      "expected": "allow"
    },
    {
      "input": "Order #2026-10-458712 has shipped.",
      "expected": "allow"
    },
    {
      "input": "Sign in with your usual account.",
      "expected": "allow"
    }
  ]
}

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

def mask_secrets(text: str) -> tuple[str, bool]:
    """Replaces secrets with [type masked]; returns the text and True if anything was masked."""
    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} masked]"
        text = re.sub(pattern, repl, text)
    return text, found