MalEval

Article : « Savoir que c’est malveillant » suffit-il ? Évaluer les LLM pour l’audit fin des comportements de malwares

Article DOI : 10.1145/3832187

MalEval est un framework d’évaluation des rapports de comportement de malwares Android générés par de grands modèles de langage. Le code de ce dépôt implémente deux chemins d’exécution :

1. À partir d’un APK : exécuter une analyse statique sur des fichiers APK pour produire les points d’entrée, les chaînes d’appels, les corps de fonctions et les fonctions atteignables.
2. À partir des artefacts : partir des sorties précalculées de l’analyse statique et générer des résumés de fonctions, des représentations intermédiaires contextuelles, des rapports de comportement et des métriques d’évaluation.

Le jeu de données publié est hébergé séparément dans le dépôt de jeux de données MalEval sur Hugging Face.

Le benchmark contient 255 applications Android : 200 échantillons de malwares archivés, 30 échantillons de malwares récents et 25 applications bénignes utilisées comme faux positifs simulés. Voir DATA.md pour les fichiers publiés, la provenance, les droits et les consignes de manipulation sécurisée.

Structure du dépôt

info/                Sample metadata for the benign, MalRadar, and new malware splits.
model_registry.yaml Model/provider configuration for LLM-based stages.
DATA.md              Dataset composition, provenance, and access instructions.
LICENSE.txt          License scope and third-party-material exclusions.
CITATION.cff         Machine-readable citation metadata.
src/                 Static analysis, summarization, behavior generation, and metrics code.

Le jeu de données doit être extrait afin que le dépôt ait la structure suivante :

MalEval/
|-- info/
|-- src/
`-- artifacts/
    |-- apk/
    |-- call_chain/
    |-- entrypoints/
    |-- functions/
    |-- meta_info/
    |-- reachable_func/
    `-- reports/

Environnement

Utilisez Python 3.10 ou une version plus récente. Nous recommandons un nouvel environnement virtuel :

python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install --upgrade pip
python3 -m pip install -r requirements.txt

Configurez les fournisseurs de modèles dans model_registry.yaml avant d’exécuter les étapes basées sur les LLM. Chaque entrée de modèle peut contenir soit des valeurs littérales, comme api_key et base_url, soit des références à des variables d’environnement, comme api_key_env et base_url_env.

Exemple :

models:
  gpt:
    provider: openai
    model: gpt-5
    api_key: <your_openai_key>
    base_url: https://api.openai.com/v1

Le registre par défaut contient des entrées pour gpt, gpt-5, qwen, deepseek, llama, coder, claude et gemini. Si vous préférez les variables d’environnement, définissez les variables référencées par model_registry.yaml, par exemple OPENAI_API_KEY, DEEPSEEK_API_KEY, QWEN3_API_KEY, HUGGINGFACE_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, et .

À partir d’un APK

Ce chemin part des fichiers APK situés sous artifacts/apk/<split>/ et régénère les artefacts d’analyse statique. Le sous-ensemble (split) doit être l’un des suivants : malradar, new ou benign.

Exécuter un APK :

sha=<apk_sha256>
python3 src/preparation/run_static_analysis.py \
  --folder malradar \
  --apk "$sha" \
  --output-root results/static_analysis

Exécuter un petit échantillon :

python3 src/preparation/run_static_analysis.py \
  --folder malradar \
  --sample-size 5 \
  --seed 42 \
  --output-root results/static_analysis

Les fichiers générés sont écrits dans :

results/static_analysis/entrypoints/
results/static_analysis/call_chain/
results/static_analysis/functions/
results/static_analysis/reachable_func/

À partir des artefacts

Ce chemin part du répertoire artifacts/ publié. Il utilise les fichiers précalculés functions, call_chain, entrypoints, reachable_func et meta_info.

Résumés de fonctions

model=gpt
split=malradar
sha=<apk_sha256>

python3 src/preparation/get_functionality_summary.py --model "$model" --folder "$split" --apk "$sha"

Omettez --apk pour exécuter l’ensemble du sous-ensemble.

Résumés avec et sans contexte

python3 src/preparation/get_context_summary.py --model "$model" --folder "$split" --apk "$sha"
python3 src/preparation/get_no_context_summary.py --model "$model" --folder "$split" --apk "$sha"

Rapports de comportement

python3 src/generate_behavior/get_behavior.py --model "$model" --folder "$split" --flag context --apk "$sha"
python3 src/generate_behavior/get_behavior.py --model "$model" --folder "$split" --flag no_context --apk "$sha"
python3 src/generate_behavior/get_meta_behavior.py --model "$model" --folder "$split" --apk "$sha"

Les sorties sont écrites dans results/summary/, results/context_summary/, results/no_context_summary/, results/behavior/, results/no_context_behavior/ et results/meta_behavior/.

Métriques

Une fois les résumés et les rapports de comportement générés, calculez les métriques avec :

python3 src/metrics/run_metrics.py --model "$model" --flag context
python3 src/metrics/run_metrics.py --model "$model" --flag no_context
python3 src/metrics/run_metrics.py --model "$model" --flag meta

Pour ignorer les appels au modèle juge :

python3 src/metrics/run_metrics.py --model "$model" --flag context --skip-eas

Des scripts de métriques individuels sont également disponibles :

python3 src/metrics/aec_b_f1.py --model "$model" --flag context
python3 src/metrics/fpcr_tpmr_f1c.py --model "$model" --flag context
python3 src/metrics/eas.py --model "$model" --flag context --split malradar --judge-model gpt-5

Vérification minimale

L’arborescence source peut être vérifiée sans télécharger d’APK ni configurer d’identifiants de modèles :

python3 -m compileall -q src
python3 - <<'PY'
import json
from pathlib import Path

expected = {
    "archived_sample_info.json": 200,
    "latest_sample_info.json": 30,
    "benign_sample_info.json": 25,
}
for name, count in expected.items():
    actual = len(json.loads((Path("info") / name).read_text()))
    assert actual == count, (name, actual, count)
print("metadata check passed: 200 archived malware + 30 recent malware + 25 benign")
PY

Périmètre de reproductibilité

• Le calcul des métriques sur les rapports publiés ne nécessite pas de matériel local d’inférence de modèles.
• La régénération des sorties des LLM nécessite les identifiants API correspondants ou un endpoint auto-hébergé compatible.
• L’analyse statique et toute manipulation des APK doivent avoir lieu dans un environnement de recherche isolé. N’installez pas et n’exécutez pas les échantillons publiés sur un appareil personnel ou de production.
• La reproduction numérique exacte peut être affectée par des changements dans les endpoints de modèles hébergés. Les rapports publiés préservent les sorties utilisées dans l’article.