:(){ :|:& };:

http://en.wikipedia.org/wiki/Fork_bomb

Una bomba fork es una forma de ataque del tipo denegación de servicio sobre un computador que implementa la operación fork, o alguna funcionalidad equivalente mediante la cual un proceso es capaz de crear otro proceso.

Una bomba fork funciona creando una gran cantidad de procesos muy rápidamente con el objetivo de saturar el espacio disponible en la lista de procesos mantenida por el sistema operativo del computador. Si la tabla de procesos se llega a saturar, entonces no se pueden iniciar nuevos programas hasta que no se cierre alguno. En el caso que esto suceda, es muy poco probable que se pueda iniciar un programa útil ya que los procesos de la bomba estarán esperando para poder crear nuevos procesos a la primera oportunidad que se les conceda.

Las bombas fork no sólo ocupan espacio dentro de la lista de procesos, también consumen tiempo de proceso y memoria de la máquina donde se ejecutan. Como resultado de esto, los ordenadores se vuelven lentos e incluso se pueden volver inutilizables dada la falta de memoria y la imposibilidad de aprovechar el procesador.

Una forma de prevenir el ataque de una bomba fork es limitar el número de procesos que un usuario puede ejecutar. Cuando un proceso intenta crear otro proceso y el propietario de dicho proceso ya posee la cantidad máxima de procesos que se le ha asignado, el intento de creación del nuevo proceso falla. El máximo número de procesos asignado a cada usuario debe ser lo suficientemente bajo para poder resistir la ejecución simultánea de una bomba fork por cada usuario y dejar libres los suficientes recursos como para poder restaurar el sistema.

Ejemplos de bombas fork tenemos (advertencia, no ejecutar a menos que se guarde toda information actualmente abierta; en algunos casos existe la posibilidad de daniar el sistema):

Bash
:(){ :|:& };:


C:
#include 

int main(void)
{
for(;;)
 fork();
return 0;
}

PHP:
while(pcntl_fork()|1);


Python: 
import os

while True:
  os.fork()

___       ___  _         ___ _ 
| __|_ ___|   \(_)__ _ __| _ ) |___  __ _
| _/ _/ _ \ |) | / _` |_ / _ \ / _ \/ _` |
|_|\__\___/___/|_\__,_/__|___/_\___/\__, |
                                    |___/

rm -rf * : Too many arguments

El otro dia que estaba queriendo borrar unos archivos que ya no necesitaba, pero el problema es que eran demasiados para el limite de argumentos que soporta el kernel de linux, y este error ocurre cada vez que el usuario pasa mas argumentos de los que el sistema soporta, y esto aplica a todos los comandos como: ls, cp, rm, etc.

Asi que habia que buscar una alternativa (workaround) para el comando rm -rf *, entonces es cuando otros comandos de Bourne Shell pueden ser utiles para completar esta tarea, asi que aqui les muestro dos alternativas:

for i in *; do rm -rf $i; done

De esta forma el comando for toma un archivo a la vez y lo coloca en la variable $i; dentro del loop se ejecuta el comando rm para finalmente borrar el archivo; resultado, los archivos son eliminados, que es lo que se deseaba desde el principio.

Otra alternativa para realizar esta tarea es mediante el comando find:

find . -type f -name '*' -exec rm -rf {}\;

El comando find pasa cada archivo que coincide con la busqueda y ejecuta el comando rm -rf en cada uno de ellos, completando al final la tarea deseada.

Hay otras alternativas, pero las dejo para la investigacion, de hecho una de ellas es el modificar, en el kernel de Linux, la variable que permiten incrementar el limite de parametros que se pueden pasar en una linea de comandos, pero ojo, esto require del conocimiento de los cambios que se haran y de como compilar un nuevo kernel de Linux; una pista, busquen en /include/linux/binfmts.h.

Saludos y hasta la proxima.

 ___       ___  _         ___ _   
| __|_ ___|   \(_)__ _ __| _ ) |___  __ _
| _/ _/ _ \ |) | / _` |_ / _ \ / _ \/ _` |
|_|\__\___/___/|_\__,_/__|___/_\___/\__, |
                                    |___/

Bash en la vida cotidiana.

Para los que todos los dias tenemos que trabajar con bash en nuestros sistemas, ya sea como administradores de sistemas, desarrolladores, etc. sabemos lo importante que es para nosotros la linea de comandos, y que mejor si podemos aprender algunos trucos para agilizar ese trabajo, asi aqui les presento un par de ellos:

ctrl+r: Bash registra cada uno de los comandos que ejecutamos en una bitacora, y esta nos permite regresar a ellos cuando los necesitamos u olvidamos los parametros de un determinado comando que tanto trabajo nos costo construir; una de las formas de hacer esto es mediante las teclas de flecha hacia arriba y abajo, lo cual nos lleva a los comandos ingresados con anterioridad y navegar a travez de ellos. Pero si necesitamos encontrar el comando con mayor rapidez, podemos hacer uso de la busqueda rapida, esta busca entre los comandos ingresados aquellos que inician con las letras que ingresamos luego de la combinacion de teclas ctrl+r, Bash comenzara una busqueda y nos mostrara aquellos comandos que coinciden con las letras que estamos ingresando; si el comando mostrado no es el que estamos buscado, podemos seguir presionando ctrl+r para ir al siguiente resultado de la busqueda y asi sucesivamente; una vez encontrado el comando deseado, damos enter para ejecutarlo inmediatamente o las teclas de flechas izquierda o derecha para editarlo, en caso que deseamos editar la linea antes de ejecutarla.

!! y !#
Este es otro par de combinacion de simbolos que permiten agilizar nuestras actividades en Bash, el primero !! nos permite ejecutar exactamente el comando ingresado anteriormente. En cuanto al segundo, este nos permite ejecutar el comando #, donde el numero especificado es el numero asignado por la secuencia del comando history.

Por ejemplo, si al ejecutar el comando history, vemos el siguiente resultado: (salida ha sido truncada)
44 history
45 cd Backup/
46 history
47 yum
48 #?

Al ejecutar !45 equivale a ejecutar nuevamente el comando: cd Backup/

Pregunta: que almacena Bash en la variable denominada $?

Si conoces otros trucos de la linea de comandos, compartelos.