fork-бомба

Рекурсивное порождение процессов, ведущее к отказу в обслуживании или падению системы

Fork-бомба — вредоносная или ошибочно написанная программа, бесконечно создающая свои копии (системным вызовом fork()), которые обычно также начинают создавать свои копии и т. д.

Выполнение такой программы может вызывать большую нагрузку вычислительной системы или даже отказ в обслуживании вследствие нехватки системных ресурсов (дескрипторов процессов, памяти, процессорного времени), что и является целью.

Программа классической fork-бомбы (написанная на языке Си) выглядит так:

 #include <unistd.h>
 
 int main()
 {
   while(1)
     fork();
 }

Схожими случаями утечки системных ресурсов являются программы, порождающие зомби и процессы-сироты. Однако, если большинство fork-бомб создаётся намеренно, то эти проблемы обычно являются результатом невнимательности или некомпетентности программиста.

Описание

fork-бомба порождает большое количество собственных копий и тем самым пытается заполнить свободное место в списке активных процессов операционной системы. После заполнения списка процессов становится невозможным старт полезной программы. Даже если какой-либо другой процесс прекратит работу и место в списке процессов освободится, то старт полезной программы маловероятен, так как множество других копий fork-бомбы уже ждут возможности запустить свою очередную копию.

Кроме заполнения списка процессов, возможны также стратегии заполнения виртуальной памяти, процессорного времени, сокетов и других системных ресурсов. Результатом исчерпания этих ресурсов становится замедление работы или практически остановка операционной системы и/или полезных программ (зависание компьютера).

Fork-бомба может быть получена и в результате ошибки при добросовестном программировании. Например, программа, слушающая сетевой порт, может при получении сетевого пакета или установлении соединения «упасть» в бесконечный цикл создания своих копий для обработки пакета или соединения. Простая ошибка программирования может привести к утечке памяти или к последствиям, характерным для результатов работы fork-бомбы.

Примеры fork-бомб на разных языках программирования

C:

#include <stdlib.h>

int main(void)
{
    for(;;) {
        system("start");
    }
}

или:

#include <unistd.h>

int main(void)
{
    while(fork()) {};
}

Bash:

 :(){ :|:& };:

или

fork() {
    fork | fork &
}
fork

Java:

public class forkbomb
{
	public static void main(String[] args)
	{
		Runtime.getRuntime().exec(new String[]{"javaw", "-cp", System.getProperty("java.class.path"), "forkbomb"});
	}
}

Perl:

 fork while fork

Python:

import os
 
while True:
    os.fork()

В некоторых системах такой вызов запрещен, копирование возможно только при сохранении идентификатора процесса:

import os
 
while True:
    a=os.fork()

Ruby:

fork while fork

Второй вариант:

loop { fork }

PHP:

<?php

while(true) {
    pcntl_fork();
}

Пакетный файл Microsoft Windows:

:s
start %0
goto :s

Второй вариант

start %0 %0

Вариант на VB.NET

Do System.Diagnostics.Process.Start(System.Reflection.Assembly.GetExecutingAssembly().Location) Loop While True

Псевдокод:

алг ПрограммаX
пока истина
   нц
      вызов ПрограммаX
   кц
кон алг ПрограммаX

Трудность ликвидации

В случае успешного срабатывания fork-бомбы становится трудным или практически невозможным восстановить нормальную работу ЭВМ без перезагрузки, так как единственный способ прекратить работу fork-бомбы — это одновременное прекращение работы всех работающих копий fork-бомбы. В большинстве реализаций операционных систем вызов команды для прекращения работы процесса требует запуска нового процесса, что в условиях успешно работающей fork-бомбы невозможно.

Однако, на практике некоторые fork-бомбы не требуют таких радикальных мер и могут быть уничтожены без необходимости перезагрузки. Рассмотрим, например, случай бомбы из примера выше:

 :(){ :|:& };:

Особенность этого кода в том, что он не зацикливается после неуспешного порождения своих копий, а завершает работу. В результате список процессов постоянно находится на грани заполнения: одна из копий fork-бомбы завершается, и освобождающееся место тут же занимается новосозданным процессом из другой копии fork-бомбы. Становится возможным конкурировать с fork-бомбой за захват места в списке процессов. Тогда возможно рано или поздно запустить команду для одновременного уничтожения всех копий-fork бомбы или запустить безопасную программу, которая будет постепенно «отвоёвывать» место в списке процессов до завершения работы последнего процесса fork-бомбы. Пример такой безопасной программы на zsh:

 while (sleep 100 &!) do; done

Предотвращение

Один из способов предотвращения негативных последствий работы fork-бомбы — принудительное ограничение количества процессов, которые пользователь может запустить одновременно. Также могут быть ограничены количество выделяемой виртуальной памяти и другие системные ресурсы. При исчерпании максимума доступных процессов попытка процесса создать новый процесс потерпит неудачу. Максимум запускаемых процессов должен быть таким, чтобы он позволял запустить разумное полезное количество программ, но не приводил к краху системы при одновременном запуске fork-бомбы от всех пользователей системы.

Необходимо отметить, что ограничение количества процессов само по себе не предотвращает запуск fork-бомбы, а лишь направлено на минимизацию возможного вреда в случае её срабатывания.

Другое решение проблемы — интеллектуальное распознавание fork-бомбы средствами самой операционной системы, но это решение не нашло широкого применения.

Существует и такая трудность, что если fork-бомба занимает всё доступное процессорное время, то результаты её работы могут быть катастрофическими не только на однопроцессорной, но и на многопроцессорной системе, даже при ограничении числа процессов. Например, если число процессоров 16, а максимум количества запущенных процессов 100, то на каждый процессор будет приходиться в среднем 6-7 работающих экземпляров fork-бомбы, пожирающих процессорное время. Для решения этой проблемы применяется ограничение по привязке к процессорам.

См. также

• fork() — системный вызов Unix-подобных операционных систем (согласно стандарту POSIX)
• Зомби и процессы-сироты — схожие случаи утечки системных ресурсов