Cryptex-AI

The Problem

AI/LLM applications face an impossible choice: - Expose secrets to AI → Security nightmare 🔓 - Hide secrets completely → Broken functionality 💥

The Solution

Cryptex-ai provides true temporal isolation - AI services receive safe placeholders while your functions use real secrets through automatic call interception.

```python from cryptexai import protectsecrets

Works immediately - no config files required!

@protectsecrets(["openaikey"]) async def aitool(prompt: str, apikey: str) -> str: # Function receives: real API key for processing # AI service receives: {{OPENAIAPIKEY}} (intercepted) import openai return await openai.chat.completions.create( model="gpt-4", messages=[{"role": "user", "content": prompt}], apikey=apikey # Real key for function, placeholder to AI ) ```

One decorator line = complete temporal isolation ✨

🚀 Key Features

• 🔧 Zero Configuration: Works immediately, no setup required
• ⚡ Built-in Patterns: OpenAI, Anthropic, GitHub, file paths, databases
• 🛡️ Security First: Zero dependencies, no config files, no parsing vulnerabilities
• 🚄 High Performance: <5ms sanitization, <10ms resolution
• 🔗 Universal: Works with any Python function - FastMCP, FastAPI, Django, Flask, etc.
• 🎯 True Isolation: Monkey-patches AI libraries to intercept actual calls
• 📝 Simple API: 95% of users need zero config, 5% get simple registration

📦 Installation

Using pip (recommended)

bash pip install cryptex-ai

Using uv (modern Python package manager)

bash uv add cryptex-ai

Requirements: Python 3.11+ • Zero dependencies

⚡ Quick Start

Zero-Config Protection (95% of users)

Cryptex works immediately with built-in patterns for common secrets:

```python from cryptexai import protectsecrets

Protect OpenAI API calls

@protectsecrets(["openaikey"]) async def aicompletion(prompt: str, apikey: str) -> str: # AI context: "{{OPENAIAPIKEY}}" # Function execution: "sk-real-key-here..." return await openai.chat.completions.create( model="gpt-4", messages=[{"role": "user", "content": prompt}], apikey=apikey )

Protect file operations

@protectsecrets(["filepath"]) async def readfile(filepath: str) -> str: # AI context: "/{USERHOME}/.../{filename}" # Function execution: "/Users/alice/secrets/document.txt" with open(filepath, 'r') as f: return f.read()

Protect multiple secrets at once

@protectsecrets(["githubtoken", "filepath", "databaseurl"]) async def processdata(repopath: str, token: str, dburl: str) -> dict: # All secrets automatically protected data = await fetchfromgithub(repopath, token) result = await processaidata(data) await savetodatabase(result, db_url) return result ```

Convenience Decorators

For common patterns, use convenience decorators:

```python from cryptexai import protectapikeys, protectfiles, protect_all

@protectapikeys() # Protects OpenAI + Anthropic keys async def aifunction(openaikey: str, anthropic_key: str) -> str: # Both API keys automatically protected pass

@protectfiles() # Protects file system paths async def filefunction(file_path: str) -> str: # File paths automatically protected pass

@protectall() # Protects all built-in patterns async def comprehensivefunction(apikey: str, filepath: str, db_url: str) -> str: # Everything automatically protected pass ```

🛠️ Built-in Patterns

Cryptex includes battle-tested patterns that handle 95% of real-world usage:

| Pattern | Detects | Example | Placeholder | |---------|---------|---------|-------------| | openai_key | OpenAI API keys | sk-... | {{OPENAI_API_KEY}} | | anthropic_key | Anthropic API keys | sk-ant-... | {{ANTHROPIC_API_KEY}} | | github_token | GitHub tokens | ghp_... | {{GITHUB_TOKEN}} | | file_path | User file paths | /Users/..., /home/... | /{USER_HOME}/.../{filename} | | database_url | Database URLs | postgres://..., mysql://... | {{DATABASE_URL}} |

No configuration required - patterns work out of the box! 📦

🔧 Custom Patterns (Advanced - 5% of users)

For edge cases, register custom patterns programmatically:

```python from cryptexai import registerpattern, protect_secrets

Register custom pattern once

registerpattern( name="slacktoken", regex=r"xoxb-[0-9-a-zA-Z]{51}", placeholder="{{SLACK_TOKEN}}", description="Slack bot token" )

Use immediately in decorators

@protectsecrets(["slacktoken"]) async def slackintegration(token: str) -> str: return await slackapi_call(token)

Bulk registration

from cryptexai import registerpatterns registerpatterns([ ("discord_token", r"[MNO][A-Za-z\d]{23}.[\w-]{6}.[\w-]{27}", "{{DISCORDTOKEN}}"), ("customkey", r"myapp-[a-f0-9]{32}", "{{CUSTOMKEY}}") ]) ```

🏗️ Framework Examples

FastMCP Tools

```python from fastmcp import FastMCPServer from cryptexai import protectsecrets

server = FastMCPServer("my-server")

@server.tool() @protectsecrets(["openaikey"]) async def aitool(prompt: str, apikey: str) -> str: # MCP sees: aitool("Hello", "{{OPENAIAPIKEY}}") # Tool gets: real API key for execution return await openaicall(prompt, api_key) ```

FastAPI Endpoints

```python from fastapi import FastAPI from cryptexai import protectsecrets

app = FastAPI()

@app.post("/api/process") @protectsecrets(["databaseurl", "openaikey"]) async def processendpoint(data: dict, dburl: str, apikey: str): # Request/response logs show placeholders # Endpoint gets real secrets for execution return await processwithsecrets(data, dburl, apikey) ```

Django Views

```python from django.http import JsonResponse from cryptexai import protectsecrets

@protectsecrets(["databaseurl"]) async def djangoview(request, dburl: str): # Django logs show placeholders # View gets real database URL return JsonResponse(await querydatabase(dburl)) ```

Any Python Function

```python from cryptexai import protectsecrets

@protectsecrets(["githubtoken"]) def syncfunction(token: str) -> str: # Works with sync functions too! return githubapi_call(token)

@protectsecrets(["openaikey"]) async def asyncfunction(apikey: str) -> str: # And async functions return await openaicall(apikey) ```

⚡ Performance

Cryptex is designed for production workloads:

| Metric | Performance | Context | |--------|-------------|---------| | Sanitization | <5ms | 1KB payloads | | **Resolution** | <10ms | 10 placeholders | | **Memory Overhead** | <5% | vs unprotected apps | | **Startup Time** | 0ms | Zero dependencies | | **Throughput** | >1000 req/s | Typical workloads |

Benchmarked on MacBook Pro M1, Python 3.11

🏗️ Architecture

Three-Phase Temporal Isolation

┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐ │ Raw Secrets │ │ AI Processing │ │ Tool Execution │ │ │ │ │ │ │ │ sk-abc123... │───▶│ {{OPENAI_KEY}} │───▶│ sk-abc123... │ │ /Users/alice/ │ │ /{USER_HOME}/ │ │ /Users/alice/ │ │ ghp_xyz789... │ │ {{GITHUB_TOKEN}} │ │ ghp_xyz789... │ └─────────────────┘ └──────────────────┘ └─────────────────┘ Phase 1: Phase 2: Phase 3: Sanitization AI sees safe Resolution for for AI context placeholders tool execution

Zero-Config Philosophy

• 🚫 No Attack Surface: No config files to inject, no parsing to exploit
• ⚡ Lightning Fast: Zero file I/O, zero parsing overhead
• 🎯 Decorator Focused: Lightweight, predictable, zero dependencies
• 👨‍💻 Developer Friendly: Works immediately, no setup friction
• 🔒 Security First: Configuration in version-controlled code only

📚 Examples

Explore comprehensive examples in the examples/ directory:

• Basic Usage: Zero-config protection patterns
• FastAPI Integration: Web API protection
• Real World Usage: Complex multi-pattern scenarios

Run examples locally:

```bash git clone https://github.com/AnthemFlynn/cryptex-ai.git cd cryptex-ai

See working temporal isolation

python simplelivetest.py

Compare protected vs unprotected

python comparison_test.py

Run basic examples

python examples/basic_usage.py ```

🛡️ Security

Cryptex follows security-first principles:

• Zero Dependencies: No external packages, no supply chain attacks
• Zero Config Files: No TOML parsing, no injection attacks
• Minimal Attack Surface: No file I/O, pure Python standard library
• Secure by Default: Built-in patterns tested against real-world secrets
• Audit Trail: Full temporal isolation with context tracking
• Pattern Validation: Runtime regex validation and comprehensive error handling

Security Policy: See SECURITY.md for vulnerability reporting.

🧪 Testing

Using pip

```bash

Install dependencies

pip install -e ".[dev]"

Run test suite

make test

Run with coverage

make test-coverage

Performance benchmarks

make test-performance

Security tests

make test-security ```

Using uv

```bash

Install dependencies

uv sync --dev

Run test suite

uv run make test

Run with coverage

uv run make test-coverage

Performance benchmarks

uv run make test-performance

Security tests

uv run make test-security ```

🤝 Contributing

We welcome contributions! Cryptex follows a zero-config philosophy - keep it simple.

Quick Development Setup

```bash

Install uv first (if not already installed)

curl -LsSf https://astral.sh/uv/install.sh | sh

Clone and set up the project

git clone https://github.com/AnthemFlynn/cryptex-ai.git cd cryptex-ai make dev-setup # Creates venv and installs dependencies with uv make test # Run test suite make lint # Code quality checks make format # Code formatting ```

Development Guidelines

• Zero-Config First: No configuration files in middleware libraries
• Security First: Every change requires security review
• Performance Matters: <5ms sanitization, <10ms resolution
• Test Everything: Every bug gets a test, every feature gets tests
• SOLID Principles: Clean architecture and abstractions

See CONTRIBUTING.md for detailed guidelines.

📈 Roadmap

• v0.3.1 ✅: Repository migration, documentation site, CI/CD improvements
• v0.4.0: Enhanced pattern validation and error reporting
• v0.5.0: Advanced caching and performance optimizations
• v0.6.0: Plugin system for custom secret sources
• v1.0.0: Production hardening and stability guarantees

📜 License

MIT License - see LICENSE file for details.

🙏 Acknowledgments

• FastMCP Community: For excellent MCP server patterns
• FastAPI: For inspiring clean API design
• Python Community: For async/await and type system excellence
• Security Researchers: For temporal isolation concepts