MalEval

Articolo: Basta “sapere che è dannoso”? Valutare gli LLM per l'audit granulare del comportamento del malware

DOI dell'articolo: 10.1145/3832187

MalEval è un framework per valutare i report sul comportamento del malware Android generati da grandi modelli linguistici. Il codice in questo repository implementa due percorsi di esecuzione:

1. Da APK: esegue l'analisi statica sui file APK per produrre punti di ingresso, catene di chiamata, corpi delle funzioni e funzioni raggiungibili.
2. Da artefatto: parte dagli output di analisi statica precalcolati e genera riepiloghi delle funzioni, rappresentazioni intermedie con contesto, report sul comportamento e metriche di valutazione.

Il dataset rilasciato è ospitato separatamente nel repository del dataset MalEval su Hugging Face.

Il benchmark contiene 255 applicazioni Android: 200 campioni di malware archiviati, 30 campioni di malware recenti e 25 applicazioni benigne utilizzate come falsi positivi simulati. Vedi DATA.md per i file rilasciati, la provenienza, i diritti e le note sulla manipolazione sicura.

Struttura del Repository

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.

Il dataset deve essere estratto in modo che il repository abbia questa struttura:

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

Ambiente

Usa Python 3.10 o versioni successive. Raccomandiamo un ambiente virtuale pulito:

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

Configura i provider dei modelli in model_registry.yaml prima di eseguire le fasi basate su LLM. Ogni voce di modello può memorizzare valori letterali, come api_key e base_url, oppure riferimenti a variabili d'ambiente, come api_key_env e base_url_env.

Esempio:

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

Il registro predefinito include voci per gpt, gpt-5, qwen, deepseek, llama, coder, claude e gemini. Se preferisci le variabili d'ambiente, imposta le variabili referenziate da model_registry.yaml, ad esempio OPENAI_API_KEY, DEEPSEEK_API_KEY, QWEN3_API_KEY, HUGGINGFACE_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, e .

Da APK

Questo percorso parte dai file APK in artifacts/apk/<split>/ e rigenera gli artefatti dell'analisi statica. Lo split deve essere uno tra malradar, new o benign.

Esegui un singolo APK:

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

Esegui un piccolo batch campionato:

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

I file generati vengono scritti in:

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

Da Artefatto

Questo percorso parte dalla directory artifacts/ rilasciata. Utilizza i file precalcolati functions, call_chain, entrypoints, reachable_func e meta_info.

Riepiloghi delle Funzioni

model=gpt
split=malradar
sha=<apk_sha256>

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

Ometti --apk per eseguire l'intero split.

Riepiloghi con Contesto e Senza Contesto

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"

Report sul Comportamento

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"

Gli output vengono scritti in results/summary/, results/context_summary/, results/no_context_summary/, results/behavior/, results/no_context_behavior/ e results/meta_behavior/.

Metriche

Dopo aver generato riepiloghi e report sul comportamento, calcola le metriche con:

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

Per saltare le chiamate al modello giudice:

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

Sono disponibili anche script per metriche individuali:

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

Verifica Minima

L'albero dei sorgenti può essere verificato senza scaricare APK o configurare le credenziali dei modelli:

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

Ambito di Riproducibilità

• Il calcolo delle metriche sui report rilasciati non richiede hardware locale per l'inferenza dei modelli.
• La rigenerazione degli output degli LLM richiede le corrispondenti credenziali API o un endpoint self-hosted compatibile.
• L'analisi statica e tutta la gestione degli APK devono avvenire in un ambiente di ricerca isolato. Non installare né eseguire i campioni rilasciati su un dispositivo personale o di produzione.
• La riproduzione numerica esatta può essere influenzata da modifiche agli endpoint dei modelli ospitati. I report rilasciati preservano gli output utilizzati nell'articolo.