nccgroup/cachegrabun outil conçu pour aider à réaliser et visualiser des attaques par cache guidées par traces contre des logiciels dans le monde sécurisé des cœurs ARMv8 compatibles TrustZone
Cachegrab est un outil conçu pour aider à réaliser et visualiser des attaques de cache guidées par les traces (trace-driven cache attacks) contre des logiciels dans le monde sécurisé des cœurs ARMv8 compatibles TrustZone. Pour un aperçu du fonctionnement interne de Cachegrab, voir l'annonce de la sortie de Cachegrab.
Il est possible d'utiliser Cachegrab sur un appareil Android. Étant donné que les versions modernes d'Android interdisent les modules du noyau, les options CONFIG_MODULES et CONFIG_MODULE_UNLOAD du noyau doivent être activées, le noyau doit être recompilé, puis flashé sur l'appareil. Compilez le module du noyau de Cachegrab à partir des sources du noyau et utilisez insmod pour l'insérer dans le noyau en cours d'exécution de l'appareil cible.
Ensuite, compilez le serveur Cachegrab et la bibliothèque shim, puis copiez les deux vers /data/local/tmp. Démarrez le serveur. Enfin, utilisez adb forward tcp:8000 tcp:8000 pour lier le port TCP local 8000 à celui de l'appareil.
Avertissement : Le serveur permet à l'attaquant de spécifier des commandes shell arbitraires pour invoquer le code victime. Ces commandes sont spécifiées via HTTP et exécutées avec les privilèges root. Il est donc essentiel que l'appareil de test exécutant Cachegrab se trouve sur un réseau de confiance.
Enfin, chargez l'interface graphique Cachegrab et connectez-vous à localhost:8000.
Le client Cachegrab est structuré autour de l'idée d'un pipeline, qui traite les échantillons contenant les données d'attaque. Les pipelines sont constitués d'une source d'échantillons, d'une liste de filtres et d'un analyseur. La source d'échantillons peut être un emplacement sur le système de fichiers, un appareil exécutant le serveur Cachegrab, ou quelque chose de personnalisé. Le pipeline collecte les échantillons depuis la source et les fait passer à travers chaque filtre du pipeline, qui peuvent modifier les données de l'échantillon. Enfin, les échantillons filtrés sont transmis à l'analyseur, qui effectue le traitement final des données d'attaque.
Une grande partie du client peut être utilisée via l'interface graphique, qui offre un moyen simple de gérer une paire de pipelines utiles. Le premier pipeline collecte des échantillons depuis le serveur Cachegrab configuré dans le panneau « Scope ». Il fait passer ces échantillons à travers une série de filtres et stocke les échantillons filtrés résultants dans un jeu de données. Les jeux de données peuvent être importés ou exportés à l'aide de l'interface graphique, ce qui permet un transfert facile des données d'échantillons. Le second pipeline prend des échantillons d'un jeu de données, fait passer les échantillons à travers une autre série de filtres, et trace les tracés filtrés dans la fenêtre.
Le module Python du client cachegrab peut également être utilisé directement pour créer un script de collecte ou d'analyse. Le script suivant prend un jeu de données exporté par l'interface graphique, effectue un certain traitement sur les traces de chaque échantillon, et affiche les données résultantes.
from cachegrab import Pipeline
from cachegrab.data import Dataset, Trace
from cachegrab.sources import DatasetSource
from cachegrab.filters import Filter
from cachegrab.sinks import AnalysisSink
class SampleFilter(Filter):
def filter(self, sample):
for t in sample.get_trace_names():
data = sample.get_trace(t).data
sample.set_trace(t, Trace(data - data.mean()))
return sample
class SampleAnalysis(AnalysisSink):
def analyze_once(self, sample):
for t in sample.get_trace_names():
print sample.get_trace(t).data
dataset = Dataset().load("exported_dataset_location")
pipeline = Pipeline(DatasetSource(dataset), SampleAnalysis())
pipeline.add_filter(SampleFilter())
pipeline.run()