ഫോർക്ക് ബോംബ്
കമ്പ്യൂട്ടിംഗിൽ, ഫോർക്ക് ബോംബ് (റാബിറ്റ് വൈറസ് അല്ലെങ്കിൽ വാബിറ്റ് എന്നും അറിയപ്പെടുന്നു[1]) എന്നത് ഒരു സേവനങ്ങൾ നിഷേധിക്കുന്നതിനുള്ള ആക്രമണമാണ്, അതിൽ ലഭ്യമായ സിസ്റ്റം ഉറവിടങ്ങൾ ഇല്ലാതാക്കുന്നതിനും റിസോഴ്സിന്റെ കുറവ് കാരണം സിസ്റ്റത്തെ മന്ദഗതിയിലാക്കുകയോ തകരാറിലാക്കുകയോ ചെയ്യുന്ന പ്രക്രിയ തുടർച്ചയായി ആവർത്തിക്കുന്നു.
ചരിത്രം[തിരുത്തുക]
1978-ൽ, വാബിറ്റ് എന്ന ഫോർക്ക് ബോംബിന്റെ ആദ്യകാല വകഭേദം സിസ്റ്റം/360-ൽ പ്രവർത്തിക്കുന്നതായി റിപ്പോർട്ട് ചെയ്യപ്പെട്ടു. 1969-ൽ വാഷിംഗ്ടൺ യൂണിവേഴ്സിറ്റിയിലെ ബറോസ് 5500-ൽ റിപ്പോർട്ട് ചെയ്ത റാബിറ്റ്സ്(RABBITS) എന്ന സമാനമായ ആക്രമണത്തിൽ നിന്നാണ് ഇത് ഉണ്ടായത്.[1]
നടപ്പിലാക്കൽ[തിരുത്തുക]
ഫോർക്ക് ബോംബുകൾ തങ്ങളുടെ പുതിയ പകർപ്പുകൾ (ഫോർക്കിംഗ്) ആവർത്തിച്ച് സൃഷ്ടിച്ചുകൊണ്ട് പ്രവർത്തിക്കുന്നു, ഇത് സിപിയുവിന്റെ സമയം ചെലവഴിക്കുന്നത് കൂടുന്നു, കൂടാതെ അവ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ പ്രോസസ്സ് ടേബിൾ നിറയ്ക്കുകയും മറ്റ് ജോലികൾ നിയന്ത്രിക്കുന്നതിനോ പുതിയ പ്രോഗ്രാമുകൾ ആരംഭിക്കുന്നതിനോ സിസ്റ്റത്തിന് ബുദ്ധിമുട്ടുണ്ടാക്കുന്നു, ഇത് ഒടുവിൽ കമ്പ്യൂട്ടർ മന്ദഗതിയിലാക്കുന്നു അല്ലെങ്കിൽ സിസ്റ്റം ക്രാഷ് ആകുന്നു.[2][3]ഒരു ഫോർക്ക് ബോംബിന്റെ അടിസ്ഥാനപരമായ നിർവ്വഹണം എന്നത് അതിന്റെ പുതിയ പകർപ്പുകൾ സൃഷ്ടിച്ച് ആരംഭിക്കുന്ന അനന്തമായ ലൂപ്പാണ്.
യുണിക്സ് പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ ഫോർക്ക് ബോംബുകൾ ഫോർക്ക് സിസ്റ്റം കോൾ ഉപയോഗപ്പെടുത്തുന്നതിനായാണ് സാധാരണയായി ഈ കോഡ് എഴുതുന്നത്.[3]ഫോർക്ക് ചെയ്ത പ്രക്രിയകൾ യഥാർത്ഥ പ്രോഗ്രാമിന്റെ കൃത്യമായ പകർപ്പുകളായി ആരംഭിക്കുന്നു. ഫോർക്കിംഗിന് ശേഷം എക്‌സിക്യൂഷൻ പുനരാരംഭിക്കുമ്പോൾ, അതേ ഫോർക്കിംഗ് പ്രക്രിയയും ആരംഭിക്കുന്നു, കൂടുതൽ സമാനമായ പകർപ്പുകൾ സൃഷ്ടിക്കുന്നു. ഓരോ പുതിയ പകർപ്പും ലൂപ്പ് തുടരുന്നതിനാൽ ഇത് പ്രക്രിയകളിൽ ഒരു എക്‌സ്‌പോണൻഷ്യൽ വർദ്ധനവിന് കാരണമാകുന്നു, ഇത് സമാന പ്രക്രിയകളുടെ ദ്രുതഗതിയിലുള്ള വ്യാപനത്തിലേക്ക് നയിക്കുന്നു. ആധുനിക യുണിക്സ് സിസ്റ്റങ്ങളിൽ, ഒരു പ്രോസസ്സ് ഫോർക്ക് ചെയ്യുമ്പോൾ, അത് തുടക്കത്തിൽ പാരന്റ് പ്രോസസിന്റെ അതേ മെമ്മറി പങ്കിടുന്നു. പാരന്റ് അല്ലെങ്കിൽ ചൈൽഡ് പ്രക്രിയയിൽ മാറ്റം വരുത്താൻ ശ്രമിച്ചാൽ മാത്രമേ മെമ്മറി ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യപ്പെടുകയുള്ളൂ. ഈ കോപ്പി-ഓൺ-റൈറ്റ് മെക്കാനിസം സിസ്റ്റം മെമ്മറി അതിവേഗം ഉപയോഗപ്പെടുത്തുന്നതിൽ നിന്ന് ഫോർക്ക് ബോംബിനെ തടയുന്നു,[4]കാരണം ഇത് മെമ്മറി ഡ്യൂപ്ലിക്കേഷൻ ആവശ്യമായി വരുന്നത് വരെ വൈകിപ്പിക്കുന്നു.
മൈക്രോസോഫ്റ്റ് വിൻഡോസ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്ക് യുണിക്സ് ഫോർക്ക് സിസ്റ്റം കോളിന് തുല്യമായ പ്രവർത്തനക്ഷമതയില്ല;[5]അത്തരം ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിലെ ഫോർക്ക് ബോംബിന് നിലവിലുള്ളതിൽ നിന്ന് ഫോർക്ക് ചെയ്യുന്നതിനുപകരം ഒരു പുതിയ പ്രക്രിയ സൃഷ്ടിക്കേണ്ടതുണ്ട്.
ഒരു ക്ലാസിക് യുണിക്സ് ഷെൽ ഫോർക്ക് ബോംബ്, പലപ്പോഴും "കോളൻ ബോംബ്" എന്ന് വിളിക്കപ്പെടുന്നു, ഇത് ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്ന ഒരു ചെറിയ കോഡാണ്, ഇത് സൂചിപ്പിക്കുന്നത് :(){ :|:& };:അത് പശ്ചാത്തലത്തിൽ ആവർത്തിച്ച് വിളിക്കുകയും ചെയ്യുന്നു. സിസ്റ്റം പ്രതികരിക്കാതിരിക്കുകയും ക്രാഷാകുകയും ചെയ്യുന്നതുവരെയുള്ള പ്രക്രിയകളുടെ എണ്ണം വർദ്ധിച്ചുകൊണ്ടിരിക്കുന്നു. ഈ ലളിതമായ കോഡ് സ്‌നിപ്പെറ്റ്, എക്‌സിക്യൂട്ട് ചെയ്യുമ്പോൾ, വേഗത്തിൽ സ്വയം പെരുകി, സിസ്റ്റത്തിന്റെ പ്രോസസ്സ് പരിധിയെ മറികടക്കുകയും അത് മരവിപ്പിക്കുകയോ ഉപയോഗശൂന്യമാവുകയോ ചെയ്യുന്നു.[6]
കൂടുതൽ എളുപ്പത്തിൽ മനസ്സിലാക്കാൻ കഴിയുന്ന ഒരു ഉദാഹരണം:
fork() {
fork | fork &
}
fork
അവലംബം[തിരുത്തുക]
- ↑ 1.0 1.1 Raymond, Eric S. (October 1, 2004). "wabbit". The Jargon Lexicon. Archived from the original on May 15, 2012. Retrieved October 15, 2013.
- ↑ Ye, Nong (2008). Secure Computer and Network Systems: Modeling, Analysis and Design. p. 16. ISBN 978-0470023242.
- ↑ 3.0 3.1 Jielin, Dong (2007). Network Dictionary. p. 200. ISBN 978-1602670006.
- ↑ Dhamdhere, Dhananjay M. (2006). Operating Systems: A Concept-based Approach. p. 285. ISBN 0-07-061194-7.
- ↑ Hammond, Mark (2000). Python Programming On Win32: Help for Windows Programmers. p. 35. ISBN 1565926218.
- ↑ Michal Zalewski (1999-08-19). "[RHSA-1999:028-01] Buffer overflow in libtermcap tgetent()". muc.lists.bugtraq. Web link. "
bash$ :(){ :|:&};:}".