Linux bietet viele Befehle, mit denen Benutzer Informationen über ihr Host-Betriebssystem sammeln können: Auflisten von Dateien oder Verzeichnissen, um Attribute zu überprüfen; Abfragen, um zu sehen, welche Pakete installiert sind, Prozesse ausgeführt werden und Dienste beim Booten gestartet werden; oder lernen Sie die Hardware des Systems kennen.
Jeder Befehl verwendet sein eigenes Ausgabeformat, um diese Informationen aufzulisten. Sie müssen Tools verwenden wie grep, sed, und awk um die Ergebnisse zu filtern, um bestimmte Informationen zu finden. Außerdem ändern sich viele dieser Informationen häufig, was zu Änderungen des Systemzustands führt.
Es wäre hilfreich, all diese Informationen formatiert wie die Ausgabe einer SQL-Datenbankabfrage anzuzeigen. Stellen Sie sich vor, Sie könnten die Ausgabe der ps und rpm Befehle, als ob Sie eine SQL-Datenbanktabelle mit ähnlichen Namen abfragen würden.
Glücklicherweise gibt es ein Tool, das genau das und noch viel mehr kann: Osquery ist ein Open-Source-Framework für die Instrumentierung, Überwachung und Analyse von Betriebssystemen mit SQL-Unterstützung.
Viele Anwendungen, die Sicherheit, DevOps, Compliance und Inventarverwaltung (um nur einige zu nennen) handhaben, hängen von den Kernfunktionen ab, die von Osquery im Kern bereitgestellt werden.
Osquery installieren
Osquery ist für Linux, macOS, Windows und FreeBSD verfügbar. Installieren Sie die neueste Version für Ihr Betriebssystem, indem Sie den Installationsanweisungen folgen. (In diesen Beispielen verwende ich Version 4.7.0.)
Überprüfen Sie nach der Installation, ob es funktioniert:
$ rpm -qa | grep osquery
osquery-4.7.0-1.linux.x86_64
$
$ osqueryi --version
osqueryi version 4.7.0
$
Osquery-Komponenten
Osquery hat zwei Hauptkomponenten:
- quietschen ist eine interaktive SQL-Abfragekonsole. Es ist ein eigenständiges Dienstprogramm, das keine Superuser-Berechtigungen benötigt (es sei denn, Sie fragen Tabellen ab, die diese Zugriffsebene benötigen).
- squeryd ist wie ein Überwachungs-Daemon für den Host, auf dem er installiert ist. Dieser Daemon kann Abfragen planen, die in regelmäßigen Abständen ausgeführt werden, um Informationen aus der Infrastruktur zu sammeln.
Sie können das Dienstprogramm osqueri ausführen, ohne dass der Dämon osqueryd ausgeführt wird. Ein weiteres Dienstprogramm, osqueryctl, steuert das Starten, Stoppen und Überprüfen des Status des Daemons.
$ rpm -ql osquery-4.8.0-1.linux.x86_64 | grep bin
/usr/bin/osqueryctl
/usr/bin/osqueryd
/usr/bin/osqueryi
$
Verwenden Sie die interaktive Eingabeaufforderung osqueryi
Sie interagieren mit Osquery ähnlich wie mit einer SQL-Datenbank. Tatsächlich ist osqueryi eine modifizierte Version der SQLite-Shell. Ausführen der osqueryi Befehl führt Sie in eine interaktive Shell, in der Sie spezifische Osquery-Befehle ausführen können, die oft mit a . beginnen .:
$ osqueryi
Using a virtual database. Need help, type '.help'
osquery>
Um die interaktive Shell zu beenden, führen Sie die .quit Befehl, um zur Shell des Betriebssystems zurückzukehren:
osquery>
osquery> .quit
$
Finden Sie heraus, welche Tabellen verfügbar sind
Wie bereits erwähnt, stellt Osquery Daten als Ausgabe von SQL-Abfragen zur Verfügung. Informationen in Datenbanken werden oft in Tabellen gespeichert. Aber wie können Sie diese Tabellen abfragen, wenn Sie ihre Namen nicht kennen? Nun, du kannst das laufen lassen .tables Befehl, um alle Tabellen aufzulisten, die Sie abfragen können. Wenn Sie ein langjähriger Linux-Benutzer oder ein Systemadministrator sind, werden die Tabellennamen bekannt sein, da Sie Betriebssystembefehle verwendet haben, um diese Informationen zu erhalten:
osquery> .tables
=> acpi_tables
=> apparmor_events
=> apparmor_profiles
=> apt_sources
<< snip >>
=> arp_cache
=> user_ssh_keys
=> users
=> yara
=> yara_events
=> ycloud_instance_metadata
=> yum_sources
osquery>
Überprüfen Sie das Schema für einzelne Tabellen
Da Sie nun die Tabellennamen kennen, können Sie sehen, welche Informationen jede Tabelle bietet. Wählen Sie als Beispiel processes, seit der ps Befehl wird häufig verwendet, um diese Informationen zu erhalten. Führen Sie die .schema -Befehl gefolgt vom Tabellennamen, um zu sehen, welche Informationen in dieser Tabelle gespeichert sind. Wenn Sie die Ergebnisse überprüfen möchten, können Sie schnell laufen ps -ef oder ps aux und vergleiche die Ausgabe mit dem Inhalt der Tabelle:
osquery> .schema processes
CREATE TABLE processes(`pid` BIGINT, `name` TEXT, `path` TEXT, `cmdline` TEXT, `state` TEXT, `cwd` TEXT, `root` TEXT, `uid` BIGINT, `gid` BIGINT, `euid` BIGINT, `egid` BIGINT, `suid` BIGINT, `sgid` BIGINT, `on_disk` INTEGER, `wired_size` BIGINT, `resident_size` BIGINT, `total_size` BIGINT, `user_time` BIGINT, `system_time` BIGINT, `disk_bytes_read` BIGINT, `disk_bytes_written` BIGINT, `start_time` BIGINT, `parent` BIGINT, `pgroup` BIGINT, `threads` INTEGER, `nice` INTEGER, `is_elevated_token` INTEGER HIDDEN, `elapsed_time` BIGINT HIDDEN, `handle_count` BIGINT HIDDEN, `percent_processor_time` BIGINT HIDDEN, `upid` BIGINT HIDDEN, `uppid` BIGINT HIDDEN, `cpu_type` INTEGER HIDDEN, `cpu_subtype` INTEGER HIDDEN, `phys_footprint` BIGINT HIDDEN, PRIMARY KEY (`pid`)) WITHOUT ROWID;
osquery>
Um den Punkt nach Hause zu bringen, verwenden Sie den folgenden Befehl, um das Schema für die RPM-Pakete anzuzeigen und die Informationen mit zu vergleichen rpm -qa und rpm -qi Betriebssystembefehle:
osquery>
osquery> .schema rpm_packages
CREATE TABLE rpm_packages(`name` TEXT, `version` TEXT, `release` TEXT, `source` TEXT, `size` BIGINT, `sha1` TEXT, `arch` TEXT, `epoch` INTEGER, `install_time` INTEGER, `vendor` TEXT, `package_group` TEXT, `pid_with_namespace` INTEGER HIDDEN, `mount_namespace_id` TEXT HIDDEN, PRIMARY KEY (`name`, `version`, `release`, `arch`, `epoch`, `pid_with_namespace`)) WITHOUT ROWID;
osquery>
Weitere Informationen finden Sie in der Tabellendokumentation von Osquery.
Verwenden Sie den PRAGMA-Befehl
Falls Ihnen die Schemainformationen zu kryptisch sind, gibt es noch eine andere Möglichkeit, die Tabelleninformationen in einem ausführlichen, tabellarischen Format auszudrucken: die PRAGMA Befehl. Zum Beispiel verwende ich PRAGMA um Informationen für die zu sehen rpm_packages Tabelle in schönem Format:
osquery> PRAGMA table_info(rpm_packages);Ein Vorteil dieser tabellarischen Informationen besteht darin, dass Sie sich auf das abzufragende Feld konzentrieren und die Art der bereitgestellten Informationen anzeigen können:
osquery> PRAGMA table_info(users);
+-----+-------------+--------+---------+------------+----+
| cid | name | type | notnull | dflt_value | pk |
+-----+-------------+--------+---------+------------+----+
| 0 | uid | BIGINT | 1 | | 1 |
| 1 | gid | BIGINT | 0 | | 0 |
| 2 | uid_signed | BIGINT | 0 | | 0 |
| 3 | gid_signed | BIGINT | 0 | | 0 |
| 4 | username | TEXT | 1 | | 2 |
| 5 | description | TEXT | 0 | | 0 |
| 6 | directory | TEXT | 0 | | 0 |
| 7 | shell | TEXT | 0 | | 0 |
| 8 | uuid | TEXT | 1 | | 3 |
+-----+-------------+--------+---------+------------+----+
osquery>
Führen Sie Ihre erste Abfrage aus
Nachdem Sie nun über alle erforderlichen Informationen aus der Tabelle, dem Schema und den abzufragenden Elementen verfügen, führen Sie Ihre erste SQL-Abfrage aus, um die Informationen anzuzeigen. Die folgende Abfrage gibt die Benutzer zurück, die auf dem System vorhanden sind, sowie deren Benutzer-ID, Gruppen-ID, Home-Verzeichnis und Standard-Shell. Linux-Benutzer können diese Informationen erhalten, indem sie den Inhalt der /etc/passwd Datei und mache etwas grep, sed, und awk Magie.
osquery>
osquery> select uid,gid,directory,shell,uuid FROM users LIMIT 7;
+-----+-----+----------------+----------------+------+
| uid | gid | directory | shell | uuid |
+-----+-----+----------------+----------------+------+
| 0 | 0 | /root | /bin/bash | |
| 1 | 1 | /bin | /sbin/nologin | |
| 2 | 2 | /sbin | /sbin/nologin | |
| 3 | 4 | /var/adm | /sbin/nologin | |
| 4 | 7 | /var/spool/lpd | /sbin/nologin | |
| 5 | 0 | /sbin | /bin/sync | |
| 6 | 0 | /sbin | /sbin/shutdown | |
+-----+-----+----------------+----------------+------+
osquery>
Führen Sie Abfragen aus, ohne in den interaktiven Modus zu wechseln
Was ist, wenn Sie eine Abfrage ausführen möchten, ohne den interaktiven Osqueri-Modus aufzurufen? Dies kann sehr nützlich sein, wenn Sie Shell-Skripte darum schreiben. In diesem Fall könnten Sie echo die SQL-Abfrage und leiten Sie sie direkt aus der Bash-Shell an osqueri:
$ echo "select uid,gid,directory,shell,uuid FROM users LIMIT 7;" | osqueryi
+-----+-----+----------------+----------------+------+
| uid | gid | directory | shell | uuid |
+-----+-----+----------------+----------------+------+
| 0 | 0 | /root | /bin/bash | |
| 1 | 1 | /bin | /sbin/nologin | |
| 2 | 2 | /sbin | /sbin/nologin | |
| 3 | 4 | /var/adm | /sbin/nologin | |
| 4 | 7 | /var/spool/lpd | /sbin/nologin | |
| 5 | 0 | /sbin | /bin/sync | |
| 6 | 0 | /sbin | /sbin/shutdown | |
+-----+-----+----------------+----------------+------+
$
Erfahren Sie, welche Dienste beim Hochfahren gestartet werden
Osquery kann auch alle Dienste zurückgeben, die so eingestellt sind, dass sie beim Booten gestartet werden. Um zum Beispiel die abzufragen startup_items Tabelle und rufen Sie den Namen, Status und Pfad der ersten fünf Dienste ab, die beim Start ausgeführt werden:
osquery> SELECT name,type,status,path FROM startup_items LIMIT 5;
name = README
type = Startup Item
status = enabled
path = /etc/rc.d/init.d/README
name = anamon
type = Startup Item
status = enabled
path = /etc/rc.d/init.d/anamon
name = functions
type = Startup Item
status = enabled
path = /etc/rc.d/init.d/functions
name = osqueryd
type = Startup Item
status = enabled
path = /etc/rc.d/init.d/osqueryd
name = AT-SPI D-Bus Bus
type = Startup Item
status = enabled
path = /usr/libexec/at-spi-bus-launcher --launch-immediately
osquery>
Suchen Sie nach ELF-Informationen für eine Binärdatei
Stellen Sie sich vor, Sie möchten mehr über die . erfahren ls binär. Normalerweise würdest du es mit dem machen readelf -h Befehl gefolgt von dem ls Pfad des Befehls. Sie können die abfragen elf_info Tabelle mit Osquery und erhalten die gleichen Informationen:
osquery> SELECT * FROM elf_info WHERE path="/bin/ls";
class = 64
abi = sysv
abi_version = 0
type = dyn
machine = 62
version = 1
entry = 24064
flags = 0
path = /bin/ls
osquery>
Jetzt haben Sie einen Vorgeschmack darauf, wie Sie mit osqueri nach Informationen suchen, die für Sie von Interesse sind. Diese Informationen werden jedoch in einer Vielzahl von Tabellen gespeichert; Ein von mir abgefragtes System hatte 156 verschiedene Tabellen, was überwältigend sein kann:
$ echo ".tables" | osqueryi | wc -l
156
$
Zur Vereinfachung können Sie mit diesen Tabellen beginnen, um Informationen zu Ihrem Linux-System zu erhalten:
Systeminformationstabelle
osquery> select * from system_info;Informationen zu Systemgrenzen
osquery> select * from ulimit_info;Von verschiedenen Prozessen geöffnete Dateien
osquery> select * from process_open_files;Offene Ports auf einem System
osquery> select * from listening_ports;Informationen zu laufenden Prozessen
osquery> select * from processes;Informationen zu installierten Paketen
osquery> select * from rpm_packages;Benutzer-Login-Informationen
osquery> select * from last;Informationen zum Systemprotokoll
osquery> select * from syslog_events;Mehr erfahren
Osquery ist ein leistungsstarkes Tool, das viele Hostinformationen bereitstellt, die zur Lösung verschiedener Anwendungsfälle verwendet werden können. Sie können mehr über Osquery erfahren, indem Sie die Dokumentation lesen.