Interrogez votre système d’exploitation Linux comme une base de données

Linux propose de nombreuses commandes pour aider les utilisateurs à rassembler des informations sur leur système d’exploitation hôte : lister les fichiers ou les répertoires pour vérifier les attributs ; interroger pour voir quels packages sont installés, les processus sont en cours d’exécution et les services démarrent au démarrage ; ou se renseigner sur le matériel du système.

Chaque commande utilise son propre format de sortie pour répertorier ces informations. Vous devez utiliser des outils comme grep, sed, et awk pour filtrer les résultats pour trouver des informations spécifiques. De plus, beaucoup de ces informations changent fréquemment, entraînant des changements dans l’état du système.

Il serait utile de visualiser toutes ces informations formatées comme la sortie d’une requête SQL de base de données. Imaginez que vous puissiez interroger la sortie du ps et rpm comme si vous interrogeiez une table de base de données SQL avec des noms similaires.

Heureusement, il existe un outil qui fait exactement cela et bien plus encore : Osquerie est un Open source « Instrumentation, surveillance et cadre d’analyse du système d’exploitation basé sur SQL.

De nombreuses applications qui gèrent la sécurité, le DevOps, la conformité et la gestion des stocks (pour n’en nommer que quelques-unes) dépendent des fonctionnalités de base fournies par Osquery.

Installer Osquery

Osquery est disponible pour Linux, macOS, Windows et FreeBSD. Installez la dernière version de votre système d’exploitation en suivant ses instructions d’installation. (J’utiliserai la version 4.7.0 dans ces exemples.)

Après l’installation, vérifiez qu’il fonctionne :

$ rpm -qa | grep osquery
osquery-4.7.0-1.linux.x86_64
$ 
$ osqueryi --version
osqueryi version 4.7.0
$ 

Composants de l’osquerie

Osquery a deux composants principaux:

• osqueri est une console de requête SQL interactive. Il s’agit d’un utilitaire autonome qui n’a pas besoin de privilèges de super-utilisateur (sauf si vous interrogez des tables qui ont besoin de ce niveau d’accès).
• osqueryd est comme un démon de surveillance pour l’hôte sur lequel il est installé. Ce démon peut programmer des requêtes à exécuter à intervalles réguliers pour collecter des informations à partir de l’infrastructure.

Vous pouvez exécuter l’utilitaire osqueri sans exécuter le démon osqueryd. Un autre utilitaire, osqueryctl, contrôle le démarrage, l’arrêt et la vérification de l’état du démon.

$ rpm -ql osquery-4.8.0-1.linux.x86_64 | grep bin
/usr/bin/osqueryctl
/usr/bin/osqueryd
/usr/bin/osqueryi
$

Utiliser l’invite interactive osqueryi

Vous interagissez avec Osquery comme si vous utilisiez une base de données SQL. En fait, osqueryi est une version modifiée du shell SQLite. Exécuter le osqueryi La commande vous dépose dans un shell interactif où vous pouvez exécuter des commandes spécifiques à Osquery, qui commencent souvent par un .:

$ osqueryi 
Using a virtual database. Need help, type '.help'
osquery> 

Pour quitter le shell interactif, exécutez le .quit commande pour revenir au shell du système d’exploitation :

Find out what tables are available

As mentioned, Osquery makes data available as the output of SQL queries. Information in databases is often saved in tables. But how can you query these tables if you don’t know their names? Well, you can run the .tables command to list all the tables that you can query. If you are a long-time Linux user or a sysadmin, the table names will be familiar, as you have been using operating system commands to get this information:

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> 
Vérifier le schéma des tables individuelles
Maintenant que vous connaissez les noms des tables, vous pouvez voir quelles informations chaque table fournit.  A titre d’exemple, choisissez processes, depuis le ps La commande est utilisée assez souvent pour obtenir ces informations.  Exécutez le .schema commande suivie du nom de la table pour voir quelles informations sont enregistrées dans cette table.  Si vous voulez vérifier les résultats, vous pouvez rapidement exécuter ps -ef ou alors ps aux et comparez la sortie avec le contenu du tableau :
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> 
Pour enfoncer le clou, utilisez la commande suivante pour voir le schéma des packages RPM et comparer les informations avec rpm -qa et rpm -qi commandes du système d’exploitation :
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> 
Vous en apprenez plus dans Osquery’s documentation des tableaux.
Utiliser la commande PRAGMA
Au cas où ces informations de schéma seraient trop cryptiques pour vous, il existe un autre moyen d’imprimer les informations du tableau dans un format tabulaire détaillé : le PRAGMA commander.  Par exemple, j’utiliserai PRAGMA pour voir les informations pour le rpm_packages tableau dans un joli format :
osquery> PRAGMA table_info(rpm_packages);
L’un des avantages de ces informations tabulaires est que vous pouvez vous concentrer sur le champ que vous souhaitez interroger et voir le type d’informations qu’il fournit :
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> 
Exécutez votre première requête
Maintenant que vous disposez de toutes les informations requises de la table, du schéma et des éléments à interroger, exécutez votre première requête SQL pour afficher les informations.  La requête ci-dessous renvoie les utilisateurs présents sur le système et l’ID utilisateur, l’ID de groupe, le répertoire personnel et le shell par défaut de chacun.  Les utilisateurs de Linux peuvent obtenir ces informations en consultant le contenu du /etc/passwd fichier et faire quelques grep, sed, et awk la 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> 
Exécuter des requêtes sans entrer en mode interactif
Que faire si vous souhaitez exécuter une requête sans entrer dans le mode interactif osqueri ?  Cela peut être très utile si vous écrivez des scripts shell autour de cela.  Dans ce cas, vous pourriez echo la requête SQL et dirigez-la vers osqueri directement depuis le shell Bash :
$ 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 |      |
+-----+-----+----------------+----------------+------+
$ 
Découvrez quels services démarrent lors du démarrage
Osquery peut également renvoyer tous les services définis pour démarrer au démarrage.  Par exemple, pour interroger le startup_items table et obtenez le nom, l’état et le chemin des cinq premiers services qui s’exécutent au démarrage :
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>
Rechercher des informations ELF pour un binaire
Imaginez que vous vouliez en savoir plus sur les ls binaire.  Habituellement, vous le feriez avec le readelf -h commande suivie de la ls chemin de la commande.  Vous pouvez interroger le elf_info table avec Osquery et obtenez les mêmes informations :
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> 
Vous savez maintenant comment utiliser osqueri pour rechercher des informations qui vous intéressent.  Cependant, ces informations sont stockées sur un grand nombre de tables ;  un système que j’ai interrogé avait 156 tables différentes, ce qui peut être écrasant :
$ echo ".tables" | osqueryi | wc -l
156
$ 
Pour faciliter les choses, vous pouvez commencer par ces tableaux pour obtenir des informations sur votre système Linux :
Tableau d’informations système
osquery> select * from system_info;
Informations sur les limites du système
osquery> select * from ulimit_info;
Fichiers ouverts par divers processus
osquery> select * from process_open_files;
Ports ouverts sur un système
osquery> select * from listening_ports;
Informations sur les processus en cours d’exécution
osquery> select * from processes;
Informations sur les packages installés
osquery> select * from rpm_packages;
Informations de connexion de l’utilisateur
osquery> select * from last;
Informations du journal système
osquery> select * from syslog_events;
Apprendre encore plus
Osquery est un outil puissant qui fournit de nombreuses informations sur l’hôte pouvant être utilisées pour résoudre divers cas d’utilisation.  Vous pouvez en savoir plus sur Osquery en lire sa documentation.