Ngày 15/03/2025, một đêm muộn tại Sài Gòn, tôi nhận được cuộc gọi từ CTO của một startup thương mại điện tử lớn. Hệ thống chatbot AI của họ vừa bị người dùng phản ánh về việc dữ liệu cá nhân bị lưu trữ không đúng cách. Đó là khoảnh khắc tôi nhận ra rằng GDPR AI API compliance không chỉ là checkbox pháp lý — mà là nền tảng để xây dựng niềm tin người dùng bền vững.
Trong bài viết này, tôi sẽ chia sẻ kinh nghiệm thực chiến khi triển khai hệ thống AI tuân thủ GDPR từ con số 0, bao gồm kiến trúc, code mẫu, và những bài học xương máu khi đối mặt với các cuộc kiểm tra của DPA (Data Protection Authority).
Tại Sao GDPR Quan Trọng Với AI API?
GDPR (General Data Protection Regulation) không chỉ áp dụng cho các công ty châu Âu. Theo Điều 3, bất kỳ tổ chức nào xử lý dữ liệu người dùng EU đều phải tuân thủ. Với AI API, điều này có nghĩa:
- Đ Article 17: Người dùng có quyền yêu cầu xóa dữ liệu ("Right to be Forgotten")
- Article 20: Quyền di chuyển dữ liệu ("Data Portability")
- Article 25: Bảo vệ dữ liệu theo thiết kế mặc định ("Privacy by Design")
- Article 32: Bảo mật xử lý dữ liệu cá nhân
Khi tôi tư vấn cho dự án RAG doanh nghiệp với hơn 2 triệu tài liệu nội bộ, câu hỏi đầu tiên của legal team là: "Dữ liệu có được lưu trữ ở đâu khi gọi API? Có được mã hóa không?"
Kiến Trúc AI API Tuân Thủ GDPR
1. Proxy Trung Gian - Lớp Bảo Vệ Đầu Tiên
Thay vì gọi trực tiếp AI API từ client, tôi luôn khuyến nghị triển khai một proxy layer. Điều này cho phép:
- Strip PII (Personally Identifiable Information) trước khi gửi request
- Audit logging không tiết lộ dữ liệu nhạy cảm
- Rate limiting và quota management
- Response caching với TTL phù hợp
#!/usr/bin/env python3
"""
GDPR-Compliant AI Proxy Server
Tác giả: HolySheep AI Technical Team
Môi trường: Python 3.10+, FastAPI
"""
import hashlib
import re
from typing import Optional
from datetime import datetime, timedelta
from fastapi import FastAPI, HTTPException, Header, Request
from pydantic import BaseModel
import httpx
app = FastAPI(title="GDPR-Compliant AI Proxy")
Cấu hình - Sử dụng HolySheep AI API
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY" # Thay thế bằng API key thực tế
class ChatRequest(BaseModel):
messages: list
model: str = "gpt-4.1"
temperature: float = 0.7
max_tokens: int = 1000
class ChatResponse(BaseModel):
request_id: str
response: str
tokens_used: int
gdpr_compliant: bool = True
Regex patterns cho PII detection
PII_PATTERNS = {
'email': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
'phone': r'\b\d{10,11}\b',
'credit_card': r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b',
'ssn': r'\b\d{3}-\d{2}-\d{4}\b',
}
def anonymize_pii(text: str) -> tuple[str, list[str]]:
"""
Thay thế PII bằng placeholder có thể trace
Trả về: (text đã anonymize, danh sách PII đã thay thế)
"""
anonymized = text
found_pii = []
for pii_type, pattern in PII_PATTERNS.items():
matches = re.finditer(pattern, anonymized)
for match in matches:
original = match.group()
placeholder = f"[{pii_type.upper()}_{hashlib.md5(original.encode()).hexdigest()[:8]}]"
anonymized = anonymized.replace(original, placeholder)
found_pii.append({
'type': pii_type,
'original_hash': hashlib.md5(original.encode()).hexdigest()[:8],
'replaced_at': datetime.utcnow().isoformat()
})
return anonymized, found_pii
async def call_ai_api(messages: list, model: str, temperature: float, max_tokens: int) -> dict:
"""
Gọi HolySheep AI API với cấu hình tuân thủ GDPR
"""
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": messages,
"temperature": temperature,
"max_tokens": max_tokens
}
async with httpx.AsyncClient(timeout=30.0) as client:
response = await client.post(
f"{HOLYSHEEP_BASE_URL}/chat/completions",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
@app.post("/v1/chat/completions", response_model=ChatResponse)
async def chat_completions(
request: ChatRequest,
x_request_id: Optional[str] = Header(None)
):
"""
Endpoint tuân thủ GDPR cho chat completions
"""
# Bước 1: Anonymize PII trong messages
processed_messages = []
all_pii_found = []
for msg in request.messages:
content = msg.get('content', '')
anonymized_content, pii_list = anonymize_pii(content)
all_pii_found.extend(pii_list)
processed_messages.append({
'role': msg.get('role', 'user'),
'content': anonymized_content
})
# Bước 2: Log audit trail (không chứa PII)
audit_log = {
'request_id': x_request_id or hashlib.uuid4().hex,
'timestamp': datetime.utcnow().isoformat(),
'model': request.model,
'pii_found': all_pii_found,
'ip_hash': hashlib.sha256(Request.client.host.encode()).hexdigest()[:16]
}
# Bước 3: Gọi AI API
try:
ai_response = await call_ai_api(
messages=processed_messages,
model=request.model,
temperature=request.temperature,
max_tokens=request.max_tokens
)
return ChatResponse(
request_id=audit_log['request_id'],
response=ai_response['choices'][0]['message']['content'],
tokens_used=ai_response.get('usage', {}).get('total_tokens', 0),
gdpr_compliant=True
)
except httpx.HTTPStatusError as e:
raise HTTPException(status_code=e.response.status_code, detail=str(e))
@app.get("/v1/gdpr/status")
async def gdpr_status():
"""
Kiểm tra trạng thái tuân thủ GDPR của hệ thống
"""
return {
"compliant": True,
"pii_processing": True,
"data_retention_days": 0,
"encryption": "AES-256-GCM",
"audit_logging": True
}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)2. Data Retention Policy - Zero Storage hoặc TTL Ngắn
Trong dự án thực tế, tôi đã triển khai chính sách zero retention cho production. Điều này có nghĩa:
- Không lưu trữ prompt/response trong database
- Chỉ log audit trail với request_id và timestamp
- Tự động xóa session sau 30 phút không hoạt động
#!/usr/bin/env python3
"""
GDPR Data Retention Manager
Xóa tự động dữ liệu theo chính sách retention
"""
import asyncio
from datetime import datetime, timedelta
from typing import Optional
import redis.asyncio as redis
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Text
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
Base = declarative_base()
class AuditLog(Base):
__tablename__ = 'gdpr_audit_logs'
id = Column(Integer, primary_key=True)
request_id = Column(String(64), unique=True, index=True)
user_hash = Column(String(64), index=True) # Không lưu user_id thực
endpoint = Column(String(255))
model_used = Column(String(50))
tokens_consumed = Column(Integer)
created_at = Column(DateTime, default=datetime.utcnow)
piis_detected = Column(Text, nullable=True) # JSON string của PII list
def to_dict(self):
return {
'request_id': self.request_id,
'timestamp': self.created_at.isoformat(),
'model': self.model_used,
'tokens': self.tokens_consumed
}
class DataRetentionManager:
"""
Quản lý retention policy theo GDPR Article 5(1)(e)
Data chỉ được giữ trong thời gian cần thiết
"""
def __init__(self, redis_url: str, db_url: str, retention_hours: int = 0):
self.redis = redis.from_url(redis_url, decode_responses=True)
self.engine = create_engine(db_url)
Base.metadata.create_all(self.engine)
self.Session = sessionmaker(bind=self.engine)
self.retention_hours = retention_hours # 0 = zero retention
async def store_session(
self,
session_id: str,
user_hash: str,
data: dict,
ttl_seconds: int = 1800 # 30 phút
):
"""
Lưu session tạm thời với TTL
"""
import json
session_data = {
'user_hash': user_hash,
'data': data,
'created_at': datetime.utcnow().isoformat()
}
await self.redis.setex(
f"session:{session_id}",
ttl_seconds,
json.dumps(session_data)
)
return session_id
async def get_session(self, session_id: str) -> Optional[dict]:
"""
Retrieve session - trả về None nếu hết hạn
"""
import json
data = await self.redis.get(f"session:{session_id}")
return json.loads(data) if data else None
async def delete_session(self, session_id: str) -> bool:
"""
Xóa session theo yêu cầu Article 17 GDPR
"""
return await self.redis.delete(f"session:{session_id}") > 0
async def cleanup_old_audit_logs(self):
"""
Xóa audit logs cũ hơn retention period
"""
if self.retention_hours == 0:
return 0
session = self.Session()
cutoff = datetime.utcnow() - timedelta(hours=self.retention_hours)
deleted = session.query(AuditLog).filter(
AuditLog.created_at < cutoff
).delete()
session.commit()
session.close()
return deleted
async def process_deletion_request(self, user_hash: str) -> dict:
"""
Xử lý Article 17 - Right to be Forgotten
"""
session = self.Session()
# Xóa tất cả audit logs của user
deleted_logs = session.query(AuditLog).filter(
AuditLog.user_hash == user_hash
).delete()
session.commit()
session.close()
# Xóa Redis sessions
cursor = 0
deleted_sessions = 0
while True:
cursor, keys = await self.redis.scan(
cursor=cursor,
match="session:*",
count=100
)
for key in keys:
data = await self.redis.get(key)
if data and user_hash in data:
await self.redis.delete(key)
deleted_sessions += 1
if cursor == 0:
break
return {
'status': 'completed',
'audit_logs_deleted': deleted_logs,
'sessions_deleted': deleted_sessions,
'completed_at': datetime.utcnow().isoformat()
}
Chạy cleanup job định kỳ
async def retention_cleanup_job(retention_manager: DataRetentionManager):
"""
Job chạy mỗi giờ để cleanup dữ liệu cũ
"""
while True:
try:
deleted = await retention_manager.cleanup_old_audit_logs()
print(f"[{datetime.utcnow()}] Cleaned up {deleted} old audit logs")
except Exception as e:
print(f"[ERROR] Retention cleanup failed: {e}")
await asyncio.sleep(3600) # Mỗi giờ
if __name__ == "__main__":
manager = DataRetentionManager(
redis_url="redis://localhost:6379",
db_url="postgresql://user:pass@localhost/gdpr_db",
retention_hours=0 # Zero retention
)
# Test deletion request
result = asyncio.run(manager.process_deletion_request("user_hash_123"))
print(f"Deletion result: {result}")3. Hashing và Pseudonymization - Bảo Vệ Định Danh
Một kỹ thuật quan trọng tôi học được là sử dụng pseudonymization thay vì anonymization hoàn toàn. Điều này cho phép:
- Tái liên kết dữ liệu khi có yêu cầu pháp lý (Article 4(5))
- Duy trì khả năng phân tích tổng hợp
- Giảm thiểu rủi ro re-identification
#!/usr/bin/env node
/**
* GDPR-Compliant Data Pseudonymization Module
* Sử dụng với Node.js 18+
*/
const crypto = require('crypto');
const { createCipheriv, createDecipheriv, randomBytes, createHash } = crypto;
// Cấu hình encryption
const ENCRYPTION_KEY = process.env.GDPR_ENCRYPTION_KEY; // 32 bytes
const ALGORITHM = 'aes-256-gcm';
const SALT = process.env.GDPR_SALT || 'holySheepGDPR2025';
class GDPRPseudonymizer {
/**
* Tạo pseudonym (ánh xạ có thể đảo ngược)
*/
static createPseudonym(pii, context = 'default') {
const timestamp = Date.now();
const input = ${pii}:${context}:${timestamp};
// Deterministic hash với salt
const hash = createHash('sha256')
.update(input + SALT)
.digest('hex');
// Mã hóa với key duy nhất cho context
const key = createHash('sha256')
.update(ENCRYPTION_KEY + context)
.digest();
const iv = randomBytes(16);
const cipher = createCipheriv(ALGORITHM, key, iv);
let encrypted = cipher.update(pii, 'utf8', 'hex');
encrypted += cipher.final('hex');
const authTag = cipher.getAuthTag();
return {
pseudonym: ${context}_${hash.substring(0, 16)},
encrypted: encrypted,
iv: iv.toString('hex'),
authTag: authTag.toString('hex'),
created: new Date().toISOString()
};
}
/**
* Giải mã pseudonym (chỉ khi có yêu cầu pháp lý)
*/
static reversePseudonym(encrypted, iv, authTag, context) {
const key = createHash('sha256')
.update(ENCRYPTION_KEY + context)
.digest();
const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(iv, 'hex'));
decipher.setAuthTag(Buffer.from(authTag, 'hex'));
let decrypted = decipher.update(encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
return decrypted;
}
/**
* Tạo user fingerprint (không thể đảo ngược)
*/
static createUserFingerprint(userData) {
const normalized = JSON.stringify(userData, Object.keys(userData).sort());
return createHash('sha256')
.update(normalized + SALT)
.digest('hex');
}
/**
* Xử lý request data - thay thế PII bằng pseudonym
*/
static processRequest(requestData, piiFields = ['email', 'phone', 'name']) {
const processed = { ...requestData };
const piiMappings = {};
for (const field of piiFields) {
if (processed[field]) {
const pseudonym = this.createPseudonym(
processed[field],
field
);
piiMappings[field] = {
pseudonym: pseudonym.pseudonym,
encrypted: pseudonym.encrypted,
iv: pseudonym.iv,
authTag: pseudonym.authTag
};
// Thay thế PII bằng pseudonym
processed[field] = pseudonym.pseudonym;
}
}
return {
processed,
piiMappings,
encryptedKey: createHash('sha256')
.update(JSON.stringify(piiMappings))
.digest('hex')
};
}
}
// Middleware cho Express.js
const gdprMiddleware = (req, res, next) => {
if (req.body) {
const result = GDPRPseudonymizer.processRequest(req.body);
req.gdprProcessed = result.processed;
req.gdprMappings = result.piiMappings;
req.gdprKey = result.encryptedKey;
req.body = result.processed;
}
next();
};
// Export cho module
module.exports = {
GDPRPseudonymizer,
gdprMiddleware
};
// Test
if (require.main === module) {
const testData = {
email: '[email protected]',
phone: '0909123456',
name: 'Nguyễn Văn A',
message: 'Tôi muốn biết về sản phẩm'
};
console.log('=== GDPR Pseudonymization Test ===\n');
const result = GDPRPseudonymizer.processRequest(testData);
console.log('Original:', testData);
console.log('\nProcessed (gửi đến AI):', result.processed);
console.log('\nMappings (lưu trữ riêng biệt):', result.piiMappings);
console.log('\nEncrypted Key:', result.encryptedKey);
// Verify PII đã được thay thế
const originalEmail = '[email protected]';
const processedEmail = result.processed.email;
console.log('\n✅ Email đã được pseudonymize:', originalEmail !== processedEmail);
console.log('📧 Pseudonym:', processedEmail);
}Tích Hợp HolyShehep AI Với GDPR Compliance
Khi triển khai production, tôi chọn HolySheep AI vì các yếu tố then chốt:
- Bảo mật: Dữ liệu không được sử dụng để train model (cam kết rõ ràng)
- Tốc độ: <50ms latency đảm bảo response nhanh cho người dùng
- Chi phí: DeepSeek V3.2 chỉ $0.42/MTok — tiết kiệm 85%+ so với OpenAI
- Thanh toán: Hỗ trợ WeChat/Alipay cho thị trường châu Á
Bảng giá tham khảo (cập nhật 2026):
| Model | Giá/MTok | Use Case |
|---|---|---|
| DeepSeek V3.2 | $0.42 | Cost-effective tasks |
| Gemini 2.5 Flash | $2.50 | Fast inference |
| GPT-4.1 | $8.00 | Complex reasoning |
| Claude Sonnet 4.5 | $15.00 | High-quality generation |
#!/usr/bin/env node
/**
* HolySheep AI GDPR-Compliant Client
* Tích hợp AI API với đầy đủ compliance features
*/
const https = require('https');
class HolySheepAIClient {
constructor(apiKey) {
this.baseUrl = 'api.holysheep.ai';
this.apiKey = apiKey;
this.version = 'v1';
}
/**
* Gọi API với timeout và retry logic
*/
async chatCompletion(messages, options = {}) {
const model = options.model || 'deepseek-v3.2';
const temperature = options.temperature ?? 0.7;
const maxTokens = options.maxTokens || 1000;
const payload = {
model,
messages,
temperature,
max_tokens: maxTokens
};
const startTime = Date.now();
try {
const response = await this._makeRequest(
'/chat/completions',
payload
);
const latency = Date.now() - startTime;
return {
success: true,
data: response,
latency,
model,
gdpr_note: 'No data stored by HolySheep AI servers'
};
} catch (error) {
return {
success: false,
error: error.message,
model,
timestamp: new Date().toISOString()
};
}
}
/**
* Make HTTPS request
*/
_makeRequest(path, payload) {
return new Promise((resolve, reject) => {
const postData = JSON.stringify(payload);
const options = {
hostname: this.baseUrl,
port: 443,
path: /${this.version}${path},
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': Bearer ${this.apiKey},
'Content-Length': Buffer.byteLength(postData),
'X-GDPR-Compliant': 'true',
'X-Data-Retention': '0'
},
timeout: 30000
};
const req = https.request(options, (res) => {
let data = '';
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
if (res.statusCode >= 200 && res.statusCode < 300) {
resolve(JSON.parse(data));
} else {
reject(new Error(HTTP ${res.statusCode}: ${data}));
}
});
});
req.on('error', reject);
req.on('timeout', () => {
req.destroy();
reject(new Error('Request timeout'));
});
req.write(postData);
req.end();
});
}
}
// Ví dụ sử dụng GDPR-compliant
async function exampleGDPRChat() {
const client = new HolySheepAIClient('YOUR_HOLYSHEEP_API_KEY');
// Prompt đã được anonymize trong production
const anonymizedMessages = [
{
role: 'system',
content: 'Bạn là trợ lý hỗ trợ khách hàng. Không bao giờ lưu trữ thông tin cá nhân.'
},
{
role: 'user',
content: 'Tôi cần hỗ trợ về [EMAIL_abc123] và đơn hàng #456789'
}
];
const result = await client.chatCompletion(anonymizedMessages, {
model: 'deepseek-v3.2', // Model tiết kiệm chi phí
maxTokens: 500
});
console.log('=== HolySheep AI Response ===');
console.log('Success:', result.success);
console.log('Latency:', result.latency, 'ms');
console.log('Model:', result.model);
console.log('GDPR Note:', result.gdpr_note);
if (result.success) {
console.log('\nResponse:', result.data.choices[0].message.content);
}
return result;
}
// Chạy ví dụ
exampleGDPRChat().catch(console.error);Triển Khai Production - Từ Concept Đến Deployment
Docker Configuration Cho GDPR Compliance
# docker-compose.yml
GDPR-Compliant AI Infrastructure
version: '3.8'
services:
# AI Proxy - Layer bảo vệ GDPR
ai-proxy:
build:
context: ./proxy
dockerfile: Dockerfile
ports:
- "8000:8000"
environment:
- HOLYSHEEP_API_KEY=${HOLYSHEEP_API_KEY}
- GDPR_ENCRYPTION_KEY=${GDPR_ENCRYPTION_KEY}
- REDIS_URL=redis://redis:6379
- DATA_RETENTION_HOURS=0
depends_on:
- redis
networks:
- gdpr-network
restart: unless-stopped
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/v1/gdpr/status"]
interval: 30s
timeout: 10s
retries: 3
# Redis - Session storage với TTL
redis:
image: redis:7-alpine
command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
networks:
- gdpr-network
volumes:
- redis-data:/data
restart: unless-stopped
# PostgreSQL - Audit logs (encrypted)
postgres:
image: postgres:15-alpine
environment:
- POSTGRES_DB=gdpr_audit
- POSTGRES_PASSWORD=${DB_PASSWORD}
networks:
- gdpr-network
volumes:
- pg-data:/var/lib/postgresql/data
- ./init-db.sh:/docker-entrypoint-initdb.d/init.sh
restart: unless-stopped
command: >
postgres
-c shared_buffers=128MB
-c effective_cache_size=256MB
-c maintenance_work_mem=64MB
# Prometheus - Monitoring
prometheus:
image: prom/prometheus:latest
ports:
- "9090:9090"
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
networks:
- gdpr-network
networks:
gdpr-network:
driver: bridge
volumes:
redis-data:
pg-data:
Kiểm Tra Tuân Thủ GDPR
Để đảm bảo tuân thủ, tôi khuyến nghị thực hiện các bài test sau:
#!/usr/bin/env python3
"""
GDPR Compliance Test Suite
Chạy trước khi deploy lên production
"""
import unittest
import hashlib
import asyncio
from unittest.mock import Mock, patch
import sys
import os
Add parent directory to path
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from gdpr_proxy import anonymize_pii, DataRetentionManager
from pseudonymization import GDPRPseudonymizer
class TestGDPRCompliance(unittest.TestCase):
"""Test cases cho GDPR compliance"""
def setUp(self):
self.test_email = "[email protected]"
self.test_phone = "0909123456"
self.test_ssn = "123-45-6789"
# Test anonymize PII
def test_email_anonymization(self):
"""Test email được thay thế đúng cách"""
text = f"Vui lòng gửi đến {self.test_email}"
anonymized, pii_list = anonymize_pii(text)
self.assertNotIn(self.test_email, anonymized)
self.assertTrue(any(p['type'] == 'email' for p in pii_list))
print(f"✅ Email anonymization passed")
def test_phone_anonymization(self):
"""Test phone number được thay thế"""
text = f"Gọi cho tôi: {self.test_phone}"
anonymized, pii_list = anonymize_pii(text)
self.assertNotIn(self.test_phone, anonymized)
self.assertTrue(any(p['type'] == 'phone' for p in pii_list))
print(f"✅ Phone anonymization passed")
def test_ssn_anonymization(self):
"""Test SSN được thay thế (pattern Mỹ)"""
text = f"SSN: {self.test_ssn}"
anonymized, pii_list = anonymize_pii(text)
self.assertNotIn(self.test_ssn, anonymized)
self.assertTrue(any(p['type'] == 'ssn' for p in pii_list))
print(f"✅ SSN anonymization passed")
def test_multiple_pii_in_text(self):
"""Test text chứa nhiều PII"""
text = f"Email: {self.test_email}, Phone: {self.test_phone}"
anonymized, pii_list = anonymize_pii(text)
self.assertNotIn(self.test_email, anonymized)
self.assertNotIn(self.test_phone, anonymized)
self.assertEqual(len(pii_list), 2)
print(f"✅ Multiple PII detection passed")
def test_no_pii_unchanged(self):
"""Test text không chứa PII giữ nguyên"""
text = "Đây là một câu không có thông tin cá nhân"
anonymized, pii_list = anonymize_pii(text)
self.assertEqual(text, anonymized)
self.assertEqual(len(pii_list), 0)
print(f"✅ No PII unchanged passed")
# Test pseudonymization
def test_pseudonym_creation(self):
"""Test tạo pseudonym có thể track"""
pseudonym = GDPRPseudonymizer.createPseudonym(
self.test_email,
'email'
)
self.assertIn('pseudonym', pseudonym)
self.assertIn('encrypted', pseudonym)
self.assertIn('iv', pseudonym)
self.assertIn('authTag', pseudonym)
print(f"✅ Pseudonym creation passed")
def test_pseudonym_different_for_same_input(self):
"""Test cùng input nhưng khác context tạo ra pseudonym khác nhau"""
p1 = GDPRPseudonymizer.createPseudonym(self.test_email, 'context1')
p2 = GDPRPseudonymizer.createPseud