Comprehensive guide to AI security and privacy for individuals and businesses. Learn data protection, API key security, local vs cloud AI, GDPR compliance, and best practices. Includes security checklists and tools.
AI tools are powerful, but they come with serious security and privacy risks. Every prompt you send, every document you upload, every API call you make—all create potential vulnerabilities.
This guide covers everything you need to know about AI security and privacy: from protecting API keys to choosing between local and cloud AI, implementing GDPR compliance, and building secure AI systems.
Data Exposure Risks:
Real-World Examples:
What AI Providers Can See:
Data Retention Policies:
| Provider | Data Retention | Training Use | Opt-Out Available |
|----------|---------------|--------------|-------------------|
| OpenAI | 30 days (API), indefinite (ChatGPT) | No (API), Yes (ChatGPT) | Yes (API only) |
| Anthropic | No training use | No | N/A |
| Google | Varies by product | Depends on settings | Yes |
| Local Models | You control | Never | N/A |
Common scenario:
```python
import openai
openai.api_key = "sk-proj-abc123..." # Committed to GitHub
```
Bots scan GitHub for exposed keys 24/7. Average time from commit to exploitation: 4 minutes.
#### Method 1: Environment Variables (Basic)
```bash
OPENAI_API_KEY=sk-proj-abc123...
ANTHROPIC_API_KEY=sk-ant-xyz789...
```
```python
import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')
if not api_key:
raise ValueError("API key not found in environment")
```
Add to .gitignore:
```
.env
.env.local
*.key
secrets/
```
#### Method 2: Secret Management Services (Production)
AWS Secrets Manager:
```python
import boto3
from botocore.exceptions import ClientError
def get_secret(secret_name: str) -> str:
"""Retrieve API key from AWS Secrets Manager"""
client = boto3.client('secretsmanager', region_name='us-east-1')
try:
response = client.get_secret_value(SecretId=secret_name)
return response['SecretString']
except ClientError as e:
raise Exception(f"Failed to retrieve secret: {e}")
api_key = get_secret('openai-api-key')
```
HashiCorp Vault:
```python
import hvac
def get_vault_secret(path: str) -> str:
"""Retrieve secret from Vault"""
client = hvac.Client(url='http://localhost:8200')
client.token = os.getenv('VAULT_TOKEN')
secret = client.secrets.kv.v2.read_secret_version(path=path)
return secret['data']['data']['api_key']
api_key = get_vault_secret('ai/openai')
```
#### Method 3: Key Rotation
```python
import os
from datetime import datetime, timedelta
import json
class RotatingAPIKey:
"""Automatically rotates API keys"""
def __init__(self, key_file: str = '.keys.json'):
self.key_file = key_file
self.load_keys()
def load_keys(self):
"""Load keys from encrypted file"""
if os.path.exists(self.key_file):
with open(self.key_file, 'r') as f:
data = json.load(f)
self.keys = data['keys']
self.current_index = data['current_index']
self.last_rotation = datetime.fromisoformat(data['last_rotation'])
else:
raise ValueError("Key file not found")
def get_key(self) -> str:
"""Get current key, rotate if needed"""
# Rotate every 30 days
if datetime.now() - self.last_rotation > timedelta(days=30):
self.rotate()
return self.keys[self.current_index]
def rotate(self):
"""Rotate to next key"""
self.current_index = (self.current_index + 1) % len(self.keys)
self.last_rotation = datetime.now()
self.save_keys()
# Notify admin
send_notification(f"API key rotated to key #{self.current_index}")
def save_keys(self):
"""Save key state"""
data = {
'keys': self.keys,
'current_index': self.current_index,
'last_rotation': self.last_rotation.isoformat()
}
with open(self.key_file, 'w') as f:
json.dump(data, f)
key_manager = RotatingAPIKey()
api_key = key_manager.get_key()
```
Set up usage alerts:
```python
import openai
from datetime import datetime, timedelta
def check_api_usage():
"""Monitor API usage and alert on anomalies"""
# Get usage from OpenAI dashboard API
usage = get_openai_usage() # Implement based on provider
# Alert thresholds
DAILY_LIMIT = 100.0 # $100/day
HOURLY_LIMIT = 20.0 # $20/hour
if usage['today'] > DAILY_LIMIT:
send_alert(f"⚠️ Daily limit exceeded: ${usage['today']:.2f}")
disable_api_key() # Emergency stop
if usage['last_hour'] > HOURLY_LIMIT:
send_alert(f"⚠️ Unusual activity: ${usage['last_hour']:.2f} in last hour")
import schedule
schedule.every().hour.do(check_api_usage)
```
Use local models when:
Local AI Setup:
```bash
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama2 # 7B model, good for most tasks
ollama pull codellama # Code-specific model
ollama pull mistral # Fast, efficient model
ollama run llama2
```
Python Integration:
```python
from langchain.llms import Ollama
local_llm = Ollama(
model="llama2",
base_url="http://localhost:11434"
)
def process_sensitive_data(patient_record: str) -> str:
"""Process healthcare data without cloud exposure"""
prompt = f"Summarize this patient record: {patient_record}"
return local_llm.predict(prompt)
```
Use cloud models when:
```python
class HybridAI:
"""Routes requests to local or cloud based on sensitivity"""
def __init__(self):
self.local_llm = Ollama(model="llama2")
self.cloud_llm = ChatOpenAI(model="gpt-4-turbo-preview")
def process(self, text: str, sensitive: bool = False) -> str:
"""Route based on data sensitivity"""
if sensitive or self.contains_pii(text):
# Use local model for sensitive data
return self.local_llm.predict(text)
else:
# Use cloud for better quality on non-sensitive data
return self.cloud_llm.predict(text)
def contains_pii(self, text: str) -> bool:
"""Detect personally identifiable information"""
import re
# Check for common PII patterns
patterns = [
r'\b\d{3}-\d{2}-\d{4}\b', # SSN
r'\b\d{16}\b', # Credit card
r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', # Email
r'\b\d{3}-\d{3}-\d{4}\b', # Phone
]
for pattern in patterns:
if re.search(pattern, text):
return True
return False
ai = HybridAI()
result1 = ai.process("Patient John Doe, SSN 123-45-6789...")
result2 = ai.process("What's the weather in San Francisco?")
```
Remove PII before sending to cloud AI:
```python
import re
from typing import Dict
class PIISanitizer:
"""Removes personally identifiable information"""
def __init__(self):
self.patterns = {
'ssn': (r'\b\d{3}-\d{2}-\d{4}\b', '[SSN]'),
'credit_card': (r'\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b', '[CARD]'),
'email': (r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]'),
'phone': (r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[PHONE]'),
'ip_address': (r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b', '[IP]'),
'name': (r'\b[A-Z][a-z]+ [A-Z][a-z]+\b', '[NAME]'), # Simple name detection
}
self.replacements = {}
def sanitize(self, text: str) -> str:
"""Remove PII and store for later restoration"""
sanitized = text
for pii_type, (pattern, replacement) in self.patterns.items():
matches = re.finditer(pattern, sanitized)
for match in matches:
original = match.group()
# Store for potential restoration
self.replacements[replacement] = original
sanitized = sanitized.replace(original, replacement)
return sanitized
def restore(self, text: str) -> str:
"""Restore original PII (if needed)"""
restored = text
for placeholder, original in self.replacements.items():
restored = restored.replace(placeholder, original)
return restored
sanitizer = PIISanitizer()
original = "Contact John Smith at [email protected] or 555-123-4567"
safe_text = sanitizer.sanitize(original)
response = cloud_ai.process(safe_text)
final = sanitizer.restore(response)
```
Encrypt sensitive data before storage:
```python
from cryptography.fernet import Fernet
import os
import json
class SecureStorage:
"""Encrypts data before storing"""
def __init__(self, key_file: str = '.encryption.key'):
self.key_file = key_file
self.key = self.load_or_create_key()
self.cipher = Fernet(self.key)
def load_or_create_key(self) -> bytes:
"""Load existing key or create new one"""
if os.path.exists(self.key_file):
with open(self.key_file, 'rb') as f:
return f.read()
else:
key = Fernet.generate_key()
with open(self.key_file, 'wb') as f:
f.write(key)
os.chmod(self.key_file, 0o600) # Restrict permissions
return key
def encrypt(self, data: str) -> bytes:
"""Encrypt string data"""
return self.cipher.encrypt(data.encode())
def decrypt(self, encrypted_data: bytes) -> str:
"""Decrypt to string"""
return self.cipher.decrypt(encrypted_data).decode()
def save_secure(self, filename: str, data: dict):
"""Save encrypted JSON"""
json_str = json.dumps(data)
encrypted = self.encrypt(json_str)
with open(filename, 'wb') as f:
f.write(encrypted)
def load_secure(self, filename: str) -> dict:
"""Load and decrypt JSON"""
with open(filename, 'rb') as f:
encrypted = f.read()
json_str = self.decrypt(encrypted)
return json.loads(json_str)
storage = SecureStorage()
sensitive_data = {
'api_keys': {'openai': 'sk-...', 'anthropic': 'sk-ant-...'},
'user_data': {'email': '[email protected]'}
}
storage.save_secure('secrets.enc', sensitive_data)
data = storage.load_secure('secrets.enc')
```
```python
from datetime import datetime, timedelta
import sqlite3
import json
class GDPRCompliantAI:
"""AI system with GDPR compliance built-in"""
def __init__(self, db_path: str = 'gdpr_data.db'):
self.db = sqlite3.connect(db_path)
self.setup_database()
def setup_database(self):
"""Create tables for GDPR compliance"""
self.db.execute('''
CREATE TABLE IF NOT EXISTS user_data (
user_id TEXT PRIMARY KEY,
data TEXT,
purpose TEXT,
consent_given BOOLEAN,
consent_date TEXT,
retention_until TEXT
)
''')
self.db.execute('''
CREATE TABLE IF NOT EXISTS processing_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id TEXT,
action TEXT,
timestamp TEXT,
purpose TEXT
)
''')
self.db.commit()
def process_with_consent(self, user_id: str, data: str, purpose: str) -> str:
"""Process data only with valid consent"""
# Check consent
if not self.has_valid_consent(user_id, purpose):
raise PermissionError(f"No valid consent for purpose: {purpose}")
# Log processing
self.log_processing(user_id, 'process', purpose)
# Process with AI (use appropriate model based on sensitivity)
result = self.ai_process(data)
return result
alid_consent(self, user_id: str, purpose: str) -> bool:
"""Check if user has given consent for this purpose"""
cursor = self.db.execute('''
SELECT consent_given, consent_date, retention_until
FROM user_data
WHERE user_id = ? AND purpose = ?
''', (user_id, purpose))
row = cursor.fetchone()
if not row:
return False
consent_given, consent_date, retention_until = row
# Check if consent is still valid
if not consent_given:
return False
if datetime.fromisoformat(retention_until) < datetime.now():
return False
return True
def request_consent(self, user_id: str, purpose: str, retention_days: int = 365):
"""Request and record user consent"""
consent_date = datetime.now().isoformat()
retention_until = (datetime.now() + timedelta(days=retention_days)).isoformat()
self.db.execute('''
INSERT OR REPLACE INTO user_data
(user_id, purpose, consent_given, consent_date, retention_until)
VALUES (?, ?, ?, ?, ?)
''', (user_id, purpose, True, consent_date, retention_until))
self.db.commit()
self.log_processing(user_id, 'consent_given', purpose)
def right_to_access(self, user_id: str) -> dict:
"""GDPR Right to Access: Return all user data"""
cursor = self.db.execute('''
SELECT * FROM user_data WHERE user_id = ?
''', (user_id,))
data = cursor.fetchall()
cursor = self.db.execute('''
SELECT * FROM processing_log WHERE user_id = ?
''', (user_id,))
logs = cursor.fetchall()
return {
'user_data': data,
'processing_history': logs,
'export_date': datetime.now().isoformat()
}
def right_to_erasure(self, user_id: str):
"""GDPR Right to Erasure: Delete all user data"""
self.db.execute('DELETE FROM user_data WHERE user_id = ?', (user_id,))
self.db.execute('DELETE FROM processing_log WHERE user_id = ?', (user_id,))
self.db.commit()
self.log_processing(user_id, 'data_deleted', 'gdpr_erasure')
def auto_delete_expired(self):
"""Automatically delete data past retention period"""
now = datetime.now().isoformat()
cursor = self.db.execute('''
SELECT user_id FROM user_data
WHERE retention_until < ?
''', (now,))
expired_users = [row[0] for row in cursor.fetchall()]
for user_id in expired_users:
self.right_to_erasure(user_id)
return len(expired_users)
def log_processing(self, user_id: str, action: str, purpose: str):
"""Log all data processing for audit trail"""
self.db.execute('''
INSERT INTO processing_log (user_id, action, timestamp, purpose)
VALUES (?, ?, ?, ?)
''', (user_id, action, datetime.now().isoformat(), purpose))
self.db.commit()
gdpr_ai = GDPRCompliantAI()
gdpr_ai.request_consent('user123', 'email_analysis', retention_days=365)
result = gdpr_ai.process_with_consent('user123', 'email content...', 'email_analysis')
user_data = gdpr_ai.right_to_access('user123')
gdpr_ai.right_to_erasure('user123')
import schedule
schedule.every().day.at("02:00").do(gdpr_ai.auto_delete_expired)
```
| Tool | Purpose | Cost |
|------|---------|------|
| git-secrets | Prevent committing secrets | Free |
| TruffleHog | Scan repos for leaked keys | Free |
| Vault | Secret management | Free (OSS) |
| 1Password | Team secret sharing | $8/user/month |
| AWS Secrets Manager | Cloud secret storage | $0.40/secret/month |
| Snyk | Dependency scanning | Free tier available |
| OWASP ZAP | Security testing | Free |
```bash
brew install git-secrets # macOS
apt-get install git-secrets # Linux
cd your-repo
git secrets --install
git secrets --register-aws
git secrets --add 'sk-[a-zA-Z0-9]{48}' # OpenAI keys
git secrets --add 'sk-ant-[a-zA-Z0-9-]{95}' # Anthropic keys
git secrets --scan-history
```
Immediate actions (within 5 minutes):
Follow-up (within 24 hours):
Prevention:
| Incident Type | Average Cost | Recovery Time |
|---------------|--------------|---------------|
| Exposed API key | $500-$10,000 | 1-7 days |
| Data breach | $50,000-$500,000 | 30-90 days |
| GDPR violation | €20M or 4% revenue | Ongoing |
| Reputation damage | Immeasurable | Months-years |
Prevention is 100x cheaper than recovery.
The OpenClaw Team specializes in secure AI infrastructure. We help organizations implement AI systems that are both powerful and secure, with GDPR compliance built-in.
Need a security audit? Get a free AI security assessment to identify vulnerabilities in your AI systems.
---
Secure your AI systems today. Start with the checklists above, or contact us for professional security consulting.
As AI moves to the edge, security challenges multiply. Learn how to protect your edge AI deployments from model theft, adversarial attacks, and data breaches with proven strategies and practical frameworks.
Complete security checklist for AI implementations. Identify vulnerabilities, ensure compliance, and protect sensitive data in your AI systems."author: "10xclaw Team
Get your free AI audit and discover optimization opportunities.
START FREE AUDIT