Linux offre molti comandi per aiutare gli utenti a raccogliere informazioni sul loro sistema operativo host:elencare file o directory per controllare gli attributi; interrogare per vedere quali pacchetti sono installati, i processi sono in esecuzione e i servizi vengono avviati all'avvio; o conoscere l'hardware del sistema.
Ciascun comando utilizza il proprio formato di output per elencare queste informazioni. Devi usare strumenti come grep , sed e awk per filtrare i risultati per trovare informazioni specifiche. Inoltre, molte di queste informazioni cambiano frequentemente, portando a cambiamenti nello stato del sistema.
Più risorse Linux
- Comandi Linux cheat sheet
- Cheat sheet sui comandi avanzati di Linux
- Corso online gratuito:Panoramica tecnica RHEL
- Cheat sheet della rete Linux
- Cheat sheet di SELinux
- Cheat sheet dei comandi comuni di Linux
- Cosa sono i container Linux?
- I nostri ultimi articoli su Linux
Sarebbe utile visualizzare tutte queste informazioni formattate come l'output di una query SQL del database. Immagina di poter interrogare l'output di ps e rpm comandi come se si stesse interrogando una tabella di database SQL con nomi simili.
Fortunatamente, esiste uno strumento che fa proprio questo e molto altro:Osquery è un "framework di analisi, monitoraggio e analisi del sistema operativo basato su SQL".
Molte applicazioni che gestiscono sicurezza, DevOps, conformità e gestione dell'inventario (solo per citarne alcune) dipendono principalmente dalle funzionalità principali fornite da Osquery.
Installa Osquery
Osquery è disponibile per Linux, macOS, Windows e FreeBSD. Installa l'ultima versione per il tuo sistema operativo seguendo le sue istruzioni di installazione. (Utilizzerò la versione 4.7.0 in questi esempi.)
Dopo l'installazione, verifica che funzioni:
$ rpm -qa | grep osquery
osquery-4.7.0-1.linux.x86_64
$
$ osqueryi --version
osqueryi version 4.7.0
$
Componenti Osquery
Osquery ha due componenti principali:
- osqueri è una console di query SQL interattiva. È un'utilità autonoma che non richiede privilegi di superutente (a meno che non si stia interrogando tabelle che richiedono quel livello di accesso).
- osqueryd è come un demone di monitoraggio per l'host su cui è installato. Questo demone può programmare query da eseguire a intervalli regolari per raccogliere informazioni dall'infrastruttura.
È possibile eseguire l'utilità osqueri senza che il demone osqueryd sia in esecuzione. Un'altra utility, osqueryctl , controlla l'avvio, l'arresto e il controllo dello stato del demone.
$ rpm -ql osquery-4.8.0-1.linux.x86_64 | grep bin
/usr/bin/osqueryctl
/usr/bin/osqueryd
/usr/bin/osqueryi
$
Utilizza il prompt interattivo osqueryi
Interagisci con Osquery proprio come faresti con un database SQL. In effetti, osqueryi è una versione modificata della shell SQLite. Esecuzione di osqueryi command ti porta in una shell interattiva in cui puoi eseguire comandi specifici per Osquery, che spesso iniziano con un . :
$ osqueryi
Using a virtual database. Need help, type '.help'
osquery>
Per uscire dalla shell interattiva, esegui .quit comando per tornare alla shell del sistema operativo:
osquery>
osquery> .quit
$
Scopri quali tavoli sono disponibili
Come accennato, Osquery rende disponibili i dati come output di query SQL. Le informazioni nei database vengono spesso salvate in tabelle. Ma come puoi interrogare queste tabelle se non conosci i loro nomi? Bene, puoi eseguire .tables comando per elencare tutte le tabelle che puoi interrogare. Se sei un utente Linux di lunga data o un amministratore di sistema, i nomi delle tabelle ti risulteranno familiari, poiché hai utilizzato i comandi del sistema operativo per ottenere queste informazioni:
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>
Controlla lo schema per le singole tabelle
Ora che conosci i nomi delle tabelle, puoi vedere quali informazioni fornisce ciascuna tabella. Ad esempio, scegli processes , dal momento che il ps comando è usato abbastanza spesso per ottenere queste informazioni. Esegui .schema comando seguito dal nome della tabella per vedere quali informazioni sono salvate in questa tabella. Se vuoi controllare i risultati, puoi eseguire rapidamente ps -ef o ps aux e confronta l'output con il contenuto della tabella:
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>
Per raggiungere il punto, usa il comando seguente per vedere lo schema per i pacchetti RPM e confrontare le informazioni con rpm -qa e rpm -qi comandi del sistema operativo:
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>
Ulteriori informazioni nella documentazione delle tabelle di Osquery.
Usa il comando PRAGMA
Nel caso in cui le informazioni sullo schema siano troppo criptiche per te, c'è un altro modo per stampare le informazioni sulla tabella in un formato tabulare dettagliato:il PRAGMA comando. Ad esempio, userò PRAGMA per visualizzare le informazioni per i rpm_packages tabella in un bel formato:
osquery> PRAGMA table_info(rpm_packages);Un vantaggio di queste informazioni tabellari è che puoi concentrarti sul campo che desideri interrogare e vedere il tipo di informazioni che fornisce:
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>
Esegui la tua prima query
Ora che hai tutte le informazioni richieste dalla tabella, dallo schema e dagli elementi da interrogare, esegui la tua prima query SQL per visualizzare le informazioni. La query seguente restituisce gli utenti presenti sul sistema e l'ID utente, l'ID gruppo, la directory home e la shell predefinita di ciascuno. Gli utenti Linux possono ottenere queste informazioni visualizzando il contenuto di /etc/passwd file e facendo un po' di grep , sed e awk magia.
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>
Esegui query senza entrare in modalità interattiva
Cosa succede se si desidera eseguire una query senza entrare nella modalità interattiva osqueri? Questo potrebbe essere molto utile se stai scrivendo script di shell attorno ad esso. In questo caso, potresti echo la query SQL e inviala a osqueri direttamente dalla 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 | |
+-----+-----+----------------+----------------+------+
$
Scopri quali servizi vengono avviati all'avvio
Osquery può anche restituire tutti i servizi impostati per l'avvio all'avvio. Ad esempio, per interrogare startup_items tabella e ottenere il nome, lo stato e il percorso dei primi cinque servizi eseguiti all'avvio:
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>
Cerca informazioni ELF per un binario
Immagina di voler scoprire maggiori dettagli su ls binario. Di solito, lo faresti con il readelf -h comando seguito da ls percorso del comando. Puoi interrogare elf_info tabella con Osquery e ottieni le stesse informazioni:
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>
Ora hai un assaggio di come usare osqueri per cercare informazioni che ti interessano. Tuttavia, queste informazioni sono memorizzate su un numero enorme di tabelle; un sistema che ho interrogato aveva 156 tabelle diverse, il che può essere schiacciante:
$ echo ".tables" | osqueryi | wc -l
156
$
Per semplificare le cose, puoi iniziare con queste tabelle per ottenere informazioni sul tuo sistema Linux:
Tabella delle informazioni di sistema
osquery> select * from system_info;Informazioni sui limiti di sistema
osquery> select * from ulimit_info;File aperti da vari processi
osquery> select * from process_open_files;Apri porte su un sistema
osquery> select * from listening_ports;Informazioni sui processi in esecuzione
osquery> select * from processes;Informazioni sui pacchetti installati
osquery> select * from rpm_packages;Informazioni di accesso utente
osquery> select * from last;Informazioni del registro di sistema
osquery> select * from syslog_events;Ulteriori informazioni
Osquery è un potente strumento che fornisce molte informazioni sull'host che possono essere utilizzate per risolvere vari casi d'uso. Puoi saperne di più su Osquery leggendo la sua documentazione.