Professional Documents
Culture Documents
Grupo: S8
Fecha: 01/10/15
Proyecto: Bomba Fork e Hilos (Thread)
Bomba FORK.
Una bomba fork es un ataque de tipo DoS para sistemas operativos.
Se le ha nombrado as por la funcin fork() de UNIX, encargada de crear
procesos hijos y base de este ataque.
Mediante unas pocas lneas de cdigo ejecutadas por cualquier usuario
de manera local, se puede tumbar cualquier mquina en cuestin de
segundos.
No es algo que se pueda parchear fcilmente debido a que no es ningn
fallo ni ninguna vulnerabilidad. Tampoco se puede identificar como virus
o malware, porque tampoco lo es. Una bomba fork suele hacer uso de
algo tan sencillo como un bucle infinito dentro del cual se crea un
proceso hijo.
De esta manera, el nmero de procesos en el sistema crece de forma
incontrolada hasta consumir los recursos de la mquina (memoria RAM y
procesador), quedando colgada.
El resultado?
Pues que hay que reiniciar a las bravas (lase tirando del cable o
pulsando el botn), pero nada ms. No supone ningn peligro, salvo que
estemos trabajando con algn documento y no hayamos guardado.
En resumidas cuentas, la bomba fork no es un agujero en la seguridad
de los sistemas operativos porque no produce ningn dao, porque lo
tiene que ejecutar el propio usuario del sistema y porque es ms bien
una caracterstica de los lenguajes de programacin y el resultado de un
programador oscioso. Vamos, que es lo mismo que tirar del cable de
alimentacin queriendo. Aun as, no deja de ser una bonita curiosidad.
Vamos a ver unos ejemplos. Empecemos con Linux. Existe una bomba
fork para este sistema que tiene el honor de ser considerada la bomba
ms bonita jams creada, tanto por su simplicidad como por su
elegancia. El cdigo es el siguiente:
funcion() {
funcion | funcion &
};
funcion
forkbomb Ahora est mucho ms claro: definimos una funcin y luego la
llamamos. Dentro de la misma, se llama a s misma y el resultado se
pasa por una tubera a ella misma de nuevo y todo estos se ejecuta en
segundo plano (carcter &). Es decir, de cada proceso salen dos
nuevos, y de cada uno de ellos, otros dos, y as hasta que el sistema
operativo lo permita.
Hilos (Threads)
Los threads son un concepto fundamental en lo que se conoce como
"programacin concurrente".
Un proceso es el resultado de una tcnica que emplean los sistemas
operativos para permitir la ejecucin simultnea de distintas
aplicaciones. Esta tcnica consiste en dejar correr a una aplicacin por
un tiempo, digamos 10 ms. Cuando se agota el tiempo, el kernel del SO
retoma el control y se lo entrega a otra aplicacin. Al mismo tiempo que
el SO cambia el control de una aplicacin a otra, tambin intercambia,
por cada aplicacin, informacin adicional tal como:
Qu archivos estn abiertos.
La memoria de la aplicacin.
La pila de ejecucin.
Mientras tanto Linux creca y creca, pero solamente tena procesos. Las
primeras versiones de Java tenan que, en Linux, simular la existencia de
los threads. Linus Torvalds, el creador de Linux, siempre pens que los
threads eran algo muy parecido a los procesos, tan parecidos que deban
ser lo mismo. Mientras que un proceso nace de un fork "completo", los
threads vendran a ser el resultado de un fork parcial, en el que en vez
de duplicar todo el contexto, el proceso hijo mantenga parte de l
compartido con el padre. Entonces se cre una llamada al sistema que
permite decirla al sistema cules partes del contexto se desean duplicar,
esta llamada es clone().
Sin embargo, la forma estndar de manipular threads en UNIX (conocida
como pthreads) no era del todo compatible con esta conceptualizacin.
Por ejemplo espera que cada thread vea el mismo "identificadoe de
proceso", y con el mecanismo de Linux eso no era posible, ya que cada
thread era un proceso distinto.
A travs de los aos Linux fue aadiendo funciones para dar mejor
soporte a una API pthreads. La implementacin actual de pthreads
(conocida como NPTL) lleg actualmente a ofrecer el manejo exacto que
ofrecen otros sistemas.
Cmo se usan: La API (pthreads)
Veamos cmo es esa API...
thread
Un puntero en donde la funcin guardar el identificador del nuevo
thread creado.
attr
Atributos del thread, puede ser NULL.
funcion
Ac empieza la ejecucin del nuevo thread. Es un puntero a una
funcin declarada de esta manera: void mi_thread(void *arg);.
arg
Parmetro a pasar a la funcin del nuevo thread
Qu pas ac?
El thread A mir, vio algo y se dispuso a actuar, pero cuando actu
alguien se le haba metido en el medio. El mundo ya no era el que era
cuando l tom la decisin de actuar. El problema, generalizado, es el
espacio de tiempo que hay entre mirar y actuar, cuando el mundo en el
que se mira es compartido por ms de un actor. A este tipo de
problemas se les llama condicin de carrera (en ingls race condition),
porque son como una competencia.
La solucin del problema
Para evitar el caso que expuse lo que se hace es establecer un lock, un
bloqueo. La API de threads provee algunos conceptos para hacer esto.
Uno de esos conceptos es el mutex. Un slo thread puede tomar el
mutex por vez, Si otro thread intenta tomar el mismo mutex, el segundo
thread se bloquea hasta que el primero suelte ese mutex.
using System;
using System.Threading;
public class Worker
{
// This method will be called when the thread is started.
public void DoWork()
{
while (!_shouldStop)
{
Console.WriteLine("worker thread: working...");
}
Console.WriteLine("worker thread: terminating gracefully.");
}
public void RequestStop()
{
_shouldStop = true;
}
// Volatile is used as hint to the compiler that this data
// member will be accessed by multiple threads.
private volatile bool _shouldStop;
}
public class WorkerThreadExample
{
static void Main()
{
// Create the thread object. This does not start the thread.
Worker workerObject = new Worker();
Thread workerThread = new Thread(workerObject.DoWork);
// Start the worker thread.
workerThread.Start();
Console.WriteLine("main thread: Starting worker thread...");
// Loop until worker thread activates.
while (!workerThread.IsAlive);
// Put the main thread to sleep for 1 millisecond to
// allow the worker thread to do some work:
Thread.Sleep(1);
// Request that the worker thread stop itself:
workerObject.RequestStop();
// Use the Join method to block the current thread
// until the object's thread terminates.
workerThread.Join();
Console.WriteLine("main thread: Worker thread has terminated.");
}