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

Linux propose de nombreuses commandes pour aider les utilisateurs à recueillir 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, quels processus sont en cours d'exécution et quels services démarrent au démarrage ; ou en apprendre davantage 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 afin de trouver des informations spécifiques. De plus, beaucoup de ces informations changent fréquemment, ce qui entraîne des changements dans l'état du système.

Plus de ressources Linux

• Aide-mémoire des commandes Linux
• Aide-mémoire des commandes Linux avancées
• Cours en ligne gratuit :Présentation technique de RHEL
• Aide-mémoire sur le réseau Linux
• Aide-mémoire SELinux
• Aide-mémoire sur les commandes courantes de Linux
• Que sont les conteneurs Linux ?
• Nos derniers articles Linux

Il serait utile d'afficher 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 commandes comme si vous interrogez une table de base de données SQL avec des noms similaires.

Heureusement, il existe un outil qui fait exactement cela et bien plus :Osquery est un "framework d'instrumentation, de surveillance et d'analyse de système d'exploitation alimenté par SQL".

De nombreuses applications qui gèrent la sécurité, 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 Osquery

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 nécessitant 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 recueillir des informations à partir de l'infrastructure.

Vous pouvez exécuter l'utilitaire osqueri sans que le démon osqueryd ne soit en cours d'exécution. 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écution de 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 
Utilisation d'une base de données virtuelle. Besoin d'aide, tapez '.help'
osquery> 

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

osquery> 
osquery> .quit
$

Découvrir les tables disponibles

Comme mentionné, Osquery rend les données disponibles en tant que sortie des requêtes SQL. Les informations contenues dans les bases de données sont souvent enregistrées dans des tables. Mais comment interroger ces tables si vous ne connaissez pas leurs noms ? Eh bien, vous pouvez exécuter le .tables commande pour lister toutes les tables que vous pouvez interroger. Si vous êtes un utilisateur Linux de longue date ou un administrateur système, les noms des tables vous seront familiers, car vous avez utilisé les commandes du système d'exploitation pour obtenir ces informations :

osquery> .tables 
   => acpi_tables
   => apparmor_events
   => apparmor_profiles
   => apt_sources

<
>

   => arp_cache
   => user_ssh_keys
  => utilisateurs
   => yara
   => yara_events
   => ycloud_instance_metadata
   => yum_sources
osquery> 

Vérifier le schéma pour les tables individuelles

Maintenant que vous connaissez les noms des tables, vous pouvez voir les informations fournies par chaque table. Par exemple, choisissez processes , puisque 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 souhaitez vérifier les résultats, vous pouvez exécuter rapidement ps -ef ou ps aux et comparez la sortie avec le contenu de la table :

osquery> processus .schema
CREATE TABLE processus(`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, CLÉ PRIMAIRE (`pid`)) SANS 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` TEXTE, `arch` TEXTE, `epoch` ENTIER, `install_time` ENTIER, `vendor` TEXTE, `package_group` TEXTE, `pid_with_namespace` ENTIER CACHÉ, `mount_namespace_id` TEXTE CACHÉ, CLÉ PRIMAIRE (`nom`, `version`, `release`, `arch`, `epoch`, `pid_with_namespace`)) SANS ROWID ;
osquery> 

Vous en apprendrez plus dans la documentation des tables d'Osquery.

Utiliser la commande PRAGMA

Dans le cas où les informations de schéma sont trop cryptiques pour vous, il existe une autre façon d'imprimer les informations de la table dans un format tabulaire verbeux :le PRAGMA commande. Par exemple, j'utiliserai PRAGMA pour voir les informations sur les 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 | nom        | taper   | nonnull | 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   | nom d'utilisateur    | TEXTE | 1       | | 2  |
| 5   | descriptif | TEXTE | 0       | | 0  |
| 6   | répertoire   | TEXTE | 0       | | 0  |
| 7   | coque       | TEXTE | 0       | | 0  |
| 8   | uuid        | TEXTE | 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 de /etc/passwd fichier et faire quelques grep , sed , et awk magique.

osquery> 
osquery> select uid,gid,directory,shell,uuid FROM users LIMIT 7;
+-----+-----+------- ---------+----------------+------+
| uid | gid | répertoire      | coque          | uuid |
+-----+-----+----------------+--------------- --+------+
| 0   | 0   | /racine          | /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/arrêt | |
+-----+-----+-----------------+--------------- -+------+
osquerie> 

Exécuter des requêtes sans passer en mode interactif

Que faire si vous souhaitez exécuter une requête sans entrer dans le mode interactif osqueri ? Cela pourrait être très utile si vous écrivez des scripts shell autour de lui. 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 | répertoire      | coque          | uuid |
+-----+-----+----------------+--------------- --+------+
| 0   | 0   | /racine          | /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/arrêt | |
+-----+-----+-----------------+--------------- -+------+
$ 

Découvrez quels services démarrent au démarrage

Osquery peut également renvoyer tous les services définis pour démarrer au démarrage. Par exemple, pour interroger les 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
 
  nom =osqueryd
  type =Élément de démarrage
status =activé
  chemin =/etc/rc.d/init.d/osqueryd

  nom =AT-SPI Bus D-Bus
  type =Élément de démarrage
status =activé
  chemin =/usr/libexec/at-spi-bus-launcher --launch-immediately
osquery> 
Rechercher les informations ELF pour un binaire
 

 Imaginez que vous vouliez en savoir plus sur le ls binaire. Habituellement, vous le feriez avec le readelf -h commande suivie du 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 des 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; 
 

 Ouvrir des ports sur un système 
 
osquery> select * from listening_ports; 
 

 Informations sur les processus 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; 
 
En savoir 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 lisant sa documentation.