Hackear redes wifi con Wifislax

Escritorio KDE en Wifislax

Wifislax es una distribución Linux basada en Slackware dirigida a la auditoría de redes inalámbricas. En este artículo vamos a enseñarte cómo utilizarla para comprobar la seguridad de distintas redes wifi

Una de las formas que los entusiastas de la tecnología tenemos de introducirnos en el mundo de la seguridad es realizando auditorías de redes inalámbricas. De acuerdo, no es lo mismo que hackear una base de datos del FBI, pero es un comienzo. Además es necesario tener en cuenta que, cuanto más sepamos sobre las debilidades de las redes wifi, mejor podremos proteger la de nuestro hogar. Esta debe ser siempre la premisa a la hora de empezar a realizar este tipo de procedimientos: el aprendizaje. Es bueno conocer cómo funcionan y qué debilidades tienen las distintas redes wirelesspara implementar mejores medidas de seguridad, pero todo este conocimiento sólo debe usarse con fines legítimos.

Existen distintas suites de scripts y programas con interfaz gráfica que podemos instalar en cualquier distribución Linux para analizar el tráfico de una red cualquiera, ya sea cableada o no. Algunos de los más famosos son Wireshark o Ettercap, que junto con otras herramientas como Angry IP Scanner nos pueden servir para conocer todo lo que deseamos sobre cualquier red. Sin embargo, conseguir todas estas herramientas por separado puede suponer un pequeño dolor de cabeza.

Ya existen distintas distribuciones Linux enfocadas a la seguridad informática. Algunas son de propósito general como Kali Linux —anteriormente conocida como BackTrack—, mientras que otras son mucho más especializadas. Es el caso de las que van dirigidas única y exclusivamente a la auditoría de redes wireless, aunque tanto en estas como en las de propósito general vamos a encontrar las herramientas antes mencionadas.

En este artículo nos vamos a centrar en wifislax, enfocada a la auditoría de redes inalámbricas. Vamos a intentar mostrarte qué necesitas y qué debes hacer para poderhackear una red wifi con ella todo ello, por supuesto, con el objetivo de aprender y saber qué debes hacer para reforzar la seguridad de tu wireless doméstico. Cualquier uso indebido que hagas de esta guía es única y exclusivamente responsabilidad tuya.

Adaptador WiFi de alta gananciaAdaptador WiFi de alta ganancia

¿Qué necesitas para usar wifislax?

En primer lugar necesitas un adaptador wifi con capacidad para modo monitor e inyección de paquetes. Antes que conseguir una imagen ISO de la distribución, asegúrate de que, si tienes una tarjeta de red inalámbrica —ya sea interna o externa—, esta se puede usar en modo monitor y se puede utilizar para realizar inyección de paquetes. Más adelante ya llegaremos a qué son estas cosas, pero por ahora te interesa saber qué tarjetas se pueden usar con wifislax y cuáles no. Tienes una relación completa de las mismas en el foro de Seguridad Wireless.

Lo siguiente es descargar una imagen ISO de la última versión de wifislax. Puedes hacerlo desde aquí. Una vez la tengas, tienes varias opciones: descomprimir la ISO en un LiveUSB usando programas como UNetbootin para usarlo en tu PC, instalarlo en tu PC o instalarlo en una máquina virtual.

Nosotros personalmente te recomendamos instalar wifislax en una máquina virtual, principalmente por varias razones:

  • Aunque se puede usar como una distro de propósito general, lo que nos interesa de verdad son los programas de auditoría. No consumen muchos recursos, por lo que no es necesario hacer un fresh install en tu ordenador.
  • Si utilizando tu ordenador principal y estás usando otras herramientas en otro sistema operativo, de esta forma podrás seguir haciendo un uso normal mientras realizas la auditoría.
  • Slackware es una distro veterana y en ella se basa wifislax, pero para usuarios no familiarizados con Linux puede ser difícil de utilizar y cuenta con una librería de software third party más limitada que otras distribuciones.

Cómo configurar la máquina virtual de wifislax

Máquina virtual de Wifislax en VirtualboxMáquina virtual de Wifislax en Virtualbox

Para tener wifislax configurado en una máquina virtual primero descargamos VirtualBox y lo instalamos en nuestro sistema operativo. Cuando lo hayamos hecho lo abrimos y hacemos clic en Nueva. Aparecerá un cuadro de diálogo, en el que tendremos que poner nombre a la máquina virtual y especificar el tipo de sistema operativo. En nuestro caso la llamaremos wifislax. En cuanto al tipo seleccionamosLinux y como versión other Linux (64-bit).

Seleccionamos Seleccionamos “Other Linux (64-bit)”

Hacemos clic en siguiente para asignar la cantidad de RAM que tendrá nuestra máquina virtual. Para evitar contratiempos yo he asignado 2 GB, pero se puede destinar menos memoria volátil si es preciso.

Ajustamos la cantidad de RAMAjustamos la cantidad de RAM

El siguiente paso nos lleva a la creación del disco duro virtual. Aceptamos los valores por defecto en todo lo que tenga que ver con este disco duro —son varios pasos— y continuamos.

Creamos el disco duro virtualCreamos el disco duro virtual

La máquina virtual ya estará creada. Ahora cuando la arranquemos nos aparecerá el siguiente cuadro de diálogo pidiéndonos la ubicación de la imagen ISO de wifislax:

Insertamos la ISO para instalar WifislaxInsertamos la ISO para instalar Wifislax

Le indicamos dónde la hemos guardado y ya podemos arrancar el sistema en modo live. Este modo nos permite probar el sistema operativo sin necesidad de instalarlo, pero tiene una pega que nos interesa sortear para poder usar wifislax correctamente: un LiveUSB, LiveCD o LiveDVD no tiene un sistema de archivos persistente, con lo que cualquier cambio que hagamos no se guardará.

Para instalar wifislax tenemos que ir a Menú > Sistema > Instalación de wifislax > wifislax Installer GUI. A partir de aquí el proceso es totalmente automático y el instalador lo hará todo por nosotros. Primero instalará el sistema operativo y después el cargador de arranque GRUB2. Cuando haya terminado de instalarlo todo, si reiniciamos la máquina virtual ya tendremos un wifislax perfectamente operativo.

Ruta de instalación de WifislaxRuta de instalación de Wifislax

Cómo usar wifislax para auditar redes inalámbricas

Antes de entrar en materia sobre la auditoría de redes en wifislax, conviene aclarar que hay dos tipos de herramientas: manuales y automáticas. Algunas se ejecutan en modo texto, mientras que otras tienen una interfaz gráfica propiamente dicha. A continuación comentaremos cómo funcionan y cómo se usan estas herramientas.

Aircrack-ng, la mejor herramienta para auditar redes wifi

La terminal de Linux es una herramienta muy poderosa. Gracias a ella podemos realizar tareas administrativas hilando muy, muy fino. Ninguna herramienta gráfica puede llegar tan lejos. Cuesta más teclear una instrucción en la terminal que hacer unos cuantos clics, de acuerdo, pero se puede llegar mucho más lejos escribiendo que clicando.

Ocurre lo mismo con la auditoría de redes inalámbricas. Aircrack-ng es una suite de auditoría de redes para la terminal, pero que es increíblemente poderosa y que nos permite realizar un amplio espectro de pruebas para saber lo bien o mal protegida que está una red inalámbrica.

Para empezar a usar Aircrack-ng primero es necesario colocar la tarjeta de red wifi en modo monitor, algo que ya mencionamos antes. Esto significa que la tarjeta podrá escanear su entorno para detectar tantas redes como estén a su alcance. Se realiza mediante el siguiente comando:

airmon-ng start wlanX

Donde X es el número que se le asigna a nuestra interfaz inalámbrica wlan. Si tenemos más de una a la primera se le asignará el cero, a la segunda el 1 y así sucesivamente. Podemos ver nuestras tarjetas de red inalámbricas con el comando iwconfig. La salida que nos debería devolver airmon-ng sería algo parecido a esto:

Salida de airmon-ngSalida de airmon-ng

Lo siguiente es escanear el entorno en busca de redes wifi. Para ello utilizamos el siguiente comando:

airodump-ng monX

Donde X es el número que se asigna al monitor en que se convierte la tarjeta —generalmente es mon0—. Es conveniente dejar que la tarjeta escanee el entorno durante unos minutos. Una vez tengamos la suficiente información, nos fijamos en la que tenga el parámetro PWR más alto. Este parámetro aparece con un valor negativo, con lo que conviene recordar que cuanto más cerca de cero está dicho valor, mayor es —dicho de otra manera, -1 es mayor que -40—. Esto nos permite conocer qué red tiene la intensidad más alta, con lo que es una buena candidata para empezar a realizar una auditoría.

Esto significa que debemos fijarnos en el BSSID —dirección MAC de la red inalámbrica— y el canal en el que se encuentra. Ahora tendremos que realizar un escáner mucho más detallado, incluyendo parámetros como el ya mencionado BSSID o el canal de la red, así como un archivo de captura de todos los datos de dicha red. El comando que usaremos quedará tal que así:

airodump-ng -c <NUMERO_DEL_CANAL_> --bssid <DIRECCION_MAC_DE_LA_RED> -w <NOMBRE_DEL_ARCHIVO_DE_CAPTURA> monX

La salida que nos debería devolver la pantalla debería ser algo similar a esto:

Escaneando una red específica con airodump-ngEscaneando una red específica con airodump-ng

Los distintos tipos de ataque de Aircrack-ng

Es conveniente dejar también que el escáner se tome su tiempo de forma que se puedan acumular tantos data como sea posible, ya que esto luego nos facilitará mucho la tarea de ejecutar pruebas de ataque. También conviene aclarar que, dependiendo del tipo de cifrado de la contraseña de la red, habrá que proceder de distintas maneras:

  • Si se trata de una contraseña cifrada mediante WEP, será necesario desautenticar un cliente y autenticarse como falso cliente antes de intentar atacar mediante inyección de paquetes ARP.
  • Si se trata de una contraseña cifrada usando WPA o WPA2 no podremos recurrir a la autenticación falsa, con lo que habrá que intentar conseguir paquetes ARP atacando directamente a un cliente legítimo.

Dicho esto, conviene mencionar que Aircrack-ng tiene a su disposición cinco tipos de ataque, cada uno con distintas características:

  • Ataque 0: se utiliza para desautenticar a un cliente conectado a la red a la que estamos atacando. Sirve para redes con cifrado WEP y WPA.
  • Ataque 1: sirve para crear un cliente falso que se conecta a la red en la que hemos desautenticado a un cliente legítimo. Es la puerta de entrada al resto de ataques cuando tratamos con una red con cifrado WEP, ya que en las WPA no funciona y es necesario intentar atacar usando un cliente legítimo.
  • Ataque 2: nos permite inyectar paquetes ARP en una red para intentar conseguir la clave wifi cifrada. Con este tipo de ataque elegimos qué paquete vamos a intentar reinyectar.
  • Ataque 3: realiza inyección automática de paquetes ARP y es el más efectivo cuando tratamos con un cliente legítimo conectado. Cuando lanzamos el ataque intenta conseguir un paquete ARP de dicho cliente, y en cuanto lo tenga empezará a reinyectárselo de forma automática.
  • Ataque 4: lo que hace es lanzar un ataque por saturación al router objetivo. Hoy en día es muy poco efectivo, debido a que los enrutadores identifican el ataque como tal y no devuelven respuesta alguna.

Para realizar estos ataques tendremos que abrir una terminal nueva, ya queairodump-ng seguirá escaneando hasta que nosotros le digamos que pare y nos conviene que siga haciéndolo mientras realizamos los distintos ataques para que también capture cómo responde la red objetivo.

Cómo realizar pruebas de ataque en cifrados WEP

Conviene aclarar para quienes no lo sepan que el cifrado WEP es más débil que el WPA. La seguridad de las redes wifi protegidas con este tipo de cifrados no es muy alta, ya que son “relativamente fáciles” de romper.

Para poder ejecutar una prueba de ataque sobre una red cuya clave está protegida con un cifrado WEP en primer lugar tenemos que desautenticar a un cliente conectado al punto de acceso al que atacamos —también sirve con redes WPA—. Esto se realiza con el siguiente comando:

aireplay-ng -0 X -a <MAC_DE_LA_RED_wifi> -c <MAC_DEL_CLIENTE_OBJETIVO> monX

Donde -0 indica el tipo de ataque que vamos a realizar —una desautenticación de un cliente conectado— y X el número de veces que vamos a lanzarlo. Si dejamos el valor a cero lo hará de forma indefinida.

Lo siguiente es autenticarnos como un cliente falso. Para ello utilizamos esta instrucción:

aireplay-ng -1 0 -e <NOMBRE_DE_LA_wifi> -a <MAC_DE_LA_RED> -h <MAC_DE_NUESTRA_TARJETA_wifi> monX

Una vez que lo hayamos conseguido, ya podemos empezar a inyectar paquetes ARP. Para ello utilizamos el siguiente comando:

aireplay-ng -3 -b <MAC_DE_LA_RED_wifi> -h <MAC_DEL_CLIENTE_FALSO> monX

La MAC del cliente falso vendrá determinada por la de nuestra tarjeta de red —que podemos saber usando el comando ifconfig—. Conviene dejar pasar un tiempo prudencial hasta que por fin tengamos paquetes ARP con los que poder intentar descifrar la clave de la red, cuanto más mejor. En cuanto a cómo obtenerla, de eso hablaremos más adelante.

Cómo realizar pruebas de ataque en cifrados WPA

Como ya establecimos antes, WPA es un cifrado de una seguridad mayor que WEP. Descifrar la contraseña de una red wifi protegida por este tipo de encriptado cuesta bastante tiempo, lo que puede requerir varios intentos hasta que por fin se logre.

El procedimiento a seguir es muy similar al que explicamos anteriormente. Primerodesautenticamos un cliente conectado para obtener el handshake con el comando que ya explicamos:

aireplay-ng -0 X -a <MAC_DE_LA_RED_wifi> -c <MAC_DEL_CLIENTE_OBJETIVO> monX

Ahora bien, si intentamos auntenticar un cliente falso el script nos devolverá un mensaje de error. Para intentar descifrar una clave WPA, una vez realizada la desautenticación del cliente, es necesario intentar inyectar paquetes ARP en uno legítimo en lugar de en uno falso. Para ello usamos de nuevo el ataque 3, pero con una ligera variación:

aireplay-ng -3 -b <MAC_DE_LA_RED_wifi> -h <MAC_DEL_CLIENTE_LEGITIMO> monX

De nuevo volvemos a dejar que el script trabaje durante un buen rato. El siguiente paso es intentar descifrar la clave de la red wifi, que pasamos a explicar ahora.

Cómo hackear la contraseña de la red wifi

Llegamos al quid de la cuestión: saber si todo el trabajo y el tiempo invertido han servido para algo. Tu PC se ha pegado unas cuantas horas intentando obtener los suficientes datos para descifrar la contraseña de la red wifi sobre la que estás ejecutando las pruebas, así que hay que saber si lo que tenemos es suficiente. Para ello usaremos el siguiente comando para los cifrados WEP:

aircrack-ng -b <MAC_DE_LA_RED_wifi> <ARCHIVO_DE_CAPTURA>.cap

La cosa se complica un poco en el caso de los cifrados por WPA pero el comando es básicamente el mismo:

aircrack-ng -b <MAC_DE_LA_RED_wifi> -w <RUTA_DE_UN_DICCIONARIO_O_LISTA_DE_PALABRAS> <ARCHIVO_DE_CAPTURA>.cap

Lo realmente espinoso del asunto es la generación de un diccionario para cifrados WPA. En wifislax hay scripts que generarán uno por ti de forma automática, pero pueden tardar mucho, mucho tiempo. En el momento de escribir esta guía, el script que utilicé yo tardaba más de un año en darme un diccionario completo que poder usar. Por otra parte, puedes intentar conseguir alguno ya creado en Internet que te facilite las cosas.

Salida de aircrack-ngSalida de aircrack-ng

Si todo está como debe, Aircrack-ng debería mostrarte la clave de la red wifi. Si necesitas más información sobre Aircrack-ng, puedes consultarla aquí.

Herramientas automáticas de auditoría de redes

wifislax está equipado con multitud de scripts de auditoría automáticos que resolverán en pocos pasos todo el proceso que acabamos de comentar. Incluso Aircrack-ng tiene su propio proceso automático que elimina la necesidad de usar todos estos comandos, aunque yo personalmente encuentro que ejecutar los comandos de forma manual es mucho más efectivo —ya hemos hablado de lo poderosa que es la terminal de Linux—.

En este sentido, la herramienta automática que mejor me ha funcionado es wifi-Eye. La necesidad de tener un diccionario guardado para descifrar la clave de la red WPA es imperiosa, de eso no hay forma de librarse. Ahora bien, es una adaptación ascript de toda la suite Aircrack-ng muy bien hecha y que funciona estupendamente bien.

Esta herramienta no sólo permite realizar auditorías de redes inalámbricas, sino quetambién permite realizar intercepción de comunicaciones mediante ataques man-in-the-middle o MITM. Si tienes un diccionario de palabras con el que trabajar, WiFi-Eye te facilitará mucho el proceso.

Fuente

Guia de iniciación a la shell de GNU/Linux Capitulo 3

Capitulo tercero.

En este capitulo trataremos los últimos aspectos de la shell a tener en cuenta antes de meternos de lleno en la programación en shell-script, aspectos tales como las expresiones regulares como patrones de búsqueda, algunos otros comandos de filtrado, el editor de textos ‘vi’,y al fin nos meteremos con aspectos básicos de shell-script, y nuestro primer shell-script.

Empecemos

Expresiones regulares .

Patrones de busqueda.

Los metacaracteres son caracteres especiales que se refieren a otros caracteres con la finalidad de de efectuar búsquedas de archivos, líneas o palabras depurando resultados.
Hay multitud de formas de intercalarlos para depurar al máximo las búsquedas, tantas como nuestra ‘imaginación’ o conocimiento del manejo de ellos nos permitan, yo me limitare a deciros cuales son, para que sirven, y os daré algunos ejemplos.

Metacarateres:

opciones:
? —————> hace coincidir con cualquier carácter al menos una vez.
* —————> hace coincidir con el carácter precedente u otro 0 o mas veces.
+ —————> hace coincidir con el carácter precedente 1 o mas veces.
{n} ————-> hace coincidir con el carácter precedente ‘n’ veces.
{,m}————-> hace coincidir con el carácter precedente al menos ‘m’ veces.
{n,m}————> busca ‘n’, ‘m’ veces.
^ —————> El acento circunflejo mira el principio de la línea de búsqueda. ejemplo: ‘^a’ buscaría las líneas que empiecen por ‘a’.
$ —————> busca al final de la línea. ejemplo: ‘a$’ busca las líneas acabadas en ‘a’.
. —————> hace coincidir con cualquier carácter solo una vez.
[]—————> hace coincidir cualquier letra dentro de los corchetes una vez o varias separadas por comas ‘,’.Se pueden dar rangos.
ejemplos:
^[a-z] —> esto buscaría las líneas empezadas de la ‘a’ la ‘z’.
^[a-z,A-Z]> esto buscaría como la anterior, también mayúsculas.
[^a-z,A-Z]> al contrario que las anteriores, buscaría las que no empiecen por ninguna letra ni mayúscula ni minúscula.
^[0-9] —> buscaría líneas empezadas por números.

 

Comandos de filtrado.

Comando ‘cut’: corta o filtra campos o columnas. el argumento puede ser la salida de una tubería, un fichero.. etc

Sintaxis: cut [opciones [delimitador]] argumento

Opciones:
-c corta columnas —-> cut -c 1-3 /etc/passwd
-f corta campos. esta opción necesitaría en algunos casos de la opción -d la cual fija un delimitador de campos. Sin usarla por defecto usa el tabulador.

Os recomiendo que practiquéis con este comando y sus distintas posibilidades, ya que es realmente útil, a continuación unos ejemplos:

cut -c 1-3 /etc/passwd
cut -c 1,3 /etc/passwd
ls -l /etc|cut -c 2-10
ls -l /etc|cut -f 1
ls -l /etc|cut -f 1 -d ” ”
cut -f 5,3 -d “:” /etc/passwd

 

Comando ‘tr’ Traductor. Traduce caracteres con la finalidad de igualar patrones de filtrado. Por defecto lee de la entrada estándar, pero se puede redireccionar la entrada a un fichero o dar argumentos a través de tubería.

Sintaxis: tr [opción] [“patrón”][“patrón”]

Al igual que con el comando anterior, os recomiendo que miréis su ayuda y practiquéis su uso, ya que es también extremadamente útil.

Opciones:
-d — delete. Se especifica solo un rango de caracteres.
-s — Elimina caracteres repetidos.
-c — Todos aquellos caracteres que no sean ‘x’ los combierte a ‘x’.

Ejemplos:

tr -d [a-z]< /ruta/archivo
tr -d [0-9]< /ruta/archivo
tr -s ” ” < /ruta/archivo
tr -c [a-z\n] “,” < /ruta/archivo
ls -l | tr -c “0-9 a\n” “x”

 

Comando ‘tee’.Duplica la salida estándar, esto es que la salida estándar además de ir redireccionada o simplemente salir por pantalla, también se guarda en un fichero de texto. Si el fichero no existe lo crea, si existe lo sobre escribe.
En el caso de que no queramos sobre escribir, existe la opción -a (append), esta opción, añade la salida al archivo sin sobre escribir.

Sintaxis: stdin tee archivo.txt —-> stdout

Ejemplo:

rh3nt0n@rh3nt0n-laptop:~$ ls | tee listado
borrador.odt
capitulo2.odt
configuracion
…..
rh3nt0n@rh3nt0n-laptop:~$ head listado
borrador.odt
capitulo2.odt
configuracion
…..

 

Comando ‘find’. Busca ficheros recursivamente directorio a directorio.

Sintaxis: find fichero [opciones]

Opciones:
-name —- busca el nombre del fichero buscado.
-maxdepth (n) Máxima profundidad. Busca solo hasta el nivel de directorios que le digamos en numero ‘n’.
-iname — No toma en consideración mayúsculas y minúsculas.
-user —- (find fichero -user [user]) Busca los ficheros del usuario especificado. se pueden incluir mas opciones con -a (and) y -o (ó).
-group — Busca los ficheros del grupo especificado.
-mtime [+ – n] Busca segun modificación. +n busca en archivos modificados hasta ‘n’ dias.-n busca en archivos modificados como mucho en ‘n’ dias.
-size [+ – n] Busca por tamaño. (find ruta -size [+ -]n[k M G])
-links [n] Busca por numero de enlaces duros.
-inum [n] Busca por numero de inodo.
-type [b c d f l] [-a -o !] [opción de find]. Busca por tipo de archivo.
-exec [orden] {}\; Ejecuta la orden sobre el fichero buscado.

Herramienta de edición de texto.

Hay muchos editores de texto de uso para linux, tanto en modo texto, como en modo grafico. En modo texto tenemos ‘emacs’ de los primeros en usarse en Unix, ‘Joe’ una extensión de GNU, ‘vi’ de los mas extendidos en distribuciones Linux, y también los de entorno Grafico, el mas usual en el entorno grafico Gnome es ‘gedit’, y para Kde ‘kedit’.Nosotros vamos a ver el editor ‘vi’ para modo texto que a mi modo de ver es el que mas y mejor se lleva con la shell, sin salir de ella.

Editor de textos ‘vi’.

El editor de textos ‘vi’ es una herramienta muy potente, para la programación de shell-script ya que nos permite ir editando el script según lo vamos probando en otra consola.

Este editor, no lo encontrareis en ningún menú grafico, ya que funciona en la shell, así que lo llamaremos de la siguiente forma desde la terminal:

vi fichero

Si el fichero existe lo abre y lo podremos editar, si no existe lo crea.
Para empezar a insertar texto, pulsaremos ‘i’ de insertar y para agregar texto, pulsaremos ‘a’ de append. En esta aplicación debéis de olvidaros del uso del ratón lo suyo es usar el teclado para moverse por el texto, con las teclas de dirección, ‘intro’ para salto de línea, ‘Supr’ para suprimir caracteres, también ‘dell’ para esto.. etc, doy por hecho que sabéis para que sirven las teclas..
Para salir de la edición pulsamos ‘Esc’, ojo, salimos de la edición pero no del editor.
Para guardar los cambios sin salir pulsamos ‘:w ‘enter’ ‘.
Para salir del editor guardando los cambios ‘:x ‘enter’ ‘.
Para salir ‘:q ‘enter”.
Para forzar salida ‘:q! ‘enter”.

Primeros pasos en shell-script.

Que es un shell-script.

Un shell script es un fichero de texto, que contiene ordenes de shell, la cual va ejecutando una a una siguiendo un guión preestablecido en el propio script.
Se pueden hacer shell-script en todos los tipos de shell que existen, ‘bash’ ‘sh’ ‘ksh’ ‘csh’… pero no tienen por que ser compatibles unos con otros, para que sean compatibles hay distintas formas de ejecutarlos y de indicar a la shell como actuar.

Maneras de ejecutar un shell-script.

Lo mejor para ver como se ejecuta un shell-script es crear uno, así que a ello.

vi script1

Una vez abierto en la shell el editor, pulsamos ‘i’ e insertamos el siguiente texto.

echo “hola mundo”

A continuación pulsamos escape ‘Esc’, y tecleamos ‘:w’ para grabar los cambios. a continuación, abrimos otra shell y empezamos a ver las formas de ejecutarlo.

1º La forma mas rápida para ir ejecutando un script según lo vamos editando, es llamar a la propia shell que estemos usando, para que ejecute el archivo de nuestro script:

rh3nt0n@rh3nt0n-laptop:~$ bash script1
hola mundo
rh3nt0n@rh3nt0n-laptop:~$

Como podéis apreciar, el script se ha ejecutado sin problemas y ha imprimido en la pantalla ‘hola mundo’ ejecutando la orden echo.

2ª Del modo anterior, usamos ‘bash’ para que ejecute nuestro script. Para ejecutar directamente nuestro script en la shell, sin tener que llamar a ‘bash’, la opción que tenemos es dar a nuestro script permiso de ejecución de la siguiente manera:

chmod +x script1

Para ejecutar nuestro script una vez tenga permiso de ejecución solo hay que llamarlo de la siguiente manera:

rh3nt0n@rh3nt0n-laptop:~$ chmod +x script1
rh3nt0n@rh3nt0n-laptop:~$ ./script1
hola mundo
rh3nt0n@rh3nt0n-laptop:~$

 

Como podréis apreciar, para ejecutarlo hemos usado ‘./’ esto no es mas que la ruta relativa de donde se encuentra el fichero de nuestro script, si este se encontrara en otro directorio de nuestro home, la orden tendría que ser: ./directorio/script1. Espero que halláis captado la idea.

3ª Para definir en que shell ha de ejecutarse nuestro script, existe el ‘shebang’ que corresponde a la primera línea de nuestro script y que es algo que tendremos que añadir siempre a nuestros script para evitarnos problemas a la hora de ejecutarlos, ya que define la shell hija donde se ejecutaran estos.

#!/bin/bash

Esto es un ‘shebang’, el cual indica que para ejecutar el script, hay que usar la aplicación ‘bash’ que se encuentra en el directorio ‘/bin’.
Una buena idea, y algo que deberíamos de tener en cuenta a la hora de programar nuestros shell-script, es comentar las ordenes que vayamos añadiendo a estos, ya que a la hora de configurar la orden sabremos que función tiene, pero a la hora de echarle tiempo después un vistazo al código, si no hemos comentado las ordenes elaboradas, puede ser realmente tedioso el hecho de interpretarlo. Esto ocurre también con la identación de el código que veremos mas adelante.
Para comentar líneas de ordenes, existe el carácter ‘#’ almohadilla, el cual la shell salta sin ejecutar el contenido de la línea que empiece por ella, esto lo veremos mejor insertando en nuestro script1, tanto el shebang, como una línea comentando lo que hace nuestro script.

Si hemos dejado abierto el editor vi, en otra terminal, vamos a ella, si no es así abrimos nuestro script1 de esta manera:

vi script1

Se abrirá nuestro fichero script1 con ‘vi’.Ahora insertamos ‘i’ las siguientes líneas, de tal modo que quede así:

#!/bin/bash
# Mi primer shell-script
echo “hola mundo”

Para poder ejecutar nuestro script desde cualquier lugar de nuestro sistema de archivos, tenemos dos opciones, la primera es copiar el script en el directorio /bin (si no existe, no hay problema en crearlo) de nuestro /home, en mi caso rh3nt0n. Lo cual permitiría que ejecutáramos nuestro script sin necesidad de tener privilegios de administrador como cualquier otro comando, con solo nombrarlo. O bien la opción de copiar nuestro script en el directorio /bin de root, lo cual permitirá ejecutarlo con privilegios de administrador con solo nombrarlo, siendo root.

En todo caso os doy los dos ejemplos, y vosotros decidís como queréis trabajar con vuestros scripts, eso si, teniendo en cuenta que trabajar como root es bastante peligroso para la integridad de nuestro sistema de ficheros.

cp script1 /home/bin
cp script1 /bin

 

Con el primer comando copiamos script1 a el directorio /home/bin, lo cual nos permitiría ejecutar el script con solo nombrarlo, pero solo a nosotros como usuario sin privilegios.

Con el segundo comando copiaríamos nuestro script a el directorio /bin, lo cual permitirá solo a ‘root’ ejecutarlo, para esta opción deberemos tener privilegios de administrador.

Supongamos que elejimos el primer caso, despues de copiar el script1 en /home/bin lo ejecutaríamos:

rh3nt0n@rh3nt0n-laptop:~$ ls -l ~/bin
total 4
-rwxr-xr-x 1 rh3nt0n rh3nt0n 18 2006-11-05 15:26 script1
rh3nt0n@rh3nt0n-laptop:~$ ./bin/script1
hola mundo
rh3nt0n@rh3nt0n-laptop:~$ ./script1
hola mundo
rh3nt0n@rh3nt0n-laptop:~$ script1
hola mundo
rh3nt0n@rh3nt0n-laptop:~$

 

Bueno, pues habiendo visto, algunos de los aspectos básicos de la programación en shell-script, os emplazo a la semana que viene, para meternos de lleno con asuntos mas serios y nuevos comandos de uso en shell-script.

 

Guia de iniciación a la shell de GNU/Linux Capitulo 2

Capitulo segundo.

En este capitulo veremos algunos aspectos interesantes de la shell y el uso de los comandos, conoceremos aspectos de las variables del sistema, como añadirlas como editarlas, redirección de la entrada/salida estándar de los comandos, los filtros de búsqueda, iniciación y manejo de los procesos ,entre alguna que otra utilidad .

Empecemos .

Antes de nada me gustaría mencionar un comando que a mi modo de ver es muy interesante, me refiero al comando ‘alias’, con este comando se puede dar un alias a un comando determinado .

Aqui vemos como le doy como alias a iwconfig ‘red’

rh3nt0n@rh3nt0n-laptop:~$ alias red=’iwconfig’
rh3nt0n@rh3nt0n-laptop:~$ red
lo no wireless extensions.
irda0 no wireless extensions.
eth1 no wireless extensions.
sit0 no wireless extensions.

 

Cabe resaltar que el alias espira cuando cerramos la shell donde la hemos creado, pero esto es fácilmente subsanable editando el archivo ‘.bashrc’ de nuestro home, añadiendo el alias al final del archivo, este archivo se encarga de la configuración inicial de nuestra shell, y ejecuta automáticamente las ordenes que contiene al iniciar la shell .
Esto es muy bueno, por ejemplo para tema de configuraciones de red etc.

Para eliminar un alias, solo hay que ejecutar el siguiente comando:

unalias -a alias_creado

Concatenación de comandos en la shell .

Cuando estamos utilizando la shell, podemos hacer que los comandos o aplicaciones actúen en el ‘back-ground‘ o en el ‘front-ground‘ .

Que es esto? muy sencillo, al ser linux un sistema operativo multitarea, la shell puede trabajar con muchos procesos a la vez, aunque solo se puede ejecutar un proceso cada vez mientras los demás están preparados o dormidos. Este tema de los procesos lo veremos mas adelante.

Los procesos en back-ground, son los que se ejecutan invisiblemente para el usuario y dejan libre la shell para seguir trabajando con ella.

los procesos en front-ground, son justo lo contrario, son procesos que se ejecutan en primer plano y ocupan la shell el tiempo que están en funcionamiento.

También podemos unir una serie de ordenes, e interactuar con la salida de cada orden aprovechando esa salida para que sirva de argumento para otra orden esto lo entenderemos mejor viendo unos ejemplos:

Modos de invocar ordenes:

orden &

El umpersand ‘&’, hace que esta orden se ejecute en back-ground y nos dejaría la shell libre para poder seguir usando otros comandos.

orden1 ; orden2

El punto y coma ‘;’ hace que se ejecuten las ordenes una a una, independientemente de que una u otra funcione.

 

rh3nt0n@rh3nt0n-laptop:~$ cd .. ; ls
rh3nt0n
rh3nt0n@rh3nt0n-laptop:/home$

Como se puede observar, en el anterior comando, se ejecuta ‘cd..’ y después se ejecuta ‘ls‘, sobre el directorio al que se sube con ‘cd..’

 orden1 | orden2

El pipe ‘|’ hace que la salida de la orden1, de argumentos a la orden 2. Ejemplo:

 dmesg | grep ipw

Estos comandos los explicare mas adelante, la orden dmesg, da los argumentos a grep para que filtre el texto especificado .

 orden1 `orden2`

Estas comillas -“- ejecutan la orden2 que esta dentro de las comillas y pasan la salida de este como argumento a la orden1.

 apt-get install kernel-headers`uname -r`

Aquí el resultado de uname -r daría argumentos al comando apt-get

 orden1 && orden2

En esta opción la orden2 se ejecutaría si orden1 termina sin errores.

make && make install

orden1 || orden2

En esta opción las ordenes irían ejecutándose, hasta que una de ellas se ejecute correctamente ,en ese momento se detiene.

Histórico de ordenes:

Un buen comando de ayuda en referencia a comandos, y a trabajar con ellos en la shell, es el comando ‘history‘, este comando guarda en buffer de memoria los comandos que se han ido ejecutando en la shell y con el es posible conocer cuales se han efectuado, y citarlos por su número
de orden.

 

rh3nt0n@rh3nt0n-laptop:/home$ history
1 sudo iwconfig eth0 essid j
………..
174 iwconfig
175 dmesg
176 lsusb
177 iwconfig
178 lsusb
179 dmesg
180 wget http://www.bluntmen.com/ipw2200-1.1.4-inject.patch
181 bogomips
182 yes
183 yes >/dev/null &
184 jobs
185 bg 2
186 fg 2
187 kill 2
188 jobs
189 top
190 cd .. ; ls
191 dmesg
192 history

La primera columna indica el número de comando, en el orden en el que se ha ejecutado.
La segunda evidentemente es el comando que se ha ejecutado, es una muy buena utilidad, ya que por ejemplo en comandos largos haciendo un history y fijándote en el número de orden, con solo citar el número de la forma que explicare ahora, se ejecutaría el comando:

Si por ejemplo de la lista anterior queremos hacer el número 180, haríamos lo siguiente:

rh3nt0n@rh3nt0n-laptop:/home$ !180
wget http://www.bluntmen.com/ipw2200-1.1.4-inject.patch
–21:03:51– http://www.bluntmen.com/ipw2200-1.1.4-inject.patch
=> `ipw2200-1.1.4-inject.patch’
Resolviendo www.bluntmen.com…

Variables de entorno.

Las variables de entorno, son como explique en el anterior capitulo, porciones de memoria que el sistema coge para guardar valores específicos necesarios para el sistema. Si queremos saber las variables de entorno que hay en el sistema, solo tenéis que usar el comando ‘set‘.

 

rh3nt0n@rh3nt0n-laptop:/home$
rh3nt0n@rh3nt0n-laptop:/home$ set | more
BASH=/bin/bash
BASH_ARGC=()
BASH_ARGV=()
BASH_COMPLETION=/etc/bash_completion
BASH_COMPLETION_DIR=/etc/bash_completion.d
BASH_LINENO=()
BASH_SOURCE=()
……..

Para ejecutar una variable de entorno solo hay que citarla de esta manera:

rh3nt0n@rh3nt0n-laptop:/home$ echo $HOSTNAME
rh3nt0n-laptop

las variables siempre se citan con el signo del dólar delante $, y es de resaltar que las variables predeterminadas del sistema, suelen estar en mayúsculas .
Nosotros podemos creas variables de entorno, las cuales pueden ejecutarse en la shell donde las hemos creado, o exportarlas para poder usarlas en cualquier terminal de la sesión que esta en marcha, aunque estas variables una vez reiniciado el sistema se pierden, esto es útil en servidores en los cuales rara vez se reinicia el sistema.

Para crear una variable de entorno seria de esta forma:

 

nombre_variable=concepto

Ejemplo:

rh3nt0n@rh3nt0n-laptop:/home$ edad=30
rh3nt0n@rh3nt0n-laptop:/home$ nombre=rh3nt0n
rh3nt0n@rh3nt0n-laptop:/home$ echo $edad
30
rh3nt0n@rh3nt0n-laptop:/home$ echo $nombre
rh3nt0n
rh3nt0n@rh3nt0n-laptop:/home$

Es recomendable a la hora de crear variables de entorno, que las que hagamos nosotros, las hagamos en minúsculas, así a la hora de borrar variables, no borraremos nada que no tengamos que borrar .
Las variables de entorno, cuando las crea un usuario, solo se ejecutan en la terminal donde se crean, para poder ejecutarlas en todas las terminales tendríamos que exportarlas:

Comando ‘export’

 

rh3nt0n@rh3nt0n-laptop:/home$ export edad

Esto haría que en la misma sesión en la que estamos, pero en otra terminal, se pueda ejecutar esa variable sin problemas.

Para borrar una variable determinada, solo habría que usar el comando ‘unset’ para ello:
comando ‘unset’

 

rh3nt0n@rh3nt0n-laptop:/home$ export edad

 

Hay variables como $PWD que se van actualizando dependiendo de donde nos encontremos y automáticamente.

Entrecomillado de caracteres en la shell.

Hay ordenes que requieren de argumentos los cuales habitualmente dependiendo de la forma que se quieren utilizar se usan unas comillas u otras.

echo ”$PATH ”
echo ‘ $PATH ‘
echo \$PATH

En el primer caso, ” ” las comillas son denominadas débiles, el comando o el argumento lo usa la shell tal y como esta escrito y lo ejecuta si viene al caso.
En el segundo caso, ‘ ‘ las comillas son denominadas fuertes ,lo cual quiere decir que la shell no actúa dentro de ellas, por lo tanto se toma literalmente el argumento.
En el tercer caso, el back slash ‘\’ se utiliza para escapar caracteres especiales como $ para que la shell tome el argumento como en el segundo caso.

Las comillas se usan en el caso de las variables para que se pueda usar un comando asignado a una variable:

fecha:`date`

Esta orden ejecutaría el comando date, al llamar a la variable ‘fecha’.

Redirección de la entrada/salida estándar.

La shell, toma información de la entrada estándar, (teclado) denominada stdin, cuando se ejecuta la orden dependiendo de como se ejecute, puede dar una salida valida o errónea, en caso de la salida valida la información por defecto la shell como salida estándar usa la pantalla, con lo cual nos muestra la información en la shell, en caso de que la ejecución del comando sea errónea, nos muestra la salida de error por defecto también por la pantalla y nos la muestra por la shell, aunque parezca en principio que tanto la salida estándar como la salida estándar de errores es lo mismo, no lo son, solo tienen por defecto asignado que enseñen la información por la pantalla .

Estas salidas, se pueden redireccionar, así mismo también la entrada estándar, o bien para que un comando tome los argumentos o sea la entrada de datos de un fichero o que la salida de un comando sea el argumento de otro, o que esa salida salga por la impresora, se imprima en un fichero etc .
Lo mejor es que lo veamos gráficamente:

 

 

Formas de redireccionar la entrada estándar ‘stdin’.

el signo ‘<‘ cambia la entrada estándar.
ejemplos:

 

mail rh3nt0n < carta.txt

El anterior comando tomaría como argumento para el comando mail, el contenido del fichero carta.txt.

 

comando < fichero

El anterior comando tomaría como argumento para el comando ejecutado, el contenido de fichero.

Formas de redireccionar la salida stantdart ‘stdout’ .

El signo ‘>’ redirecciona la salida estándar, creando el fichero si no existe y sobre escribiendo el archivo si existe.

comando > fichero
comando > contenido
comando > argumentos
comando > /dev/dispositivo

comando > stdout

El comando anterior, redireccionaria la salida del comando a el fichero stdout

La salida estándar de errores, también puede redireccionarse, ya que si el comando ejecutado, aun teniendo la salida estándar redireccionada a el sitio que sea que no sea la salida estándar, si ese comando falla, la salida de errores la muestra por pantalla.

Para que esto no ocurra si no es nuestro deseo, o bien capturar en un fichero las posibles salidas de error, se usa ‘2>’ lo cual hace lo mismo que con la anterior opción hacia con la salida estándar.

 

comando 2> stderr

Este comando mostraría en caso de que la ejecución fuera correcta, por la pantalla, salida estándar de errores. y en caso de que hubiera algún error, la salida de error la mostraría en el fichero stderr.

En conjunción ,seria algo como esto:

comando > stdout 2> stderr

Esta sintaxis, redireccionaria la salida del comando en caso de que fuera correcto, a el archivo stdout, en caso de que fallara enviaría la salida de error a el fichero stderr.

Cuando no queremos que el archivo, a sabiendas de que existe, se sobrescriba, se utiliza el mayor que doble ‘>>’ de esta forma:

echo ” hola mundo ” >> fichero.txt

 

El anterior comando añadiría el texto hola mundo a el fichero.txt sin sobrescribirlo.
esto ocurre de igual manera con la salida de errores, pero de este modo:

 

echo “hola mundo” 2>> errores.txt

Como se podrá apreciar, el comando echo esta mal escrito, pero la salida de errores se redireccionaria a el fichero errores.txt, en lugar de mostrarla por la pantalla.

rh3nt0n@rh3nt0n-laptop:~$ eco “hola mundo” 2>> errores.txt
rh3nt0n@rh3nt0n-laptop:~$ cat errores.txt
bash: eco: orden no encontrada
rh3nt0n@rh3nt0n-laptop:~$

Redirección a dispositivos ‘especiales’

Se pueden redireccionar salidas muy extensas, o salidas de errores a el dispositivo ‘/dev/null’, para evitar colapsar de información la salida estándar, o simplemente por que no nos interese ver esa salida. Este dispositivo es denominado ‘agujero negro’ ya que lo que es redireccionado allí, no se puede recuperar.

Ejemplo de uso:

Aquí cabe resaltar el uso del comando ‘time’, el cual tiene la peculiaridad de mostrar su salida estándar, por la salida de errores. En el siguiente ejemplo ,este comando se encarga de cronometrar el tiempo que tarda en ejecutarse el comando junto al que se ejecuta, mostrando la salida por pantalla y enviando la salida del comando a ejecutar a el dispositivo /dev/null.

 

rh3nt0n@rh3nt0n-laptop:~$ time ls -R /etc > /dev/null
ls: /etc/cups/ssl: Permiso denegado
ls: /etc/ssl/private: Permiso denegado
real 0m0.382s
user 0m0.024s
sys 0m0.012s
rh3nt0n@rh3nt0n-laptop:~$

Los filtros de búsqueda.

Los filtros de búsqueda son una utilidad muy interesante a la hora de buscar palabras comandos etc de forma ordenada y desechando lo que no nos interesa .
vamos a ver algunos comandos de búsqueda interesantes:

Comando “sort” sin opciones, ordena líneas de texto alfabéticamente aunque sean números.

opciones:
-n ordena números ” 1 2 3 4 ”
-t: define delimitador de campos
+(n) n de número, para elegir que columna queremos ver primero.
-F no considera mayúsculas o minúsculas.
-r invierte la salida normal.

Comando “grep”, busca líneas de texto en un archivo o salida de comando especificada.
sintaxis: grep patrón fichero
ejemplo de otro uso:
dmesg argumento | grep
opciones:
-v busca todas las líneas que no contienen el patrón
-i no considera mayúsculas de minúsculas .
-n numera las líneas que contienen el patrón especificado.

Comando “wc” ‘word count’ cuenta palabras la salida normal sin parámetros saca tres columnas:
sintaxis: wc [opciones] fichero
1º cantidad de líneas del fichero .
2º cantidad de palabras.
3º cantidad de caracteres.

opciones:
-l número de líneas únicamente
-w número de palabras únicamente
-c número de caracteres únicamente

Ejemplo de redirección con este comando:

 

ls /bin/l* | wc-l

Iniciación a los procesos.

Los procesos no son mas que los programas que se están ejecutando, cada procesador puede ejecutar solo un proceso cada vez que actúa. existen multitud de estados de los procesos, pero a groso modo podríamos destacar estos cuatro:

Los procesos pueden estar en varios estados:
Estado runing – solo puede haber un proceso runing o funcionando.

Estado preparado – son procesos que están preparados para ser ejecutados por el procesador.

Estado dormido – son procesos que han acabado, pero pueden ser llamados otra vez a funcionar.

Estado zombie – son procesos como su propio nombre indica, que al no acabar bien, siguen en memoria sin borrarse.

Esto se aprecia mejor con el siguiente grafico:

 

Comandos de información de procesos.

Comando “ps” este comando sirve para ver los procesos que se están ejecutando. Esto es muy útil para dar preferencias a algún proceso determinado, matar procesos, en definitiva conocer los PID de los procesos, para poder mandarles señales entre otras cosas .
La forma mas habitual de usar este comando es con las opciones a y x.

a para ver todos los procesos y x que muestre cuales se están ejecutando.

sintaxis: ps ax

 

ejemplo:
rh3nt0n@rh3nt0n-laptop:~$ ps ax
PID TTY STAT TIME COMMAND
1 ? S 0:01 init [2]
2 ? SN 0:00 [ksoftirqd/0]
3 ? S 0:00 [watchdog/0]
4 ? S< 0:00 [events/0]
5 ? S< 0:00 [khelper]
6 ? S< 0:00 [kthread]
8 ? S< 0:00 [kblockd/0]
9 ? S< 0:00 [kacpid]
10 ? S< 0:00 [kacpid-work-0]
162 ? S 0:00 [pdflush]
163 ? S 0:00 [pdflush]
165 ? S< 0:00 [aio/0]
164 ? S 0:00 [kswapd0]
766 ? ………………

La primera columna de la salida del comando anterior muestra el PID del proceso ,todos los procesos tienen un PID del proceso, no es mas que un número identificador, para poder mandarle señal a cada proceso ejecutandose desde la consola.
La segunda columna indica la consola virtual donde se esta ejecutando el proceso, si no tiene aparece un signo de interrogacion ‘?’.
La tercera columna indica en el estado en el que se encuentra el proceso:

s —- dormido
r —- runing o corriendo
z —- zombie
t —– detenido

comando útil:

 

ps ax | grep “proceso”

Busca y filtra el proceso buscado.

La cuarta columna, indica el tiempo que lleva ejecutándose el proceso.

Los procesos pueden recibir señales a través de la terminal, para interactuar con ellos .
Pueden trabajar como he explicado anteriormente en el front-ground, de forma visible en la terminal, y en el back-ground, de forma transparente, para nosotros desde la terminal.
Cuando un proceso recibe una señal desde la terminal, puede reaccionar de tres maneras diferentes:
1º puede ignorar la señal .
2º puede interpretar la señal .
3º puede aceptar que se encargue de el, el kernel .

Señales a los procesos.

Comando “kill” en principio mata el proceso, con opciones puede hacer reiniciar procesos dormidos.
sintaxis: kill -señal PID
Señales mas importantes:

señal -1 para que se reinicie un proceso, si no se puede, el sistema lo mata .
señal -2 interrupción
señal -3 para que el proceso acabe, pero sin errores .
señal -9 para el proceso, y el proceso no puede ignorar esta orden.
señal -15 es lo mismo que ejecutar kill sin opciones es como decirle al proceso ‘cuando puedas cierra’, esta señal puede ser ignorada por el proceso .

Comando ‘nohup’ Ejecuta la orden ignorando las señales de colgar, sirve para que las ordenes sigan funcionando, aunque salgamos de la terminal.

Sintaxis: nohup orden [argumento]

Cabe resaltar que cuando la shell deja un comando funcionando y salimos de ella lo hereda init.

Para ver los procesos y los niveles de ejecución existe el comando ‘top’, este comando muestra de forma dinámica los procesos que se ejecutan en el sistema:

 

 

Esta aplicación (parecida a el visor de procesos de Windows) nos es muy útil para interactuar con los procesos, a la hora de mandar señales, y dar prioridades a uno u otro proceso .

Prioridades de los procesos.

Podemos asignar prioridades de ejecución a los procesos, si queremos que un programa tenga mas prioridad o menos, podemos bajarle o subirle el nivel de ejecución con el comando “nice”.

Comando “nice”
Este comando asigna nivel de ejecución a los procesos, por defecto asigna el valor 10.
sintaxis: nice [valor] orden [argumentos]
Los valores de nivel de ejecución van de el +19 al -19 siendo el de menor valor ‘-19’ el que mas prioridad tiene de ejecucion.

Los valores del -0 al -19 solo puede asignarlo el usuario root.

Comando “renice”.

Este comando repone el nivel de ejecución, a un procesos que este ejecutándose.

Sintaxis: renice [valor] número PID

Comando “sleep”.

Este comando duerme el proceso deseado ‘x‘ segundos especificados.

Sintaxis: sleep [tiempo] [opción] [orden]

Opciones:

-s tiempo en segundos (por defecto)
-h tiempo en horas.
-d tiempo en días.

Comando “jobs”. Muestra los procesos que se ejecutan en el back-ground.

Para usar este comando y los siguientes, nos viene muy bien el comando anteriormente citado “top“, ya que debemos apoyarnos en el IDE de proceso “PID“, para poder interactuar con los procesos en back-ground.

 

rh3nt0n@rh3nt0n-laptop:~$ yes > /dev/null &
[2] 6521
rh3nt0n@rh3nt0n-laptop:~$ jobs
[1]+ Stopped yes >/dev/null
[2]- Running yes >/dev/null &
rh3nt0n@rh3nt0n-laptop:~$

 

Comando “fg”. Lleva un comando ejecutándose en back-ground, al front-ground.

Sintaxis: fg [PID de proceso]

 

rh3nt0n@rh3nt0n-laptop:~$ fg 2
yes >/dev/null

 

Comando “bg”. Relanza un proceso dormido, ejecutándolo en el back-ground.

Sintaxis: bg [PID del proceso dormido]

 

[2]+ Stopped yes >/dev/null
rh3nt0n@rh3nt0n-laptop:~$ jobs
[1]- Stopped yes >/dev/null
[2]+ Stopped yes >/dev/null
rh3nt0n@rh3nt0n-laptop:~$ bg 2
[2]+ yes >/dev/null &
rh3nt0n@rh3nt0n-laptop:~$ jobs
[1]+ Stopped yes >/dev/null
[2]- Running yes >/dev/null &
rh3nt0n@rh3nt0n-laptop:~$

 

En este punto, recuerdo que para matar un proceso conociendo su PID podemos usar lo siguiente:

Sintaxis: kill “% PID”

 

rh3nt0n@rh3nt0n-laptop:~$ kill %2
rh3nt0n@rh3nt0n-laptop:~$ jobs
[1]+ Stopped yes >/dev/null
[2]- Terminado yes >/dev/null
rh3nt0n@rh3nt0n-laptop:~$

también recuerdo, como lanzar un proceso en el back-ground.

Sintaxis: orden [argumentos] &