Aumente a segurança do seu aplicativo com o campo nonce da API Play Integrity

postado por Oscar Rodriguez, engenheiro de relações com desenvolvedores

Com o recente lançamento do API de integridade do jogomais desenvolvedores estão tomando medidas para proteger seus jogos e aplicativos de interações potencialmente arriscadas e fraudulentas.

Além de sinais úteis sobre a integridade do aplicativo, a integridade do dispositivo e informações de licenciamento, a Play Integrity API apresenta um recurso simples, mas muito útil, chamado “nonce” que, quando usado corretamente, pode fortalecer ainda mais as proteções existentes a Play Integrity API oferece, além de mitigar certos tipos de ataques, como ataques de adulteração de pessoa no meio (PITM) e ataques de repetição.

Nesta postagem do weblog, analisaremos mais detalhadamente o que é o nonce, como funciona e como pode ser usado para proteger ainda mais seu aplicativo.

O que é um nonce?

Em criptografia e engenharia de segurança, um nonce (número uma vez) é um número usado apenas uma vez em uma comunicação segura. Existem muitas aplicações para nonces, como autenticação, criptografia e hashing.

Na API Play Integrity, o nonce é um blob binário codificado em base 64 opaco que você outline antes de invocar a verificação de integridade da API e será retornado como está dentro da resposta assinada da API. Dependendo de como você cria e valida o nonce, é possível aproveitá-lo para fortalecer ainda mais as proteções existentes que a Play Integrity API oferece, bem como mitigar certos tipos de ataques, como adulteração de pessoa no meio (PITM). ataques e ataques de repetição.

Além de retornar o nonce como está na resposta assinada, a Play Integrity API não executa nenhum processamento dos dados reais do nonce, portanto, desde que seja um valor de base 64 válido, você pode definir qualquer valor arbitrário. Dito isso, para assinar digitalmente a resposta, o nonce é enviado para os servidores do Google, por isso é muito importante não definir o nonce para nenhum tipo de informação de identificação pessoal (PII), como o nome do usuário, telefone ou endereço de email .

Configurando o nonce

Depois de ter configurar seu aplicativo para usar a API Play Integritytu definir o nonce com o setNonce() ou sua variante apropriada, disponível nas versões Kotlin, Java, Team spirit e Local da API.

Kotlin:

val nonce: String = ...

// Create an example of a supervisor.
val integrityManager =
    IntegrityManagerFactory.create(applicationContext)

// Request the integrity token by way of offering a nonce.
val integrityTokenResponse: Activity<IntegrityTokenResponse> =
    integrityManager.requestIntegrityToken(
        IntegrityTokenRequest.builder()
             .setNonce(nonce) // Set the nonce
             .construct())

Java:

String nonce = ...

// Create an example of a supervisor.
IntegrityManager integrityManager =
    IntegrityManagerFactory.create(getApplicationContext());

// Request the integrity token by way of offering a nonce.
Activity<IntegrityTokenResponse> integrityTokenResponse =
    integrityManager
        .requestIntegrityToken(
            IntegrityTokenRequest.builder()
            .setNonce(nonce) // Set the nonce
            .construct());

Unidade:

string nonce = ...

// Create an example of a supervisor.
var integrityManager = new IntegrityManager();

// Request the integrity token by way of offering a nonce.
var tokenRequest = new IntegrityTokenRequest(nonce);
var requestIntegrityTokenOperation =
    integrityManager.RequestIntegrityToken(tokenRequest);

Nativo:

/// Create an IntegrityTokenRequest object.
const char* nonce = ...
IntegrityTokenRequest* request;
IntegrityTokenRequest_create(&request);
IntegrityTokenRequest_setNonce(request, nonce); // Set the nonce
IntegrityTokenResponse* reaction;
IntegrityErrorCode error_code =
        IntegrityManager_requestIntegrityToken(request, &reaction);

Verificando o nonce

A resposta da API Play Integrity é retornada na forma de um Token da Internet JSON (JWT)cuja carga é um texto JSON de texto simplesno seguinte formato:

  requestDetails:  ... 
  appIntegrity:  ... 
  deviceIntegrity:  ... 
  accountDetails:  ... 

O nonce pode ser encontrado dentro do requestDetails estrutura, que é formatada da seguinte maneira:

requestDetails: 
  requestPackageName: "...",
  nonce: "...",
  timestampMillis: ...

O valor do nonce campo deve corresponder exatamente ao que você passou anteriormente para a API. Além disso, como o nonce está dentro da resposta assinada criptograficamente da Play Integrity API, não é viável alterar seu valor após o recebimento da resposta. É aproveitando essas propriedades que é possível usar o nonce para proteger ainda mais seu aplicativo.

Protegendo operações de alto valor

Consideremos o cenário em que um usuário mal-intencionado está interagindo com um jogo on-line que informa a pontuação do jogador ao servidor do jogo. Nesse caso, o dispositivo não é comprometido, mas o usuário pode visualizar e modificar o fluxo de dados da rede entre o jogo e o servidor com a ajuda de um servidor proxy ou VPN, para que o usuário mal-intencionado possa reportar uma pontuação mais alta, enquanto o pontuação actual é muito menor.

A simples chamada da Play Integrity API não é suficiente para proteger o aplicativo neste caso: o dispositivo não está comprometido e o aplicativo é legítimo, portanto, todas as verificações feitas pela Play Integrity API serão aprovadas.

No entanto, é possível aproveitar o nonce da API Play Integrity para proteger essa operação específica de alto valor de relatar a pontuação do jogo, codificando o valor da operação dentro do nonce. A implementação é a seguinte:

1. O usuário inicia a ação de alto valor.
2. Seu aplicativo prepara uma mensagem que deseja proteger, por exemplo, no formato JSON.
3. Seu aplicativo calcula um hash criptográfico da mensagem que deseja proteger. Por exemplo, com os algoritmos de hash SHA-256 ou SHA-3-256.
4. Seu aplicativo chama a API Play Integrity e chama setNonce() para definir o campo nonce para o hash criptográfico calculado na etapa anterior.
5. Seu aplicativo envia a mensagem que deseja proteger e o resultado assinado da Play Integrity API para seu servidor.
6. Seu servidor de aplicativos verifica se o hash criptográfico da mensagem recebida corresponde ao valor do campo nonce no resultado assinado e rejeita quaisquer resultados que não correspondam.

O diagrama de sequência a seguir ilustra essas etapas:

Contanto que a mensagem unique a ser protegida seja enviada junto com o resultado assinado, e tanto o servidor quanto o cliente usem exatamente o mesmo mecanismo para calcular o nonce, isso oferece uma area of expertise garantia de que a mensagem não foi adulterada.

Follow que, nesse cenário, o modelo de segurança funciona sob a suposição de que o ataque está acontecendo na rede, não no dispositivo ou no aplicativo, portanto, é particularmente importante verificar também os sinais de integridade do dispositivo e do aplicativo que a Play Integrity API oferece como Nós vamos.

Evitando ataques de repetição

Vamos considerar outro cenário em que um usuário mal-intencionado está tentando interagir com um aplicativo cliente-servidor protegido pela Play Integrity API, mas deseja fazê-lo com um dispositivo comprometido, de forma que o servidor não detecte isso.

Para fazer isso, o invasor primeiro america o aplicativo com um dispositivo legítimo e coleta a resposta assinada da API Play Integrity. O invasor america o aplicativo com o dispositivo comprometido, intercepta a chamada da Play Integrity API e, em vez de realizar as verificações de integridade, simplesmente retorna a resposta assinada gravada anteriormente.

Como a resposta assinada não foi alterada de forma alguma, a assinatura virtual parecerá correta e o servidor do aplicativo pode ser enganado ao pensar que está se comunicando com um dispositivo legítimo. Isso é chamado de ataque de repetição.

A primeira linha de defesa contra tal ataque é verificar a timestampMillis campo na resposta assinada. Este campo contém o carimbo de knowledge/hora de quando a resposta foi criada e pode ser útil na detecção de respostas antigas suspeitas, mesmo quando a assinatura virtual é verificada como autêntica.

Dito isso, também é possível aproveitar o nonce na API Play Integrity, para atribuir um valor exclusivo a cada resposta e verificar se a resposta corresponde ao valor exclusivo definido anteriormente. A implementação é a seguinte:

1. O servidor cria um valor globalmente exclusivo de uma forma que os usuários mal-intencionados não podem prever. Por exemplo, um número aleatório criptograficamente seguro de 128 bits ou maior.
2. Seu aplicativo chama a API Play Integrity e outline o campo nonce como o valor exclusivo recebido pelo servidor de aplicativos.
3. Seu aplicativo envia o resultado assinado da Play Integrity API para seu servidor.
4. Seu servidor verifica se o campo nonce no resultado assinado corresponde ao valor exclusivo gerado anteriormente e rejeita quaisquer resultados que não correspondam.

O diagrama de sequência a seguir ilustra essas etapas:

Com essa implementação, cada vez que o servidor solicita que o aplicativo chame a API Play Integrity, ele o faz com um valor único globalmente diferente, portanto, enquanto esse valor não puder ser previsto pelo invasor, não será possível reutilizar uma resposta anterior , pois o nonce não corresponderá ao valor esperado.

Combinando ambas as proteções

Embora os dois mecanismos descritos acima funcionem de maneiras muito diferentes, se um aplicativo exigir as duas proteções ao mesmo pace, é possível combiná-las em uma única chamada à API Play Integrity, por exemplo, anexando os resultados de ambas as proteções em um arquivo maior base-64 nonce. Uma implementação que combina ambas as abordagens é a seguinte:

1. O usuário inicia a ação de alto valor.
2. Seu aplicativo solicita ao servidor um valor exclusivo para identificar a solicitação
3. Seu servidor de aplicativos gera um valor globalmente exclusivo de uma forma que usuários mal-intencionados não podem prever. Por exemplo, você pode usar um gerador de números aleatórios criptograficamente seguro para criar tal valor. Recomendamos criar valores de 128 bits ou maiores.
4. Seu servidor de aplicativos envia o valor globalmente exclusivo para o aplicativo.
5. Seu aplicativo prepara uma mensagem que deseja proteger, por exemplo, no formato JSON.
6. Seu aplicativo calcula um hash criptográfico da mensagem que deseja proteger. Por exemplo, com os algoritmos de hash SHA-256 ou SHA-3-256.
7. Seu aplicativo cria uma string anexando o valor exclusivo recebido de seu servidor de aplicativos e o hash da mensagem que deseja proteger.
8. Seu aplicativo chama a API Play Integrity e chama setNonce() para definir o campo nonce para a string criada na etapa anterior.
9. Seu aplicativo envia a mensagem que deseja proteger e o resultado assinado da Play Integrity API para seu servidor.
10. Seu servidor de aplicativos divide o valor do campo nonce e verifica se o hash criptográfico da mensagem, bem como o valor exclusivo gerado anteriormente, correspondem aos valores esperados e rejeita quaisquer resultados que não correspondam.

O diagrama de sequência a seguir ilustra essas etapas:

Estes são alguns exemplos de como você pode usar o nonce para proteger ainda mais seu aplicativo contra usuários mal-intencionados. Se seu aplicativo lida com dados confidenciais ou está vulnerável a abusos, esperamos que você tome medidas para mitigar essas ameaças com a ajuda da Play Integrity API.

Para saber mais sobre como usar a API Play Integrity e começar, visite a documentação em g.co/play/integrityapi.