Una vez instalado y configurado Parrot pasamos a ver conceptos básicos de Linux
Comandos básicos de Linux
Abrimos nuestra terminal
Whoami
Con este comando averiguaremos quienes somos dentro del sistema, si somos roots y cuál es nuestro nombre de usuario_
┌─[deepi@parrot]─[~]
└──╼ $whoami
deepi
id
Dentro de un sistema pueden existir múltiples usuarios, para saber a qué grupo pertenezco puedo introducir el comando id
┌─[deepi@parrot]─[~]
└──╼ $id
uid=1000(deepi) gid=1003(deepi) grupos=1003(deepi),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),108(netdev),116(bluetooth),1000(lpadmin),1001(scanner),1002(docker)
┌─[deepi@parrot]─[~]
└──╼ $
Algo a destacar es que normalmente cada usuario tiene un grupo asignado con su mismo nombre, como podemos ver resaltados en amarillo los grupos a los que estamos asignados.
Algunos grupos se consideran peligrosos ya que a través de ellos se puede efectuar un abuso para buscar una escalada de privilegios y convertirte en root dentro de un sistema que queremos comprometer, por ejemplo en nuestro caso el grupo 1002(docker) es uno de ellos, también 27(sudo).
Esto curre por que nuestro usuario tiene el privilegio concedido de convertirse en root.
En este moemto yo me encuentro conectado a parrot como deepi, éste es mi usuario normal, no es un usuario root, al estar en el grupo sudo esto nos permite introducir la palabra reservada sudo, por ejemplo lancemos el comando siguiente: sudo su veremos que se nos pide una contraseña:
┌─[deepi@parrot]─[~]
└──╼ $sudo su
We trust you have received the usual lecture from the local System
Administrator. It usually boils down to these three things:
#1) Respect the privacy of others.
#2) Think before you type.
#3) With great power comes great responsibility.
[sudo] password for deepi:
Si introduzco la contraseña y hago un whoami veo que ahora soy root:
[sudo] password for deepi:
┌─[root@parrot]─[/home/deepi]
└──╼ #whoami
root
┌─[root@parrot]─[/home/deepi]
└──╼ #
Si ahora que somos root hacemos un id
┌─[root@parrot]─[/home/deepi]
└──╼ #id
uid=0(root) gid=0(root) grupos=0(root)
┌─[root@parrot]─[/home/deepi]
└──╼ #
Esto quiere decir que soy root y tengo acceso a todo el sistema. Para salir del modo Root solo tendremos que lanzar el comando exit
┌─[root@parrot]─[/home/deepi]
└──╼ #exit
exit
┌─[deepi@parrot]─[~]
└──╼ $
Volvemos a ser el usuario deepi que no es root. Algo a tener en cuenta que ahora si hago sudo su de nuevo, ya no me va a pedir la contraeña, esto es debido a que por detrás el sistema ha guardado un token privilege, que durante un tiempo va a recordarme.
OTRAS FORMAS DE CONVERTIRTE EN ROOT
Para convertirnos en root no es necesario hacer un sudo su, por ejemplo podría ejecutart de forma privilegiada cualquier comando como un whoami:
┌─[deepi@parrot]─[~]
└──╼ $sudo whoami
Y esto no me convierte en root, pero he ejecutado el comando como root:
┌─[deepi@parrot]─[~]
└──╼ $sudo whoami
root
┌─[deepi@parrot]─[~]
└──╼ $
GRUPOS
Todos los grupos anteriormente mencionados que hemos visto con el comando id, los podemos ver en una ruta del sistema que es: /etc/group
Existen muchos directorios, todos parten de la raíz del sistema operativo, etc es un directorio y group es un archivo, si a esta ruta le ponemos la palabra reservada cat al principio se nos listará el contenido del archivo group. Por tanto deducimos que cat es un flag para listar contenido, veamos que hay en ese archivo group:
┌─[deepi@parrot]─[~]
└──╼ $cat /etc/group
root:x:0:
daemon:x:1:
bin:x:2:
sys:x:3:
adm:x:4:
tty:x:5:
disk:x:6:
lp:x:7:
mail:x:8:
news:x:9:
uucp:x:10:
man:x:12:
proxy:x:13:
kmem:x:15:
dialout:x:20:
fax:x:21:
voice:x:22:
lo que vemos es una lista de todos los grupos existentes (la lista es más larga) y el número de cada grupo es su identificador.
RUTAS ABSOLUTAS Y RUTAS RELATIVAS
Una ruta es la forma de referirse a los archivos y directorios. Da la ubicación de un archivo o directorio en la estructura de directorios Linux. Se compone de un nombre de la sintaxis de barra diagonal.
Ruta absoluta
Una ruta absoluta siempre empieza en el directorio raíz (/). Por ejemplo
ls -l /home/itsfoss/scripts/mi_script.sh
O bien podemos utilizar una ruta relativa (que comienza en el directorio actual, no en la raíz /):
ls -l scripts/mi_script.sh
Por ejemplo, cuando hacemos un whoami el sistema me devuelve mi usuario actual, esto es una ejecución del comando whoami (un archivo binario) mediante ruta relativa, es decir yo no he tenido que especificar la ruta absoluta del ese archivo binario desde la raíz del sistema para poder ejecutarlo.
Cada binario (todo archivo) posee una ruta absoluta, que podemos ver con el comando which
which en Linux es un comando que se utiliza para localizar el archivo ejecutable asociado al comando dado buscándolo en la variable de entorno path. Tiene 3 estados de retorno 0 : Si todos los comandos especificados son encontrados y ejecutables
si yo hago un which whoami, esto me devuelve la ruta absoluta del archivo binario whoami:
┌─[deepi@parrot]─[~]
└──╼ $which whoami
/usr/bin/whoami
┌─[deepi@parrot]─[~]
└──╼ $
Por tanto whoami es equivalente a hacer /usr/bin/whoami, donde:
whoami: sería la ruta relativa
/usr/bin/whoami: sería la ruta absoluta
VARIABLES DE ENTORNO
¿Por qué el sistema conoce las rutas absolutas de determinados archivos como whoami de forma que podemos llamarlos con rutas relativas como whoami?
Esto es debido a que existe algo llamado Varaible de Entorno llamada PATH, para ver estas variables debemos anteponer el símbolo de dólar y un echo para que se imprima en pantalla:
┌─[deepi@parrot]─[~]
└──╼ $echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/share/games:/usr/local/sbin:/usr/sbin:/sbin:/home/deepi/.local/bin:/snap/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
┌─[deepi@parrot]─[~]
└──╼ $
Estas variables de entorno, podemeos ver que tienen varias rutas separadas por dos puntos, esto es un orden de prioridad existente a través del cua, cuando ejecutamos por ejemplo whoami, empieza a buscar en todas esas direcciones y por ese orden hasta que la encuentra y la ejecuta.
Podemos customizar nuestras variables de entorno y sus rutas, esto es algo que veremos más adelante cuando personalicemos nuestro setup.
También veremos como utilizar estas rutas para comprometer un sistema.
COMADO GREP
Volviendo a los grupos de usuario, si volvemos a hacer un id
┌─[deepi@parrot]─[~]
└──╼ $id
uid=1000(deepi) gid=1003(deepi) grupos=1003(deepi),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),108(netdev),116(bluetooth),1000(lpadmin),1001(scanner),1002(docker)
┌─[deepi@parrot]─[~]
└──╼ $
Si nos fijamos en algúno d ellos grupos por ejemplo en el floppy, vemos que tiene como identificador el número 25. Si hacemos un /bin/cat /etc/group
┌─[deepi@parrot]─[~]
└──╼ $/bin/cat /etc/group
root:x:0:
daemon:x:1:
bin:x:2:
sys:x:3:
adm:x:4:
tty:x:5:
disk:x:6:
lp:x:7:
mail:x:8:
news:x:9:
uucp:x:10:
man:x:12:
proxy:x:13:
kmem:x:15:
dialout:x:20:
fax:x:21:
voice:x:22:
cdrom:x:24:deepi
floppy:x:25:deepi
vemos nuestro grupo, pero esta dentro de una lista inmensa de grupos, por tanto, podríamos intentar filtrar un poco nuestra búsqueda. Para ello vamos a usar un filtro.
El comando anterior /bin/cat /etc/group nos arroja un output, que es toda la lista de grupos entera. Para ello usaremos el comando grep para añadir comandos de forma separada en una segunda línea u operatoria usamos el símbolo | que llamamos “pipe”, así a nuestro comando anterior le agregamso una segunda operatoria “pipeándolo” de la siguiente manera:
┌─[✗]─[deepi@parrot]─[~]
└──╼ $/bin/cat /etc/group | grep "floppy"
Donde con elk comando grep y la palabra a filtrar (en este caso floppy) el sistema nos busca y nos devuelve solo las líneas donde esté la palabra floopt, las comillas no son necesarias pero si recomendables. Si hacemos intro:
Vemos que solo nos devuelve la línea de la lista donde aparece la palabra floppy que hemos filtrado mediante el ocmando grep
┌─[✗]─[deepi@parrot]─[~]
└──╼ $/bin/cat /etc/group | grep "floppy"
floppy:x:25:deepi
┌─[deepi@parrot]─[~]
└──╼ $
Si quisiéramos saber en qué línea de la lista se encuentra, podemos usar el flag -n
┌─[deepi@parrot]─[~]
└──╼ $/bin/cat /etc/group | grep "floppy" -n
19:floppy:x:25:deepi
┌─[deepi@parrot]─[~]
└──╼ $
COMANDOS BÁSICOS DE LINUX 2
Vamos a ver algunos comandos básicos más.
BUSCANDO COMANDOS command -v
Como comentamos en el apartado anterior si yo hago un which whoami
┌─[deepi@parrot]─[~]
└──╼ $which whoami
/usr/bin/whoami
┌─[deepi@parrot]─[~]
└──╼ $
Podemos ver que la ruta absoluta de whoami es usr/bin/whoami
Algo a tener en cuanta es que hay ocasiones en las que cuando logremos, a través de una página web ejecutar comando de forma remota (por ejemplo con un a inyección) hay ocasiones en las que queremos ejecutar cierto comando pero es preferible comprobar previamente si el comando existe. Lo que haremos será hacer which a l comando a ejecutar para ver si nos arroja una ruta absoluta. Lo que indica que el comando existe.
Si yo hago un which de algo que no existe el sistema nos dirá que no lo encuentra o no nos dirá nada, por ejemplo:
┌─[deepi@parrot]─[~]
└──╼ $which asdr
┌─[✗]─[deepi@parrot]─[~]
└──╼ $
Si which no encuentra nuestro comando, tenemos otra alternativa que es command -v donde -v es el flag verbose para que la información arrojada sea más legible:
┌─[deepi@parrot]─[~]
└──╼ $command -v whoami
/usr/bin/whoami
┌─[deepi@parrot]─[~]
└──╼ $
Como puedes ver nos reporta de la misma manera la ruta absoluta, así que si usamos which y no parece nada tenemos esta alternativa.
Cuando tú como usuario abres una terminal, obviamente estamos en una ruta. Como ya vimos si hacemos pwd no dirá en que ruta estamos:
┌─[deepi@parrot]─[~]
└──╼ $pwd
/home/deepi
┌─[deepi@parrot]─[~]
└──╼ $
Si yo hago ls para ver que hay dentro del directorio en le que me encuentro:
┌─[deepi@parrot]─[~]
└──╼ $pwd
/home/deepi
┌─[deepi@parrot]─[~]
└──╼ $ls
Descargas Desktop Documentos Imágenes Música Público Templates Vídeos
┌─[deepi@parrot]─[~]
└──╼ $
Se me lista todo lo que este contiene. Tenemos flags para listar de forma más detallad el contenido de un directorio, si yo a mi ls le añado un -l
┌─[deepi@parrot]─[~]
└──╼ $ls -l
total 0
drwxr-xr-x 1 deepi deepi 0 sep 7 11:13 Descargas
drwxr-xr-x 1 deepi deepi 28 abr 28 13:03 Desktop
drwxr-xr-x 1 deepi deepi 0 sep 7 11:13 Documentos
drwxr-xr-x 1 deepi deepi 0 sep 7 11:13 Imágenes
drwxr-xr-x 1 deepi deepi 0 sep 7 11:13 Música
drwxr-xr-x 1 deepi deepi 0 sep 7 11:13 Público
drwxr-xr-x 1 deepi deepi 22 abr 28 13:03 Templates
drwxr-xr-x 1 deepi deepi 0 sep 7 11:13 Vídeos
┌─[deepi@parrot]─[~]
└──╼ $
Toda la información de permisos que se nos ofrece al hacer un -l (resaltado en azul), debemos conocer ese tipo de nomenclatura de permisos como la palma de la mano.
Ya que si podemos identificar una mala configuración de permisos en un sistema al que nos hemos conectado, puede suponer un vector de ataque, una forma de escalada de privilegios, convertirnos en root, migrar de usuario y se puede tensar.
Tanbién podemos listar con ls un directorio que no sea el actual en el que nos encontramos, por ejemplo si quisiera listar el contenido del directorio bin haría:
┌─[deepi@parrot]─[~]
└──╼ $ls /bin/
Pero volvamos a lo que estábamos, si hago un ls tengo el contenido de la ruta actual en la que estoy situado
┌─[deepi@parrot]─[~]
└──╼ $ls
Descargas Desktop Documentos Imágenes Música Público Templates Vídeos
Sabemos que con el comando cd podemos cambiar de directorio (Change Directory)
También sabemos que con cd.. vamos una posición atrás
Bien pues vamos a meternos dentro del directorio descargas, haríamos cd Descargas y ya estaríamos dentro del directorio descargas, si hacemos un ls podremos ver que hay dentro (en este caso lo tengo vacío)
┌─[deepi@parrot]─[~]
└──╼ $ls
Descargas Desktop Documentos Imágenes Música Público Templates Vídeos
┌─[deepi@parrot]─[~]
└──╼ $cd Descargas/
┌─[deepi@parrot]─[~/Descargas]
└──╼ $ls
┌─[deepi@parrot]─[~/Descargas]
└──╼ $
También puedo ver que estoy dentro con pwd
┌─[deepi@parrot]─[~/Descargas]
└──╼ $pwd
/home/deepi/Descargas
┌─[deepi@parrot]─[~/Descargas]
└──╼ $
Desde aquí podría meterme directamente en el directorio Imágenes,pero para ello debería salir de nuevo al directorio raíz home con cd ..
┌─[✗]─[deepi@parrot]─[~/Descargas]
└──╼ $cd ..
┌─[deepi@parrot]─[~]
└──╼ $pwd
/home/deepi
┌─[deepi@parrot]─[~]
└──╼ $cd Imágenes
┌─[deepi@parrot]─[~/Imágenes]
└──╼ $pwd
/home/deepi/Imágenes
┌─[deepi@parrot]─[~/Imágenes]
└──╼ $
O desde el subdirectorio Imágenes, usar la ruta absoluta, en este ejemplo me voy a meter en imágenes y desde ese subdirectorio me voy a ir a Descargas sin salir al directorio raíz usando una ruta absi¡oluta y mostrando en cada paso donde estoy con pwd:
┌─[deepi@parrot]─[~]
└──╼ $ls
Descargas Desktop Documentos Imágenes Música Público Templates Vídeos
┌─[deepi@parrot]─[~]
└──╼ $cd Imágenes
┌─[deepi@parrot]─[~/Imágenes]
└──╼ $pwd
/home/deepi/Imágenes
┌─[deepi@parrot]─[~/Imágenes]
└──╼ $cd Descargas
bash: cd: Descargas: No existe el fichero o el directorio
┌─[✗]─[deepi@parrot]─[~/Imágenes]
└──╼ $cd /home/deepi/Descargas
┌─[deepi@parrot]─[~/Descargas]
└──╼ $pwd
/home/deepi/Descargas
┌─[deepi@parrot]─[~/Descargas]
└──╼ $
Si quisiera podría irme a la raíz del sistema operativo solo con hacer
cd /
┌─[deepi@parrot]─[~/Descargas]
└──╼ $cd /
┌─[deepi@parrot]─[/]
└──╼ $ls
bin crypto_keyfile.bin etc initrd.img lib lib64 media opt root sbin sys usr vmlinuz
boot dev home initrd.img.old lib32 libx32 mnt proc run srv tmp var vmlinuz.old
┌─[deepi@parrot]─[/]
└──╼ $
Y si quisiera volver a mi home de usuario bastaría con hacer cd
┌─[deepi@parrot]─[/]
└──╼ $cd
┌─[deepi@parrot]─[~]
└──╼ $ls
Descargas Desktop Documentos Imágenes Música Público Templates Vídeos
┌─[deepi@parrot]─[~]
└──╼ $
Para saber cual es nuesto directorio personal de usario? Tenemos la variable de entorno HOME
Haríamos echo $HOME
┌─[deepi@parrot]─[~]
└──╼ $echo $HOME
/home/deepi
┌─[deepi@parrot]─[~]
└──╼ $
Además de los usuarios existentes a nivel de sistema, los directorios personales de usuario se definen en un archivo llamado passwd, para verlo podríamos hacer:
┌─[deepi@parrot]─[~]
└──╼ $cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
deepi:x:1000:1003:deep_interf4ce:/home/deepi:/bin/bash
la lista continúa…
básicamente a la izquierda aparece el nombre de usario y podemos ver identificadores de usuario, en la ultima línea me puedo ver a mi que soy deepi, y tengo el identificador de usuario 1000:1003.
Reguerda que si hacía un id podía verme mi usuario y mis grupos, allí también parecen estos identificadores 1000-1003
┌─[deepi@parrot]─[~]
└──╼ $id
uid=1000(deepi) gid=1003(deepi) grupos=1003(deepi),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),108(netdev),116(bluetooth),1000(lpadmin),1001(scanner),1002(docker)
y también me está listando la ruta de mi directorio personal y el tipo de Shell que uso (en azul).
Conocer la Shell es muy importante, estamos usando bash en este momento pero es recomendable usar la zsh que veremos como instalar más adelante.
Para ver los tipos de Shell podemos ir a etc/shells
┌─[deepi@parrot]─[~]
└──╼ $cat /etc/shells
# /etc/shells: valid login shells
/bin/sh
/bin/bash
/usr/bin/bash
/bin/rbash
/usr/bin/rbash
/bin/dash
/usr/bin/dash
/usr/bin/pwsh
/opt/microsoft/powershell/7/pwsh
/usr/bin/tmux
/usr/bin/screen
┌─[deepi@parrot]─[~]
└──╼ $
Como ves todo está definido en archivos dentro del sistema, estas son los tipos de shells existentes.
Entre ellas tenemos por ejemplo la rbash, que es una Shell restrngida, que no te permite ejecutar un gran número de comando, veremos en su momento como salir de esa restricción cuando estamos atacando un sistema.
Para saber cual es mi Shell puedo escribir con echo y la variable de entorno $SHELL cuál es la mia en estos momentos:
┌─[deepi@parrot]─[~]
└──╼ $echo $SHELL
/bin/bash
Y como ves me indica que estoy usando la bin/bash. Pero yo podría migrar a cualquiera de las anteriores que hemos visto en pantalla. Para ello
CONTROL DEL FLUJO stdeer-stdout, operadores y procesos en segundo plano.
Abriremos una nueva consola, hay una cosa que deberemos tener en cuenta y es que en una misma línea nosotros podemos concatenar múltiples comandos. Existe una serie de operadores, and, or, not, etc.
Por ejemplo, podemos hacer un whoami y después un ls para listar lo que contienen nuestro directorio personal. Nosotros podríamos concatenar estos dos comandos de forma que solo tengamos una línea de instrucciones de la siguiente manera (con ;)
┌─[deepi@parrot]─[~]
└──╼ $whoami ; ls
deepi
Descargas Desktop Documentos Imágenes Música Público Templates Vídeos
Como puedes ver se nos devuelve quien soy y acto seguido los directorios de mi directorio actual. Podemos encadenar tantos comando como queramos, separándolos con ;
Operador &
Del mismo modo también podemos usar el operador & para concatenar comandos, vamos a hacer lo mismo que en el ejemplo anterior, un whoami y un ls, pero esta vez con &
┌─[deepi@parrot]─[~]
└──╼ $whoami && ls
deepi
Descargas Desktop Documentos Imágenes Música Público Templates Vídeos
En principio puede parecer que hemos hecho lo mismo ya que nos arroja el mismo resultado, pero en realidad no es lo mismo. La diferencia es que
El operador && ejecuta el comando siguiente sí y solo sí, el comando previo se ha ejecutado con éxito
Si intento hacer algo que no existe y luego el lds no me hará el ls ya que el primer comando no tiene un código de estado exitoso, ejemplo;
Woami && ls no ejecutará ls ya que Woami no existe y dará un código de estado no exitoso.
COMO VER LOS CÓDIGOS DE ESTADO DE UN COMANDO
Imaginemos que hacemos por ejemplo el siguiente comando, para abrir un archivo del sistema
┌─[deepi@parrot]─[~]
└──╼ $cat /etc/hosts
# Host addresses
127.0.0.1 localhost
127.0.1.1 parrot
::1 localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
# Others
Para ver el código de estado del ocmando que acabamos de realizar ejecutaremos un echo de la siguiente manera:
┌─[deepi@parrot]─[~]
└──╼ $echo $?
0
Este comando nos devolverá un 0 o un número:
0: el comando ejecutado ha sido exitoso
Otro número: el comando ejecutado no ha sido exitoso
Veamos un código no exitoso, lancemos un comando que no exista:
┌─[deepi@parrot]─[~]
└──╼ $whioam
bash: whioam: orden no encontrada
┌─[✗]─[deepi@parrot]─[~]
└──╼ $echo $?
127
No tienen por que ser siempre un 127, existen distintos tipos de códigos de estado no exitoso.
Operador or ||
El operador or ejecutará el primer comando y el segundo comando por ese orden y lo hará aunque el primer comando no sea correcto.
Ejemplo, lancemos dos comandos, siendo el primero erróneo y el segundo no, con operador or veremos como el segundo comando se ejecuta.
┌─[deepi@parrot]─[~]
└──╼ $whoam || ls
bash: whoam: orden no encontrada
Descargas Desktop Documentos Imágenes Música Público Templates Vídeos
Vemos que la consola nos da información del error “orden no encontrada”, esto ya tiene que ver con el concepto de scripting en Bush. Nosotros cuando hacemos scripts y en Python, hay ocasiones en la que no nos interesa que el usuario vea estos mensajes de error por consola porque puede entorpecer el trabajo, por ejemplo, imagina que estamos lanzando instrucciones en bucle y de pronto vemos toda una tanda de errores.
Para evitar este tipo de situaciones podemos hacer cosas con nuestros mensajes de error.
MENSAJES DE ERROR
Un error se define como stderr y se puede referenciar con el número 2. Usando una redirección (símbolo >) podemos redireccionar todos los mensajes de error a donde queramos. Por ejemplo, al directorio dev/null.
/dev/null
Es un tipo de archivo especial, cualquier cosa que enviemos o que guardemos en este archivo es como si desapareciera. Puedes pensar en este archivo como en una especie de agujero negro informático.
Como ejemplo vamos a lanzar un comando erróneo y lo vamos a redirigir al abismo /dev/null:
┌─[deepi@parrot]─[~]
└──╼ $whoam 2>/dev/null
Vemos que no nosofrece ningún resultado, aunque si se ha ejecutado el comando y ha sido erróneo.
Entondes recuerda:
2: hacemos referencia a los errores stderr
> : símbolo para redireccionar a una ruta
/dev/null: Archivo especial, abismo.
Cómo utilizar dev null
Ejemplo:
┌─[deepi@parrot]─[~]
└──╼ $cat /etc/host 2>/dev/null
Como host no existe tira el error a dev null, a un resultado de error lo llamamos stderr
┌─[✗]─[deepi@parrot]─[~]
└──╼ $cat /etc/hosts 2>/dev/null
# Host addresses
127.0.0.1 localhost
127.0.1.1 parrot
::1 localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
# Others
Como hosts si existe, nos muestra el resultado. A los resultados que nos muestra un comando determinado se le llama stdout
REDIRECCIONAMIENTOS DE STDOUT Y STDERR
Nosotros podemos redirigir cualquier salida al devnull tanto lo mensajes de error (stderr) como la respuesta de un comando exitoso (stdout) de forma que ejecutaríamos los comandos y no veríamos nada en pantalla. Pero ojo los errores de sistema si se ven en salida, aunque estemos enviándolos a devnull. Por ejemplo:
┌─[deepi@parrot]─[~]
└──╼ $cat /etc/host > /dev/null
cat: /etc/host: No existe el fichero o el directorio
esto se debe a que este mensaje no es un error de comando si no que es el sitema el que nos indica que ese no existe. Este es un mensaje stderr. Sabiendo esto, una cosa que podemos hacer es hacer que todos los mensajes de error del tipo stderr los convirtamos a stdout.
Es decir los stderr los vas a interpretar como stdout y melos vas a mandar también al devnull, esto lo conseguimos de la siguiente manera:
┌─[deepi@parrot]─[~]
└──╼ $cat /etc/host > /dev/null 2>&1
Acabamos de introducir un comando erróneo, el mismo que ene le ejemplo anterior y ya no vemos nada ni si quiera el mensaje de que el directorio no exista. El comando se va a ejecutar pero si hay errores no los vamos a ver.
En este momento puede que te preguntes para qué sirve esto, pero más adelante verás que nos resultará muy útil en distintas circunstancias.
Lo anterior es una forma explícita para que se entienda, pero una forma mejor de hacerlo es la siguiente:
┌─[deepi@parrot]─[~]
└──╼ $cat /etc/host &>/dev/null
De este modo no vamos a ver los errores por salida ni del tipo stderr ni del tipo stdout
PERO, ¿POR QUÉ QUERRÍAMOS OCULTAR EL OUTPUT DE UN SCRIPT, COMANDO O PROGRAMA?
Veamos por qué. Vamos a ponernos en modo root en nuestra consola:
┌─[deepi@parrot]─[~]
└──╼ $sudo su
[sudo] password for deepi:
┌─[root@parrot]─[/home/deepi]
└──╼ #
Imaginemos que como roots nos abrimos un snifer como wireshark
┌─[root@parrot]─[/home/deepi]
└──╼ #wireshark
Y me pongo a la escucha digamos por eth0, todo lo que la herramienta wireshark está capturando, se me está reflejando en la terminal como mensajes stderr y stdout, como se puede ver en la siguiente captura:
Puede que nosotros no queramos que la herramienta nos ocupe la consola mientras realiza determinado procedimiento, pues para esto usaríamos lo que hemos visto anteriormente, solo tendríamos que hacer:
┌─[root@parrot]─[/home/deepi]
└──╼ #wireshark &>/dev/null
Lo redirijo tod al devnull y así tengo la aplicación wireshark corriendo pero no veo el output en pantalla:
Pero hay un detalle, la consola sigue si ofrecernos el prompt, esto es debido a que una aplicación que abrimos por consola es hija de esa consola, es decir depende de ella. Si lo que queremos es dejar la aplicación tyrabajando en segundo plano y disponer de la consola, podemos hacerlo de la siguiente manera:
┌─[root@parrot]─[/home/deepi]
└──╼ #wireshark &>/dev/null &
Basta con añadir un & al final de este modo tendremos a wireshark corriendo en segundo plano, y la consola disponible para ejecutar más comando, además en la consola se nos mostrará un número que es el identificador de ese proceso que tenemos corriendo en segundo plano:
