:(){ :|:& };:, ફોર્ક બોમ્બ આદેશ: તે કેવી રીતે કાર્ય કરે છે અને તમારી જાતને કેવી રીતે સુરક્ષિત કરવી

કમ્પ્યુટરની દુનિયામાં, ચોક્કસ આદેશો તેઓ પ્રથમ નજરમાં હાનિકારક લાગે છે, પરંતુ તેઓ એક વિનાશક શક્તિને છુપાવે છે જેનો ઉપયોગ દૂષિત અથવા આકસ્મિક રીતે થાય છે, સમગ્ર સિસ્ટમને વિનાશ તરફ દોરી શકે છે. આ આદેશો પૈકી, શ્રેષ્ઠ જાણીતા - અથવા નહીં - અને ભયભીત, કહેવાતા છે કાંટો બોમ્બ, અથવા કાંટો બોમ્બ.

ફોર્ક બોમ્બ એ ડિનાયલ-ઓફ-સર્વિસ (DoS) હુમલાના સ્વરૂપ સિવાય બીજું કંઈ નથી, ઉપલબ્ધ સિસ્ટમ સંસાધનોનો ઉપયોગ કરવા માટે રચાયેલ છે, જેમ કે CPU અને મેમરી, જ્યાં સુધી તે બિનઉપયોગી બની જાય છે. જો તમે ક્યારેય વિચાર્યું હોય કે આ આદેશ કેવી રીતે કાર્ય કરે છે, તે શા માટે આટલો હાનિકારક હોઈ શકે છે, અને તમે તમારી જાતને બચાવવા માટે કયા પગલાં લઈ શકો છો, તો અહીં તમને સુલભ અને વિગતવાર રીતે સમજાવાયેલ, તમારે જાણવાની જરૂર છે તે બધું મળશે.

ફોર્ક બોમ્બ શું છે?

ફોર્ક બોમ્બ, જેને "રેબિટ વાઈરસ" તરીકે પણ ઓળખવામાં આવે છે, કારણ કે તે ઝડપથી નકલ કરવાની તેની વૃત્તિ છે, તે એક તકનીક છે જે સિસ્ટમને સંતૃપ્ત કરવા માટે પ્રક્રિયાઓની સામૂહિક રચનાનો ઉપયોગ કરે છે ઓપરેશનલ યુનિક્સ અને લિનક્સ સિસ્ટમ્સ પર ઉપલબ્ધ ફોર્ક ફંક્શનનો ઉપયોગ કરતા આદેશ દ્વારા આ પ્રાપ્ત થાય છે. ફોર્ક ફંક્શન પ્રક્રિયાને પોતાની એક ચોક્કસ નકલ બનાવવા માટે પરવાનગી આપે છે, જેને બાળ પ્રક્રિયા તરીકે ઓળખવામાં આવે છે.

એ સાથે સંકળાયેલ સૌથી પ્રતિનિધિ આદેશ કાંટો બોમ્બ નીચેના છે:

: ()) {: |: &};:

આ આદેશમાં એક માળખું છે જે કોમ્પેક્ટ હોવા છતાં, અતિ શક્તિશાળી છે. તે શું કરે છે તે કાર્યને વ્યાખ્યાયિત કરે છે જેને કહેવાય છે :, જે પોતાને પુનરાવર્તિત રીતે બોલાવે છે, દરેક એક્ઝેક્યુશનમાં બે નવી પ્રક્રિયાઓ પેદા કરે છે જે ઓપરેટરને આભારી છે. પાઇપ | અને & સાથે પૃષ્ઠભૂમિમાં અમલ. પરિણામ એ પ્રક્રિયાઓની ઘાતાંકીય વૃદ્ધિ છે જે સેકન્ડોની બાબતમાં સિસ્ટમને પતન કરે છે.

ફોર્ક બોમ્બ કેવી રીતે કામ કરે છે?

આદેશ : ()) {: |: &};: તે શરૂઆતમાં મૂંઝવણભર્યું લાગે છે, તેથી ચાલો તેને તબક્કાવાર તોડીએ:

• :: આ પ્રતીક ફંક્શનનું નામ દર્શાવે છે. ખરેખર, તમે કોઈપણ નામનો ઉપયોગ કરી શકો છો.
• () { }: આ વાક્યરચના કોઈપણ પરિમાણો વિના કાર્યને વ્યાખ્યાયિત કરે છે.
• :|:: એકવાર વ્યાખ્યાયિત કર્યા પછી, ફંક્શન પોતાને અને ઑપરેટરને કૉલ કરે છે | તેના આઉટપુટને પોતાના એક નવા ઉદાહરણ પર રીડાયરેક્ટ કરે છે.
• &: આ પ્રતીક પૃષ્ઠભૂમિમાં કૉલને એક્ઝિક્યુટ કરે છે, પ્રક્રિયાઓની એક સાથે રચના કરવાની મંજૂરી આપે છે.
• ;: કાર્યની વ્યાખ્યા અને તેના પ્રારંભિક અમલ વચ્ચે વિભાજક તરીકે સેવા આપે છે.
• :: છેલ્લે, આ છેલ્લું પ્રતીક કાર્યને એક્ઝિક્યુટ કરે છે, જે પ્રક્રિયાઓનો કાસ્કેડ શરૂ કરે છે.

એકવાર દોડ્યા પછી, ફોર્ક બોમ્બ ઝડપથી સિસ્ટમ સંસાધનોનો ઉપયોગ કરે છે, નવી પ્રક્રિયાઓ ચલાવવાની ક્ષમતાને અવરોધિત કરવી અને સામાન્ય રીતે કમ્પ્યુટરને ફરજિયાત પુનઃપ્રારંભ કરવાની ફરજ પાડે છે.

સંવેદનશીલ સિસ્ટમો

વ્યવહારીક રીતે કોઈપણ યુનિક્સ અથવા લિનક્સ આધારિત ઓપરેટિંગ સિસ્ટમ, જેમ કે ઉબુન્ટુ, ડેબિયન અથવા રેડ હેટ, ફોર્ક બોમ્બ માટે સંવેદનશીલ છે, કારણ કે આ બધા ફોર્ક સિસ્ટમ કોલનો ઉપયોગ કરે છે. જો કે, સિસ્ટમ્સ વિન્ડોઝ તેઓ આ ચોક્કસ પ્રકારના હુમલા માટે સંવેદનશીલ નથી, કારણ કે તેમની પાસે કાંટો સમકક્ષ કાર્ય નથી. તેના બદલે, વિન્ડોઝ પર તમારે સમાન રીતે નવી પ્રક્રિયાઓનો સમૂહ બનાવવો પડશે, પરંતુ આને વધુ જટિલ અભિગમની જરૂર છે.

વિવિધ ભાષાઓમાં ફોર્ક બોમ્બના ઉદાહરણો

La કાંટો બોમ્બ તે બાશ માટે વિશિષ્ટ નથી; તે અન્ય પ્રોગ્રામિંગ ભાષાઓમાં લાગુ કરી શકાય છે. અહીં કેટલાક ઉદાહરણો છે:

પાયથોન ફોર્ક બોમ્બ

#!/usr/bin/env python os આયાત કરો જ્યારે True: os.fork()

જાવા ફોર્ક બોમ્બ

પબ્લિક ક્લાસ બોમ્બ { પબ્લિક સ્ટેટિક વોઈડ મેઈન(ફાઈનલ સ્ટ્રિંગ[] આર્ગ્સ) { જ્યારે (સાચું) { Runtime.getRuntime().exec("java Bomb"); } } }

સી ફોર્ક બોમ્બ

# સમાવેશ થાય છે પૂર્ણાંક મુખ્ય(રદબાતલ) { જ્યારે (1) { ફોર્ક(); } }

ફોર્ક બોમ્બની અસર

ફોર્ક બોમ્બની મુખ્ય અસર છે સિસ્ટમ ઓવરલોડ. CPU, મેમરી અને પ્રોસેસ ઇનપુટ્સ જેવા સંસાધનોનો ઝડપથી વપરાશ થાય છે, જેના કારણે સિસ્ટમ અસ્થિર અથવા પ્રતિભાવવિહીન બની જાય છે. મોટા ભાગના કિસ્સાઓમાં, તમારે એ ફરજિયાત ફરીથી પ્રારંભ કરો ફરીથી નિયંત્રણ મેળવવા માટે. વધુમાં, આપત્તિ દરમિયાન અચાનક એપ્લિકેશન વર્તણૂકને કારણે ડેટા ગુમાવવાનું નોંધપાત્ર જોખમ છે.

નિવારક પગલાં

જોકે કાંટો બોમ્બ વિનાશક હોઈ શકે છે, તેની અસર ઘટાડવાના અને તેને રોકવાના રસ્તાઓ છે. સંપૂર્ણપણે:

1. પ્રક્રિયાઓની સંખ્યા મર્યાદિત કરો

આદેશ મર્યાદા Linux માં તે તમને વપરાશકર્તા બનાવી શકે તેવી મહત્તમ પ્રક્રિયાઓની મર્યાદા સેટ કરવાની પરવાનગી આપે છે. ઉદાહરણ તરીકે:

ulimit -u 5000

આ વપરાશકર્તાને મહત્તમ હોવા માટે મર્યાદિત કરે છે 5000 સક્રિય પ્રક્રિયાઓ.

2. સતત મર્યાદાઓ ગોઠવો

કાયમી ધોરણે મર્યાદા લાગુ કરવા માટે, તમે ફાઇલમાં ફેરફાર કરી શકો છો /etc/security/limits.conf. ઉદાહરણ તરીકે:

સખત વપરાશકર્તા nproc 5000

આ સુનિશ્ચિત કરે છે કે વપરાશકર્તા લૉગ આઉટ થયા પછી પણ મર્યાદા ચાલુ રહે છે.

3. Cgroups નો ઉપયોગ

આધુનિક Linux સિસ્ટમો પર, cgroups (નિયંત્રણ જૂથો) તમને સિસ્ટમ સ્રોતો પર વધુ દાણાદાર નિયંત્રણ સ્થાપિત કરવાની મંજૂરી આપે છે, જેમાં સંખ્યાનો સમાવેશ થાય છે મંજૂરી પ્રક્રિયાઓ.

તમે સોશિયલ નેટવર્ક પર જે જુઓ છો તેના પર ધ્યાન ન આપો

આ પ્રકારના આદેશો સામાજિક નેટવર્ક્સ પર વ્યવહારિક મજાક તરીકે દેખાઈ શકે છે, તેથી આપણે સાવચેત રહેવું જોઈએ અને તેઓ અમને જે કહે છે તે ટર્મિનલમાં દાખલ ન કરવું જોઈએ. આગળ વધ્યા વિના, જો આપણે X માં "ફોર્ક બોમ્બ" મૂકીએ, તો આપણે જોઈએ છીએ પોસ્ટનો પ્રતિભાવ જે કહે છે "હેલો, ફોર્ક બોમ્બ." મૂળ પોસ્ટ, થોડી ક્ષણો પહેલા શેર કરવામાં આવી હતી, કહે છે કે નામની એક બિલાડી છે :(){ :|:& };: અને તમે તેને ટર્મિનલમાં મૂક્યું છે. અમે પહેલેથી જ સમજાવ્યું છે કે તે શું કરે છે, તેથી તે ન કરો.

ફોર્ક બોમ્બ, ખ્યાલમાં સરળ હોવા છતાં, નબળા સિસ્ટમો પર ઊંડી અસર કરે છે. તે કેવી રીતે કાર્ય કરે છે, તેની અસરો અને તેને ઘટાડવાની રીતો સમજવી આધુનિક કમ્પ્યુટિંગ વાતાવરણને સુરક્ષિત રાખવા માટે મહત્વપૂર્ણ છે. તે એક રીમાઇન્ડર છે કે કેવી રીતે એક સરળ આદેશ વિનાશક પરિણામો તરફ દોરી શકે છે, અને યોગ્ય સિસ્ટમોના વહીવટ અને સુરક્ષા સીમાઓ નક્કી કરવાના મહત્વની પણ.