mquire

mquire, un jeu de mots entre memory et inquire, est un outil d'interrogation de mémoire inspiré de osquery.

Avantage clé : aucun symbole de débogage externe nécessaire

mquire peut analyser des instantanés de mémoire du noyau Linux sans nécessiter de symboles de débogage externes.

Tout ce qui est nécessaire à l'analyse est déjà intégré dans l'image mémoire elle-même. Cela signifie que vous pouvez analyser :

• Des noyaux inconnus ou personnalisés que vous n'avez jamais vus auparavant
• N'importe quelle distribution Linux sans préparation
• Des instantanés mémoire pour lesquels les symboles de débogage externes sont indisponibles ou perdus

Prérequis

Version du noyau requise :

• Support BTF : Noyau 4.18 ou plus récent avec BTF activé (la plupart des distributions modernes l'activent par défaut)
• Support Kallsyms : Noyau 6.4 ou plus récent (en raison des modifications du format de scripts/kallsyms.c)

Comment ça fonctionne

mquire analyse la mémoire du noyau en lisant deux types d'informations intégrées dans les noyaux Linux modernes :

1. Informations de type issues du BTF (BPF Type Format) – Décrit la structure et l'agencement des types de données du noyau. Les données BTF sont analysées à l'aide de la crate btfparse.
2. Informations de symboles issues de Kallsyms – Fournit les emplacements mémoire des symboles du noyau (les mêmes données que celles utilisées par /proc/kallsyms)

En combinant les informations de type avec les emplacements des symboles, mquire peut trouver et lire des structures de données complexes du noyau comme :

• Les mappages mémoire des processus (en utilisant les structures maple tree)
• Les données de fichiers en cache (en utilisant les structures XArray)
• Les messages du journal du noyau

Cela permet d'extraire des fichiers directement depuis le cache de fichiers du noyau, même s'ils ont été supprimés du disque.

Notes de compatibilité

Le scanner Kallsyms dépend du format de données issu de scripts/kallsyms.c dans le code source du noyau. Si les futures versions du noyau modifient ce format, les heuristiques du scanner pourraient nécessiter des mises à jour.

Capacités

Tables

mquire fournit des tables SQL pour interroger différents aspects du système ou de l'état de l'outil lui-même.

mquire n'est pas une base de données. Chaque requête reconstruit les structures de données du noyau en parcourant la mémoire et en suivant les pointeurs. Il n'y a pas d'index précalculés ni de résultats mis en cache : chaque accès à une table est une traversée des données du noyau. Utilisez AS MATERIALIZED pour éviter des analyses redondantes (voir Optimisation des requêtes), et fournissez des contraintes comme task lors de l'interrogation de tables par processus comme task_open_files et memory_mappings pour limiter l'analyse à un seul processus.

Principe de conception : les adresses virtuelles comme clés de jointure. Les tables utilisent virtual_address (l'adresse noyau de la structure de données sous-jacente) comme clé de jointure canonique : pas le pid ou d'autres identifiants visibles par l'utilisateur. C'est intentionnel, car un même PID peut apparaître plusieurs fois à travers différentes sources de découverte et tâches racines, alors qu'une adresse virtuelle identifie de manière unique un objet spécifique du noyau. Les tables SQL ainsi que l'API sous-jacente LinuxOperatingSystem sont construites autour de cette convention.

Informations système

• os_version – Version du noyau et architecture
• system_info – Nom d'hôte et nom de domaine
• boot_time – Heure de démarrage du système
• kallsyms – Adresses des symboles du noyau (mêmes données que /proc/kallsyms)
• dmesg – Messages du tampon en anneau du noyau (mêmes données que la commande dmesg)

Informations sur les processus

• tasks – Processus en cours d'exécution avec les lignes de commande et les chemins des binaires. Chaque tâche est découverte via plusieurs sources indépendantes, ce qui est utile pour la détection de rootkits. Voir Comparaison des méthodes d'énumération des tâches pour la détection de rootkits et Liste des processus dédupliquée.
• task_open_files – Fichiers ouverts par chaque processus (fournissez une contrainte task pour une analyse ciblée, ou interrogez toutes les tâches à la fois)
• memory_mappings – Régions mémoire mappées par chaque processus (fournissez une contrainte task pour une analyse ciblée, ou interrogez toutes les tâches à la fois)
• task_capabilities – Ensembles de capacités Linux (effectives, permises, héritables, limites, ambiantes) pour une tâche. Nécessite une contrainte task, donc faites une jointure avec tasks/processes (ex. JOIN task_capabilities c ON c.task = p.virtual_address).
• task_ptrace_flags – Décode le champ ptrace d'une tâche donnée. Nécessite une contrainte task.

Modules du noyau

• kernel_modules – Modules du noyau chargés avec métadonnées (nom, état, version, paramètres, indicateurs de souillure)
• kernel_module_mem_entries – Les entrées mem d'un objet module du noyau. Nécessite une contrainte kernel_module, donc faites une jointure avec kernel_modules (ex. JOIN kernel_module_mem_entries r ON r.kernel_module = m.virtual_address).
• ftrace_ops – Une liste de nœuds struct ftrace_ops, parcourue à partir du symbole ftrace_ops_list par défaut. Contraignez virtual_address pour lire un seul nœud, ou start_vaddr (éventuellement borné par end_vaddr) pour parcourir à partir d'un nœud arbitraire.

Informations réseau

• network_connections – Connexions réseau actives (sockets TCP)
• network_interfaces – Interfaces réseau avec adresses IP et adresses MAC

Système de fichiers

• syslog_file – Journaux système lus depuis le cache de fichiers du noyau (fonctionne même si les fichiers journaux sont supprimés ou indisponibles, tant qu'ils sont mis en cache en mémoire)

Débogage

• mquire_diagnostics – Journaux internes de mquire montrant la progression de l'analyse, les avertissements et les erreurs

Commandes

mquire propose trois commandes principales :

• mquire shell – Démarrer un shell SQL interactif pour interroger les instantanés mémoire
• mquire query – Exécuter une seule requête SQL et afficher les résultats (prend en charge le format JSON ou tableau)
• mquire command – Exécuter des commandes personnalisées sur les instantanés mémoire (par exemple, .task_tree, .system_version, .dump)

Commandes pointées

mquire fournit des commandes spéciales préfixées par un point (.) pour les distinguer des requêtes SQL.

Commandes intégrées

Ces commandes fonctionnent dans le shell interactif et avec mquire query :

• .tables – Lister toutes les tables disponibles
• .schema – Afficher le schéma de toutes les tables
• .schema <table> – Afficher le schéma d'une table spécifique
• .commands – Lister toutes les commandes personnalisées disponibles
• .exit – Quitter le shell interactif (shell uniquement)

Commandes personnalisées

Ces commandes fonctionnent dans le shell interactif et avec mquire command :

Utilisez --help avec n'importe quelle commande pour voir les options disponibles et les informations d'utilisation. Par exemple : .task_tree --help

.system_version

Affiche les informations de version du système d'exploitation.

C'est une commande pratique équivalente à SELECT * FROM os_version, mais avec une sortie formatée.

.task_tree

Affiche un arbre hiérarchique des processus et threads en cours d'exécution, similaire à la commande pstree sous Linux.

Options :

• --show-threads – Inclure les threads en plus des processus. Lorsqu'activé, affiche à la fois TGID et TID pour chaque entrée.
• --use-real-parent – Utiliser le champ real_parent au lieu de parent pour construire la structure en arbre. Le champ real_parent montre le processus parent d'origine avant tout réaffectation (utile pour suivre les chaînes de création de processus même après la fin des processus parents).

Remarques :

• Le format est [TGID TID] lorsque les threads sont affichés, ou [TGID] lorsqu'ils sont masqués. TGID (Thread Group ID) est ce qu'on appelle couramment le PID. Pour les threads principaux (où TGID == TID), les deux valeurs seront identiques.

.carve

Extraire une région de mémoire virtuelle vers le disque. Cette commande extrait le contenu mémoire brut d'une plage d'adresses virtuelles spécifique à l'aide d'une table de pages donnée, utile pour extraire la mémoire d'un processus, le contenu du tas ou d'autres régions mémoire.

Arguments :

• ROOT_PAGE_TABLE – L'adresse physique de la table de pages racine (chaîne hexadécimale avec préfixe 0x optionnel). Cela détermine l'espace d'adressage à utiliser pour la traduction.
• VIRTUAL_ADDRESS – L'adresse virtuelle à partir de laquelle commencer l'extraction (chaîne hexadécimale avec préfixe 0x optionnel).
• SIZE – Nombre d'octets à extraire.
• DESTINATION_PATH – Chemin du fichier de sortie où la mémoire extraite sera écrite.

Remarques :

• La commande affiche un résumé des régions mappées et non mappées avant l'écriture.
• Les régions non mappées sont remplies de zéros dans le fichier de sortie.

.dump

Extraire les fichiers du cache de fichiers du noyau pour récupérer les fichiers directement depuis la mémoire. Cette commande parcourt toutes les tâches et leurs descripteurs de fichiers ouverts, en extrayant le contenu des fichiers du cache de pages.

Arguments :

• OUTPUT – Répertoire de sortie pour les fichiers extraits. Les fichiers sont organisés par TGID (ex. tgid_1234/path/to/file).

Remarques :

• Fonctionne actuellement avec les fichiers ouverts via des descripteurs de fichiers (depuis la table des descripteurs de fichiers du processus).
• Ne prend pas encore en charge l'extraction de données à partir de fichiers mappés en mémoire.
• Les fichiers vides (aucune donnée dans le cache de pages) sont ignorés.
• Les régions avec des erreurs de lecture sont remplies de zéros dans la sortie.

Cas d'utilisation

mquire est conçu pour :

• L'analyse forensique – Analyser des instantanés mémoire de systèmes compromis pour comprendre ce qui s'exécutait et quels fichiers ont été consultés
• La réponse aux incidents – Interroger rapidement des images mémoire pour trouver des preuves d'activité malveillante
• La recherche en sécurité – Étudier les internes du noyau et le comportement des processus à partir d'instantanés mémoire
• L'analyse de malwares – Examiner les processus en cours d'exécution et leurs opérations sur les fichiers sans être détecté
• Les outils personnalisés – Construire vos propres outils d'analyse en utilisant la bibliothèque crate mquire, qui fournit une API réutilisable pour l'analyse de la mémoire du noyau

Compilation et installation

Paquets pré-construits depuis l'IC

Des paquets pré-construits sont disponibles en tant qu'artefacts des exécutions d'IC. Vous pouvez les télécharger depuis l'onglet Actions en sélectionnant une exécution de workflow réussie et en téléchargeant les artefacts. Les formats de paquets suivants sont disponibles :

• linux-deb-package – Paquet Debian/Ubuntu .deb
• linux-rpm-package – Paquet Fedora/RHEL/CentOS .rpm
• linux-tgz-package – Archive Linux générique .tar.gz

Compilation à partir des sources

mquire est écrit en Rust. Pour le compiler :```bash

Clone the repository

git clone https://github.com/trailofbits/mquire cd mquire

Build the project

cargo build --release

The binary will be in target/release/

- mquire: Unified tool with shell, query, and command modes

## Supported snapshot formats

mquire supporte les formats d'instantanés mémoire suivants, détectés par extension de fichier :

| Format | Extension | Description |
|--------|-----------|-------------|
| Raw | `.raw` | Vidage mémoire physique plat (copie octet par octet de l'espace d'adressage physique) |
| LiME | `.lime` | Format [Linux Memory Extractor](https://github.com/504ensicsLabs/LiME) avec en-têtes de plage d'adresses |
| ELF core | `.elf` | Vidage mémoire central ELF avec segments PT_LOAD (tel que produit par `virsh dump` ou QEMU `dump-guest-memory`) |

## Acquisition d'un instantané mémoire

### Utilisation d'AVML (recommandé)

Nous recommandons [AVML](https://github.com/microsoft/avml) pour l'acquisition d'instantanés mémoire depuis des systèmes Linux en fonctionnement. [LiME](https://github.com/504ensicsLabs/LiME) était auparavant suggéré mais n'est plus activement maintenu.```bash
sudo avml output.lime

Important : N'utilisez pas --compress lors de l'acquisition de snapshots pour mquire. mquire ne prend pas en charge les snapshots AVML compressés. Si vous avez un snapshot compressé, utilisez avml-convert pour le décompresser d'abord : avml-convert compressed.lime uncompressed.lime

Consultez la documentation AVML pour connaître les options supplémentaires.

Utilisation de virsh (machines virtuelles)

Pour les machines virtuelles libvirt/KVM, utilisez virsh dump pour produire un core dump ELF :```bash virsh -c qemu:///system dump output.elf --memory-only --format elf

La VM est mise en pause pendant le dump et reprise après. Ajoutez `--live` pour éviter la pause, au détriment de la cohérence du snapshot.

## Pour commencer

Une fois que vous avez un snapshot mémoire, vous pouvez interagir avec lui à l'aide de requêtes SQL et de commandes personnalisées. mquire offre trois façons d'interagir avec les snapshots :

### Shell interactif

Lancez un shell SQL interactif :```bash
mquire shell /path/to/memory.raw

Cela ouvre une invite où vous pouvez exécuter à la fois des requêtes SQL et des commandes de manière interactive :```bash mquire> .tables # List all available tables mquire> .schema tasks # Show schema for a specific table mquire> SELECT * FROM tasks; # Run SQL queries mquire> .task_tree --show-threads # Run custom commands mquire> .exit # Exit the shell

### Requêtes SQL ponctuelles

Exécutez une seule requête SQL ou une commande intégrée à partir de la ligne de commande :```bash
# Output as JSON (default)
mquire query /path/to/memory.raw "SELECT * FROM os_version"

# Output as table format
mquire query /path/to/memory.raw "SELECT * FROM tasks" --format table

# Built-in commands work too
mquire query /path/to/memory.raw ".tables"
mquire query /path/to/memory.raw ".schema tasks"

Exécuter des commandes personnalisées

Exécutez des commandes personnalisées pour une analyse spécialisée :```bash

List all available commands (default behavior)

mquire command /path/to/memory.raw

Display system version

mquire command /path/to/memory.raw ".system_version"

Show process tree

mquire command /path/to/memory.raw ".task_tree"

Show process tree with threads

mquire command /path/to/memory.raw ".task_tree --show-threads"

Get help for a command

mquire command /path/to/memory.raw ".task_tree --help"

## Fichiers SQL de démarrage automatique

mquire charge et exécute automatiquement les fichiers SQL depuis `$HOME/.config/trailofbits/mquire/autostart/` au démarrage. Les fichiers sont organisés par système d'exploitation et architecture :```
autostart/
  common/common/    # All platforms and architectures
  common/{arch}/    # All platforms, specific architecture
  {os}/common/      # Specific platform, all architectures
  {os}/{arch}/      # Specific platform and architecture

Les fichiers dans chaque répertoire sont triés alphabétiquement. Les répertoires sont scannés dans l'ordre indiqué ci-dessus.

Caractéristiques:

• Les fichiers doivent avoir une extension .sql
• Les erreurs sont enregistrées dans mquire_diagnostics mais ne bloquent pas l'exécution
• Fonctionne avec les commandes mquire shell et mquire query

Vues fournies

mquire fournit des vues SQL réutilisables dans le répertoire sql/views/. Installez-les avec just install-views. Consultez le README des vues pour la liste complète, la convention de numérotation et la structure des répertoires.

Vues Linux (sql/views/linux/common/):

• 000_processes.sql - Liste dédupliquée des processus de toutes les sources de découverte, filtrée sur les leaders de processus en espace utilisateur. Interrogez avec SELECT * FROM processes.
• 100_process_network_connections.sql - Mappe les connexions réseau aux processus propriétaires en joignant via les descripteurs de fichiers. Interrogez avec SELECT * FROM process_network_connections WHERE comm = 'sshd'.
• 120_process_capabilities.sql - Aperçu rapide des capacités, une ligne par processus avec chaque ensemble sous forme de liste compacte (ALL, '', ou noms de cap ; NULL si illisible). Interrogez avec SELECT * FROM process_capabilities.
• - Aperçu rapide de ptrace, une ligne par processus avec les indicateurs définis sous forme de liste compacte ( lorsqu'il n'est pas tracé) plus la valeur brute. Interrogez avec .

Optimisation des requêtes

Les requêtes mquire nécessitent de reconstruire les structures de données du noyau à partir de la mémoire virtuelle en déréférençant les pointeurs à l'aide d'informations de type intégrées et de symboles de débogage. Ce traitement peut être coûteux, alors utilisez des techniques d'optimisation des requêtes pour améliorer considérablement les performances.

Matérialisation avec AS MATERIALIZED

Utilisez l'indice AS MATERIALIZED pour mettre en cache les résultats des tables lorsqu'elles sont utilisées dans des JOINs ou accédées plusieurs fois.

Quand matérialiser :

• Les tables coûteuses à générer (par exemple, tasks nécessite de parcourir les listes chaînées des structures de processus, en déréférençant plusieurs pointeurs par processus)
• Les tables utilisées dans des JOINs (accédées plusieurs fois lors de l'exécution de la requête)
• Les tables référencées plusieurs fois dans la même requête

Exemple :```sql -- Find network connections for a specific process using materialization WITH target_tasks AS MATERIALIZED ( SELECT * FROM tasks WHERE comm = 'sshd' AND type = 'thread_group_leader' ),

network_connections_mat AS MATERIALIZED ( SELECT * FROM network_connections )

SELECT t.tgid, t.comm, nc.local_address, nc.local_port, nc.remote_address, nc.remote_port, nc.state, nc.protocol FROM target_tasks t JOIN task_open_files tof ON tof.task = t.virtual_address JOIN network_connections_mat nc ON nc.inode = tof.inode;

**Note :** Les tables `task_open_files` et `memory_mappings` utilisent la colonne `task` comme entrée du générateur. Lorsqu'elles sont jointes à la table `tasks`, SQLite transmet automatiquement la contrainte via des jointures de boucles imbriquées, rendant les jointures directes efficaces.

**Impact sur les performances :** La matérialisation peut accélérer significativement les requêtes avec des jointures (généralement 2 à 5 fois plus rapide)

**Exemple de résultats de benchmark :**

*Test effectué sur un instantané Ubuntu 24.04 (kernel 6.8.0-63), 351 processus, 50 connexions, 2142 fichiers ouverts. Les performances varient selon la taille de l'instantané, la version du noyau et le matériel.*

| Méthode | Temps réel | Temps utilisateur | Accélération |
|---------|------------|-------------------|--------------|
| SANS matérialisation | 12.067s | 16.373s | base de référence |
| AVEC matérialisation | 3.171s | 8.786s | **3,8x plus rapide** |

### Optimisation de l'ordre des jointures

**Commencez par la plus petite table et joignez vers les tables plus grandes** pour minimiser le nombre de lignes traitées tôt dans le pipeline de la requête.

**Tailles typiques des tables :**
- `network_connections` : la plus petite – seulement les processus avec une activité réseau
- `tasks` : taille moyenne – tous les processus
- `task_open_files` : la plus grande – tous les descripteurs de fichiers ouverts

**Ordre optimal :**

Commencez par la table des tâches filtrée et joignez vers les tables plus grandes :```sql
FROM target_tasks t                                       -- filtered tasks
JOIN task_open_files tof ON tof.task = t.virtual_address  -- open files
JOIN network_connections_mat nc ON nc.inode = tof.inode   -- matching connections

Comprendre l'exécution des requêtes

Utilisez EXPLAIN QUERY PLAN pour voir comment SQLite exécute votre requête :```sql EXPLAIN QUERY PLAN SELECT ... FROM target_tasks t JOIN task_open_files tof ON tof.task = t.virtual_address JOIN network_connections_mat nc ON nc.inode = tof.inode;

Recherchez :
- **BLOOM FILTER** : optimisation de SQLite pour les grandes jointures
- **AUTOMATIC COVERING INDEX** : index temporaires créés pour les recherches
- **SCAN** : analyse complète de la table (attendue pour la table pilote)
- **SEARCH** : recherche basée sur un index (efficace)

### Bonnes pratiques

1. **Matérialisez toujours les tables coûteuses** utilisées dans les jointures
2. **Commencez par la plus petite table** comme table pilote
3. **Utilisez du SQL multiligne** dans les scripts pour la lisibilité
4. **Vérifiez les plans de requêtes** avec `EXPLAIN QUERY PLAN` pour les requêtes complexes
5. **Évitez `SELECT *`** en production – ne spécifiez que les colonnes nécessaires

### Extraction de fichiers

Extrayez les fichiers de la mémoire vers le disque :```bash
mquire command /path/to/memory.raw ".dump /output/directory"

Exemples de requêtes

Toutes les requêtes utilisent la syntaxe SQL standard.

Version du système```bash

$ mquire shell ubuntu2404_6.14.0-37-generic.lime mquire> SELECT * FROM os_version; arch:"x86_64" kernel_version:"6.14.0-37-generic" system_version:"#37~24.04.1-Ubuntu SMP PREEMPT_DYNAMIC Thu Nov 20 10:25:38 UTC 2"

#### Informations système```bash
$ mquire shell ubuntu2404_6.14.0-37-generic.lime
mquire> SELECT * FROM system_info;
domain:"(none)" hostname:"ubuntu2404"

Modules du noyau```bash

$ mquire shell ubuntu2404_6.14.0-37-generic.lime mquire> SELECT name, state, src_version, parameters FROM kernel_modules LIMIT 5; name:"snd_seq_dummy" state:"live" src_version:"7A40E0FD47A0746D1C9CD85" parameters:"ump (perm: 0o444), duplex (perm: 0o444), ports (perm: 0o444)" name:"snd_hrtimer" state:"live" src_version:"81EE6D58896E2C2E63E252D" parameters:"" name:"qrtr" state:"live" src_version:"473C5AB47E04ECEA0106681" parameters:"" name:"virtio_rng" state:"live" src_version:"0852940240D554836D22CB2" parameters:"" name:"intel_rapl_msr" state:"live" src_version:"34853C4F5EB8FCAD28ACFB3" parameters:""

#### Exécution des tâches```bash
$ mquire shell ubuntu2404_6.14.0-37-generic.lime
mquire> SELECT comm, binary_path, command_line FROM tasks WHERE command_line NOT NULL AND comm LIKE "%systemd%";
comm:"systemd" binary_path:"/usr/lib/systemd/systemd" command_line:"/sbin/init splash"
comm:"systemd-oomd" binary_path:"/usr/lib/systemd/systemd-oomd" command_line:"/usr/lib/systemd/systemd-oomd"
comm:"systemd-resolve" binary_path:"/usr/lib/systemd/systemd-resolved" command_line:"/usr/lib/systemd/systemd-resolved"
comm:"systemd-udevd" binary_path:"/usr/bin/udevadm" command_line:"/usr/lib/systemd/systemd-udevd"
comm:"systemd" binary_path:"/usr/lib/systemd/systemd" command_line:"/usr/lib/systemd/systemd --user"
comm:"systemd-logind" binary_path:"/usr/lib/systemd/systemd-logind" command_line:"/usr/lib/systemd/systemd-logind"
comm:"systemd-journal" binary_path:"/usr/lib/systemd/systemd-journald" command_line:"/usr/lib/systemd/systemd-journald"
comm:"systemd-timesyn" binary_path:"/usr/lib/systemd/systemd-timesyncd" command_line:"/usr/lib/systemd/systemd-timesyncd"

Connexions

Trouvez les connexions réseau pour un processus spécifique en joignant tasks, task_open_files et network_connections.```bash $ mquire shell ubuntu2404_6.14.0-37-generic.lime mquire> SELECT t.tgid, t.comm, nc.protocol, nc.local_address, nc.local_port, nc.remote_address, nc.remote_port, nc.state FROM tasks t JOIN task_open_files tof ON tof.task = t.virtual_address JOIN network_connections nc ON nc.inode = tof.inode WHERE t.comm = 'sshd'; tgid:"1134" comm:"sshd" protocol:"tcp" local_address:"0.0.0.0" local_port:"22" remote_address:"" remote_port:"" state:"listen" tgid:"1134" comm:"sshd" protocol:"tcp" local_address:"::" local_port:"22" remote_address:"" remote_port:"" state:"listen"

#### Fichiers ouverts d'une tâche

Lister les fichiers ouverts pour des processus spécifiques en joignant `tasks` avec `task_open_files` :```bash
$ mquire shell ubuntu2404_6.14.0-37-generic.lime
mquire> SELECT t.comm, tof.path
FROM tasks t
JOIN task_open_files tof ON tof.task = t.virtual_address
WHERE t.comm LIKE '%systemd%'
LIMIT 10;
comm:"systemd" path:"/null"
comm:"systemd" path:"/null"
comm:"systemd" path:"/null"
comm:"systemd" path:"/kmsg"
comm:"systemd" path:"[eventpoll]"
comm:"systemd" path:"[signalfd]"
comm:"systemd" path:"inotify"
comm:"systemd" path:"/"
comm:"systemd" path:"[timerfd]"
comm:"systemd" path:"/usr/lib/systemd/systemd-executor"

Exemples de requêtes en ligne de commande

Sortie JSON (par défaut)```bash

$ mquire query --format=json ubuntu2404_6.14.0-37-generic.lime "SELECT * FROM os_version" [ { "arch": "x86_64", "kernel_version": "6.14.0-37-generic", "system_version": "#37~24.04.1-Ubuntu SMP PREEMPT_DYNAMIC Thu Nov 20 10:25:38 UTC 2" } ]

##### Sortie tableau```bash
$ mquire query --format=table ubuntu2404_6.14.0-37-generic.lime "SELECT * FROM os_version"
arch:"x86_64" kernel_version:"6.14.0-37-generic" system_version:"#37~24.04.1-Ubuntu SMP PREEMPT_DYNAMIC Thu Nov 20 10:25:38 UTC 2"

Exemples de commandes personnalisées

Lister les commandes disponibles```bash

$ mquire command ubuntu2404_6.14.0-37-generic.lime Available commands: .carve Carve a region of virtual memory to disk .dump Dump all open files from tasks to disk .system_version Display the operating system version .task_tree Display a hierarchical task tree

##### Afficher la version du système```bash
$ mquire command ubuntu2404_6.14.0-37-generic.lime ".system_version"
System Version: #37~24.04.1-Ubuntu SMP PREEMPT_DYNAMIC Thu Nov 20 10:25:38 UTC 2
Kernel Version: 6.14.0-37-generic
Architecture: x86_64

Afficher l'arborescence des processus```bash

$ mquire command ubuntu2404_6.8.0-63-generic.lime .task_tree | head -n 10 Parent: task_struct::parent Threads: Disabled Page Table: paddr(0x0000000001a60000)

└─ [0] (ffffffff90c0fcc0) swapper/0 ╎ ↳ [0] (ffff982a00e33518) \xef\xbf\xbd\xef\xbf\xbd\xef\xbf\xbd,)\xef\xbf\xbd\xef\xbf\xbd\xef\xbf\xbd\x0e ├─ [1] (ffff982a0084a8c0) systemd │ ├─ [430] (ffff982a0d27a8c0) systemd-journal │ ├─ [495] (ffff982a08a88000) systemd-udevd │ ├─ [786] (ffff982a07a60000) systemd-oomd

**Note :** Lorsque plusieurs entrées `task_struct` existent avec le même TID (Thread ID, ce qui peut se produire en raison d'une corruption mémoire ou de l'instant de capture), les entrées dupliquées sont affichées avec le symbole de continuation `╎   ↳` en retrait sous l'entrée principale. Le format est `[TGID] (adresse_virtuelle) nom` lorsque les threads sont masqués, ou `[TGID TID]` lorsque les threads sont affichés (où TGID est l'identifiant du groupe de threads, communément appelé PID).

#### Extraire les fichiers de la mémoire```bash
$ mquire command ubuntu2404_6.14.0-37-generic.lime ".dump ./extracted_files"
Legend: SK = skipped, OK = all good, ER = errored

Summary:
  Total files processed: 1234
  Successfully dumped: 1156
  Skipped: 45
  Errors: 33

File Status:
  OK /usr/lib/systemd/systemd (TGID 1)
  OK /etc/passwd (TGID 1)
  SK /dev/null (TGID 1)
  ...

Dépannage

Utilisez le drapeau --debug pour activer les messages de débogage détaillés lors de l'initialisation et de l'analyse :```bash mquire --debug command /path/to/memory.raw ".system_version"

- **`shell` et `query`** : Les messages de débogage sont stockés dans la table SQL `mquire_diagnostics`. Interrogez-les avec `SELECT * FROM mquire_diagnostics;`
- **Mode `command`** : Les messages de débogage sont imprimés directement sur stderr.

Pour les problèmes d'initialisation qui empêchent mquire de charger correctement l'instantané, il est recommandé d'utiliser le mode `command` avec une commande simple comme `.system_version`, car il imprime la sortie de débogage sur stderr immédiatement sans avoir besoin d'interroger la table `mquire_diagnostics`.

## Configuration

mquire peut être configuré via un fichier TOML à `$HOME/.config/trailofbits/mquire/config.toml`. Si le fichier n'existe pas, les valeurs par défaut sont utilisées.

### Options disponibles et valeurs par défaut```toml
[database]
# Maximum number of entries retained in the mquire_diagnostics table.
# During initialization, all entries are kept regardless of this limit.
# Once initialization completes, new log entries trigger eviction of the
# oldest entries when the total exceeds this value.
mquire_diagnostics_max_entries = 1000

Développement

Ce projet utilise just comme gestionnaire de commandes. Exécutez just pour voir les commandes disponibles :

Tests d'intégration de requêtes SQL

Ces tests vérifient que mquire produit une sortie correcte pour les requêtes sur des instantanés mémoire.

• just integration-test - Exécute les tests et compare la sortie aux fichiers JSON attendus
• just integration-update - Met à jour les fichiers JSON attendus avec la sortie réelle (à utiliser lors de la modification des schémas de table)

Après avoir exécuté integration-update, examinez le diff git pour vous assurer que les modifications correspondent à vos attentes avant de valider.

Ajout de nouveaux tests : Créez un fichier .sql et un fichier .json correspondant dans le répertoire d'instantané approprié, puis exécutez just integration-update pour remplir la sortie attendue.

Contribution

Les contributions sont les bienvenues ! Lorsque vous contribuez, veuillez suivre ces directives :

1. Testez vos modifications - Assurez-vous que vos modifications fonctionnent correctement avant de les soumettre
2. Gardez les dépendances minimales - N'ajoutez de nouvelles dépendances que lorsque cela est absolument nécessaire
3. Évitez la mise en cache de données volatiles - Ne mettez pas en cache des valeurs qui pourraient se déplacer ou changer dans les objets du noyau. Ne mettez en cache que des références stables comme :
   • L'emplacement de Kallsyms
   • L'adresse virtuelle de init_task
   • Les données BTF

Licence

Ce projet est sous licence Apache License 2.0. Voir le fichier LICENSE pour plus de détails.