🎽 🐂 👨‍🏫 और फिर से निष्कासन के खतरे के बारे में () ⚾️ ⏸️ ✊🏽

प्रश्न की चर्चा करते समय कितनी प्रतियाँ टूट गई थीं "क्या यह सुरक्षित बनाना संभव है?" - यह गिनती करना असंभव है। हमेशा कोई है जो दावा करता है कि इस कार्य को करने के सभी संभावित परिणामों से खुद को बचाने का एक तरीका मिल गया है।

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

संक्षेप में समस्या के बारे में

पायथन में एक अंतर्निहित फ़ंक्शन eval()

जो कोड की एक पंक्ति निष्पादित करता है और निष्पादन का परिणाम देता है:

 assert eval("2 + 3 * len('hello')") == 17

यह एक बहुत शक्तिशाली है, लेकिन एक ही समय में बहुत खतरनाक निर्देश है, खासकर अगर आप जिस रेखा से बाहर eval

हैं वह एक विश्वसनीय स्रोत से प्राप्त नहीं होता है। यदि हम eval

को खिलाने का निर्णय लेते हैं तो क्या होता है 'y is os.system('rm -rf /')

? दुभाषिया ईमानदारी से कंप्यूटर से सभी डेटा को हटाने की प्रक्रिया शुरू करेगा, और यह अच्छा है अगर इसे कम से कम विशेषाधिकार प्राप्त उपयोगकर्ता की ओर से निष्पादित किया जाता है (निम्नलिखित उदाहरणों में मैं rm -rf /

बजाय clear

( cls

अगर आप Windows का उपयोग करता हूं) का उपयोग करेंगे rm -rf /

ताकि कोई भी पाठक गलती से न हो पैर में गोली नहीं लगी )।

समाधान क्या हैं?

कुछ लोगों का तर्क है कि ग्लोबल्स के पात्रों तक पहुंच के बिना इसे चलाकर सुरक्षित बनाना संभव है। दूसरे (वैकल्पिक) तर्क के रूप में, eval()

एक शब्दकोष लेता है, जिसका उपयोग वैश्विक नाम स्थान (सभी वर्गों, विधियों, चर, आदि eval()

बजाय "शीर्ष" स्तर पर, कोड में कहीं से भी सुलभ) कोड द्वारा किया जाएगा, जो कि eval

द्वारा निष्पादित किया जाएगा। 'ओम। यदि इस तर्क के बिना eval

कहा जाता है, तो यह वर्तमान वैश्विक नामस्थान का उपयोग करता है जिसमें os

मॉड्यूल आयात किया जा सकता है। यदि आप एक खाली शब्दकोश पास करते हैं, तो eval

लिए वैश्विक नाम स्थान खाली हो जाएगा। यह कोड अब निष्पादित नहीं कर पाएगा और NameError: name 'os' is not defined

अपवाद को फेंक देगा NameError: name 'os' is not defined

:

 eval("os.system('clear')", {})

हालाँकि, हम अभी भी मॉड्यूल आयात कर सकते हैं और __import__

अंतर्निहित फ़ंक्शन का उपयोग करके उन्हें एक्सेस कर सकते हैं। इसलिए, नीचे दिया गया कोड बिना त्रुटियों के काम करेगा:

 eval("__import__('os').system('clear')", {})

अगले प्रयास में आम तौर पर __builtins__

तक पहुंच से वंचित करने का निर्णय शामिल होता है, क्योंकि 'ए' अंदर से, क्योंकि __import__ जैसे नाम हमारे लिए उपलब्ध हैं क्योंकि वे वैश्विक चर __builtins__

। यदि हम इसके बजाय स्पष्ट रूप से एक खाली शब्दकोश पास करते हैं, तो नीचे दिए गए कोड को निष्पादित नहीं किया जा सकता है:

 eval("__import__('os').system('clear')", {'__builtins__':{}}) # NameError: name '__import__' is not defined

अच्छा, अब, क्या हम सुरक्षित हैं?

कुछ हाँ कहते हैं और एक गलती करते हैं। उदाहरण के लिए, यह कोड का एक छोटा सा टुकड़ा है, जिसे अगर आप CPython में चलाते हैं, तो इसे segfault

कहेंगे:

 s = """ (lambda fc=( lambda n: [ c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == n ][0] ): fc("function")( fc("code")( 0,0,0,0,"KABOOM",(),(),(),"","",0,"" ),{} )() )() """ eval(s, {'__builtins__':{}})

तो, आइए जानें कि यहां क्या हो रहा है। आइए इसकी शुरुआत करें:

 ().__class__.__bases__[0]

जैसा कि कई लोग अनुमान लगा सकते हैं, यह object

तक पहुंचने का सिर्फ एक तरीका है। हम सिर्फ object

नहीं लिख सकते हैं, क्योंकि __builtins__

खाली है, लेकिन हम एक खाली टपल बना सकते हैं, जिसका पहला बेस क्लास object

और इसके गुणों से गुजरते हुए, क्लास object

एक्सेस करते हैं।

अब हमें उन सभी वर्गों की एक सूची मिलती है जो object

से प्राप्त object

या, दूसरे शब्दों में, कार्यक्रम में वर्तमान में घोषित सभी वर्गों की सूची:

 ().__class__.__bases__[0].__subclasses__()

यदि हम इस अभिव्यक्ति को ALL_CLASSES

लिए ALL_CLASSES

प्रतिस्थापित करते हैं, तो यह नोटिस करना आसान होगा कि नीचे दी गई अभिव्यक्ति अपने नाम से वर्ग ढूंढती है:

 [c for c in ALL_CLASSES if c.__name__ == n][0]

कोड में आगे, हमें दो बार कक्षा की खोज करनी होगी, इसलिए एक फ़ंक्शन बनाएं:

 lambda n: [c for c in ALL_CLASSES if c.__name__ == n][0]

किसी फ़ंक्शन को कॉल करने के लिए, आपको इसे किसी भी तरह से कॉल करने की आवश्यकता है, लेकिन चूंकि हम इस कोड को eval

के अंदर निष्पादित करेंगे 'a, हम न तो फ़ंक्शन को घोषित कर सकते हैं ( def

का उपयोग करके) और न ही असाइनमेंट ऑपरेटर का उपयोग किसी भी वेरिएबल पर हमारे लंबो को बांधने के लिए कर सकते हैं ।

हालाँकि, एक तीसरा विकल्प है: डिफ़ॉल्ट सेटिंग्स। एक लैम्ब्डा की घोषणा करते समय, साथ ही साथ किसी भी सामान्य फ़ंक्शन की घोषणा करते हुए, हम डिफ़ॉल्ट पैरामीटर सेट कर सकते हैं, इसलिए यदि हम सभी कोड को दूसरे लैम्ब्डा के अंदर रखते हैं और इसे डिफ़ॉल्ट पैरामीटर के रूप में सेट करते हैं, तो हम वह प्राप्त करेंगे जो हम चाहते हैं:

 (lambda fc=( lambda n: [ c for c in ALL_CLASSES if c.__name__ == n ][0] ): #         fc )()

इसलिए, हमारे पास एक फ़ंक्शन है जो कक्षाओं के लिए देख सकता है, और हम इसे नाम से एक्सेस कर सकते हैं। आगे क्या है? हम क्लास code

(आंतरिक वर्ग, इसका उदाहरण, उदाहरण के लिए, किसी फ़ंक्शन ऑब्जेक्ट की func_code

संपत्ति है) का एक ऑब्जेक्ट func_code

:

 fc("code")(0,0,0,0,"KABOOM",(),(),(),"","",0,"")

सभी प्रारंभिक मापदंडों में से, हम केवल कबाओम में रुचि रखते हैं। यह बाइटकोड का अनुक्रम है जो हमारी वस्तु का उपयोग करेगा, और, जैसा कि आप अनुमान लगा सकते हैं, यह अनुक्रम "अच्छा" नहीं है। वास्तव में, इसमें से कोई भी बायोटेक पर्याप्त होगा, क्योंकि ये सभी बाइनरी ऑपरेटर हैं जिन्हें स्टैक खाली होने पर बुलाया जाएगा, जो कि सीपीथॉन के सेगफॉल्ट का कारण बनेगा '। " काबूम " बस मजेदार लग रहा है, इस उदाहरण के लिए धन्यवाद lvh ।

इसलिए, हमारे पास वर्ग code

की एक वस्तु है, लेकिन हम इसे सीधे निष्पादित नहीं कर सकते हैं। फिर एक फ़ंक्शन बनाएं, जिसमें से कोड हमारी वस्तु होगी:

 fc("function")(CODE_OBJECT, {})

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

यहाँ फिर से पूरा कोड है:

 (lambda fc=(lambda n: [c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == n][0]): fc("function")(fc("code")(0,0,0,0,"KABOOM",(),(),(),"","",0,""),{})() )()

निष्कर्ष

इसलिए, मुझे आशा है कि अब किसी को कोई संदेह नहीं eval

कि eval

SECURE नहीं है , भले ही आप वैश्विक और अंतर्निहित वैरिएबल की पहुंच को हटा दें।

उपरोक्त उदाहरण में, हमने code

और function

कक्षाओं की वस्तुओं को बनाने के लिए object

क्लास के सभी उपवर्गों की एक सूची का उपयोग किया। ठीक उसी तरह से, आप किसी भी वर्ग को उस समय प्राप्त कर सकते हैं (और तत्काल) जिसे आप eval()

।

यहाँ एक और उदाहरण दिया जा सकता है:

 s = """ [ c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == "Quitter" ][0](0)() """ eval(s, {'__builtins__':{}})

Lib / site.py मॉड्यूल में क्विटर क्लास होता है, जो आपके द्वारा टाइप किए जाने पर quit()

दुभाषिया द्वारा मंगाई जाती है।

ऊपर दिया गया कोड इस वर्ग को ढूंढता है, उसे त्वरित करता है, और उसे कॉल करता है, जो दुभाषिया के काम को पूरा करता है।

अब हम खाली वातावरण में भाग गए, इस तथ्य के आधार पर कि लेख में निर्दिष्ट कोड हमारे कार्यक्रम का सभी कोड है।

एक वास्तविक एप्लिकेशन में eval

का उपयोग करने के मामले में, एक हमलावर उन सभी वर्गों तक पहुंच प्राप्त कर सकता है जो आप उपयोग करते हैं, ताकि उसकी क्षमताओं को व्यावहारिक रूप से कुछ भी सीमित न हो।

eval

सुरक्षित बनाने के ऐसे सभी प्रयासों के साथ समस्या यह है कि वे सभी blacklists के विचार पर आधारित हैं, उन सभी चीज़ों तक पहुँच को हटाने का विचार जो हम सोचते हैं कि eval

में उपयोग किए जाने पर खतरनाक हो सकते हैं। ऐसी रणनीति के साथ, व्यावहारिक रूप से जीत की कोई संभावना नहीं है, क्योंकि अगर कम से कम कुछ निषिद्ध पाया जाता है, तो सिस्टम कमजोर होगा।

जब मैं इस विषय पर शोध कर रहा था, मैं पायथन में eval

संरक्षित मोड में आया, जो इस समस्या को दूर करने का एक और प्रयास है:

 >>> eval("(lambda:0).func_code", {'__builtins__':{}}) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<string>", line 1, in <module> RuntimeError: function attributes not accessible in restricted mode

संक्षेप में, यह निम्नानुसार काम करता है: यदि __builtins__

अंदर eval

"आधिकारिक" वाले से अलग है, तो eval

संरक्षित मोड में चला जाता है, जो कुछ खतरनाक गुणों जैसे कार्यों के लिए func_code

तक पहुंच से func_code

करता है। इस विधा का अधिक विस्तृत विवरण यहां पाया जा सकता है , लेकिन जैसा कि हमने ऊपर देखा है , यह "चांदी की गोली" भी नहीं है।

फिर भी, eval

सुरक्षित है? यह कहना मुश्किल है यह मुझे लगता है कि एक हमलावर दो निचले अंडरस्कोर के साथ वस्तुओं तक पहुंच के बिना नुकसान नहीं पहुंचाएगा जो नाम को फ्रेम करते हैं, इसलिए यह संभव है कि दो कम अंडरस्कोर वाले सभी लाइनों को प्रसंस्करण से बाहर रखा जाए, तो हम सुरक्षित रहेंगे। शायद ...

पुनश्च

Reddit पर थ्रेड में, मुझे एक छोटा स्निपेट मिला , जो हमें eval में "मूल" __builtins__ प्राप्त करने की अनुमति देता है:

 [ c for c in ().__class__.__base__.__subclasses__() if c.__name__ == 'catch_warnings' ][0]()._module.__builtins__

और फिर से निष्कासन के खतरे के बारे में ()

संक्षेप में समस्या के बारे में

समाधान क्या हैं?

अच्छा, अब, क्या हम सुरक्षित हैं?

निष्कर्ष

पुनश्च

Habr के लिए पारंपरिक पीपीएस: मैं पीएम में सभी त्रुटियों, अशुद्धियों और टाइपोस के बारे में लिखने के लिए कहता हूं :)

More articles: