Carregamento dinâmico de código

Categoria do OWASP: MASVS-CODE - Qualidade do código (link em inglês)

Visão geral

O carregamento dinâmico de código em um aplicativo introduz um nível de risco que precisa ser mitigado. Os invasores podem adulterar ou substituir o código para acessar dados sensíveis ou executar ações nocivas.

Muitas formas de carregamento de código dinâmico, especialmente aquelas que usam fontes remotas, violam as políticas do Google Play e podem levar à suspensão do app no Google Play.

Impacto

Se os invasores conseguirem ter acesso ao código que será carregado no aplicativo, eles poderão modificá-lo para atingir as metas. Isso pode levar à exfiltração de dados e à execução de explorações de execução. Mesmo que os invasores não possam modificar o código para executar ações arbitrárias da sua escolha, ainda é possível corromper ou remover o código e afetar a disponibilidade do aplicativo.

Mitigações

Evite usar o carregamento de código dinâmico

A menos que haja uma necessidade comercial, evite o carregamento dinâmico de código. Sempre que possível, inclua todas as funcionalidades diretamente no aplicativo.

Usar fontes confiáveis

O código que será carregado no aplicativo precisa ser armazenado em locais confiáveis. Em relação ao armazenamento local, o armazenamento interno do aplicativo ou o armazenamento com escopo (para o Android 10 e versões mais recentes) são os locais recomendados. Esses locais têm medidas para evitar o acesso direto de outros apps e usuários.

Ao carregar código de locais remotos, como URLs, evite usar terceiros sempre que possível e armazene o código na sua própria infraestrutura, seguindo as práticas de segurança recomendadas. Se você precisar carregar um código de terceiros, verifique se o provedor é confiável.

Realizar verificações de integridade

As verificações de integridade são recomendadas para garantir que o código não tenha sido adulterado. Essas verificações precisam ser realizadas antes de carregar o código no aplicativo.

Ao carregar recursos remotos, a integridade do subrecurso pode ser usada para validar a integridade dos recursos acessados.

Ao carregar recursos do armazenamento externo, use verificações de integridade para verificar se nenhum outro aplicativo adulterou esses dados ou o código. Os hashes dos arquivos precisam ser armazenados de forma segura, de preferência criptografados e no armazenamento interno.

Kotlin

package com.example.myapplication

import java.io.BufferedInputStream
import java.io.FileInputStream
import java.io.IOException
import java.security.MessageDigest
import java.security.NoSuchAlgorithmException

object FileIntegrityChecker {
    @Throws(IOException::class, NoSuchAlgorithmException::class)
    fun getIntegrityHash(filePath: String?): String {
        val md = MessageDigest.getInstance("SHA-256") // You can choose other algorithms as needed
        val buffer = ByteArray(8192)
        var bytesRead: Int
        BufferedInputStream(FileInputStream(filePath)).use { fis ->
            while (fis.read(buffer).also { bytesRead = it } != -1) {
                md.update(buffer, 0, bytesRead)
            }

    }

    private fun bytesToHex(bytes: ByteArray): String {
        val sb = StringBuilder(bytes.length * 2)
        for (b in bytes) {
            sb.append(String.format("%02x", b))
        }
        return sb.toString()
    }

    @Throws(IOException::class, NoSuchAlgorithmException::class)
    fun verifyIntegrity(filePath: String?, expectedHash: String): Boolean {
        val actualHash = getIntegrityHash(filePath)
        return actualHash == expectedHash
    }

    @Throws(Exception::class)
    @JvmStatic
    fun main(args: Array<String>) {
        val filePath = "/path/to/your/file"
        val expectedHash = "your_expected_hash_value"
        if (verifyIntegrity(filePath, expectedHash)) {
            println("File integrity is valid!")
        } else {
            println("File integrity is compromised!")
        }
    }
}

Java

package com.example.myapplication;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class FileIntegrityChecker {

    public static String getIntegrityHash(String filePath) throws IOException, NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-256"); // You can choose other algorithms as needed
        byte[] buffer = new byte[8192];
        int bytesRead;

        try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream(filePath))) {
            while ((bytesRead = fis.read(buffer)) != -1) {
                md.update(buffer, 0, bytesRead);
            }
        }

        byte[] digest = md.digest();
        return bytesToHex(digest);
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    public static boolean verifyIntegrity(String filePath, String expectedHash) throws IOException, NoSuchAlgorithmException {
        String actualHash = getIntegrityHash(filePath);
        return actualHash.equals(expectedHash);
    }

    public static void main(String[] args) throws Exception {
        String filePath = "/path/to/your/file";
        String expectedHash = "your_expected_hash_value";

        if (verifyIntegrity(filePath, expectedHash)) {
            System.out.println("File integrity is valid!");
        } else {
            System.out.println("File integrity is compromised!");
        }
    }
}

Assinar o código

Outra opção para garantir a integridade dos dados é assinar o código e verificar a assinatura antes de carregá-lo. Esse método tem a vantagem de também garantir a integridade do código hash, não apenas o código em si, o que oferece uma proteção anti-adulteração adicional.

Embora a assinatura de código ofereça camadas de segurança adicionais, é importante considerar que esse é um processo mais complexo que pode exigir mais esforço e recursos para ser implementado.

Alguns exemplos de assinatura de código podem ser encontrados na seção "Recursos" deste documento.

Recursos