O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Esta página foi traduzida pela API Cloud Translation.

DRM

Este documento fornece uma visão geral da estrutura de gerenciamento de direitos digitais (DRM) do Android e apresenta as interfaces que um plug-in DRM deve implementar. Este documento não descreve regras de robustez ou regras de conformidade que podem ser definidas por um esquema DRM.

Estrutura

A plataforma Android fornece uma estrutura de DRM extensível que permite que os aplicativos gerenciem conteúdo protegido por direitos de acordo com as restrições de licença associadas ao conteúdo. A estrutura DRM suporta muitos esquemas DRM; quais esquemas de DRM um dispositivo suporta depende do fabricante do dispositivo. A estrutura de DRM fornece uma interface unificada para desenvolvedores de aplicativos e oculta a complexidade das operações de DRM. A estrutura DRM fornece um modo de operação consistente para conteúdo protegido e não protegido. Os esquemas de DRM podem definir modelos de uso complexos por metadados de licença. A estrutura DRM fornece a associação entre o conteúdo DRM e a licença e trata do gerenciamento de direitos. Isso permite que o media player seja abstraído de conteúdo protegido por DRM ou não protegido. Consulte MediaDrm para obter a classe para obter chaves para descriptografar fluxos de mídia protegidos.

Figura 1a. Camada de abstração de hardware DRM antes do Android 11

Figura 1b. Camada de abstração de hardware DRM começando no Android 11

A disponibilidade de conteúdo digital rico é importante para usuários em dispositivos móveis. Para tornar seu conteúdo amplamente disponível, os desenvolvedores Android e os editores de conteúdo digital precisam de uma implementação consistente de DRM com suporte em todo o ecossistema Android. Para disponibilizar esse conteúdo digital em dispositivos Android e garantir que haja pelo menos um DRM consistente disponível em todos os dispositivos, o Google fornece DRM sem taxas de licença em dispositivos Android compatíveis. O plug-in DRM é integrado à estrutura DRM do Android e pode usar proteção com suporte de hardware para proteger o conteúdo premium e as credenciais do usuário.

A proteção de conteúdo fornecida pelo plug-in DRM depende dos recursos de segurança e proteção de conteúdo da plataforma de hardware subjacente. Os recursos de hardware do dispositivo devem incluir inicialização segura de hardware para estabelecer uma cadeia de confiança de segurança e proteção de chaves criptográficas. Os recursos de proteção de conteúdo do dispositivo devem incluir proteção de quadros descriptografados no dispositivo e proteção de conteúdo por meio de um mecanismo de proteção de saída confiável. Nem todas as plataformas de hardware suportam todos os recursos de segurança e proteção de conteúdo acima. A segurança nunca é implementada em um único lugar na pilha, mas depende da integração de hardware, software e serviços. A combinação de funções de segurança de hardware, um mecanismo de inicialização confiável e um sistema operacional seguro isolado para lidar com funções de segurança é fundamental para fornecer um dispositivo seguro.

Arquitetura

A estrutura DRM foi projetada para ser independente de implementação e abstrai os detalhes da implementação específica do esquema DRM em um plug-in DRM específico do esquema. A estrutura DRM inclui APIs simples para lidar com operações DRM complexas, adquirir licenças, provisionar o dispositivo, associar conteúdo DRM e sua licença e, finalmente, descriptografar conteúdo DRM.

A estrutura de DRM do Android é implementada em duas camadas de arquitetura:

Uma API de estrutura de DRM, que é exposta a aplicativos por meio da estrutura de aplicativo Android.
Uma estrutura de DRM de código nativo, que expõe uma interface para plug-ins de DRM (agentes) para lidar com gerenciamento de direitos e descriptografia para vários esquemas de DRM.

Figura 2a. Estrutura de DRM antes do Android 11

Figura 2b. Estrutura de DRM a partir do Android 11

Consulte Android Media DRM e Android Media Crypto para obter mais detalhes.

Plug-ins DRM

Na inicialização do sistema, a estrutura DRM verifica instâncias/serviços HAL (descritos em arquivos .rc ) e os plug-ins são descobertos por meio do registro HIDL. Media DRM Server ( mediadrmserver ) cria objetos CryptoHal e DrmHal . CryptoHal e DrmHal então chamam os plugins com implementações específicas do fornecedor.

Os plug-ins devem implementar HALs vinculados. Os HALs vinculados usam a linguagem de definição de interface HAL (HIDL) , que permite que a estrutura seja substituída sem a necessidade de reconstruir HALs.

Os plug-ins são criados por fornecedores ou fabricantes de SOC e colocados em uma partição /vendor no dispositivo. Todos os dispositivos lançados com Android 8.0 ou superior devem oferecer suporte a HALs vinculados escritos na linguagem HIDL.

Implementação

Para implementar novas APIs de frameworks DRM por um plug-in:

Adicione o serviço de plug-in aos arquivos de compilação do dispositivo.
Atualize o manifesto do dispositivo.
Adicione permissões do SELinux.
Crie um arquivo .rc em /vendor .
Implemente o plug-in.

As APIs são definidas em cada versão de IDrmPlugin.hal , ICryptoPlugin.hal , IDrmFactory.hal e ICryptoFactory.hal

PLATFORM_ROOT/hardware/interfaces/drm/VERSION/

Adicionando serviço de plug-in aos arquivos de compilação do dispositivo

Por exemplo, para adicionar suporte à interface 1.3, o arquivo VENDOR DEVICE /device.mk deve incluir os pacotes android.hardware.drm@1.3-service.* :

As versões 1.0 a 1.2 estão obsoletas no R / Android 11. Os dispositivos atualizados para R ainda podem executar as versões 1.0 a 1.2. No entanto, novos dispositivos iniciados com R devem executar apenas a versão 1.3.


  PRODUCT_PACKAGES += \
    android.hardware.drm@1.0-impl \
    android.hardware.drm@1.0-service \
    android.hardware.drm@1.3-service.clearkey \
    android.hardware.drm@1.3-service.widevine

Atualizando o manifesto do dispositivo

O arquivo vendor manifest.xml para o dispositivo deve incluir as seguintes entradas:


  <hal format="hidl">
    <name>android.hardware.drm</name>
      <transport>hwbinder</transport>
      <fqname>@1.3::ICryptoFactory/clearkey</fqname>
      <fqname>@1.3::IDrmFactory/clearkey</fqname>
      <fqname>@1.3::ICryptoFactory/widevine</fqname>
      <fqname>@1.3::IDrmFactory/widevine</fqname>
  </hal>

Como alternativa, recomendamos o uso de vintf_fragments.

Adicionando permissões do SELinux

Adicionar ao VENDOR DEVICE /sepolicy/vendor/file.te

type mediadrm_vendor_data_file, file_type, data_file_type;

Adicionar ao VENDOR DEVICE /sepolicy/vendor/file_contexts

Recomendamos o uso de expressões regulares para especificar os números de versão para evitar fazer atualizações para novos lançamentos, por exemplo:

/vendor/bin/hw/android\.hardware\.drm@\[0-9]+\.[0-9]+-service\.clearkey
      u:object_r:hal_drm_clearkey_exec:s0

    /data/vendor/mediadrm(/.*)? u:object_r:mediadrm_vendor_data_file:s0

Como alternativa, atualize os números de versão conforme mostrado abaixo.

/vendor/bin/hw/android\.hardware\.drm@1\.3-service\.clearkey
      u:object_r:hal_drm_clearkey_exec:s0

    /data/vendor/mediadrm(/.*)? u:object_r:mediadrm_vendor_data_file:s0

Adicione a device/sepolicy/vendor/hal_drm_clearkey.te

allow hal_drm_clearkey mediadrm_vendor_data_file:dir create_dir_perms;
    allow hal_drm_clearkey mediadrm_vendor_data_file:file create_file_perms;

Criando um arquivo .rc em /vendor

O arquivo .rc especifica as ações a serem tomadas quando um serviço é iniciado.

Consulte o idioma de inicialização do Android para obter detalhes.

Implementando o plug-in

Implemente o ponto de entrada main() em service.cpp do serviço de plugin.
Implemente ICryptoPlugin , IDrmPlugin , ICryptoFactory e IDrmFactory .
Implemente as novas APIs no plug-in.

Detalhes do plug-in DRM

Os fornecedores de plug-ins DRM implementam o plug-in DrmFactory , CryptoFactory e DRM.

DrmFactory

A classe DrmHal procura por serviços de plug-in DRM registrados e constrói plug-ins correspondentes que suportam um determinado esquema de criptografia por meio da classe DrmFactory .

IDrmFactory é o principal ponto de entrada para interagir com o drm HAL de um fornecedor por meio da API createPlugin. A API createPlugin é usada para criar instâncias de IDrmPlugin. O IDrmFactory 1.3 deve sempre criar interfaces IDrmPlugin 1.2, que são retornadas através do método createPlugin 1.0.

Return<void> getSupportedCryptoSchemes(getSupportedCryptoSchemes_cb _hidl_cb);

Novo no IDrmFactory 1.3, getSupportedCryptoSchemes retorna uma lista de esquemas de criptografia suportados para a instância HIDL drm HAL.

Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>uuid);

Determina se a fábrica de plugins é capaz de construir plugins DRM que suportam um determinado esquema de criptografia, que é especificado por um UUID.

Return<bool> isContentTypeSupported(const hidl_string &mimeType);

Determina se a fábrica de plug-ins é capaz de construir plug-ins DRM que suportam um determinado formato de contêiner de mídia especificado por mimeType .

Return<void> createPlugin(const hidl_array<uint8_t, 16>uuid,
        const hidl_string& appPackageName, createPlugin_cb _hidl_cb);

Constrói um plugin DRM para o esquema de criptografia especificado pelo UUID.

CryptoFactory

A classe CryptoHal procura por serviços de plug-in DRM registrados e constrói plug-ins correspondentes que suportam um determinado esquema de criptografia por meio da classe CryptoFactory .

Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>uuid);

Determina se a fábrica de criptografia é capaz de construir plugins de criptografia que suportam um determinado esquema de criptografia, que é especificado por um UUID.

Return<void> createPlugin(const hidl_array<uint8_t, 16>uuid,
        const hidl_vec<uint8_t>initData, createPlugin_cb _hidl_cb)

Determina se a fábrica de plug-ins é capaz de construir plug-ins de criptografia que suportam um determinado esquema de criptografia, que é especificado por um UUID.

Plug-in DRM

As APIs são definidas em hardware/interfaces/drm/ VERSION /IDrmPlugin.hal . O arquivo IDrmPlugin.h correspondente pode ser encontrado em out/Logo após a compilação.