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

  • FrançaisFrançais



  • 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.

    Source

    N'oubliez pas de voter pour cet article !
    1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
    Loading...

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée.