Gestión de paquetes con RPM en Linux

Introducción

En esta práctica de laboratorio, aprenderás los fundamentos de la gestión de paquetes de software en distribuciones de Linux basadas en RPM utilizando la potente utilidad de línea de comandos rpm. Adquirirás experiencia práctica en tareas esenciales de administración de paquetes, incluyendo la consulta de información detallada, la verificación de la integridad de los paquetes instalados y la inspección del contenido de los archivos RPM.

A lo largo de los pasos, utilizarás comandos rpm específicos para descubrir a qué paquete pertenece un archivo, listar las dependencias y los archivos de configuración de un paquete, y comprobar las dependencias inversas. También aprenderás a simular de forma segura la eliminación de un paquete para comprender su impacto y a examinar el contenido de un archivo de paquete RPM antes de su instalación utilizando herramientas como rpm2cpio y cpio.

Consultar información básica de paquetes con rpm -qi y rpm -qf

En este paso, aprenderás a consultar información sobre los paquetes instalados utilizando el Red Hat Package Manager (rpm). rpm es una potente utilidad de línea de comandos para gestionar software en distribuciones de Linux basadas en RPM como CentOS, Fedora y RHEL. Nos centraremos en dos opciones de consulta fundamentales: -qi para obtener información detallada del paquete y -qf para averiguar a qué paquete pertenece un archivo específico.

Primero, inspeccionemos los detalles de un paquete que ya está instalado en tu sistema. El shell bash es un componente central del sistema, lo que lo convierte en un ejemplo perfecto. La bandera -q significa 'query' (consulta) y la bandera i significa 'information' (información).

Ejecuta el siguiente comando en tu terminal para consultar información sobre el paquete bash:

rpm -qi bash

Verás una salida detallada que enumera varios atributos del paquete. La salida se verá similar a esta (los números de versión y las fechas pueden variar):

Name        : bash
Version     : 4.4.20
Release     : 5.el8
Architecture: x86_64
Install Date: <some_date>
Group       : System Environment/Shells
Size        : 4989189
License     : GPLv3+
Signature   : RSA/SHA256, <some_date_and_time>, Key ID <some_key_id>
Source RPM  : bash-4.4.20-5.el8.src.rpm
Build Date  : <some_date>
Build Host  : <some_build_host>
Relocations : (not relocatable)
Vendor      : CentOS
URL         : http://www.gnu.org/software/bash
Summary     : The GNU Bourne-Again Shell
Description :
The GNU Bourne-Again Shell (Bash) is a shell or command language
interpreter that is compatible with the Bourne shell (sh). Bash
incorporates useful features from the Korn shell (ksh) and the C
shell (csh).  Most sh scripts can be run by bash without
modification.

Esta salida proporciona una gran cantidad de información, incluyendo la versión del paquete, un resumen de su propósito y una descripción más detallada.

Ahora, imagina que tienes un archivo en tu sistema, como el ejecutable bash ubicado en /usr/bin/bash, y quieres saber qué paquete lo instaló. Esta es una tarea común al auditar un sistema o solucionar problemas. Para esto, puedes usar las banderas -qf, donde f significa 'file' (archivo).

Ejecuta el siguiente comando para averiguar qué paquete es el propietario del archivo /usr/bin/bash:

rpm -qf /usr/bin/bash

El comando devolverá el nombre completo del paquete que proporciona este archivo:

bash-5.1.8-9.el9.x86_64

Como puedes ver, el sistema identifica correctamente que /usr/bin/bash proviene del paquete bash, coincidiendo con la información que encontramos anteriormente. Incluso puedes combinar estas banderas para obtener directamente información sobre el paquete propietario de un archivo ejecutando rpm -qif /usr/bin/bash.

Listar dependencias de paquetes y archivos de configuración con rpm -qR y rpm -qc

En este paso, continuarás explorando rpm aprendiendo a listar las dependencias de un paquete y sus archivos de configuración asociados. Comprender las dependencias es crucial porque la mayoría del software depende de otros paquetes para funcionar correctamente. Saber dónde se encuentran los archivos de configuración es esencial para la administración y personalización del sistema.

Comencemos por averiguar qué otros paquetes o capacidades requiere el paquete bash. Usamos la bandera -qR (o --requires) para esto. La R significa 'requires' (requiere).

Ejecuta el siguiente comando para ver las dependencias de bash:

rpm -qR bash

La salida será una lista de paquetes y capacidades del sistema de los que depende bash. Esta lista puede ser bastante larga.

/bin/sh
config(bash) = 4.4.20-5.el8
filesystem >= 3
glibc
info
libc.so.6(GLIBC_2.17)(64bit)
libc.so.6(GLIBC_2.2.5)(64bit)
libc.so.6(GLIBC_2.28)(64bit)
libc.so.6(GLIBC_2.3)(64bit)
...
rtld(GNU_HASH)

Esta salida muestra que bash requiere el paquete glibc (que proporciona la biblioteca de C libc.so.6), el paquete filesystem y otros componentes a nivel de sistema.

A continuación, busquemos los archivos de configuración que se instalaron como parte del paquete bash. Esto es útil cuando necesitas modificar el comportamiento predeterminado del shell para nuevos usuarios. La bandera -qc se utiliza para esto, donde c significa 'configfiles' (archivos de configuración).

Ejecuta este comando para listar los archivos de configuración de bash:

rpm -qc bash

La salida mostrará las rutas completas a los archivos de configuración:

/etc/skel/.bash_logout
/etc/skel/.bash_profile
/etc/skel/.bashrc

Estos archivos en /etc/skel son archivos de plantilla que se copian al directorio de inicio de un nuevo usuario cuando se crea su cuenta.

También puedes combinar banderas para encontrar los archivos de configuración relacionados con un comando específico. Por ejemplo, para ver los archivos de configuración utilizados por el comando passwd, puedes usar -qcf. Esto le indica a rpm que primero encuentre el paquete del archivo (-f /usr/bin/passwd) y luego liste sus archivos de configuración (-c).

rpm -qcf /usr/bin/passwd

Este comando revela los archivos de configuración asociados con la utilidad passwd:

/etc/pam.d/passwd

Esta es una forma potente de identificar rápidamente qué archivos podrías necesitar editar para cambiar el comportamiento de un comando.

Verificar la integridad del paquete y los cambios en los archivos con rpm -V

En este paso, aprenderás a verificar la integridad de un paquete instalado utilizando rpm -V (o rpm --verify). Este comando es una herramienta crucial de seguridad y resolución de problemas. Compara los archivos instalados por un paquete con la información almacenada en la base de datos RPM, como tamaños de archivo, permisos y sumas de comprobación (checksums). Esto te permite detectar cualquier cambio no autorizado o accidental en los archivos del sistema.

Primero, asegurémonos de que un par de paquetes de utilidades, lsscsi y at, estén instalados en el sistema. Los usaremos para nuestras pruebas de verificación.

sudo dnf install -y lsscsi at

Ahora, verifiquemos el paquete lsscsi. Dado que acabamos de instalarlo y no hemos realizado ningún cambio, debería pasar la prueba de verificación. Una verificación exitosa no produce ninguna salida.

rpm -V lsscsi

Como era de esperar, el prompt del comando regresa sin ningún mensaje, lo que indica que todos los archivos del paquete lsscsi están en su estado original.

A continuación, modifiquemos intencionadamente un archivo de configuración y veamos cómo rpm -V informa del cambio. Añadiremos una línea al archivo /etc/at.deny, que pertenece al paquete at. Este archivo controla qué usuarios no tienen permiso para usar el comando at.

echo "labex" | sudo tee -a /etc/at.deny

Ahora que hemos modificado un archivo, verifiquemos el paquete at nuevamente.

sudo rpm -V at

Esta vez, el comando produce una salida, indicando que se detectó un cambio:

S.5....T.  c /etc/at.deny

Desglosemos esta salida:

• S: El tamaño (Size) del archivo ha cambiado.
• 5: La suma de comprobación MD5 ha cambiado.
• T: La hora de modificación (Time) ha cambiado.
• c: Esto denota un archivo de configuración (configuration).
• /etc/at.deny: La ruta al archivo modificado.

Cada posición de carácter en la cadena de 8 caracteres S.5....T. representa una prueba diferente. Un . significa que la prueba pasó. Esta salida muestra claramente que el archivo de configuración /etc/at.deny ha sido alterado desde su instalación.

También puedes verificar el paquete que posee un archivo específico directamente usando las banderas -qVf.

sudo rpm -qVf /etc/at.deny

Este comando producirá la misma salida, ya que primero encuentra el paquete propietario de /etc/at.deny (at) y luego lo verifica.

Comprobar dependencias inversas y simular la eliminación de paquetes con rpm -e --test

En este paso, aprenderás a comprobar las dependencias inversas y a simular de forma segura la eliminación de un paquete. Mientras que el comando rpm -qR muestra lo que un paquete necesita (sus dependencias), rpm -q --whatrequires muestra qué otros paquetes lo necesitan a él (sus dependencias inversas). Es extremadamente importante saber esto antes de eliminar un paquete, ya que podrías romper otras partes del sistema.

Para comprobar de forma segura las consecuencias de eliminar un paquete, puedes usar el comando rpm -e --test. La bandera -e significa 'erase' (borrar) y la bandera --test le indica a RPM que realice un simulacro sin eliminar realmente ningún archivo.

Comencemos examinando un paquete central del sistema del que dependen muchos otros paquetes. El paquete glibc proporciona la Biblioteca GNU C, que es fundamental para casi todos los programas en un sistema Linux. Comprobemos qué paquetes requieren glibc.

rpm -q --whatrequires glibc

La salida mostrará varios paquetes que dependen de glibc:

glibc-common-2.34-168.el9_6.19.x86_64
glibc-langpack-en-2.34-168.el9_6.19.x86_64
libstdc++-11.5.0-5.el9_5.x86_64
glibc-headers-2.34-168.el9_6.19.x86_64
pam-1.5.1-23.el9.x86_64
glibc-devel-2.34-168.el9_6.19.x86_64
nscd-2.34-168.el9_6.19.x86_64

Como puedes ver, muchos paquetes críticos del sistema dependen de glibc. Ahora veamos qué sucede cuando intentamos eliminar glibc. Usaremos la bandera --test para asegurarnos de no eliminarlo realmente, lo que rompería todo el sistema.

sudo rpm -e --test glibc

Debido a que tantos paquetes necesitan glibc, RPM informará de errores de dependencia y evitará la eliminación. La salida mostrará una larga lista de dependencias fallidas:

error: Failed dependencies:
 glibc = 2.34-168.el9_6.19 is needed by (installed) glibc-common-2.34-168.el9_6.19.x86_64
 glibc = 2.34-168.el9_6.19 is needed by (installed) glibc-langpack-en-2.34-168.el9_6.19.x86_64
 glibc >= 2.34 is needed by (installed) libstdc++-11.5.0-5.el9_5.x86_64
 ... (errores de dependencia adicionales)

Ahora miremos un paquete con menos dependencias. El paquete lsscsi que instalamos anteriormente es un paquete de utilidad con menos dependencias inversas. Comprobemos qué lo requiere:

rpm -q --whatrequires lsscsi

Deberías ver una salida indicando que ningún paquete requiere lsscsi:

no package requires lsscsi

Dado que ningún paquete depende de lsscsi, podemos simular su eliminación de forma segura:

sudo rpm -e --test lsscsi

Este comando debería completarse sin errores, indicando que la eliminación de lsscsi no rompería ningún otro paquete en el sistema.

Esto demuestra cómo puedes predecir el impacto de eliminar un paquete y evitar romper tu sistema comprobando primero las dependencias inversas.

Inspeccionar el contenido de un paquete RPM con rpm2cpio y cpio

En este paso, aprenderás una técnica potente para inspeccionar el contenido de un archivo de paquete RPM sin instalarlo. Esto es útil para verificar los archivos que contiene un paquete antes de la instalación o para extraer un solo archivo de un paquete para restaurar un archivo dañado o eliminado. Este proceso involucra dos comandos: rpm2cpio, que convierte un archivo RPM en un archivo cpio, y cpio, que luego puede listar o extraer archivos de ese archivo.

Primero, necesitas un archivo .rpm real para inspeccionar. Descarguemos el archivo del paquete para bash en tu directorio actual (~/project) utilizando el gestor de paquetes dnf. El subcomando download obtiene el archivo del paquete sin instalarlo.

sudo dnf download bash

Verás una salida indicando que el archivo se ha descargado correctamente. El nombre del archivo incluirá la versión y la arquitectura.

Last metadata expiration check: ...
bash-<version>.<arch>.rpm

Ahora, usa el comando ls para confirmar que el archivo .rpm está en tu directorio ~/project:

ls bash-*.rpm

Con el archivo RPM listo, ahora puedes usar los comandos rpm2cpio y cpio juntos para listar su contenido. El comando rpm2cpio lee el archivo RPM y envía un archivo cpio a la salida estándar. Luego canalizamos (|) esta salida al comando cpio, que lee el archivo desde su entrada estándar. La bandera -t para cpio le indica que liste la tabla de contenidos.

rpm2cpio bash-*.rpm | cpio -t

Esto producirá una larga lista de todos los archivos y directorios contenidos dentro del paquete bash. La salida se verá algo como esto:

.
./etc
./etc/skel
./etc/skel/.bash_logout
./etc/skel/.bash_profile
./etc/skel/.bashrc
./usr
./usr/bin
./usr/bin/bash
./usr/bin/sh
./usr/share
./usr/share/doc
...

Esta técnica te brinda una visión completa de la carga útil de un paquete, permitiéndote ver exactamente qué se colocará en tu sistema si decidieras instalarlo.

Resumen

En esta práctica de laboratorio, aprendiste a gestionar y consultar paquetes de software utilizando la utilidad RPM en un entorno Linux. Comenzaste recuperando información detallada sobre los paquetes instalados con rpm -qi e identificando a qué paquete pertenece un archivo específico mediante rpm -qf. También practicaste el listado de las dependencias de un paquete con rpm -qR y la localización de sus archivos de configuración con rpm -qc, proporcionando una visión integral de cómo se integra un paquete en el sistema.

A partir de estas habilidades de consulta, aprendiste a verificar la integridad de los archivos de un paquete instalado utilizando rpm -V para comprobar si hubo modificaciones. También exploraste cómo comprobar de forma segura las dependencias inversas y simular la eliminación de un paquete con rpm -e --test para comprender el impacto potencial sin realizar cambios reales. Finalmente, adquiriste la capacidad de inspeccionar el contenido de un archivo de paquete RPM antes de la instalación utilizando rpm2cpio y cpio para extraer y listar su contenido.