宠物监控数据安全与隐私保护：端到端加密与合规实践

宠物监控数据安全与隐私保护：端到端加密与合规实践

系列第9篇 | 从加密传输到合规审计的全链路安全方案

前言

宠物摄像头拍到的不仅是猫狗，还有你的家、你的家人、你的生活。2023年某知名宠物摄像头品牌泄露了数万用户的实时视频流，画面中包含家庭隐私场景。这件事给我们敲响了警钟：宠物监控的安全等级必须对标家庭安防。

本文将从端到端加密、安全存储、合规审计（GDPR/个人信息保护法）、安全开发实践四个维度，构建完整的宠物监控数据安全体系。

---

一、威胁模型分析

1.1 攻击面梳理

┌─────────────────────────────────────────────────────┐
│                   攻击面全景图                         │
├──────────┬──────────────────────────────────────────┤
│ 设备层    │ 固件篡改、物理拆解、调试接口暴露           │
│ 传输层    │ 中间人攻击、WiFi窃听、DNS劫持             │
│ 云端层    │ 数据库泄露、API未授权访问、存储桶公开       │
│ 应用层    │ 弱密码、Token泄露、CSRF、越权访问          │
│ 人为因素  │ 内部员工越权、第三方SDK数据采集             │
└──────────┴──────────────────────────────────────────┘

1.2 数据分类与保护级别

数据类别	敏感等级	示例	保护措施
视频流	极高	实时/录像视频	端到端加密 + 访问日志
音频流	极高	环境音频	同视频流
图片	高	抓拍截图、宠物照片	加密存储 + 签名URL
行为数据	中	活动量、进食记录	脱敏 + 访问控制
设备元数据	中	IP、MAC、位置	加密存储
账户信息	高	手机号、邮箱	哈希/加密 + 最小化收集
宠物信息	低	名字、品种、体重	基础保护

---

二、端到端加密方案

2.1 加密架构设计

设备端                        云端                        客户端
┌─────────┐              ┌──────────┐              ┌─────────┐
│摄像头    │───DTLS───▶  │中继服务器 │──────TLS───▶│手机App   │
│         │              │          │              │         │
│ AES-256 │              │ 无法解密  │              │ AES-256 │
│ 加密视频 │              │ 仅转发    │              │ 解密播放 │
└─────────┘              └──────────┘              └─────────┘
     │                        │                        │
     └───── 密钥通过 ECDH 协商，不经过服务器 ──────────┘

核心原则：云端服务器只能看到密文，无法解密视频内容。

2.2 密钥协商与管理

# e2e_crypto.py
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
import time
import json

class E2ECryptoManager:
    """
    端到端加密管理器
    使用 ECDH 密钥协商 + AES-256-GCM 数据加密
    """

    def __init__(self):
        self._private_key = ec.generate_private_key(ec.SECP256R1())
        self._public_key = self._private_key.public_key()

    def get_public_key_bytes(self) -> bytes:
        """导出公钥用于交换"""
        return self._public_key.public_bytes(
            serialization.Encoding.DER,
            serialization.PublicFormat.SubjectPublicKeyInfo
        )

    def derive_shared_key(self, peer_public_key_bytes: bytes) -> bytes:
        """从对方公钥派生共享密钥"""
        peer_public_key = serialization.load_der_public_key(peer_public_key_bytes)
        shared_secret = self._private_key.exchange(ec.ECDH(), peer_public_key)

        # 使用HKDF派生AES密钥
        derived_key = HKDF(
            algorithm=hashes.SHA256(),
            length=32,  # 256-bit key
            salt=None,
            info=b"pet-monitor-e2e-v1",
        ).derive(shared_secret)
        return derived_key

    @staticmethod
    def encrypt_frame(aes_key: bytes, plaintext: bytes,
                      associated_data: bytes = None) -> dict:
        """加密单帧视频数据"""
        nonce = os.urandom(12)  # 96-bit nonce for GCM
        aesgcm = AESGCM(aes_key)
        ciphertext = aesgcm.encrypt(nonce, plaintext, associated_data)
        return {
            "nonce": nonce.hex(),
            "ciphertext": ciphertext.hex(),
            "timestamp": int(time.time() * 1000),
        }

    @staticmethod
    def decrypt_frame(aes_key: bytes, frame: dict,
                      associated_data: bytes = None) -> bytes:
        """解密单帧视频数据"""
        nonce = bytes.fromhex(frame["nonce"])
        ciphertext = bytes.fromhex(frame["ciphertext"])
        aesgcm = AESGCM(aes_key)
        return aesgcm.decrypt(nonce, ciphertext, associated_data)


class DeviceKeyManager:
    """
    设备密钥管理 - 持久化存储与轮换
    密钥存储在设备安全区域（TEE/SE），不暴露给云端
    """

    def __init__(self, secure_storage_path: str):
        self.storage_path = secure_storage_path
        self.current_key_id = None
        self.key_rotation_interval = 86400 * 7  # 7天轮换一次

    def generate_device_identity(self) -> dict:
        """生成设备身份密钥对"""
        private_key = ec.generate_private_key(ec.SECP256R1())
        public_key = private_key.public_key()

        # 序列化存储
        priv_pem = private_key.private_bytes(
            serialization.Encoding.PEM,
            serialization.PrivateFormat.PKCS8,
            serialization.NoEncryption()
        )
        pub_pem = public_key.public_bytes(
            serialization.Encoding.PEM,
            serialization.PublicFormat.SubjectPublicKeyInfo
        )

        # 实际生产中，私钥应存储在TEE/SE中
        self._save_to_secure_storage("device_privkey", priv_pem)
        self._save_to_secure_storage("device_pubkey", pub_pem)

        return {
            "device_id": self._generate_device_id(pub_pem),
            "public_key": pub_pem.decode(),
            "created_at": int(time.time()),
        }

    def should_rotate_key(self, key_created_at: int) -> bool:
        """判断是否需要轮换密钥"""
        return (time.time() - key_created_at) > self.key_rotation_interval

    def _save_to_secure_storage(self, key: str, value: bytes):
        """保存到安全存储（生产环境用TPM/Keychain）"""
        # 实际实现应使用:
        # - Android: Android Keystore
        # - iOS: Secure Enclave
        # - Linux: TPM 2.0 / dm-crypt
        # - 简易方案: 加密文件 + 文件权限
        path = os.path.join(self.storage_path, key)
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path, "wb") as f:
            f.write(value)
        os.chmod(path, 0o600)

    def _generate_device_id(self, pubkey_pem: bytes) -> str:
        """从公钥派生设备ID"""
        digest = hashes.Hash(hashes.SHA256())
        digest.update(pubkey_pem)
        return digest.finalize().hex()[:16]

2.3 视频流加密传输

# secure_stream.py
import asyncio
import struct
from dataclasses import dataclass

class SecureVideoStream:
    """
    安全视频流传输
    设备 -> 中继 -> 客户端，中继无法解密
    """

    FRAME_HEADER_SIZE = 20  # 4B magic + 4B seq + 4B timestamp + 4B length + 4B key_id
    MAGIC = b'PV01'  # Pet Video v1

    def __init__(self, crypto: E2ECryptoManager):
        self.crypto = crypto
        self.sequence = 0

    async def send_encrypted_frame(self, writer: asyncio.StreamWriter,
                                    aes_key: bytes, frame_data: bytes,
                                    key_id: int):
        """发送一帧加密视频"""
        self.sequence += 1

        # 加密帧数据
        aad = struct.pack(">II", self.sequence, key_id)  # 附加认证数据
        encrypted = E2ECryptoManager.encrypt_frame(aes_key, frame_data, aad)

        nonce = bytes.fromhex(encrypted["nonce"])
        ciphertext = bytes.fromhex(encrypted["ciphertext"])

        # 构建帧头
        header = struct.pack(">4sIII4s",
            self.MAGIC,
            self.sequence,
            encrypted["timestamp"],
            len(ciphertext) + 12,  # nonce + ciphertext
            struct.pack(">I", key_id),
        )

        # 发送: header + nonce + ciphertext
        writer.write(header + nonce + ciphertext)
        await writer.drain()

    async def receive_encrypted_frame(self, reader: asyncio.StreamReader,
                                       aes_key: bytes) -> bytes:
        """接收并解密一帧视频"""
        # 读取帧头
        header = await reader.readexactly(self.FRAME_HEADER_SIZE)
        magic, seq, timestamp, data_len, key_id_bytes = struct.unpack(
            ">4sIII4s", header
        )

        if magic != self.MAGIC:
            raise ValueError(f"Invalid frame magic: {magic}")

        # 读取加密数据
        data = await reader.readexactly(data_len)
        nonce = data[:12]
        ciphertext = data[12:]

        key_id = struct.unpack(">I", key_id_bytes)[0]
        aad = struct.pack(">II", seq, key_id)

        # 解密
        aesgcm = AESGCM(aes_key)
        plaintext = aesgcm.decrypt(nonce, ciphertext, aad)
        return plaintext

---

三、安全存储与访问控制

3.1 视频存储加密

# secure_storage.py
import boto3
import hashlib
from cryptography.fernet import Fernet
from datetime import datetime, timedelta
from urllib.parse import quote

class SecureVideoStorage:
    """
    安全视频存储
    - 服务端加密 (SSE-C / SSE-KMS)
    - 签名URL限时访问
    - 自动过期清理
    """

    def __init__(self, s3_client, kms_key_id: str):
        self.s3 = s3_client
        self.bucket = "pet-monitor-videos"
        self.kms_key_id = kms_key_id

    def upload_video_segment(self, user_id: str, device_id: str,
                              video_data: bytes, duration_sec: int) -> str:
        """上传视频片段，自动加密"""
        # 生成存储路径: /{user_id}/{device_id}/{date}/{timestamp}.enc
        now = datetime.utcnow()
        key = (
            f"{user_id}/{device_id}/"
            f"{now.strftime('%Y/%m/%d')}/"
            f"{now.strftime('%H%M%S')}_{duration_sec}s.mp4"
        )

        # 计算数据完整性校验
        md5_hash = hashlib.md5(video_data).hexdigest()

        # 使用S3服务端加密(KMS)
        self.s3.put_object(
            Bucket=self.bucket,
            Key=key,
            Body=video_data,
            ServerSideEncryption="aws:kms",
            SSEKMSKeyId=self.kms_key_id,
            Metadata={
                "user_id": user_id,
                "device_id": device_id,
                "duration": str(duration_sec),
                "md5": md5_hash,
                "encrypted_at": now.isoformat(),
            },
            # 自动过期：90天后删除
            # (通过S3 Lifecycle Policy实现)
        )

        return key

    def generate_presigned_url(self, key: str, expires_in: int = 3600) -> str:
        """生成限时签名URL"""
        url = self.s3.generate_presigned_url(
            "get_object",
            Params={"Bucket": self.bucket, "Key": key},
            ExpiresIn=expires_in,
        )
        return url

    def generate_signed_stream_url(self, user_id: str, device_id: str,
                                    expires_in: int = 300) -> dict:
        """生成签名的实时流URL（5分钟有效）"""
        # 使用HLS签名
        token = self._generate_stream_token(user_id, device_id, expires_in)
        return {