Modelos de ML maliciosos e picles quebrados

Modelos de ML maliciosos aproveitam o formato de picles quebrados para evitar a detecção

Recentemente, pesquisadores de segurança cibernética descobriram dois modelos de machine learning (ML) maliciosos na plataforma Hugging Face. Esses modelos exploraram uma técnica incomum envolvendo arquivos Pickle “quebrados” para evadir detecção. O caso, batizado de nullifAI, revela uma vulnerabilidade crítica no formato de serialização Pickle, amplamente utilizado para distribuir modelos de ML.

Neste artigo, vamos explorar o que aconteceu, os riscos associados ao formato Pickle e como você pode usar scripts em Python para mitigar esses riscos.

 

O Que aconteceu?

Os modelos maliciosos, hospedados nos repositórios glockr1/ballr7 e who-r-u0000/0000000000000000000000000000000000000, continham arquivos Pickle manipulados. Esses arquivos incluíam um payload malicioso no início do fluxo de dados, que consistia em um reverse shell conectado a um endereço IP pré-definido. O objetivo era executar código arbitrário no sistema da vítima assim que o modelo fosse carregado.

 

Por que o Pickle é um problema?

O formato Pickle é amplamente utilizado para serializar e desserializar objetos em Python, incluindo modelos de ML. No entanto, ele é conhecido por ser inseguro, pois permite a execução de código arbitrário durante a desserialização. No caso dos modelos maliciosos, os atacantes exploraram essa característica para injetar código malicioso.

Além disso, os modelos foram compactados no formato 7z (em vez do formato ZIP padrão usado pelo PyTorch), o que ajudou a evitar a detecção por ferramentas como o Picklescan, utilizado pelo Hugging Face para identificar arquivos Pickle suspeitos.

 

Modelos de ML maliciosos

 

Riscos associados ao pickle

  • Execução de código arbitrário: A desserialização de arquivos Pickle pode executar código Python, o que pode ser explorado para injetar malware.

  • Evasão  de detecção: : A manipulação de arquivos Pickle, como a inserção de payloads no início do fluxo, pode fazer com que ferramentas de segurança ignorem o código malicioso.

  • Falha na desserialização: Arquivos Pickle “quebrados” podem ainda executar código malicioso, mesmo que a desserialização falhe parcialmente.

 

Como mitigar os riscos?

Abaixo estão exemplos de scripts em Python que você pode usar para mitigar os riscos associados a arquivos Pickle maliciosos.

 

1. Verificação de arquivos Pickle com Picklescan

O Picklescan é uma ferramenta de código aberto que analisa arquivos Pickle em busca de código suspeito. Você pode integrá-lo ao seu fluxo de trabalho para verificar modelos antes de carregá-los.

 

import picklescan

def scan_pickle_file(file_path):
    try:
        results = picklescan.scan(file_path)
        if results['unsafe_opcodes']:
            print(f"Arquivo {file_path} contém opcodes inseguros: 
{results['unsafe_opcodes']}")
        else:
            print(f"Arquivo {file_path} é seguro.")
    except Exception as e:
        print(f"Erro ao escanear o arquivo {file_path}: {e}")

# Exemplo de uso
scan_pickle_file("modelo_malicioso.pkl")

https://thehackernews.com/2025/02/malicious-ml-models-found-on-hugging.html


2. Carregamento Seguro de Modelos com Verificação de Hash

Antes de carregar um modelo, verifique sua integridade usando um hash (como SHA-256) para garantir que o arquivo não foi alterado.

 

import hashlib

def calculate_file_hash(file_path):
    sha256_hash = hashlib.sha256()
    with open(file_path, "rb") as f:
        for byte_block in iter(lambda: f.read(4096), b""):
            sha256_hash.update(byte_block)
    return sha256_hash.hexdigest()

def verify_model_integrity(model_path, expected_hash):
    file_hash = calculate_file_hash(model_path)
    if file_hash == expected_hash:
        print("Integridade do modelo verificada. Carregando...")
        # Carregue o modelo aqui
    else:
        print("Erro: Hash do modelo não corresponde ao esperado. 
Possível alteração maliciosa.")

# Exemplo de uso
expected_hash = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
verify_model_integrity("modelo.pkl", expected_hash)

 

3. Análise de conteúdo de arquivos Pickle

Você pode inspecionar manualmente o conteúdo de um arquivo Pickle para identificar código suspeito.

 

import pickle

def inspect_pickle_file(file_path):
    try:
        with open(file_path, "rb") as f:
            data = pickle.load(f)
            print("Conteúdo do arquivo Pickle:", data)
    except Exception as e:
        print(f"Erro ao carregar o arquivo Pickle: {e}")

# Exemplo de uso
inspect_pickle_file("modelo_malicioso.pkl")


4. Uso de formatos alternativos

Prefira formatos mais seguros, como ONNX ou TensorFlow SavedModel, que não permitem a execução de código arbitrário.

 

import onnx

def load_onnx_model(file_path):
    try:
        model = onnx.load(file_path)
        print("Modelo ONNX carregado com sucesso.")
        return model
    except Exception as e:
        print(f"Erro ao carregar o modelo ONNX: {e}")

# Exemplo de uso
load_onnx_model("modelo_seguro.onnx")


Boas práticas para evitar riscos

  • Verifique a origem dos modelos: Só baixe modelos de fontes confiáveis.

  • Use ferramentas de análise: Integre ferramentas como Picklescan ao seu fluxo de trabalho.

  • Prefira formatos seguros: Evite o uso de Pickle sempre que possível.

  • Monitore atividades suspeitas: Fique atento a comportamentos incomuns durante o carregamento de modelos.

 

Conclusão

A descoberta de modelos maliciosos no Hugging Face é um alerta importante sobre os riscos associados ao formato Pickle. Ao adotar práticas de segurança robustas e utilizar scripts de verificação, você pode proteger seus sistemas contra ameaças semelhantes. Lembre-se: a segurança deve ser uma prioridade em todas as etapas do desenvolvimento e implantação de modelos de ML.

 

Fonte e imagens: https://thehackernews.com/2025/02/malicious-ml-models-found-on-hugging.html