Sécurité et éthique des avatars IA personnels

# Example of SOUL.md — the "brain" of your avatar
personality:
  tone: "warm but direct"
  humor: "sarcastic, pop culture references"
  values: ["transparency", "privacy", "open source"]

memory:
  - "Nicolas prefers explanations with concrete examples"
  - "Always suggest open-source alternatives"
  - "Avoid anglicisms when a French word exists"

# Check where your data is hosted
# Example: trace the route to your server
traceroute your-avatar.example.com

# Check SSL certificate and host
curl -vI https://your-avatar.example.com 2>&1 | grep -E "subject|issuer|expire"

# Recommended Nginx configuration for your avatar
server {
    listen 443 ssl http2;
    server_name avatar.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/avatar.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/avatar.yourdomain.com/privkey.pem;

    # TLS 1.3 only
    ssl_protocols TLSv1.3;
    ssl_prefer_server_ciphers off;

    # Security headers
    add_header Strict-Transport-Security "max-age=63072000" always;
    add_header X-Content-Type-Options nosniff;
    add_header X-Frame-Options DENY;
}

# Encrypt memory directory with LUKS
sudo cryptsetup luksFormat /dev/sdb1
sudo cryptsetup luksOpen /dev/sdb1 avatar-memory
sudo mkfs.ext4 /dev/mapper/avatar-memory
sudo mount /dev/mapper/avatar-memory /opt/openclaw/memory

# Simpler alternative: file-by-file encryption with age
age-keygen -o key.txt
age --encrypt -R key.txt.pub -o memory.age memory/

# AES-256 encryption of sensitive memory files
from cryptography.fernet import Fernet
import json

# Generate and save the key (ONLY ONCE)
key = Fernet.generate_key()
# Store this key in a secrets manager, NOT on the same server

cipher = Fernet(key)

# Encrypt memory before writing
def encrypt_memory(memory_data: dict) -> bytes:
    json_bytes = json.dumps(memory_data).encode()
    return cipher.encrypt(json_bytes)

# Decrypt on reading
def decrypt_memory(encrypted_data: bytes) -> dict:
    decrypted = cipher.decrypt(encrypted_data)
    return json.loads(decrypted.decode())

# Example usage
memory = {
    "user_preferences": {"tone": "formal", "sensitive_topics": ["health"]},
    "conversation_summary": "Discussion about project X..."
}

encrypted = encrypt_memory(memory)
# Store 'encrypted' on disk — unreadable without the key

# Example authentication middleware for an exposed avatar
import hashlib
import time
from functools import wraps

# Simple rate limiting
request_log = {}

def rate_limit(max_requests=10, window_seconds=60):
    def decorator(func):
        @wraps(func)
        def wrapper(user_id, *args, **kwargs):
            now = time.time()
            key = f"{user_id}"

            if key not in request_log:
                request_log[key] = []

            # Clean old entries
            request_log[key] = [
                t for t in request_log[key]
                if now - t < window_seconds
            ]

            if len(request_log[key]) >= max_requests:
                return {"error": "Too many requests. Try again later."}

            request_log[key].append(now)
            return func(user_id, *args, **kwargs)
        return wrapper
    return decorator

@rate_limit(max_requests=20, window_seconds=60)
def chat_with_avatar(user_id, message):
    # Conversation logic
    pass

# Best practice: API keys in .env
OPENROUTER_API_KEY=sk-or-xxxxxxxxxxxxx
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxx

# Restrictive permissions
chmod 600 .env

# Example safeguards in SOUL.md
safety:
  hard_limits:
    - "Never claim to be human if directly asked"
    - "Never give personalized medical or legal advice"
    - "Never generate content intended to manipulate or deceive"
    - "Never share my creator's personal data"
    - "Always clarify that I am an AI avatar when relevant"

  soft_limits:
    - "Redirect sensitive questions to appropriate resources"
    - "Flag when unsure about information"
    - "Provide warnings on controversial topics"

# Example: consent banner for a web avatar
CONSENT_MESSAGE = """
Hello! I'm an AI avatar.

Before we chat, here’s what you need to know:
- Our conversations may be temporarily stored to improve my responses
- You can request deletion of your data at any time
- I don’t share your data with third parties
- My responses are AI-generated and may contain errors

Type "I accept" to continue, or "privacy" for more details.
"""

def handle_consent(user_id, message):
    if message.lower() == "i accept":
        store_consent(user_id)
        return "Thank you! How can I help?"
    elif message.lower() in ("privacy", "delete", "erase"):
        delete_user_data(user_id)
        return "All your data has been deleted."
    return CONSENT_MESSAGE