Privacy Audit Checklist for Web Applications: A Developer

# Example: Data inventory tracking
class DataAsset:
    def __init__(self, name, category, pii, retention_period, legal_basis):
        self.name = name
        self.category = category  # user_input, analytics, technical
        self.pii = pii  # boolean - personally identifiable?
        self.retention_period = retention_period
        self.legal_basis = legal_basis  # consent, contract, legitimate_interest

# Document your data assets
data_inventory = [
    DataAsset("email", "user_input", True, "until_withdrawal", "consent"),
    DataAsset("ip_address", "technical", True, "90_days", "legitimate_interest"),
    DataAsset("session_token", "technical", False, "session", "contract"),
]

from dataclasses import dataclass
from datetime import datetime
from typing import List
import hashlib
import json

@dataclass
class ConsentRecord:
    user_id: str
    consent_types: List[str]
    timestamp: datetime
    ip_address: str
    user_agent: str
    purpose: str
    version: str
    hash: str

class ConsentStore:
    def __init__(self):
        self.consents = {}  # In production, use a database
    
    def record_consent(self, record: ConsentRecord) -> bool:
        # Verify consent integrity
        expected_hash = self._compute_hash(record)
        if expected_hash != record.hash:
            return False
        
        # Store consent with version tracking
        if record.user_id not in self.consents:
            self.consents[record.user_id] = []
        
        self.consents[record.user_id].append({
            'consent_types': record.consent_types,
            'timestamp': record.timestamp.isoformat(),
            'purpose': record.purpose,
            'version': record.version
        })
        return True
    
    def has_valid_consent(self, user_id: str, consent_type: str) -> bool:
        if user_id not in self.consents:
            return False
        
        # Check most recent consent for type
        consents = self.consents[user_id]
        if not consents:
            return False
        
        latest = consents[-1]
        return consent_type in latest.get('consent_types', [])

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2
import base64
import os

class EncryptionManager:
    def __init__(self, master_key: str):
        self.key = self._derive_key(master_key)
        self.cipher = Fernet(self.key)
    
    def _derive_key(self, master_key: str) -> bytes:
        salt = os.urandom(16)  # In production, store salt securely
        kdf = PBKDF2(
            algorithm=hashes.SHA256(),
            length=32,
            salt=salt,
            iterations=100000,
        )
        key = base64.urlsafe_b64encode(kdf.derive(master_key.encode()))
        return key
    
    def encrypt(self, data: str) -> str:
        return self.cipher.encrypt(data.encode()).decode()
    
    def decrypt(self, encrypted_data: str) -> str:
        return self.cipher.decrypt(encrypted_data.encode()).decode()

# Usage
encryption = EncryptionManager(os.environ['MASTER_KEY'])

# Encrypt PII before storage
user_email_encrypted = encryption.encrypt("user@example.com")
# Store encrypted_email in database

from datetime import datetime
from typing import Dict, List
import asyncio

class DataSubjectRights:
    def __init__(self, db_connection):
        self.db = db_connection
    
    async def handle_erasure_request(self, user_id: str) -> Dict:
        # Verify identity first
        if not await self._verify_identity(user_id):
            return {'status': 'identity_verification_required'}
        
        # Collect all data locations
        data_locations = await self._find_user_data(user_id)
        
        # Execute erasure from each location
        erasure_results = []
        for location in data_locations:
            result = await self._erase_from_location(user_id, location)
            erasure_results.append(result)
        
        # Create audit trail
        await self._create_erasure_audit(user_id, erasure_results)
        
        return {
            'status': 'completed',
            'erased_from': data_locations,
            'timestamp': datetime.utcnow().isoformat()
        }
    
    async def _find_user_data(self, user_id: str) -> List[Dict]:
        locations = []
        
        # Check main user table
        locations.append({'table': 'users', 'id': user_id})
        
        # Check analytics data
        locations.append({'table': 'analytics_events', 'user_id': user_id})
        
        # Check logs (mark for deletion)
        locations.append({'table': 'application_logs', 'user_id': user_id})
        
        return locations
    
    async def _erase_from_location(self, user_id: str, location: Dict) -> bool:
        table = location['table']
        # Actual deletion or anonymization
        query = f"DELETE FROM {table} WHERE user_id = ?"
        await self.db.execute(query, (user_id,))
        return True

import json
from datetime import datetime

class DataPortability:
    def export_user_data(self, user_id: str) -> Dict:
        export_data = {
            'export_timestamp': datetime.utcnow().isoformat(),
            'user_id': user_id,
            'data': {}
        }
        
        # Collect all user data
        export_data['data']['profile'] = self.get_profile(user_id)
        export_data['data']['activity'] = self.get_activity(user_id)
        export_data['data']['preferences'] = self.get_preferences(user_id)
        export_data['data']['consents'] = self.get_consent_history(user_id)
        
        return export_data
    
    def format_as_json(self, user_id: str) -> str:
        data = self.export_user_data(user_id)
        return json.dumps(data, indent=2)