En gaffelbomb är ett skadligt eller felaktigt skrivet program som i oändlighet skapar kopior av sig själv (med hjälp av systemanropet fork() ), som vanligtvis också börjar skapa kopior av sig själv osv.
Utförandet av ett sådant program kan orsaka en stor belastning på datorsystemet eller till och med ett överbelastningsskydd på grund av brist på systemresurser (processhandtag, minne, processortid), vilket är målet.
Det klassiska gaffelbombprogrammet (skrivet i C ) ser ut så här:
#include <unistd.h> int main () { medan ( 1 ) gaffel (); }Liknande fall av systemresursläckor är program som skapar zombies och föräldralösa processer . Men om de flesta gaffelbomber skapas avsiktligt, är dessa problem vanligtvis resultatet av vårdslöshet eller inkompetens hos programmeraren.
Gaffelbomben skapar ett stort antal kopior av sig själv och försöker därigenom fylla det lediga utrymmet i listan över aktiva processer i operativsystemet . Efter att ha fyllt i listan med processer blir det omöjligt att starta ett användbart program. Även om någon annan process avslutas och utrymme i processlistan blir ledigt, är det osannolikt att ett användbart program kommer att starta, eftersom många andra kopior av gaffelbomben redan väntar på möjligheten att starta sin nästa kopia.
Förutom att fylla i listan med processer, är strategier också möjliga för att fylla i virtuellt minne, CPU-tid, sockets och andra systemresurser. Resultatet av uttömningen av dessa resurser är att sakta ner eller praktiskt taget stoppa operativsystemet och/eller användbara program ( datorn fryser ).
En gaffelbomb kan också erhållas som ett resultat av ett fel i samvetsgrann programmering. Till exempel kan ett program som lyssnar på en nätverksport, när det tar emot ett nätverkspaket eller upprättar en anslutning, "falla" in i en ändlös loop av att skapa kopior av sig själv för att bearbeta paketet eller anslutningen. Ett enkelt programmeringsfel kan leda till en minnesläcka eller konsekvenserna av en gaffelbomb.
eller:
#include <unistd.h> int main ( void ) { while ( gaffel ()) {}; } : (){ : | : & } ; :eller
gaffel () { gaffel | gaffel & } gaffelJava :
public class forkbomb { public static void main ( String [] args ) { Runtime . getRuntime (). exec ( ny sträng [] { "javaw" , "-cp" , System . getProperty ( "java.class.path" ), "gaffelbomb" }); } }Perl :
gaffel medan gaffelPython :
importera os medan Sant : os . gaffel ()I vissa system är ett sådant samtal förbjudet, kopiering är endast möjlig om process-ID sparas:
importera os medan Sant : a = os . gaffel ()rubin :
gaffel medan gaffelAndra alternativet:
loop { gaffel } <?php while ( sant ) { pcntl_fork (); } : s start %0 goto : sAndra alternativet
starta %0 %0Variant på VB.NET
DoSystem . _ diagnostik . process . Start ( System . Reflektion . Assembly . GetExecutingAssembly ( ). Plats ) Loop While True alg ProgramX medan true nc anropar ProgramX cc con alg ProgramXI händelse av en framgångsrik gaffelbomb blir det svårt eller nästan omöjligt att återställa datorns normala funktion utan att starta om, eftersom det enda sättet att stoppa gaffelbomben från att fungera är att samtidigt stoppa alla körande kopior av gaffelbomben. I de flesta operativsystemimplementeringar kräver anrop av ett kommando för att döda en process att en ny process startas, vilket inte är möjligt under villkoren för en framgångsrik gaffelbomb.
Men i praktiken kräver vissa gaffelbomber inte så drastiska åtgärder och kan förstöras utan att behöva startas om. Tänk till exempel på bombfallet från exemplet ovan:
: (){ : | : & } ; :Det speciella med denna kod är att den inte loopar efter den misslyckade genereringen av dess kopior, utan går ut. Som ett resultat är listan över processer ständigt på väg att fyllas: en av kopiorna av gaffelbomben avslutas, och det frigjorda utrymmet ockuperas omedelbart av en nyskapad process från en annan kopia av gaffelbomben. Det blir möjligt att konkurrera med gaffelbomben om plats i processlistan. Då är det förr eller senare möjligt att köra ett kommando för att döda alla kopior av gaffelbomben samtidigt, eller att köra ett säkert program som gradvis kommer att "återta" en plats i listan över processer fram till den sista processen av gaffeln bomben upphör. Ett exempel på ett sådant säkert program i zsh :
medan ( sömn 100 & ! ) gör ; GjortEtt sätt att förhindra de negativa effekterna av en gaffelbomb är att kraftfullt begränsa antalet processer som en användare kan köra samtidigt. Mängden tilldelat virtuellt minne och andra systemresurser kan också vara begränsade. När det maximala antalet tillgängliga processer är slut, kommer processens försök att skapa en ny process att misslyckas. Det maximala antalet processer som kan startas bör vara sådant att det låter dig köra ett rimligt användbart antal program, men leder inte till en systemkrasch när en gaffelbomb avfyras från alla användare av systemet samtidigt.
Det bör noteras att en begränsning av antalet processer i sig inte hindrar lanseringen av en gaffelbomb, utan syftar endast till att minimera möjlig skada om den utlöses.
En annan lösning på problemet är den intelligenta igenkänningen av gaffelbomben med hjälp av själva operativsystemet, men denna lösning har inte fått någon bred tillämpning.
Det finns också en sådan svårighet att om en gaffelbomb tar all tillgänglig processortid kan resultaten av dess arbete vara katastrofala inte bara på en enda processor utan också på ett multiprocessorsystem, även med en begränsning av antalet processer . Till exempel, om antalet processorer är 16 och det maximala antalet körande processer är 100, kommer det för varje processor att finnas i genomsnitt 6-7 körande instanser av gaffelbomben, vilket slukar processortid. För att lösa det här problemet tillämpas en gräns för processoraffinitet.