lure

Analyse locale de binaires Linux. Zéro cloud. Zéro root. Zéro coût.

lure est un outil local d'analyse et de sandboxing d'ELF Linux destiné aux chercheurs en sécurité, aux ingénieurs en rétro-ingénierie et aux joueurs de CTF. La version 0.7.1 ajoute la prise en charge des binaires ARM64 via l'émulation en mode utilisateur QEMU.

Démo de lure

Il propose trois flux de travail complémentaires :

Analyse statique avec lure inspect — inspecter un ELF sans l'exécuter.
Analyse comportementale avec lure run — exécuter un ELF sous des namespaces Linux, strace et une politique seccomp-bpf, puis produire un rapport lisible.
Comparaison de rapports avec lure diff — comparer deux rapports comportementaux enregistrés.

Tout est traité localement. Aucun échantillon ni rapport n'est envoyé vers un service cloud.

Logiciel alpha : lure est encore en développement actif. Testez-le dans un environnement adapté à la recherche en sécurité et ne considérez pas ce sandbox comme un remplacement d'une VM dédiée à l'analyse de malwares.

Verdict dangereux de lure

Ce qu'il fait

Lure combine l'inspection statique d'ELF avec une analyse comportementale d'exécution. Il peut montrer ce à quoi un binaire accède, quelles connexions réseau il tente, quels processus il lance, et comment l'exécution est classée comme CLEAN, SUSPICIOUS ou DANGEROUS.

Pourquoi

Confidentialité — les échantillons et les rapports restent sur votre machine.
Lisible — des rapports structurés au lieu du bruit brut de strace.
Flux de travail simple — inspecter, exécuter, enregistrer et comparer depuis une seule CLI.
Gratuit — sous licence MIT et construit autour des outils Linux standard.
Multi-architecture — x86-64 natif + ARM64 via l'émulation en mode utilisateur QEMU.

Fonctionnalités

Inspection statique d'ELF

lure inspect rapporte :

L'architecture et le type d'ELF (x86-64, ARM64, et plus)
L'endianness
La taille du fichier
Les hachages MD5 et SHA-256
NX
PIE
L'état RELRO
La présence de stack-canary
Les bibliothèques liées
Les en-têtes de sections ELF avec --sections
Les chaînes ASCII imprimables avec --strings

Le fichier inspecté n'est pas exécuté.

lure inspect /bin/ls
lure inspect ./arm64_binary   # ELF ARM64 — aucun QEMU nécessaire pour l'inspection

inspect

Exécution en sandbox

lure run combine :

Les namespaces utilisateur Linux
Un namespace réseau
Un namespace de montage
Un namespace PID
Le traçage des appels système strace
Une politique d'appels système seccomp-bpf appliquée à l'invité
Un système de fichiers sandbox minimal
Un délai d'expiration (30 secondes par défaut)
Un accès réseau optionnel avec --allow-net
Une sortie brute strace optionnelle
Des rapports TXT + JSON optionnels
Des limites de ressources cgroups v2 au mieux-effort lorsqu'elles sont disponibles
Émulation de binaires ARM64 via qemu-aarch64 (v0.7.1+)

L'accès réseau est bloqué par défaut.

lure run ./suspicious_binary
lure run ./arm64_binary          # ARM64 : qemu-aarch64 enveloppe le binaire automatiquement

Lorsqu'un binaire ARM64 est détecté, lure :

Vérifie que qemu-aarch64 est dans le PATH (se termine avec un message d'installation clair sinon).
Prépende qemu-aarch64 à la commande d'exécution — strace trace toute la chaîne QEMU.
Affiche Architecture : ARM64 (émulé par QEMU) dans le panneau Résumé d'exécution.

Comparaison de rapports

lure diff compare deux rapports .json enregistrés :

lure run --save ./binary_v1
lure run --save ./binary_v2
lure diff ~/.lure/reports/binary_v1_*.json ~/.lure/reports/binary_v2_*.json

Installation

Depuis PyPI

pip install lure-analyze

Dépendances système (requises)

Outil	Paquet	Objectif
`strace`	`sudo pacman -S strace`	traçage des appels système
`unshare`	partie de `util-linux` (pré-installé)	isolation par namespaces
`gcc` / `cc`	`sudo pacman -S gcc`	compiler le wrapper seccomp à l'exécution

Dépendances système (optionnelles)

Outil	Paquet	Objectif
`qemu-aarch64`	`sudo pacman -S qemu-user`	émulation de binaires ARM64

Installez qemu-user pour analyser les binaires ELF ARM64 avec lure run. L'inspection statique avec lure inspect fonctionne pour les ELF ARM64 sans aucun outil supplémentaire.

Limites de ressources cgroups v2 (optionnelles)

Pour activer les limites de mémoire et de PID, déléguez une sous-arborescence cgroup à votre utilisateur :

sudo mkdir -p /sys/fs/cgroup/lure
sudo chown "$USER" /sys/fs/cgroup/lure

Utilisation

lure inspect BINARY [--json] [--sections] [--strings]
lure run BINARY [--timeout SECS] [--args 'ARG ...'] [--allow-net] [--out FILE] [--save]
lure diff REPORT1 REPORT2

Journal des modifications

v0.7.1

Prise en charge des binaires ARM64 via l'émulation en mode utilisateur qemu-aarch64
lure inspect affiche correctement ARM64 pour les ELF AArch64
lure run détecte automatiquement les ELF ARM64 et enveloppe l'exécution avec qemu-aarch64
Le Résumé d'exécution affiche Architecture : ARM64 (émulé par QEMU) pour les exécutions ARM64
Erreur propre et message d'installation lorsque qemu-aarch64 est manquant
4 nouveaux tests couvrant l'inspection ARM64 (affichage + JSON) et l'exécution (qemu-manquant + succès QEMU)

v0.6.0

Limites de ressources cgroups v2 (512 Mo de mémoire, 64 PID max)
Liste d'autorisation seccomp-bpf via le wrapper C compilé lure-wrapper
Isolation complète des namespaces de montage + PID avec chroot minimal
Comparaison de rapports lure diff

Licence

MIT — voir LICENSE.

Lire plus

lure v0.7.1

Catégories