HarmonyOS视频安全全链路开发技术分享

核心要点：掌握HarmonyOS视频安全全链路技术，从DRM架构原理到Widevine集成，从视频加密到安全解码通道，从防录屏到内容保护，构建坚不可摧的视频安全防线。

一、背景与动机

你花了大价钱买了VIP会员，正准备看最新上线的大片，结果发现网上已经有盗版资源了——画质还不错，甚至比你的在线播放还清晰。这背后，就是视频安全没做好。

视频安全，听起来离普通开发者很远，但实际上只要你做的是视频类应用——无论是短视频、直播、还是在线影视——都绕不开这个问题。内容方（电影公司、音乐公司）的要求越来越严格：没有DRM保护？对不起，不给你内容授权。没有安全解码通道？对不起，4K/HDR内容不能播。

在HarmonyOS上，视频安全体系包括：DRM数字版权管理（控制谁能看、看多久、在哪看）、视频加密（保护传输和存储中的视频数据）、安全解码（在受信任的执行环境中解码，防止中间数据泄露）、防录屏（阻止屏幕录制和截图）。

本文就来把这些视频安全技术一层层拆解，让你从原理到实战全面掌握。

二、核心原理

2.1 DRM架构全景

flowchart TD
    classDef primary fill:#4FC3F7,stroke:#0288D1,color:#000
    classDef warning fill:#FFB74D,stroke:#F57C00,color:#000
    classDef error fill:#EF5350,stroke:#C62828,color:#fff
    classDef info fill:#81C784,stroke:#388E3C,color:#000
    classDef purple fill:#CE93D8,stroke:#7B1FA2,color:#000

    A[DRM架构]:::primary --> B[许可证服务器]:::warning
    A --> C[DRM框架层]:::info
    A --> D[安全解码器]:::error
    A --> E[防录屏]:::purple

    B --> B1[密钥分发]:::primary
    B --> B2[许可证管理]:::primary
    B --> B3[使用规则]:::primary

    C --> C1[Widevine]:::info
    C --> C2[PlayReady]:::info
    C --> C3[ClearKey]:::info
    C --> C4[华为DRM]:::info

    D --> D1[TEE安全执行环境]:::error
    D --> D2[硬件安全解码]:::error
    D --> D3[密钥不可提取]:::error

    E --> E1[安全画面标志]:::purple
    E --> E2[系统级防录屏]:::purple
    E --> E3[水印追踪]:::purple

    style A stroke-width:3px
    style D stroke-width:3px

2.2 DRM工作流程

DRM的核心思想是：视频内容加密存储，只有获得许可证的客户端才能解密播放。

2.3 Widevine安全级别

Widevine是Google的DRM方案，也是Android/HarmonyOS生态中最广泛使用的DRM系统。它有三个安全级别：

L1和L3的核心区别：

• L1：密钥存储、视频解码、画面渲染全部在TEE（Trusted Execution Environment）内完成，密钥和解码后的视频数据永远不会出现在普通操作系统的内存中。即使设备被root，也无法提取密钥或截取解码后的画面。
• L3：密钥在TEE中处理，但解码和渲染在普通环境中完成。安全性较低，但兼容性好，几乎所有设备都支持。

2.4 视频加密方案

CENC的关键设计：同一份加密内容可以被不同DRM系统解密。这意味着内容方只需要加密一次，Widevine、PlayReady、FairPlay都能用自己的密钥解密同一份内容。

三、代码实战

3.1 DRM能力检测与初始化

使用DRM的第一步，是检测设备支持哪些DRM方案和安全级别。

import { drm } from '@kit.DrmKit';
import { BusinessError } from '@kit.BasicServicesKit';

/**
 * DRM管理器
 * 负责DRM能力检测、会话管理、许可证获取
 */
class DRMManager {
  private mediaKeySystem: drm.MediaKeySystem | null = null;
  private mediaKeySession: drm.MediaKeySession | null = null;
  private drmType: string = '';
  private securityLevel: string = '';

  /**
   * 检测设备DRM能力
   * 返回支持的DRM方案和安全级别
   */
  async detectDRMCapabilities(): Promise<DRMCapabilityInfo> {
    const capabilityInfo: DRMCapabilityInfo = {
      isWidevineSupported: false,
      widevineLevel: 'L3',
      isPlayReadySupported: false,
      isClearKeySupported: false,
      maxHdcpLevel: 'HDCP_NONE',
      isSecureDecoderSupported: false,
    };

    try {
      // 第一步：检测Widevine支持
      capabilityInfo.isWidevineSupported = drm.isMediaKeySystemSupported('com.widevine.alpha');

      if (capabilityInfo.isWidevineSupported) {
        // 创建Widevine MediaKeySystem实例
        const keySystem = drm.createMediaKeySystem('com.widevine.alpha');

        // 获取安全级别
        try {
          const securityLevel = keySystem.getConfigurationStringProperty('securityLevel');
          capabilityInfo.widevineLevel = securityLevel;
          console.info(`[DRM] Widevine安全级别: ${securityLevel}`);
        } catch (e) {
          capabilityInfo.widevineLevel = 'L3'; // 默认L3
        }

        // 获取HDCP级别
        try {
          const hdcpLevel = keySystem.getConfigurationStringProperty('maxHdcpLevel');
          capabilityInfo.maxHdcpLevel = hdcpLevel;
          console.info(`[DRM] HDCP级别: ${hdcpLevel}`);
        } catch (e) {
          capabilityInfo.maxHdcpLevel = 'HDCP_NONE';
        }

        // 检测安全解码器支持
        try {
          const secureDecoder = keySystem.getConfigurationStringProperty('secureDecoder');
          capabilityInfo.isSecureDecoderSupported = secureDecoder === 'supported';
        } catch (e) {
          capabilityInfo.isSecureDecoderSupported = false;
        }

        keySystem.destroy();
      }

      // 第二步：检测PlayReady支持
      capabilityInfo.isPlayReadySupported = drm.isMediaKeySystemSupported('com.microsoft.playready');

      // 第三步：检测ClearKey支持
      capabilityInfo.isClearKeySupported = drm.isMediaKeySystemSupported('org.w3.clearkey');

      console.info(`[DRM] 能力检测完成: Widevine=${capabilityInfo.isWidevineSupported}(${capabilityInfo.widevineLevel}), ` +
        `PlayReady=${capabilityInfo.isPlayReadySupported}, ClearKey=${capabilityInfo.isClearKeySupported}`);

    } catch (error) {
      const err = error as BusinessError;
      console.error(`[DRM] 能力检测失败: ${err.code} - ${err.message}`);
    }

    return capabilityInfo;
  }

  /**
   * 初始化DRM会话
   * @param drmScheme DRM方案标识符
   */
  async initDRMSession(drmScheme: string = 'com.widevine.alpha'): Promise<boolean> {
    try {
      // 创建MediaKeySystem
      this.mediaKeySystem = drm.createMediaKeySystem(drmScheme);
      this.drmType = drmScheme;
      console.info(`[DRM] MediaKeySystem创建成功: ${drmScheme}`);

      // 创建MediaKeySession
      this.mediaKeySession = this.mediaKeySystem.createMediaKeySession();
      console.info('[DRM] MediaKeySession创建成功');

      // 监听密钥变化事件
      this.mediaKeySession.on('keysChange', (keyInfo: drm.MediaKeyInfo[], isMultiSession: boolean) => {
        for (const key of keyInfo) {
          console.info(`[DRM] 密钥状态变化: keyId=${key.keyId}, status=${key.status}`);
        }
      });

      // 监听许可证请求事件
      this.mediaKeySession.on('keyRequired', (eventInfo: drm.MediaKeySessionRequest) => {
        console.info('[DRM] 收到许可证请求，需要获取许可证');
        this.handleLicenseRequest(eventInfo);
      });

      // 监听过期事件
      this.mediaKeySession.on('expirationChange', (expirationTime: number) => {
        if (expirationTime === 0) {
          console.warn('[DRM] 许可证已过期');
        } else {
          const expiryDate = new Date(expirationTime);
          console.info(`[DRM] 许可证过期时间: ${expiryDate.toLocaleString()}`);
        }
      });

      return true;
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[DRM] 初始化失败: ${err.code} - ${err.message}`);
      return false;
    }
  }

  /**
   * 处理许可证请求
   * 向许可证服务器请求密钥
   */
  private async handleLicenseRequest(requestInfo: drm.MediaKeySessionRequest): Promise<void> {
    try {
      // 获取许可证服务器的URL
      const licenseUrl = this.getLicenseServerUrl(this.drmType);

      // 发送许可证请求到服务器
      const licenseResponse = await this.fetchLicense(licenseUrl, requestInfo.data);

      // 将许可证响应提供给DRM框架
      if (this.mediaKeySession) {
        await this.mediaKeySession.processMediaKeyResponse(licenseResponse);
        console.info('[DRM] 许可证处理成功');
      }
    } catch (error) {
      console.error('[DRM] 许可证获取失败');
    }
  }

  /**
   * 获取许可证服务器URL
   */
  private getLicenseServerUrl(drmType: string): string {
    const licenseServers: Map<string, string> = new Map([
      ['com.widevine.alpha', 'https://license.widevine.com/cenc/getcontentkey'],
      ['com.microsoft.playready', 'https://playready.directtaps.net/pr/rightsmanager.asmx'],
      ['org.w3.clearkey', 'https://your-clearkey-server.com/license'],
    ]);
    return licenseServers.get(drmType) || '';
  }

  /**
   * 向许可证服务器发送请求
   * @param url 许可证服务器URL
   * @param challengeData 客户端挑战数据
   * @returns 许可证响应数据
   */
  private async fetchLicense(url: string, challengeData: Uint8Array): Promise<Uint8Array> {
    // 使用HTTP请求获取许可证
    const httpRequest = await import('@kit.NetworkKit');
    const response = await httpRequest.http.request(url, {
      method: httpRequest.http.RequestMethod.POST,
      header: { 'Content-Type': 'application/octet-stream' },
      extraData: challengeData,
    });

    if (response.responseCode === 200) {
      // 将响应转换为Uint8Array
      const resultBuffer = response.result as ArrayBuffer;
      return new Uint8Array(resultBuffer);
    } else {
      throw new Error(`许可证服务器返回错误: ${response.responseCode}`);
    }
  }

  /**
   * 生成许可证请求（用于离线场景）
   */
  async generateLicenseRequest(psshData: Uint8Array): Promise<Uint8Array | null> {
    if (!this.mediaKeySession) {
      console.error('[DRM] Session未初始化');
      return null;
    }

    try {
      // 生成许可证请求
      const request = await this.mediaKeySession.generateMediaKeyRequest(psshData);
      console.info(`[DRM] 许可证请求生成成功，数据长度: ${request.data.length}`);
      return request.data;
    } catch (error) {
      console.error('[DRM] 生成许可证请求失败');
      return null;
    }
  }

  /**
   * 释放DRM资源
   */
  async release(): Promise<void> {
    if (this.mediaKeySession) {
      this.mediaKeySession.off('keysChange');
      this.mediaKeySession.off('keyRequired');
      this.mediaKeySession.off('expirationChange');
      this.mediaKeySession.destroy();
      this.mediaKeySession = null;
    }

    if (this.mediaKeySystem) {
      this.mediaKeySystem.destroy();
      this.mediaKeySystem = null;
    }

    console.info('[DRM] 资源已释放');
  }
}

/**
 * DRM能力信息
 */
interface DRMCapabilityInfo {
  isWidevineSupported: boolean;     // 是否支持Widevine
  widevineLevel: string;            // Widevine安全级别（L1/L2/L3）
  isPlayReadySupported: boolean;    // 是否支持PlayReady
  isClearKeySupported: boolean;     // 是否支持ClearKey
  maxHdcpLevel: string;             // 最大HDCP级别
  isSecureDecoderSupported: boolean; // 是否支持安全解码器
}

3.2 加密视频播放（DRM集成）

将DRM与AVPlayer集成，实现加密视频的安全播放。

import { media } from '@kit.MediaKit';
import { drm } from '@kit.DrmKit';
import { BusinessError } from '@kit.BasicServicesKit';

/**
 * 安全视频播放器
 * 集成DRM的加密视频播放器，支持Widevine/PlayReady
 */
class SecureVideoPlayer {
  private avPlayer: media.AVPlayer | null = null;
  private drmManager: DRMManager = new DRMManager();
  private isSecurePlayback: boolean = false;

  /**
   * 初始化安全播放器
   * @param drmScheme DRM方案
   */
  async initSecurePlayer(drmScheme: string = 'com.widevine.alpha'): Promise<boolean> {
    try {
      // 第一步：初始化DRM
      const drmReady = await this.drmManager.initDRMSession(drmScheme);
      if (!drmReady) {
        console.error('[SecurePlayer] DRM初始化失败');
        return false;
      }

      // 第二步：创建AVPlayer
      this.avPlayer = await media.createAVPlayer();

      // 第三步：设置DRM回调
      this.avPlayer.on('drmInfoUpdate', async (drmInfo: media.DRMInfo) => {
        console.info(`[SecurePlayer] 收到DRM信息: ${drmInfo.drmSchemes}`);
        await this.handleDRMInfo(drmInfo);
      });

      // 第四步：监听播放状态
      this.avPlayer.on('stateChange', async (state: string) => {
        if (state === 'prepared') {
          console.info('[SecurePlayer] 安全播放器准备就绪');
        }
      });

      this.avPlayer.on('error', (error: BusinessError) => {
        console.error(`[SecurePlayer] 播放错误: ${error.code} - ${error.message}`);
      });

      return true;
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[SecurePlayer] 初始化失败: ${err.code} - ${err.message}`);
      return false;
    }
  }

  /**
   * 处理DRM信息
   * 当AVPlayer检测到加密内容时触发
   */
  private async handleDRMInfo(drmInfo: media.DRMInfo): Promise<void> {
    try {
      // 从drmInfo中提取PSSH数据
      const psshData = this.extractPSSHData(drmInfo);

      if (psshData) {
        // 生成许可证请求
        const licenseRequest = await this.drmManager.generateLicenseRequest(psshData);

        if (licenseRequest) {
          console.info('[SecurePlayer] 许可证请求已生成，等待许可证响应');
          this.isSecurePlayback = true;
        }
      }
    } catch (error) {
      console.error('[SecurePlayer] DRM信息处理失败');
    }
  }

  /**
   * 从DRM信息中提取PSSH数据
   * PSSH（Protection System Specific Header）包含DRM系统标识和初始化数据
   */
  private extractPSSHData(drmInfo: media.DRMInfo): Uint8Array | null {
    // PSSH通常在DASH的mpd文件或HLS的m3u8文件中
    // 这里简化处理，实际需要从drmInfo中解析
    try {
      if (drmInfo.psshData && drmInfo.psshData.length > 0) {
        return drmInfo.psshData;
      }
    } catch (e) {
      // 忽略
    }
    return null;
  }

  /**
   * 播放加密视频
   * @param videoUrl 加密视频的URL（DASH/HLS）
   */
  async playSecureVideo(videoUrl: string): Promise<void> {
    if (!this.avPlayer) {
      console.error('[SecurePlayer] 播放器未初始化');
      return;
    }

    try {
      // 设置视频URL（DASH的mpd或HLS的m3u8）
      this.avPlayer.url = videoUrl;

      // 准备播放
      await this.avPlayer.prepare();

      // 开始播放
      await this.avPlayer.play();

      console.info('[SecurePlayer] 加密视频播放开始');
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[SecurePlayer] 播放失败: ${err.code} - ${err.message}`);

      // 如果是DRM相关错误，给出明确提示
      if (err.code === 5400104) {
        console.error('[SecurePlayer] DRM许可证无效或过期，请重新获取');
      } else if (err.code === 5400105) {
        console.error('[SecurePlayer] 设备安全级别不足，无法播放此内容');
      }
    }
  }

  /**
   * 检查是否为安全播放模式
   */
  isSecurePlaybackActive(): boolean {
    return this.isSecurePlayback;
  }

  /**
   * 释放资源
   */
  async release(): Promise<void> {
    if (this.avPlayer) {
      await this.avPlayer.release();
      this.avPlayer = null;
    }
    await this.drmManager.release();
    this.isSecurePlayback = false;
  }
}

/**
 * DRM信息扩展（包含PSSH数据）
 */
declare module '@kit.MediaKit' {
  interface DRMInfo {
    drmSchemes: string[];
    psshData?: Uint8Array;
  }
}

3.3 防录屏与内容保护

即使有了DRM和加密，如果用户可以用另一台手机录屏，内容还是会泄露。防录屏是视频安全的最后一道防线。

import { window } from '@kit.ArkUI';
import { BusinessError } from '@kit.BasicServicesKit';

/**
 * 内容保护管理器
 * 提供防录屏、防截图、水印注入等安全能力
 */
class ContentProtectionManager {
  private mainWindow: window.Window | null = null;
  private isScreenCaptureProtected: boolean = false;
  private watermarkText: string = '';

  /**
   * 初始化内容保护
   * @param windowStage 应用窗口
   */
  async initContentProtection(windowStage: window.WindowStage): Promise<void> {
    try {
      this.mainWindow = windowStage.getMainWindow();

      // 设置窗口安全标志，防止屏幕录制和截图
      await this.enableScreenCaptureProtection();

      console.info('[ContentProtection] 内容保护已启用');
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[ContentProtection] 初始化失败: ${err.code} - ${err.message}`);
    }
  }

  /**
   * 启用防录屏保护
   * 设置窗口标志，使系统阻止屏幕录制和截图
   */
  async enableScreenCaptureProtection(): Promise<void> {
    if (!this.mainWindow) {
      console.error('[ContentProtection] 窗口未初始化');
      return;
    }

    try {
      // 设置窗口安全标志
      // HarmonyOS通过设置窗口属性来防止录屏
      this.mainWindow.setWindowPrivacyMode(true);
      this.isScreenCaptureProtected = true;

      console.info('[ContentProtection] 防录屏保护已启用');
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[ContentProtection] 启用防录屏失败: ${err.code} - ${err.message}`);
    }
  }

  /**
   * 禁用防录屏保护
   * 在非DRM内容播放时可以关闭，节省性能
   */
  async disableScreenCaptureProtection(): Promise<void> {
    if (!this.mainWindow) {
      return;
    }

    try {
      this.mainWindow.setWindowPrivacyMode(false);
      this.isScreenCaptureProtected = false;

      console.info('[ContentProtection] 防录屏保护已禁用');
    } catch (error) {
      console.error('[ContentProtection] 禁用防录屏失败');
    }
  }

  /**
   * 设置用户水印
   * 在视频画面上叠加用户信息水印，用于泄露追踪
   * @param userId 用户ID
   * @param userName 用户名
   */
  setUserWatermark(userId: string, userName: string): void {
    // 水印内容：用户ID + 时间戳的哈希
    this.watermarkText = `${userId.slice(0, 4)}***${this.generateWatermarkHash(userId)}`;
    console.info(`[ContentProtection] 水印已设置: ${this.watermarkText}`);
  }

  /**
   * 生成水印哈希值
   * 简化的哈希算法，实际应使用SHA256等安全哈希
   */
  private generateWatermarkHash(input: string): string {
    let hash = 0;
    for (let i = 0; i < input.length; i++) {
      const char = input.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // 转为32位整数
    }
    return Math.abs(hash).toString(16).slice(0, 6).toUpperCase();
  }

  /**
   * 检查HDCP保护状态
   * 确保内容不会通过HDMI输出到未授权设备
   */
  async checkHDCPProtection(): Promise<HDCPStatus> {
    const status: HDCPStatus = {
      isSupported: false,
      currentLevel: 'HDCP_NONE',
      isContentProtected: false,
    };

    try {
      // 通过DRM框架检查HDCP状态
      const drmCapabilities = await new DRMManager().detectDRMCapabilities();
      status.isSupported = drmCapabilities.maxHdcpLevel !== 'HDCP_NONE';
      status.currentLevel = drmCapabilities.maxHdcpLevel;
      status.isContentProtected = drmCapabilities.maxHdcpLevel === 'HDCP_V2_2' ||
        drmCapabilities.maxHdcpLevel === 'HDCP_V2_1' ||
        drmCapabilities.maxHdcpLevel === 'HDCP_V1';
    } catch (error) {
      console.warn('[ContentProtection] HDCP检查失败');
    }

    return status;
  }

  /**
   * 根据内容安全级别自动配置保护策略
   * @param contentLevel 内容安全级别
   */
  async configureProtectionByLevel(contentLevel: ContentSecurityLevel): Promise<void> {
    switch (contentLevel) {
      case ContentSecurityLevel.STANDARD:
        // 标准保护：DRM加密 + 防录屏
        await this.enableScreenCaptureProtection();
        console.info('[ContentProtection] 标准保护策略已应用');
        break;

      case ContentSecurityLevel.HIGH:
        // 高级保护：DRM加密 + 防录屏 + 水印 + HDCP检查
        await this.enableScreenCaptureProtection();
        const hdcpStatus = await this.checkHDCPProtection();
        if (!hdcpStatus.isContentProtected) {
          console.warn('[ContentProtection] HDCP保护不足，可能限制画质');
        }
        console.info('[ContentProtection] 高级保护策略已应用');
        break;

      case ContentSecurityLevel.MAXIMUM:
        // 最高保护：所有安全措施 + 限制画质 + 禁止外部显示
        await this.enableScreenCaptureProtection();
        console.info('[ContentProtection] 最高保护策略已应用');
        break;

      default:
        await this.disableScreenCaptureProtection();
        break;
    }
  }

  /**
   * 获取当前保护状态
   */
  getProtectionStatus(): ContentProtectionStatus {
    return {
      isScreenCaptureProtected: this.isScreenCaptureProtected,
      hasWatermark: this.watermarkText.length > 0,
      watermarkText: this.watermarkText,
    };
  }
}

/**
 * HDCP保护状态
 */
interface HDCPStatus {
  isSupported: boolean;       // 设备是否支持HDCP
  currentLevel: string;       // 当前HDCP级别
  isContentProtected: boolean; // 内容是否受HDCP保护
}

/**
 * 内容安全级别
 */
enum ContentSecurityLevel {
  NONE = 'NONE',             // 无保护
  STANDARD = 'STANDARD',     // 标准保护
  HIGH = 'HIGH',             // 高级保护
  MAXIMUM = 'MAXIMUM',       // 最高保护
}

/**
 * 内容保护状态
 */
interface ContentProtectionStatus {
  isScreenCaptureProtected: boolean;  // 是否启用防录屏
  hasWatermark: boolean;              // 是否有水印
  watermarkText: string;              // 水印文本
}

/**
 * 带水印的视频播放组件
 */
@Component
struct SecureVideoPlayerWithWatermark {
  @State isPlaying: boolean = false;
  @State watermarkVisible: boolean = false;
  private protectionManager: ContentProtectionManager = new ContentProtectionManager();
  private userId: string = 'user_12345';

  build() {
    Stack() {
      // 视频播放区域
      Video({})
        .width('100%')
        .height('100%')
        .autoPlay(false)
        .controls(true)

      // 不可见水印层（叠加在视频上）
      if (this.watermarkVisible) {
        Text(this.protectionManager.getProtectionStatus().watermarkText)
          .fontSize(10)
          .fontColor('rgba(255, 255, 255, 0.08)') // 极低透明度，肉眼不可见但可追踪
          .rotate({ angle: -30 })
          .position({ x: '70%', y: '15%' })
      }

      // 安全状态指示器
      Row() {
        Image($r('sys.media.ohos_ic_public_lock'))
          .width(16)
          .height(16)
          .fillColor('#4CAF50')
        Text('安全播放')
          .fontSize(12)
          .fontColor('#4CAF50')
          .margin({ left: 4 })
      }
      .padding({ left: 8, right: 8, top: 4, bottom: 4 })
      .backgroundColor('rgba(0, 0, 0, 0.5)')
      .borderRadius(12)
      .position({ x: '80%', y: 8 })
    }
    .width('100%')
    .height('100%')
  }

  /**
   * 启用安全播放
   */
  async enableSecurePlayback(): Promise<void> {
    this.protectionManager.setUserWatermark(this.userId, '');
    this.watermarkVisible = true;
    await this.protectionManager.configureProtectionByLevel(ContentSecurityLevel.HIGH);
  }
}

四、踩坑与注意事项

4.1 DRM开发常见陷阱

4.2 防录屏注意事项

问题1：setWindowPrivacyMode不生效

可能原因：

• 窗口类型不支持（需要主窗口）
• 系统版本不支持
• 权限不足

解决方案：

// 确保在正确的时机设置
aboutToAppear(): void {
  // 在组件创建后设置
  setTimeout(async () => {
    await this.protectionManager.enableScreenCaptureProtection();
  }, 500);
}

问题2：防录屏影响性能

setWindowPrivacyMode(true)会增加GPU渲染开销，因为系统需要对画面做额外处理。建议：

• 仅在播放DRM内容时启用
• 播放普通内容时及时关闭
• 避免频繁切换

问题3：录屏检测的局限性

防录屏只能防止系统级的录屏和截图，无法防止：

• 用另一台设备拍摄屏幕
• 使用硬件捕获卡
• 使用模拟器截取

因此，水印是防录屏的重要补充手段。

4.3 安全最佳实践

1. 最小权限原则：只在播放DRM内容时启用安全措施，普通内容不需要
2. 分层防护：DRM加密 + 安全解码 + 防录屏 + 水印，多层防护
3. 密钥安全：密钥永远不要存储在应用层，使用TEE或KeyStore
4. 许可证缓存：离线场景需要安全存储许可证，使用设备绑定的加密存储
5. 完整性校验：定期校验设备状态（是否root、是否有模拟器），异常时降级或拒绝

五、HarmonyOS 6适配

5.1 API变更

5.2 迁移指南

// HarmonyOS 6 新增的PlayReady支持
import { drm } from '@kit.DrmKit';

async function initPlayReadyDRM(): Promise<void> {
  // HarmonyOS 6 支持PlayReady
  const isSupported = drm.isMediaKeySystemSupported('com.microsoft.playready');
  if (isSupported) {
    const keySystem = drm.createMediaKeySystem('com.microsoft.playready');
    const session = keySystem.createMediaKeySession();
    console.info('[DRM] PlayReady初始化成功');
  }
}

// HarmonyOS 6 新增的不可见水印
async function applyInvisibleWatermark(videoSurfaceId: string, userId: string): Promise<void> {
  // 不可见水印嵌入到视频帧中，肉眼不可见但可提取追踪
  const watermark = drm.createInvisibleWatermark({
    surfaceId: videoSurfaceId,
    payload: userId,
    strength: 0.02,  // 水印强度，越高越耐攻击但越可见
    algorithm: 'dwt', // 离散小波变换
  });

  await watermark.apply();
  console.info('[DRM] 不可见水印已应用');
}

// HarmonyOS 6 新增的设备证明
async function verifyDeviceIntegrity(): Promise<boolean> {
  try {
    const attestation = drm.getDeviceAttestation();
    const result = await attestation.verify({
      challenge: new Uint8Array(32), // 随机挑战值
      includeRootOfTrust: true,
    });

    if (result.isTrusted && !result.isRooted && !result.isEmulator) {
      console.info('[DRM] 设备完整性验证通过');
      return true;
    } else {
      console.warn('[DRM] 设备完整性验证失败');
      return false;
    }
  } catch (error) {
    return false;
  }
}

5.3 HarmonyOS 6离线许可证管理

// HarmonyOS 6 离线许可证管理
import { drm } from '@kit.DrmKit';

class OfflineLicenseManager {
  private keySystem: drm.MediaKeySystem | null = null;

  /**
   * 下载离线许可证
   * 在有网络时预先获取，离线时使用
   */
  async downloadOfflineLicense(contentId: string, psshData: Uint8Array): Promise<boolean> {
    try {
      this.keySystem = drm.createMediaKeySystem('com.widevine.alpha');
      const session = this.keySystem.createMediaKeySession();

      // 请求离线许可证
      const request = await session.generateMediaKeyRequest(psshData);

      // 向服务器请求许可证
      const licenseResponse = await this.fetchLicenseFromServer(request.data);

      // 处理许可证响应
      await session.processMediaKeyResponse(licenseResponse);

      // 保存离线许可证（系统安全存储）
      const offlineLicense = await session.getOfflineLicense();
      await this.saveOfflineLicense(contentId, offlineLicense);

      console.info(`[OfflineLicense] 离线许可证下载成功: ${contentId}`);
      return true;
    } catch (error) {
      console.error('[OfflineLicense] 下载失败');
      return false;
    }
  }

  /**
   * 使用离线许可证播放
   */
  async playWithOfflineLicense(contentId: string): Promise<boolean> {
    try {
      const license = await this.loadOfflineLicense(contentId);
      if (!license) {
        console.error('[OfflineLicense] 未找到离线许可证');
        return false;
      }

      // 检查许可证是否过期
      if (license.expiryTime < Date.now()) {
        console.error('[OfflineLicense] 许可证已过期');
        await this.removeOfflineLicense(contentId);
        return false;
      }

      console.info('[OfflineLicense] 离线许可证有效，可以播放');
      return true;
    } catch (error) {
      return false;
    }
  }

  private async fetchLicenseFromServer(data: Uint8Array): Promise<Uint8Array> {
    // 简化：实际需要HTTP请求
    return new Uint8Array(0);
  }

  private async saveOfflineLicense(contentId: string, license: drm.OfflineLicense): Promise<void> {
    // 安全存储
  }

  private async loadOfflineLicense(contentId: string): Promise<drm.OfflineLicense | null> {
    return null;
  }

  private async removeOfflineLicense(contentId: string): Promise<void> {
    // 删除过期许可证
  }
}

六、总结

mindmap
  root((视频安全))
    DRM数字版权管理
      Widevine
        L1 最高安全
        L2 中等安全
        L3 基础安全
      PlayReady
        微软方案
        HarmonyOS 6支持
      ClearKey
        W3C标准
        测试/低安全场景
      华为DRM
        HDR Vivid配套
    视频加密
      CENC通用加密
      AES-CTR流式加密
      AES-CBC块加密
      SAMPLE-AES采样加密
    安全解码
      TEE安全执行环境
      硬件安全解码器
      密钥不可提取
      画面直接输出
    防录屏
      setWindowPrivacyMode
      系统级防截图
      不可见水印
      HDCP保护
    许可证管理
      在线许可证
      离线许可证
      许可证刷新
      过期处理
    HarmonyOS 6
      PlayReady支持
      不可见水印API
      设备证明
      离线许可证管理
      实时HDCP监控

关键要点回顾：

1. DRM是视频安全的核心：没有DRM，加密的视频密钥可以被提取，所有安全措施都形同虚设
2. Widevine L1是行业标杆：L1级别要求TEE内完成解码和渲染，是目前移动端最高安全级别
3. CENC让多DRM共存：一份加密内容，Widevine/PlayReady/FairPlay都能解密，降低内容方的分发成本
4. 防录屏是必要补充：DRM防不了物理录屏，水印是追踪泄露源的关键手段
5. 安全与体验要平衡：过度安全措施会影响播放性能和用户体验，根据内容价值选择合适的安全级别
6. HarmonyOS 6安全能力大幅增强：PlayReady支持、不可见水印、设备证明、离线许可证管理，构建完整的视频安全生态

至此，「视频开发下」系列5篇文章全部完成。从直播推流到视频缩略图，从字幕渲染到HDR视频，再到视频安全，我们完整覆盖了HarmonyOS视频开发的高级主题。希望这些内容能帮助你在实际项目中少走弯路，打造出色的视频体验。