Linux ofrece una gran cantidad de comandos para ayudar a los usuarios a recopilar información sobre su sistema operativo host:enumerar archivos o directorios para verificar atributos; consultar para ver qué paquetes están instalados, los procesos se están ejecutando y los servicios se inician en el arranque; o aprender sobre el hardware del sistema.
Cada comando usa su propio formato de salida para mostrar esta información. Necesitas usar herramientas como grep , sed y awk para filtrar los resultados para encontrar información específica. Además, mucha de esta información cambia con frecuencia, lo que genera cambios en el estado del sistema.
Más recursos de Linux
- Hoja de trucos de los comandos de Linux
- Hoja de trucos de comandos avanzados de Linux
- Curso en línea gratuito:Descripción general técnica de RHEL
- Hoja de trucos de red de Linux
- Hoja de trucos de SELinux
- Hoja de trucos de los comandos comunes de Linux
- ¿Qué son los contenedores de Linux?
- Nuestros últimos artículos sobre Linux
Sería útil ver toda esta información formateada como la salida de una consulta SQL de la base de datos. Imagina que pudieras consultar la salida de ps y rpm comandos como si estuviera consultando una tabla de base de datos SQL con nombres similares.
Afortunadamente, existe una herramienta que hace exactamente eso y mucho más:Osquery es un "marco de análisis, supervisión e instrumentación del sistema operativo basado en SQL de código abierto".
Muchas aplicaciones que manejan la seguridad, DevOps, el cumplimiento y la gestión de inventario (por nombrar algunas) dependen de las funcionalidades principales proporcionadas por Osquery en su esencia.
Instalar Osquery
Osquery está disponible para Linux, macOS, Windows y FreeBSD. Instale la última versión para su sistema operativo siguiendo sus instrucciones de instalación. (Usaré la versión 4.7.0 en estos ejemplos).
Después de la instalación, verifique que esté funcionando:
$ rpm -qa | grep osquery
osquery-4.7.0-1.linux.x86_64
$
$ osqueryi --version
osqueryi version 4.7.0
$
Componentes de osquery
Osquery tiene dos componentes principales:
- osqueros es una consola de consulta SQL interactiva. Es una utilidad independiente que no necesita privilegios de superusuario (a menos que esté consultando tablas que necesitan ese nivel de acceso).
- osqueryd es como un demonio de monitoreo para el host en el que está instalado. Este demonio puede programar consultas para que se ejecuten a intervalos regulares para recopilar información de la infraestructura.
Puede ejecutar la utilidad osqueri sin tener el demonio osqueryd ejecutándose. Otra utilidad, osqueryctl , controla el inicio, la detención y la comprobación del estado del daemon.
$ rpm -ql osquery-4.8.0-1.linux.x86_64 | grep bin
/usr/bin/osqueryctl
/usr/bin/osqueryd
/usr/bin/osqueryi
$
Utilice el indicador interactivo de osqueryi
Interactúa con Osquery como si usara una base de datos SQL. De hecho, osqueryi es una versión modificada del shell de SQLite. Ejecutando osqueryi El comando lo lleva a un shell interactivo donde puede ejecutar comandos específicos de Osquery, que a menudo comienzan con un . :
$ osqueryi
Using a virtual database. Need help, type '.help'
osquery>
Para salir del shell interactivo, ejecute .quit comando para volver al shell del sistema operativo:
osquery>
osquery> .quit
$
Descubre qué mesas están disponibles
Como se mencionó, Osquery hace que los datos estén disponibles como resultado de las consultas SQL. La información en las bases de datos a menudo se guarda en tablas. Pero, ¿cómo puede consultar estas tablas si no sabe sus nombres? Bueno, puedes ejecutar .tables comando para enumerar todas las tablas que puede consultar. Si es un usuario de Linux desde hace mucho tiempo o un administrador de sistemas, los nombres de las tablas le resultarán familiares, ya que ha estado usando los comandos del sistema operativo para obtener esta información:
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>
Verificar el esquema para tablas individuales
Ahora que conoce los nombres de las tablas, puede ver qué información proporciona cada tabla. Como ejemplo, elija processes , ya que el ps El comando se usa con bastante frecuencia para obtener esta información. Ejecute el .schema comando seguido del nombre de la tabla para ver qué información se guarda en esta tabla. Si desea verificar los resultados, puede ejecutar rápidamente ps -ef o ps aux y compare la salida con el contenido de la tabla:
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>
Para aclarar el punto, use el siguiente comando para ver el esquema de los paquetes RPM y compare la información con rpm -qa y rpm -qi comandos 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>
Puede obtener más información en la documentación de las tablas de Osquery.
Utilice el comando PRAGMA
En caso de que la información del esquema sea demasiado críptica para usted, hay otra forma de imprimir la información de la tabla en un formato tabular detallado:el PRAGMA dominio. Por ejemplo, usaré PRAGMA para ver información sobre los rpm_packages tabla en un formato agradable:
osquery> PRAGMA table_info(rpm_packages);Una de las ventajas de esta información tabular es que puede centrarse en el campo que desea consultar y ver el tipo de información que proporciona:
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>
Ejecutar su primera consulta
Ahora que tiene toda la información requerida de la tabla, el esquema y los elementos para consultar, ejecute su primera consulta SQL para ver la información. La consulta a continuación devuelve los usuarios que están presentes en el sistema y la ID de usuario, la ID de grupo, el directorio de inicio y el shell predeterminado de cada uno. Los usuarios de Linux pueden obtener esta información al ver el contenido de /etc/passwd archivo y haciendo algo de grep , sed y 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>
Ejecutar consultas sin ingresar en modo interactivo
¿Qué sucede si desea ejecutar una consulta sin ingresar al modo interactivo osqueri? Esto podría ser muy útil si está escribiendo scripts de shell a su alrededor. En este caso, podrías echo la consulta SQL y canalizarla a osqueri directamente desde el shell de 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 | |
+-----+-----+----------------+----------------+------+
$
Aprenda qué servicios se inician al iniciar
Osquery también puede devolver todos los servicios configurados para iniciarse en el arranque. Por ejemplo, para consultar startup_items y obtenga el nombre, el estado y la ruta de los primeros cinco servicios que se ejecutan al inicio:
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>
Buscar información ELF para un binario
Imagina que quieres saber más detalles sobre el ls binario. Por lo general, lo haría con readelf -h comando seguido del ls camino del comando. Puede consultar el elf_info table con Osquery y obtenga la misma información:
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>
Ahora tiene una idea de cómo usar osqueri para buscar información de su interés. Sin embargo, esta información se almacena en una gran cantidad de tablas; un sistema que consulté tenía 156 tablas diferentes, lo que puede ser abrumador:
$ echo ".tables" | osqueryi | wc -l
156
$
Para facilitar las cosas, puede comenzar con estas tablas para obtener información sobre su sistema Linux:
Tabla de información del sistema
osquery> select * from system_info;Información de límite del sistema
osquery> select * from ulimit_info;Archivos abiertos por varios procesos
osquery> select * from process_open_files;Puertos abiertos en un sistema
osquery> select * from listening_ports;Información de procesos en ejecución
osquery> select * from processes;Información de paquetes instalados
osquery> select * from rpm_packages;Información de inicio de sesión del usuario
osquery> select * from last;Información de registro del sistema
osquery> select * from syslog_events;Más información
Osquery es una herramienta poderosa que proporciona mucha información del host que se puede usar para resolver varios casos de uso. Puede obtener más información sobre Osquery leyendo su documentación.