mquire

mquire, ein Wortspiel aus den Wörtern memory und inquire, ist ein Speicher-Abfragewerkzeug, inspiriert von osquery.

Hauptvorteil: Keine externen Debugsymbole erforderlich

mquire kann Linux-Kernel-Speicherabbilder analysieren, ohne dass externe Debugsymbole erforderlich sind.

Alles, was für die Analyse benötigt wird, ist bereits im Speicherabbild selbst eingebettet. Dies bedeutet, dass Sie Folgendes analysieren können:

• Unbekannte oder benutzerdefinierte Kernel, die Sie noch nie gesehen haben
• Jede Linux-Distribution ohne Vorbereitung
• Speicherabbilder, bei denen externe Debugsymbole nicht verfügbar oder verloren gegangen sind

Anforderungen

Anforderungen an die Kernel-Version:

• BTF-Unterstützung: Kernel 4.18 oder neuer mit aktiviertem BTF (die meisten modernen Distributionen aktivieren es standardmäßig)
• Kallsyms-Unterstützung: Kernel 6.4 oder neuer (aufgrund von Änderungen im scripts/kallsyms.c-Format)

Funktionsweise

mquire analysiert Kernel-Speicher, indem es zwei Arten von Informationen liest, die in modernen Linux-Kerneln eingebettet sind:

1. Typinformationen aus BTF (BPF Type Format) – Beschreibt die Struktur und das Layout von Kernel-Datentypen. BTF-Daten werden mit der btfparse crate geparst.
2. Symbolinformationen aus Kallsyms – Liefert die Speicheradressen von Kernel-Symbolen (gleiche Daten wie /proc/kallsyms)

Durch die Kombination von Typinformationen mit Symbolpositionen kann mquire komplexe Kernel-Datenstrukturen finden und lesen, wie zum Beispiel:

• Prozessspeicherzuordnungen (unter Verwendung von Maple-Tree-Strukturen)
• Zwischengespeicherte Dateidaten (unter Verwendung von XArray-Strukturen)
• Kernel-Lognachrichten

Dies ermöglicht es, Dateien direkt aus dem Kernel-Dateicache zu extrahieren, selbst wenn sie von der Festplatte gelöscht wurden.

Kompatibilitätshinweise

Der Kallsyms-Scanner hängt vom Datenformat aus scripts/kallsyms.c im Kernel-Quellcode ab. Wenn zukünftige Kernel-Versionen dieses Format ändern, müssen die Scanner-Heuristiken möglicherweise aktualisiert werden.

Funktionen

Tabellen

mquire bietet SQL-Tabellen, um verschiedene Aspekte des Systems oder den Zustand des Werkzeugs selbst abzufragen.

mquire ist keine Datenbank. Jede Abfrage rekonstruiert Kernel-Datenstrukturen, indem Speicher durchsucht und Zeigern gefolgt wird. Es gibt keine vorberechneten Indizes oder zwischengespeicherten Ergebnisse: Jeder Tabellenzugriff ist eine Traversierung von Kernel-Daten. Verwenden Sie AS MATERIALIZED, um redundante Scans zu vermeiden (siehe Abfrageoptimierung), und geben Sie Einschränkungen wie task an, wenn Sie prozessbezogene Tabellen wie task_open_files und memory_mappings abfragen, um den Scan auf einen einzelnen Prozess zu beschränken.

Designprinzip: Virtuelle Adressen als Join-Schlüssel. Tabellen verwenden virtual_address (die Kernel-Adresse der zugrunde liegenden Datenstruktur) als kanonischen Join-Schlüssel, nicht pid oder andere für den Benutzer sichtbare Identifikatoren. Dies ist beabsichtigt, da dieselbe PID mehrmals in verschiedenen Erkennungsquellen und Root-Tasks auftauchen kann, während eine virtuelle Adresse ein bestimmtes Kernel-Objekt eindeutig identifiziert. Sowohl die SQL-Tabellen als auch die zugrunde liegende LinuxOperatingSystem-API sind um diese Konvention herum aufgebaut.

Systeminformationen

• os_version – Kernel-Version und Architektur
• system_info – Hostname und Domainname
• boot_time – Systemstartzeit
• kallsyms – Kernel-Symboladressen (gleiche Daten wie /proc/kallsyms)
• dmesg – Kernel-Ringpuffernachrichten (gleiche Daten wie der Befehl dmesg)

Prozessinformationen

• tasks – Laufende Prozesse mit Befehlszeilen und Binärpfaden. Jeder Task wird über mehrere unabhängige Quellen entdeckt, was für die Rootkit-Erkennung nützlich ist. Siehe Vergleich der Task-Enumeration-Methoden zur Rootkit-Erkennung und Deduplizierte Prozessliste.
• task_open_files – Von jedem Prozess geöffnete Dateien (geben Sie eine task-Einschränkung für eine gezielte Analyse an oder fragen Sie alle Tasks auf einmal ab)
• memory_mappings – Speicherbereiche, die jedem Prozess zugeordnet sind (geben Sie eine task-Einschränkung für eine gezielte Analyse an oder fragen Sie alle Tasks auf einmal ab)
• task_capabilities – Linux-Fähigkeitssets (effective, permitted, inheritable, bounding, ambient) für einen Task. Erfordert eine task-Einschränkung, also joinen Sie es mit tasks/processes (z.B. JOIN task_capabilities c ON c.task = p.virtual_address).
• task_ptrace_flags – Dekodiert das ptrace-Feld eines angegebenen Tasks. Erfordert eine task-Einschränkung.

Kernel-Module

• kernel_modules – Geladene Kernel-Module mit Metadaten (Name, Status, Version, Parameter, Taint-Flags)
• kernel_module_mem_entries – Die mem-Einträge aus einem Kernel-Modul-Objekt. Erfordert eine kernel_module-Einschränkung, also joinen Sie es mit kernel_modules (z.B. JOIN kernel_module_mem_entries r ON r.kernel_module = m.virtual_address).
• ftrace_ops – Eine Liste von struct ftrace_ops-Knoten, standardmäßig vom Symbol ftrace_ops_list aus durchlaufen. Beschränken Sie virtual_address, um einen einzelnen Knoten zu lesen, oder start_vaddr (optional begrenzt durch end_vaddr), um von einem beliebigen Knoten aus zu durchlaufen.

Netzwerkinformationen

• network_connections – Aktive Netzwerkverbindungen (TCP-Sockets)
• network_interfaces – Netzwerkschnittstellen mit IP-Adressen und MAC-Adressen

Dateisystem

• syslog_file – Systemprotokolle, die aus dem Kernel-Dateicache gelesen wurden (funktioniert auch, wenn Protokolldateien gelöscht oder nicht verfügbar sind, solange sie im Cache zwischengespeichert sind)

Debugging

• mquire_diagnostics – Interne mquire-Protokolle, die Analysefortschritt, Warnungen und Fehler anzeigen

Befehle

mquire bietet drei Hauptbefehle:

• mquire shell – Startet eine interaktive SQL-Shell zur Abfrage von Speicherabbildern
• mquire query – Führt eine einzelne SQL-Abfrage aus und gibt Ergebnisse aus (unterstützt JSON- oder Tabellenformat)
• mquire command – Führt benutzerdefinierte Befehle auf Speicherabbildern aus (z.B. .task_tree, .system_version, .dump)

Punkt-Befehle

mquire bietet spezielle Befehle, die mit einem Punkt (.) beginnen, um sie von SQL-Abfragen zu unterscheiden.

Eingebaute Befehle

Diese Befehle funktionieren in der interaktiven Shell und mit mquire query:

• .tables – Listet alle verfügbaren Tabellen auf
• .schema – Zeigt das Schema für alle Tabellen an
• .schema <tabelle> – Zeigt das Schema für eine bestimmte Tabelle an
• .commands – Listet alle verfügbaren benutzerdefinierten Befehle auf
• .exit – Beendet die interaktive Shell (nur Shell)

Benutzerdefinierte Befehle

Diese Befehle funktionieren in der interaktiven Shell und mit mquire command:

Verwenden Sie --help bei jedem Befehl, um verfügbare Optionen und Nutzungsinformationen anzuzeigen. Zum Beispiel: .task_tree --help

.system_version

Zeigt die Betriebssystemversionsinformationen an.

Dies ist ein praktischer Befehl, der SELECT * FROM os_version entspricht, jedoch mit formatierter Ausgabe.

.task_tree

Zeigt einen hierarchischen Baum der laufenden Prozesse und Threads an, ähnlich dem Befehl pstree unter Linux.

Optionen:

• --show-threads – Schließt Threads zusätzlich zu den Prozessen ein. Wenn aktiviert, werden sowohl TGID als auch TID für jeden Eintrag angezeigt.
• --use-real-parent – Verwendet das Feld real_parent anstelle von parent für die Baumstruktur. Das Feld real_parent zeigt den ursprünglichen Elternprozess vor einer etwaigen Neuzuordnung (nützlich, um Prozesserstellungsketten auch nach Beenden der Elternprozesse zu verfolgen).

Hinweise:

• Das Format ist [TGID TID] bei Anzeige von Threads oder [TGID] bei versteckten Threads. TGID (Thread Group ID) ist das, was allgemein als PID bezeichnet wird. Bei Hauptthreads (wo TGID == TID) sind beide Werte gleich.

.carve

Extrahiert einen Bereich des virtuellen Speichers auf die Festplatte. Dieser Befehl extrahiert rohen Speicherinhalt aus einem bestimmten virtuellen Adressbereich unter Verwendung einer bestimmten Seitentabelle. Nützlich zum Extrahieren von Prozessspeicher, Heap-Inhalten oder anderen Speicherbereichen.

Argumente:

• ROOT_PAGE_TABLE – Die physische Adresse der Wurzel-Seitentabelle (Hex-String mit optionalem 0x-Präfix). Diese bestimmt den für die Übersetzung zu verwendenden Adressraum.
• VIRTUAL_ADDRESS – Die virtuelle Adresse, ab der das Carven beginnen soll (Hex-String mit optionalem 0x-Präfix).
• SIZE – Anzahl der zu extrahierenden Bytes.
• DESTINATION_PATH – Ausgabedateipfad, in den der gecarvte Speicher geschrieben wird.

Hinweise:

• Der Befehl zeigt vor dem Schreiben eine Zusammenfassung der zugeordneten vs. nicht zugeordneten Bereiche an.
• Nicht zugeordnete Bereiche werden in der Ausgabedatei mit Nullen gefüllt.

.dump

Extrahiert Dateien aus dem Kernel-Dateicache, um Dateien direkt aus dem Speicher wiederherzustellen. Dieser Befehl durchläuft alle Tasks und deren offene Dateideskriptoren und extrahiert Dateiinhalte aus dem Page-Cache.

Argumente:

• OUTPUT – Ausgabeverzeichnis für extrahierte Dateien. Dateien werden nach TGID organisiert (z.B. tgid_1234/pfad/zur/datei).

Hinweise:

• Funktioniert derzeit mit Dateien, die über Dateideskriptoren geöffnet wurden (aus der Prozessdateideskriptortabelle).
• Unterstützt noch nicht das Extrahieren von Daten aus speicherzugeordneten Dateien.
• Leere Dateien (keine Daten im Page-Cache) werden übersprungen.
• Bereiche mit Lesefehlern werden in der Ausgabe mit Nullen aufgefüllt.

Anwendungsfälle

mquire ist ausgelegt für:

• Forensische Analyse – Analysieren von Speicherabbildern kompromittierter Systeme, um zu verstehen, was lief und auf welche Dateien zugegriffen wurde
• Incident Response – Schnelles Abfragen von Speicherabbildern, um Beweise für bösartige Aktivitäten zu finden
• Sicherheitsforschung – Untersuchen von Kernel-Interna und Prozessverhalten anhand von Speicherabbildern
• Malware-Analyse – Untersuchen laufender Prozesse und deren Dateioperationen ohne Erkennung
• Benutzerdefinierte Werkzeuge – Erstellen eigener Analysewerkzeuge mit der mquire-Bibliothekscrate, die eine wiederverwendbare API für die Kernel-Speicheranalyse bereitstellt

Kompilierung und Installation

Vorkompilierte Pakete aus CI

Vorkompilierte Pakete sind als Artefakte von CI-Läufen verfügbar. Sie können diese über den Actions-Tab herunterladen, indem Sie einen erfolgreichen Workflow-Lauf auswählen und die Artefakte herunterladen. Die folgenden Paketformate sind verfügbar:

• linux-deb-package – Debian/Ubuntu .deb-Paket
• linux-rpm-package – Fedora/RHEL/CentOS .rpm-Paket
• linux-tgz-package – Generisches Linux .tar.gz-Archiv

Kompilierung aus dem Quellcode

mquire ist in Rust geschrieben. Zum Kompilieren:```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

## Unterstützte Snapshot-Formate

mquire unterstützt die folgenden Speicher-Snapshot-Formate, die anhand der Dateierweiterung erkannt werden:

| Format | Erweiterung | Beschreibung |
|--------|-------------|--------------|
| Raw | `.raw` | Flaches physisches Speicherabbild (byteweise Kopie des physischen Adressraums) |
| LiME | `.lime` | [Linux Memory Extractor](https://github.com/504ensicsLabs/LiME)-Format mit Adressbereichs-Headern |
| ELF core | `.elf` | ELF-Core-Dump mit PT_LOAD-Segmenten (erzeugt durch `virsh dump` oder QEMU `dump-guest-memory`) |

## Erfassen eines Speicher-Snapshots

### Verwendung von AVML (empfohlen)

Wir empfehlen [AVML](https://github.com/microsoft/avml) zum Erfassen von Speicher-Snapshots von laufenden Linux-Systemen. [LiME](https://github.com/504ensicsLabs/LiME) wurde zuvor vorgeschlagen, wird aber nicht mehr aktiv gewartet.```bash
sudo avml output.lime

Wichtig: Verwenden Sie --compress nicht, wenn Sie Snapshots für mquire erfassen. mquire unterstützt keine komprimierten AVML-Snapshots. Wenn Sie einen komprimierten Snapshot haben, dekomprimieren Sie ihn zuerst mit avml-convert: avml-convert compressed.lime uncompressed.lime

Weitere Optionen finden Sie in der AVML-Dokumentation.

Verwendung von virsh (virtuelle Maschinen)

Verwenden Sie für libvirt/KVM-VMs virsh dump, um einen ELF-Core-Dump zu erstellen:```bash virsh -c qemu:///system dump output.elf --memory-only --format elf

Die VM wird während des Dumps pausiert und danach fortgesetzt. Fügen Sie `--live` hinzu, um die Pausierung zu vermeiden, auf Kosten der Snapshot-Konsistenz.

## Erste Schritte

Sobald Sie ein Speicherabbild haben, können Sie mithilfe von SQL-Abfragen und benutzerdefinierten Befehlen damit interagieren. mquire bietet drei Möglichkeiten, mit Snapshots zu interagieren:

### Interaktive Shell

Starten Sie eine interaktive SQL-Shell:```bash
mquire shell /path/to/memory.raw

Dadurch wird eine Eingabeaufforderung geöffnet, in der Sie sowohl SQL-Abfragen als auch Befehle interaktiv ausführen können:```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

### Einmalige SQL-Abfragen

Führen Sie eine einzelne SQL-Abfrage oder einen integrierten Befehl von der Befehlszeile aus:```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"

Benutzerdefinierte Befehle ausführen

Führen Sie benutzerdefinierte Befehle für spezielle Analysen aus:```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"

## Autostart SQL-Dateien

mquire lädt und führt beim Start automatisch SQL-Dateien aus `$HOME/.config/trailofbits/mquire/autostart/` aus. Dateien werden nach Betriebssystem und Architektur organisiert:```
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

Dateien in jedem Verzeichnis sind alphabetisch sortiert. Verzeichnisse werden in der oben gezeigten Reihenfolge durchsucht.

Eigenschaften:

• Dateien müssen eine .sql-Erweiterung haben
• Fehler werden in mquire_diagnostics protokolliert, blockieren aber nicht die Ausführung
• Funktioniert sowohl mit den Befehlen mquire shell als auch mquire query

Mitgelieferte Views

mquire liefert wiederverwendbare SQL-Views im Verzeichnis sql/views/ mit. Installieren Sie sie mit just install-views. Im Views-README finden Sie die vollständige Liste, Nummerierungskonvention und Verzeichnisstruktur.

Linux-Views (sql/views/linux/common/):

• 000_processes.sql - Deduplizierte Prozessliste über alle Erkennungsquellen hinweg, gefiltert auf User-Space-Prozessleiter. Abfrage mit SELECT * FROM processes.
• 100_process_network_connections.sql - Ordnet Netzwerkverbindungen den zugehörigen Prozessen zu, indem es über Dateideskriptoren joint. Abfrage mit SELECT * FROM process_network_connections WHERE comm = 'sshd'.
• 120_process_capabilities.sql - Schnellübersicht über Capabilities, eine Zeile pro Prozess mit jedem Set als kompakte Liste (ALL, '' oder Cap-Namen; NULL falls nicht lesbar). Abfrage mit SELECT * FROM process_capabilities.
• - Schnellübersicht über ptrace, eine Zeile pro Prozess mit den gesetzten -Flags als kompakte Liste ( wenn nicht getrace) plus dem Rohwert. Abfrage mit .

Abfrageoptimierung

mquire-Abfragen erfordern die Rekonstruktion von Kernel-Datenstrukturen aus dem virtuellen Speicher durch Dereferenzieren von Zeigern mithilfe eingebetteter Typinformationen und Debug-Symbole. Diese Verarbeitung kann aufwändig sein, daher sollten Sie Abfrageoptimierungstechniken einsetzen, um die Leistung drastisch zu verbessern.

Materialisierung mit AS MATERIALIZED

Verwenden Sie den Hinweis AS MATERIALIZED, um Tabellenergebnisse zwischenzuspeichern, wenn Tabellen in JOINs verwendet oder mehrfach aufgerufen werden.

Wann materialisieren:

• Tabellen, deren Erstellung teuer ist (z. B. erfordert tasks das Durchlaufen von verknüpften Listen von Prozessstrukturen, wobei mehrere Zeiger pro Prozess dereferenziert werden)
• Tabellen, die in JOINs verwendet werden (während der Abfrageausführung mehrfach aufgerufen)
• Tabellen, die in derselben Abfrage mehrfach referenziert werden

Beispiel:```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;

**Hinweis:** Die Tabellen `task_open_files` und `memory_mappings` verwenden die Spalte `task` als Generator-Eingabe. Wenn sie mit der Tabelle `tasks` verknüpft werden, übergibt SQLite die Einschränkung automatisch über verschachtelte Schleifen-Joins, was direkte JOINs effizient macht.

**Auswirkung auf die Leistung:** Die Materialisierung kann eine erhebliche Beschleunigung für Abfragen mit JOINs bieten (typischerweise 2-5x schneller)

**Beispiel-Benchmark-Ergebnisse:**

*Test durchgeführt auf einem Ubuntu 24.04 Snapshot (Kernel 6.8.0-63), 351 Prozesse, 50 Verbindungen, 2142 geöffnete Dateien. Die Leistung variiert je nach Snapshot-Größe, Kernel-Version und Hardware.*

| Methode | Echtzeit | Benutzerzeit | Beschleunigung |
|--------|-----------|-----------|---------|
| OHNE Materialisierung | 12.067s | 16.373s | Basiswert |
| MIT Materialisierung | 3.171s | 8.786s | **3,8x schneller** |

### Optimierung der JOIN-Reihenfolge

**Beginnen Sie mit der kleinsten Tabelle und JOINen Sie zu größeren Tabellen**, um die Anzahl der früh in der Abfragepipeline verarbeiteten Zeilen zu minimieren.

**Typische Tabellengrößen:**
- `network_connections`: am kleinsten – nur Prozesse mit Netzwerkaktivität
- `tasks`: mittel – alle Prozesse
- `task_open_files`: am größten – alle geöffneten Dateideskriptoren

**Optimale Reihenfolge:**

Beginnen Sie mit der gefilterten tasks-Tabelle und JOINen Sie zu größeren Tabellen:

- Gefilterte tasks (kleinste Teilmenge)
- `task_open_files` (größer, aber durch den task-Filter eingeschränkt)
- `network_connections` (groß, aber durch den task-Join gefiltert)```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

Verständnis der Abfrageausführung

Verwenden Sie EXPLAIN QUERY PLAN, um zu sehen, wie SQLite Ihre Abfrage ausführt:```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;

Suchen Sie nach:
- **BLOOM FILTER**: SQLites Optimierung für große JOINs
- **AUTOMATIC COVERING INDEX**: Temporäre Indizes, die für Lookups erstellt werden
- **SCAN**: Vollständiger Tabellenscan (für die führende Tabelle erwartet)
- **SEARCH**: Indexbasierte Suche (effizient)

### Bewährte Vorgehensweisen

1. **Materialisieren Sie stets teure Tabellen** in JOINs
2. **Beginnen Sie mit der kleinsten Tabelle** als führende Tabelle
3. **Verwenden Sie mehrzeiliges SQL** in Skripten für bessere Lesbarkeit
4. **Überprüfen Sie Abfragepläne** mit `EXPLAIN QUERY PLAN` für komplexe Abfragen
5. **Vermeiden Sie `SELECT *`** in der Produktion – geben Sie nur die benötigten Spalten an

### Dateiextraktion

Extrahieren Sie Dateien aus dem Arbeitsspeicher auf die Festplatte:```bash
mquire command /path/to/memory.raw ".dump /output/directory"

Beispielabfragen

Alle Abfragen verwenden die standardmäßige SQL-Syntax.

Systemversion```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"

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

Kernel-Module```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:""

#### Aufgaben ausführen```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"

Verbindungen

Finden Sie Netzwerkverbindungen für einen bestimmten Prozess durch Verknüpfen von tasks, task_open_files und 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"

#### Offene Dateien einer Aufgabe

Liste offene Dateien für bestimmte Prozesse auf, indem `tasks` mit `task_open_files` verknüpft werden:```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"

Kommandozeilen-Abfragebeispiele

JSON-Ausgabe (Standard)```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" } ]

##### Tabellenausgabe```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"

Beispiele für benutzerdefinierte Befehle

Verfügbare Befehle auflisten```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

##### Systemversion anzeigen```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

Prozessbaum anzeigen```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

**Hinweis:** Wenn mehrere `task_struct`-Einträge mit derselben TID (Thread-ID, die aufgrund von Speicherkorruption oder Snapshot-Zeitpunkt auftreten kann) vorhanden sind, werden doppelte Einträge mit dem Fortsetzungssymbol `╎   ↳` eingerückt unter dem primären Eintrag angezeigt. Das Format ist `[TGID] (virtuelle_Adresse) name`, wenn Threads ausgeblendet sind, oder `[TGID TID]` bei Anzeige von Threads (wobei TGID die Thread-Gruppen-ID ist, allgemein als PID bekannt).

#### Dateien aus dem Speicher extrahieren```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)
  ...

Fehlerbehebung

Verwenden Sie das --debug-Flag, um ausführliche Debug-Meldungen während der Initialisierung und Analyse zu aktivieren:```bash mquire --debug command /path/to/memory.raw ".system_version"

- **`shell` und `query` Modi**: Debug-Nachrichten werden in der SQL-Tabelle `mquire_diagnostics` gespeichert. Abfragen mit `SELECT * FROM mquire_diagnostics;`
- **`command` Modus**: Debug-Nachrichten werden direkt an stderr ausgegeben.

Bei Initialisierungsproblemen, die verhindern, dass mquire den Snapshot erfolgreich lädt, wird die Verwendung des `command` Modus mit einem einfachen Befehl wie `.system_version` empfohlen, da die Debug-Ausgabe sofort an stderr ausgegeben wird, ohne dass die Tabelle `mquire_diagnostics` abgefragt werden muss.

## Konfiguration

mquire kann über eine TOML-Datei unter `$HOME/.config/trailofbits/mquire/config.toml` konfiguriert werden. Wenn die Datei nicht existiert, werden Standardwerte verwendet.

### Verfügbare Optionen und Standardwerte```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

Entwicklung

Dieses Projekt verwendet just als Befehlsausführer. Führe just aus, um verfügbare Befehle zu sehen:

SQL-Abfrage-Integrationstests

Diese Tests überprüfen, dass mquire korrekte Ausgaben für Abfragen gegen Speicher-Snapshots erzeugt.

• just integration-test - Führe Tests aus und vergleiche Ausgabe mit erwarteten JSON-Dateien
• just integration-update - Aktualisiere erwartete JSON-Dateien mit tatsächlicher Ausgabe (verwende beim Ändern von Tabellenschemata)

Nachdem du integration-update ausgeführt hast, überprüfe den git diff, um sicherzustellen, dass die Änderungen deinen Erwartungen entsprechen, bevor du committest.

Neue Tests hinzufügen: Erstelle eine .sql-Datei und eine dazugehörige .json-Datei im entsprechenden Snapshot-Verzeichnis und führe dann just integration-update aus, um die erwartete Ausgabe zu füllen.

Mitwirken

Beiträge sind willkommen! Wenn du einen Beitrag leistest, befolge bitte diese Richtlinien:

1. Teste deine Änderungen - Stelle sicher, dass deine Änderungen korrekt funktionieren, bevor du sie einreichst
2. Halte Abhängigkeiten minimal - Füge nur dann neue Abhängigkeiten hinzu, wenn es unbedingt notwendig ist
3. Vermeide das Cachen flüchtiger Daten - Cache keine Werte, die sich innerhalb von Kernel-Objekten verschieben oder ändern könnten. Cache nur stabile Referenzen wie:
   • Kallsyms-Speicherort
   • init_task virtuelle Adresse
   • BTF-Daten

Lizenz

Dieses Projekt ist unter der Apache License 2.0 lizenziert. Siehe die LICENSE-Datei für Details.