¿Qué es una Bomba Fork?
Una bomba lógica fork es un código informático que produce un ataque de denegación de servicio (DOS), haciendo uso de la operación fork. Fork o bifurcación, en lenguaje de programación, consiste en hacer que un programa se replique a sí mismo, creando una serie de procesos hijos dependientes del proceso padre. Son procesos en cadena idénticos, que se replican hasta el infinito produciendo la saturación de los recursos de hardware de un sistema (CPU y RAM), y produciendo así la caída del sistema y/o la denegación del servicio (DOS).
Las bombas de fork se consideran un “wabbit”, pues a diferencia de virus o troyanos, no infectan documentos del sistema ni utilizan la red para replicarse. Se limitan a reproducirse en la máquina donde se ha ejecutado hasta hacerla caer consumiendo todos sus recursos físicos. El término “wabbit” viene de la peculiar forma en que «Elmer el Gruñón» (Warner Brothers), tartamudeando, pronuncia la palabra conejo. “You wascawwy wabbit!” – Elmer Fudd (inglés).
El creador de este pequeño código de tan sólo 11 caracteres es Denis Roio, conocido como “Jaromil”, programador de software libre, net-artista y hacktivista.
código:
este hermoso y elegante código, si se teclea en una consola o terminal de Linux con Bash, tendrá el demoledor efecto de congelar el sistema produciendo la inoperatividad del mismo. Los «wabbits» hacen esto a una velocidad de vértigo. La bomba fork saturará en décimas de segundo todos los recursos del microprocesador y la RAM y bloqueará la máquina. Como buen «wabbit» no estropeará nada, sino que una vez apretado el botón de apagado y reiniciado el sistema, todo estará ok.
Expliquemos brevemente la estructura de la bomba:
:() Define la función llamada. Esta función no admite argumentos.
:|: A continuación se llama a sí misma utilizando la recursividad y mediante un pipe canaliza la salida a “:”
& Ejecuta la función en segundo plano para que trabaje hasta colapsar el sistema.
; Este símbolo es necesario para terminar la definición de función en bash.
: Llama a ejecución la función contenida () y lanza la bomba.
¿Cómo podemos prevenirla?
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 padre intenta crear otro proceso hijo y el propietario de éste ya posee la cantidad máxima de procesos que se le ha asignado, el intento de creación de otros nuevos 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.
Los sistemas de tipo Unix típicamente tienen establecido este límite, y se controla con el comando “ulimit” de la 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á.
Algunos ejemplos de bombas fork en diferentes lenguajes de programación.
C++
======================
#include <unistd.h>
void main()
{
while(1)
fork();
}
======================
Bash
======================
:(){ :|:& };:
======================
Perl
======================
fork while fork
======================
Python
======================
import os
while True:
os.fork()
======================
Ruby
======================
def forkbomb
loop { fork { forkbomb } }
end; forkbomb
=======================
Batch Microsoft Windows
=======================
%0|%0
=======================
Otro script BATCH más rápido
=======================
:s
start «» %0
goto :s
=======================
Procedimiento para proteger el sistema de este tipo de ataque:
Básicamente consiste en controlar el número de procesos permitidos en el sistema, de modo que no llegue a colapsar nuestra máquina. Podemos configurar o establecer dicha limitación para usuarios y/o grupos específicos, o de modo general.
Es importante no poner unos límites por debajo de los procesos que necesita nuestro SO para funcionar, de lo contrario vamos a tener problemas. Escritorios como Gnome o KDE necesitan lanzar un número relativamente alto de procesos.
Para conocer el número de procesos que permite ejecutar el SO ejecutaremos el comando “ulimit”.
Si ejecutamos “ulimit –a”, obtendremos todos los parámetro que podemos modificar. Para el número de procesos basta con la opción “-u”:
$ ulimit –u (Ubuntu)
2835
$ ulimit –u (Fedora 22)
3897
Para obtener el número de procesos que está corriendo actualmente nuestro sistema ejecutamos “ps”:
$ ps aux | wc -l
Hacer los cambios permanentes después de reiniciar la máquina
Editamos como “root” el archivo “/etc/security/limits.conf” y estableceremos un límite máximo de procesos (escribiéndolo al final del archivo), éste debe de ser holgado. La orden tiene la siguiente sintáxis:
<dominio> <tipo> <valor> <límite>
Donde:
dominio puede ser:
– un nombre de usuario.
– un grupo, con la sintáxis @grupo.
– asterisco (*), para hacer la orden general a todos los usuarios y grupos.
tipo puede ser:
– «soft» para una limitación suave. Limita los procesos hasta el número indicado, pero permite que el usuario pueda aumentar ese número en caso necesario.
– «hard» para una limitación dura. No permite que el usuario cambie dicha limitación.
valor, para nuestro propósito será:
– «nproc» para indicar que el cambio se realizará sobre el número de procesos.
límite.
– Número de procesos limite.
Algunos ejemplos:
* hard nproc 500
Limita a 500 el número de procesos corriendo en el SO, para cualquier usuario o grupo.
usuario hard nproc 500
Limita a 500 los procesos para el usuario “usuario”.
@grupo hard nproc 500
Limita a 500 los procesos para todos los usuarios del grupo “grupo”.
El procedimiento es bastante sencillo pero muy importante para proteger nuestro sistema de esta forma de ataque.
Ahora si queréis hacer la prueba nada más que tenéis que copiar o escribir ese pequeño código en una SHELL Bash y veréis de primera mano como la máquina se cuelga inmediatamente.
«Now, it’s up to you!».
Saludos cordiales.
A Linux a Day 