ग्रूवी स्क्रिप्ट के लिए बेहतर सैंडबॉक्सिंग

अनुवादक से: सीयूबीए प्लेटफ़ॉर्म को विकसित करते समय , हम इस फ्रेमवर्क को एप्लिकेशन व्यवसाय तर्क के अधिक लचीले विन्यास के लिए कस्टम स्क्रिप्ट निष्पादित करने की क्षमता रखते हैं। चाहे यह अवसर अच्छा हो या बुरा (और हम केवल सीयूबीए के बारे में बात नहीं कर रहे हैं) पर लंबे समय से बहस चल रही है, लेकिन यह तथ्य कि उपयोगकर्ता स्क्रिप्ट के निष्पादन पर नियंत्रण आवश्यक है, कोई प्रश्न नहीं उठाता है। कस्टम स्क्रिप्ट के निष्पादन के प्रबंधन के लिए ग्रूवी की उपयोगी विशेषताओं में से एक Cdric Champeau के अनुवाद में प्रस्तुत किया गया है। इस तथ्य के बावजूद कि उन्होंने हाल ही में ग्रूवी विकास टीम को छोड़ दिया, प्रोग्रामर का समुदाय आने वाले लंबे समय के लिए अपने मजदूरों का लाभ उठाता दिख रहा है।

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

यह पोस्ट आपको बताएगा

• क्यों आंतरिक dsl लिखने के लिए groovy अच्छा है
• आपके आवेदन की सुरक्षा के संदर्भ में इसकी विशेषताएं क्या हैं
• कैसे DSL सुधार करने के लिए संकलन कॉन्फ़िगर करने के लिए
• SecureASTCustomizer के मूल्य के बारे में
• प्रकार नियंत्रण एक्सटेंशन के बारे में
• सैंडबॉक्सिंग को प्रभावी बनाने के लिए टाइप कंट्रोल एक्सटेंशन का उपयोग कैसे करें

उदाहरण के लिए, कल्पना करें कि आपको क्या करने की आवश्यकता है ताकि उपयोगकर्ता गणितीय अभिव्यक्तियों की गणना कर सके। एक कार्यान्वयन विकल्प एक आंतरिक डीएसएल को एम्बेड करना, एक पार्सर बनाना और अंत में इन अभिव्यक्तियों के लिए एक दुभाषिया है। ऐसा करने के लिए, निश्चित रूप से, आपको काम करना होगा, लेकिन अगर आपको उत्पादकता बढ़ाने की आवश्यकता है, उदाहरण के लिए, इंटरप्रेटर में गणना करने के बजाय भावों के लिए बायटेकोड उत्पन्न करके या रनटाइम में उत्पन्न कक्षाओं के कैशिंग का उपयोग करना है, तो ग्रूवी एक बढ़िया विकल्प है।

प्रलेखन में वर्णित कई विकल्प हैं, लेकिन सबसे सरल उदाहरण सिर्फ Eval क्लास का उपयोग करना है:

Example.java

 int sum = (Integer) Eval.me("1+1"); 

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

 1+1 x+y 1+(2*x)**y cos(alpha)*r v=1+x 

लेकिन निश्चित रूप से नहीं

 println 'Hello' (0..100).each { println 'Blah' } Pong p = new Pong() println(new File('/etc/passwd').text) System.exit(-1) Eval.me('System.exit(-1)') // a script within a script! 

यह यहां है कि कठिनाइयां शुरू होती हैं, और यह भी स्पष्ट हो जाता है कि हमें कई समस्याओं को हल करने की आवश्यकता है:

• भाषा की व्याकरण को उसकी क्षमताओं के सबसेट तक सीमित करता है
• उपयोगकर्ताओं को प्रदान किए गए कोड को निष्पादित करने से रोकें
• दुर्भावनापूर्ण कोड के निष्पादन को रोकें

कैलकुलेटर का उदाहरण काफी सरल है, लेकिन अधिक जटिल डीएसएल के लिए, लोग यह नहीं देख सकते हैं कि वे समस्याग्रस्त कोड लिख रहे हैं, खासकर यदि डीएसएल इतना सरल है कि इसका उपयोग गैर-डेवलपर्स द्वारा किया जा सकता है ।

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

वास्तव में, कई लोगों की समान आवश्यकताएं हैं। पिछले 4 वर्षों में, मैंने बहुत से ऐसे लोगों से बात की है जिनके पास एक ही सवाल है: मैं उपयोगकर्ताओं को ग्रूवी लिपियों में बकवास करने से कैसे रोक सकता हूं?

अनुकूलन संकलक

उस समय, मेरे पास पहले से ही अपना निर्णय था और मुझे पता था कि अन्य लोगों ने भी कुछ इसी तरह का विकास किया है। अंत में, गिलियूम लाफॉर्ग ने सुझाव दिया कि मैं इन समस्याओं को हल करने में मदद करने के लिए ग्रूवी कर्नेल में एक तंत्र बनाता हूं। यह संकलन कस्टमाइज़र के रूप में ग्रूवी 1.8.0 में दिखाई दिया।

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

• आयात कस्टमाइज़र जो स्क्रिप्ट में आयात जोड़ता है, इसलिए उपयोगकर्ताओं को आयात विवरण जोड़ने की आवश्यकता नहीं है
• Customizer AST (Abstract Syntax Tree) परिवर्तन, आपको स्क्रिप्ट में सीधे एएसटी रूपांतरण जोड़ने की अनुमति देता है
• सुरक्षित एएसटी कस्टमाइज़र एक भाषा के व्याकरण और वाक्य रचना को प्रतिबंधित करता है

एएसटी ट्रांसफ़ॉर्मेशन के कस्टमाइज़र ने मुझे @ThreadInterrupt ट्रांसफ़ॉर्मेशन के साथ अंतहीन लूप की समस्या को हल करने में मदद की, लेकिन SecureASTCustomizer वह चीज़ है जो संभवतः अधिकांश मामलों में बहुत गलत समझा जाता है।

मुझे इसके लिए माफी मांगनी चाहिए। तब मैं बेहतर नाम के साथ नहीं आ सकता था। "SecureASTCustomizer" नाम का सबसे महत्वपूर्ण हिस्सा एएसटी है । इस तंत्र का उद्देश्य कुछ एएसटी कार्यों तक पहुंच को सीमित करना था। शीर्षक में "सुरक्षित" शब्द आम तौर पर शानदार है, और मैं समझाऊंगा कि क्यों। यहां तक ​​कि जेनकिन्स-प्रसिद्ध कोसुके कवागुची द्वारा एक ब्लॉग पोस्ट भी है, जिसका शीर्षक है "घातक ग्रूवी सिक्योरकैस्टमाइज़र" । और वहां सब कुछ बहुत सही लिखा गया है। SecureASTCustomizer सैंडबॉक्सिंग के लिए डिज़ाइन नहीं किया गया था। यह संकलन समय पर भाषा को सीमित करने के लिए बनाया गया था, लेकिन निष्पादन नहीं। अब मुझे लगता है कि सबसे अच्छा नाम GrammarCustomizer होगा। लेकिन, जैसा कि आप निश्चित रूप से जानते हैं, कंप्यूटर विज्ञान में तीन कठिनाइयाँ हैं: कैश अमान्य होना, नामों का आविष्कार करना, और प्रति यूनिट एक त्रुटि।

अब कल्पना करें कि आप अपनी स्क्रिप्ट की सुरक्षा सुनिश्चित करने के लिए एक साधन के रूप में सुरक्षित एएसटी कस्टमाइज़र पर विचार कर रहे हैं, और आपका कार्य उपयोगकर्ता को स्क्रिप्ट से System.exit को System.exit से रोकना है। दस्तावेज़ में कहा गया है कि कॉल को विशेष रिसीवरों में ब्लैक या व्हाइट लिस्ट बनाकर वर्जित किया जा सकता है। यदि सुरक्षा की आवश्यकता है, तो मैं हमेशा श्वेत सूचीवादियों को सलाह देता हूं कि कड़ाई से राज्य को अनुमति दी जाए, लेकिन अश्वेत नहीं जो किसी भी चीज का निषेध करते हैं। क्योंकि हैकर्स हमेशा वही सोचते हैं जो आपने नहीं माना होगा। मैं एक उदाहरण दूंगा।

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

 public class Sandbox { public static void main(String[] args) { CompilerConfiguration conf = new CompilerConfiguration(); SecureASTCustomizer customizer = new SecureASTCustomizer(); customizer.setReceiversBlackList(Arrays.asList(System.class.getName())); conf.addCompilationCustomizers(customizer); GroovyShell shell = new GroovyShell(conf); Object v = shell.evaluate("System.exit(-1)"); System.out.println("Result = " +v); } } 

1. संकलक विन्यास बनाएँ
2. सुरक्षित एएसटी कस्टमाइज़र बनाएँ
3. घोषित करें कि System कॉल के रिसीवर के रूप में System वर्ग को ब्लैकलिस्ट किया गया है
4. कंपाइलर कॉन्फ़िगरेशन में कस्टमाइज़र जोड़ें
5. शेल स्क्रिप्ट के साथ कॉन्फ़िगरेशन को बांधें, अर्थात, सैंडबॉक्स बनाने का प्रयास करें
6. "खराब" स्क्रिप्ट चलाएँ
7. स्क्रिप्ट चलाने का परिणाम प्रदर्शित करें

यदि आप इस वर्ग को चलाते हैं, तो स्क्रिप्ट निष्पादन के दौरान एक त्रुटि होगी:

 General error during canonicalization: Method calls not allowed on [java.lang.System] java.lang.SecurityException: Method calls not allowed on [java.lang.System] 

यह निष्कर्ष एक सुरक्षित एएसटी कस्टमाइज़र के साथ एक आवेदन द्वारा जारी किया गया है, जो System क्लास के तरीकों के निष्पादन की अनुमति नहीं देता है। सफलता! इसलिए हमने अपनी स्क्रिप्ट की रक्षा की है! लेकिन एक मिनट रुकिए ...

SecureASTCustomizer हैक हो गया है!

संरक्षण, कहना? लेकिन अगर मैं ऐसा करूँ तो:

 def c = System c.exit(-1) 

यदि आप प्रोग्राम को फिर से चलाते हैं, तो आप देखेंगे कि यह त्रुटि के बिना और स्क्रीन पर परिणाम प्रदर्शित किए बिना क्रैश हो जाता है। प्रक्रिया निकास कोड -1 है, जिसका अर्थ है कि उपयोगकर्ता स्क्रिप्ट को चलाया गया है! क्या हुआ? संकलित समय पर, सुरक्षित एएसटी कस्टमाइज़र यह पहचानने में असमर्थ है कि c.exit सिद्धांत रूप में System विधि का एक कॉल है क्योंकि यह एएसटी स्तर पर काम करता है! यह विधि कॉल का विश्लेषण करता है, और इस मामले में, विधि कॉल c.exit(-1) , फिर यह रिसीवर को निर्धारित करता है और जांचता है कि क्या यह सफेद (या काला) सूची में है। इस स्थिति में, रिसीवर c , इस चर को def के माध्यम से घोषित किया जाता है , और इसे Object रूप में घोषित करने के समान है, और सुरक्षित AST कस्टमाइज़र सोचेंगे कि चर c का प्रकार Object , System नहीं!

सामान्य तौर पर, सुरक्षित एएसटी कस्टमाइज़र पर बनाए गए विभिन्न कॉन्फ़िगरेशनों के आसपास आने के कई तरीके हैं। यहाँ कुछ अच्छे हैं:

 ((Object)System).exit(-1) Class.forName('java.lang.System').exit(-1) ('java.lang.System' as Class).exit(-1) import static java.lang.System.exit exit(-1) 

और भी बहुत कुछ हो सकता है। ग्रूवी का गतिशील स्वभाव संकलन के समय इन मुद्दों को ठीक करने की क्षमता को रोकता है। हालाँकि, एक समाधान मौजूद है। एक विकल्प मानक जेवीएम सुरक्षा प्रबंधक पर भरोसा करना है। हालांकि, यह पूरी प्रणाली के लिए तुरंत एक भारी और बड़ा समाधान है, और यह गौरैया पर तोप दागने के बराबर है। इसके अलावा, यह सभी मामलों में काम नहीं करता है, उदाहरण के लिए, यदि आप पढ़ने वाली फ़ाइलों को प्रतिबंधित करना चाहते हैं, लेकिन नहीं बना रहे हैं ...

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

• जिम व्हाइट द्वारा SecureScript
• कोसुके कावागुची द्वारा ग्रूवी सैंडबॉक्स
• शमौन मंदिर द्वारा ग्रूवी सैंडबॉक्स

हालाँकि, इनमें से कोई भी कार्यान्वयन पूरी तरह से विश्वसनीय और सुरक्षित नहीं है। उदाहरण के लिए, कोसुके का संस्करण कैशिंग कॉल साइट के आंतरिक कार्यान्वयन की हैक पर आधारित है। समस्या यह है कि यह ग्रूवी के चालान किए गए संस्करण के साथ संगत नहीं है, और ये आंतरिक वर्ग ग्रूवी के भविष्य के संस्करणों में नहीं होंगे। दूसरी ओर, साइमन का संस्करण एएसटी परिवर्तनों पर आधारित है, लेकिन कई संभावित छिद्रों को छोड़ देता है।

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

 xml { cars { // cars is a method call on an implicit this: "this".cars(...) car(make:'Renault', model: 'Clio') } } 

आज तक, मुझे अभी भी ग्रूवी में मेटा-ऑब्जेक्ट प्रोटोकॉल की वास्तुकला के कारण इस समस्या को हल करने का एक तरीका नहीं मिला है, जो इस तथ्य पर आधारित है कि जब रिसीवर किसी अन्य रिसीवर पर स्विच करने से पहले, विधि को नहीं पा सकता है, तो एक अपवाद फेंकता है। संक्षेप में, इसका मतलब है कि वास्तविक विधि कॉल से पहले आप रिसीवर के प्रकार का पता नहीं लगा सकते हैं। और अगर कॉल पास हो गया, तो बहुत देर हो चुकी है ...

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

प्रकार की जाँच

आइए SecureASTCustomizer के साथ मुख्य समस्या पर लौटते हैं: यह एक अमूर्त वाक्यविन्यास पेड़ के साथ काम करता है और इसमें विशिष्ट संदेश प्रकारों और रिसीवरों के बारे में जानकारी नहीं होती है। लेकिन ग्रूवी 2 के साथ, ग्रूवी ने संकलन जोड़ा है, और ग्रूवी 2.1 में हमने टाइप चेकिंग के लिए एक्सटेंशन जोड़े हैं।

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

क्या होगा अगर, पार्सर के परिणामों का उपयोग करने के बजाय, हम जाँच के प्रकार से जानकारी पर भरोसा कर सकते हैं? उस कोड को लें जिसे हमारे हैकर ने लिखने की कोशिश की थी:

((Object)System).exit(-1)

यदि आप चेक टाइप करते हैं, तो कोड संकलित नहीं होता है:

 1 compilation error: [Static type checking] - Cannot find matching method java.lang.Object#exit(java.lang.Integer). Please check if the declared type is right and if the method exists. 

इसलिए यह कोड अब संकलित नहीं है। और अगर हम इस कोड को लेते हैं:

 def c = System c.exit(-1) 

जैसा कि आप देख सकते हैं, यह टाइप चेक, एक विधि में लिपटे और groovy कमांड का उपयोग करके निष्पादित करता है:

 @groovy.transform.TypeChecked // or even @CompileStatic void foo() { def c = System c.exit(-1) } foo() 

टाइप चेकर यह पता लगाता है कि System क्लास से exit मेथड को बुलाया गया है और यह वैध है। इससे हमें यहां मदद नहीं मिलेगी। लेकिन हम जानते हैं कि यदि यह कोड टाइप चेक पास करता है, तो इसका मतलब है कि कंपाइलर रिसीवर को कॉल को टाइप System पहचानता है। सामान्य तौर पर, विचार यह है कि टाइप चेकिंग के लिए एक्सटेंशन के साथ कॉल को प्रतिबंधित किया जाए।

टाइप जाँच के लिए सरल विस्तार

सैंडबॉक्सिंग में विस्तार से जानकारी देने से पहले, आइए हमारी स्क्रिप्ट को टाइप चेकिंग के लिए एक मानक एक्सटेंशन की मदद से "सुरक्षित" करने का प्रयास करें। इस तरह के एक्सटेंशन को पंजीकृत करना आसान है: यदि आप स्थैतिक संकलन का उपयोग कर रहे हैं तो @TypeChecked एनोटेशन (या @CompileStatic ) के लिए extensions पैरामीटर सेट करें:

 @TypeChecked(extensions=['SecureExtension1.groovy']) void foo() { def c = System c.exit(-1) } foo() 

एक्सटेंशन सर्च क्लासपाथ में सोर्स कोड फॉर्मेट में होगा (आप टाइप चेकिंग के लिए प्री-कनेक्टेड एक्सटेंशन कर सकते हैं, लेकिन हम इस लेख में उन पर विचार नहीं करेंगे):

SecureExtension1.groovy

 onMethodSelection { expr, methodNode -> if (methodNode.declaringClass.name=='java.lang.System') { addStaticTypeError("Method call is not allowed!", expr) } } 

1. जब प्रकार चेकर कॉल करने के लिए एक विधि का चयन करता है
2. यदि विधि वर्ग System
3. फिर टाइप करें चेकर एक त्रुटि उत्पन्न करता है

आपको बस इतना ही चाहिए अब कोड फिर से चलाएँ और आपको एक संकलन त्रुटि दिखाई देगी!

 /home/cchampeau/tmp/securetest.groovy: 6: [Static type checking] - Method call is not allowed! @ line 6, column 3. c.exit(-1) ^ 1 error 

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

मान लीजिए कि आपका एप्लिकेशन किसी दस्तावेज़ के लिए कुछ मीट्रिक की गणना करता है और उपयोगकर्ताओं को उन्हें अनुकूलित करने की अनुमति देता है। इस मामले में, डीएसएल:

• (कम से कम) score चर का संचालन करेगा
• उपयोगकर्ताओं को गणितीय कार्य करने की अनुमति देता है (कॉलिंग कॉस , एब्स , ... विधियों सहित)
• अन्य सभी तरीकों से मना करना चाहिए

नमूना उपयोगकर्ता स्क्रिप्ट:

abs(cos(1+score))

यह डीएसएल कॉन्फ़िगर करना आसान है। यह एक प्रकार है जिसे हमने ऊपर परिभाषित किया है:

Sandbox.java

 CompilerConfiguration conf = new CompilerConfiguration(); ImportCustomizer customizer = new ImportCustomizer(); customizer.addStaticStars("java.lang.Math"); conf.addCompilationCustomizers(customizer); Binding binding = new Binding(); binding.setVariable("score", 2.0d); GroovyShell shell = new GroovyShell(binding,conf); Double userScore = (Double) shell.evaluate("abs(cos(1+score))"); System.out.println("userScore = " + userScore); 

1. इंपोर्ट कस्टमाइज़र जोड़ें जो सभी स्क्रिप्ट्स में import static java.lang.Math.* जोड़ देगा
2. स्क्रिप्ट के लिए score चर उपलब्ध कराएं
3. स्क्रिप्ट निष्पादित करें

प्रत्येक बार पार्स करने और उन्हें संकलित करने के बजाय स्क्रिप्ट को कैश करने के तरीके हैं। विवरण के लिए दस्तावेज देखें।

तो, हमारी स्क्रिप्ट काम करती है, लेकिन कुछ भी हैकर को दुर्भावनापूर्ण कोड लॉन्च करने से नहीं रोकता है। चूंकि हम प्रकार की जाँच का उपयोग करने की योजना बनाते हैं, इसलिए मैं @CompileStatic परिवर्तन का उपयोग करने की सलाह @CompileStatic :

• यह स्क्रिप्ट में टाइप चेकिंग को सक्रिय करता है, और हम टाइप चेकिंग के लिए एक्सटेंशन के लिए अतिरिक्त जांच करने में सक्षम होंगे
• स्क्रिप्ट प्रदर्शन में सुधार

अपनी स्क्रिप्ट्स में @CompileStatic एनोटेशन को जोड़ना बहुत सरल है। आपको केवल कंपाइलर कॉन्फ़िगरेशन को अपडेट करने की आवश्यकता है:

 ASTTransformationCustomizer astcz = new ASTTransformationCustomizer(CompileStatic.class); conf.addCompilationCustomizers(astcz); 

अब यदि आप स्क्रिप्ट को फिर से चलाने का प्रयास करते हैं, तो आपको एक संकलन त्रुटि दिखाई देगी:

 Script1.groovy: 1: [Static type checking] - The variable [score] is undeclared. @ line 1, column 11. abs(cos(1+score)) ^ Script1.groovy: 1: [Static type checking] - Cannot find matching method int#plus(java.lang.Object). Please check if the declared type is right and if the method exists. @ line 1, column 9. abs(cos(1+score)) ^ 2 errors 

क्या हुआ? यदि आप संकलक के दृष्टिकोण से स्क्रिप्ट पढ़ते हैं, तो यह स्पष्ट हो जाता है कि वह चर "स्कोर" के बारे में कुछ नहीं जानता है। लेकिन आप एक डेवलपर के रूप में जानते हैं कि यह एक double वैरिएबल है, लेकिन कंपाइलर इसे आउटपुट नहीं कर सकता है। इसके लिए, टाइप चेकिंग के एक्सटेंशन बनाए जाते हैं: आप कंपाइलर को अतिरिक्त जानकारी दे सकते हैं, और संकलन ठीक काम करेगा। इस मामले में, हमें यह इंगित करने की आवश्यकता है कि score चर double प्रकार का है।

इसलिए, आप उस तरीके को थोड़ा बदल सकते हैं जिसमें @CompileStatic एनोटेशन @CompileStatic :

 ASTTransformationCustomizer astcz = new ASTTransformationCustomizer( singletonMap("extensions", singletonList("SecureExtension2.groovy")), CompileStatic.class); 

यह @CompileStatic(extensions=['SecureExtension2.groovy']) द्वारा एनोटेट किए गए कोड का "अनुकरण" करता है। अब, निश्चित रूप से, हमें एक विस्तार लिखना होगा जो score चर को पहचान लेगा:

SecureExtension2.groovy

 unresolvedVariable { var -> if (var.name=='score') { return makeDynamic(var, double_TYPE) } } 

1. मामले में प्रकार चेकर चर का निर्धारण नहीं कर सकता
2. यदि चर नाम score
3. कंपाइलर को डायनेमिक रूप से टाइप double साथ परिभाषित करने दें

टाइपिंग चेकिंग के लिए डीएसएल एक्सटेंशन का पूरा विवरण प्रलेखन के इस खंड में पाया जा सकता है, लेकिन एक संयुक्त संकलन मोड का एक उदाहरण है: कंपाइलर एक score चर को परिभाषित नहीं कर सकता है। आप एक डीएसएल डेवलपर के रूप में जानते हैं कि चर वास्तव में इसका प्रकार है - double , इसलिए makeDynamic करने के लिए कॉल यहां है: "ठीक है, चिंता मत करो, मुझे पता है कि मैं क्या कर रहा हूं, इस चर को double प्रकार से गतिशील रूप से परिभाषित किया जा सकता है। "। वह सब है!

पहले पूरा "सुरक्षित" एक्सटेंशन

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

SecureExtension3.groovy

 // disallow calls on System onMethodSelection { expr, methodNode -> if (methodNode.declaringClass.name=='java.lang.System') { addStaticTypeError("Method call is not allowed!", expr) } } // resolve the score variable unresolvedVariable { var -> if (var.name=='score') { return makeDynamic(var, double_TYPE) } } 

प्रकार की जाँच के लिए नए एक्सटेंशन का उपयोग करने के लिए अपने जावा क्लास में कॉन्फ़िगरेशन को अपडेट करना याद रखें:

 ASTTransformationCustomizer astcz = new ASTTransformationCustomizer( singletonMap("extensions", singletonList("SecureExtension3.groovy")), CompileStatic.class); 

कोड फिर से चलाएँ - यह अभी भी काम करता है। अब यह प्रयास करें:

 abs(cos(1+score)) System.exit(-1) 

स्क्रिप्ट का संकलन एक त्रुटि के साथ क्रैश हो जाएगा:

 Script1.groovy: 1: [Static type checking] - Method call is not allowed! @ line 1, column 19. abs(cos(1+score));System.exit(-1) ^ 1 error 

बधाई हो, आपने अभी पहला टाइप-चेकिंग एक्सटेंशन लिखा है जो दुर्भावनापूर्ण कोड को चलने से रोकता है!

बढ़ाया विस्तार विन्यास

इसलिए, सब कुछ ठीक चल रहा है, हम System क्लास के तरीकों पर कॉल को प्रतिबंधित कर सकते हैं, लेकिन ऐसा लगता है कि नई कमजोरियों को जल्द ही खोजा जाएगा, और हमें दुर्भावनापूर्ण कोड के लॉन्च को रोकने की आवश्यकता होगी। इसलिए विस्तार में सब कुछ हार्डकोड के बजाय, हम अपने विस्तार को सार्वभौमिक और अनुकूलन योग्य बनाने की कोशिश करेंगे। यह शायद सबसे कठिन है, क्योंकि टाइपिंग चेकिंग के लिए एक्सटेंशन के संदर्भ को पास करने का कोई सीधा तरीका नहीं है। इसलिए, यह विचार, थ्रेडर्स टाइप करने के लिए कॉन्फ़िगरेशन डेटा पास करने के लिए थ्रेड लोकल वैरिएबल (कर्व विधि, यस) का उपयोग करने पर आधारित है।

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

Sandbox.java

 public class Sandbox { public static final String VAR_TYPES = "sandboxing.variable.types"; public static final ThreadLocal<Map<String, Object>> COMPILE_OPTIONS = new ThreadLocal<>(); public static void main(String[] args) { CompilerConfiguration conf = new CompilerConfiguration(); ImportCustomizer customizer = new ImportCustomizer(); customizer.addStaticStars("java.lang.Math"); ASTTransformationCustomizer astcz = new ASTTransformationCustomizer( singletonMap("extensions", singletonList("SecureExtension4.groovy")), CompileStatic.class); conf.addCompilationCustomizers(astcz); conf.addCompilationCustomizers(customizer); Binding binding = new Binding(); binding.setVariable("score", 2.0d); try { Map<String,ClassNode> variableTypes = new HashMap<String, ClassNode>(); variableTypes.put("score", ClassHelper.double_TYPE); Map<String,Object> options = new HashMap<String, Object>(); options.put(VAR_TYPES, variableTypes); COMPILE_OPTIONS.set(options); GroovyShell shell = new GroovyShell(binding, conf); Double userScore = (Double) shell.evaluate("abs(cos(1+score));System.exit(-1)"); System.out.println("userScore = " + userScore); } finally { COMPILE_OPTIONS.remove(); } } } 

1. ThreadLocal ,
2. — SecureExtension4.groovy
3. variableTypes — “ → ”
4. score
5. options —
6. "variable types" VAR_TYPES
7. thread local
8. , , thread local

:

 import static Sandbox.* def typesOfVariables = COMPILE_OPTIONS.get()[VAR_TYPES] unresolvedVariable { var -> if (typesOfVariables[var.name]) { return makeDynamic(var, typesOfVariables[var.name]) } } 

1. thread local
2. , ,
3. type checker

thread local, , type checker . , unresolvedVariable , , , type checker, . , . !

. , .

. , . , , . , System.exit , :

 java.lang.System#exit(int) 

, Java, :

 public class Sandbox { public static final String WHITELIST_PATTERNS = "sandboxing.whitelist.patterns"; // ... public static void main(String[] args) { // ... try { Map<String,ClassNode> variableTypes = new HashMap<String, ClassNode>(); variableTypes.put("score", ClassHelper.double_TYPE); Map<String,Object> options = new HashMap<String, Object>(); List<String> patterns = new ArrayList<String>(); patterns.add("java\\.lang\\.Math#"); options.put(VAR_TYPES, variableTypes); options.put(WHITELIST_PATTERNS, patterns); COMPILE_OPTIONS.set(options); GroovyShell shell = new GroovyShell(binding, conf); Double userScore = (Double) shell.evaluate("abs(cos(1+score));System.exit(-1)"); System.out.println("userScore = " + userScore); } finally { COMPILE_OPTIONS.remove(); } } } 

2. java.lang.Math

:

 import groovy.transform.CompileStatic import org.codehaus.groovy.ast.ClassNode import org.codehaus.groovy.ast.MethodNode import org.codehaus.groovy.ast.Parameter import org.codehaus.groovy.transform.stc.ExtensionMethodNode import static Sandbox.* @CompileStatic private static String prettyPrint(ClassNode node) { node.isArray()?"${prettyPrint(node.componentType)}[]":node.toString(false) } @CompileStatic private static String toMethodDescriptor(MethodNode node) { if (node instanceof ExtensionMethodNode) { return toMethodDescriptor(node.extensionMethodNode) } def sb = new StringBuilder() sb.append(node.declaringClass.toString(false)) sb.append("#") sb.append(node.name) sb.append('(') sb.append(node.parameters.collect { Parameter it -> prettyPrint(it.originType) }.join(',')) sb.append(')') sb } def typesOfVariables = COMPILE_OPTIONS.get()[VAR_TYPES] def whiteList = COMPILE_OPTIONS.get()[WHITELIST_PATTERNS] onMethodSelection { expr, MethodNode methodNode -> def descr = toMethodDescriptor(methodNode) if (!whiteList.any { descr =~ it }) { addStaticTypeError("You tried to call a method which is not allowed, what did you expect?: $descr", expr) } } unresolvedVariable { var -> if (typesOfVariables[var.name]) { return makeDynamic(var, typesOfVariables[var.name]) } } 

1. MethodNode
2. thread local
4. ,

, :

 Script1.groovy: 1: [Static type checking] - You tried to call a method which is not allowed, what did you expect?: java.lang.System#exit(int) @ line 1, column 19. abs(cos(1+score));System.exit(-1) ^ 1 error 

, ! , , . , ! , , . , ( foo.text , foo.getText() ).

, type checker' "property selection", , . , , . , , — . .

SandboxingTypeCheckingExtension.groovy

 import groovy.transform.CompileStatic import org.codehaus.groovy.ast.ClassCodeVisitorSupport import org.codehaus.groovy.ast.ClassHelper import org.codehaus.groovy.ast.ClassNode import org.codehaus.groovy.ast.MethodNode import org.codehaus.groovy.ast.Parameter import org.codehaus.groovy.ast.expr.PropertyExpression import org.codehaus.groovy.control.SourceUnit import org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys import org.codehaus.groovy.transform.stc.ExtensionMethodNode import org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport import org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport import static Sandbox.* class SandboxingTypeCheckingExtension extends GroovyTypeCheckingExtensionSupport.TypeCheckingDSL { @CompileStatic private static String prettyPrint(ClassNode node) { node.isArray()?"${prettyPrint(node.componentType)}[]":node.toString(false) } @CompileStatic private static String toMethodDescriptor(MethodNode node) { if (node instanceof ExtensionMethodNode) { return toMethodDescriptor(node.extensionMethodNode) } def sb = new StringBuilder() sb.append(node.declaringClass.toString(false)) sb.append("#") sb.append(node.name) sb.append('(') sb.append(node.parameters.collect { Parameter it -> prettyPrint(it.originType) }.join(',')) sb.append(')') sb } @Override Object run() { // Fetch white list of regular expressions of authorized method calls def whiteList = COMPILE_OPTIONS.get()[WHITELIST_PATTERNS] def typesOfVariables = COMPILE_OPTIONS.get()[VAR_TYPES] onMethodSelection { expr, MethodNode methodNode -> def descr = toMethodDescriptor(methodNode) if (!whiteList.any { descr =~ it }) { addStaticTypeError("You tried to call a method which is not allowed, what did you expect?: $descr", expr) } } unresolvedVariable { var -> if (isDynamic(var) && typesOfVariables[var.name]) { storeType(var, typesOfVariables[var.name]) handled = true } } // handling properties (like foo.text) is harder because the type checking extension // does not provide a specific hook for this. Harder, but not impossible! afterVisitMethod { methodNode -> def visitor = new PropertyExpressionChecker(context.source, whiteList) visitor.visitMethod(methodNode) } } private class PropertyExpressionChecker extends ClassCodeVisitorSupport { private final SourceUnit unit private final List<String> whiteList PropertyExpressionChecker(final SourceUnit unit, final List<String> whiteList) { this.unit = unit this.whiteList = whiteList } @Override protected SourceUnit getSourceUnit() { unit } @Override void visitPropertyExpression(final PropertyExpression expression) { super.visitPropertyExpression(expression) ClassNode owner = expression.objectExpression.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER) if (owner) { if (expression.spreadSafe && StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(owner, classNodeFor(Collection))) { owner = typeCheckingVisitor.inferComponentType(owner, ClassHelper.int_TYPE) } def descr = "${prettyPrint(owner)}#${expression.propertyAsString}" if (!whiteList.any { descr =~ it }) { addStaticTypeError("Property is not allowed: $descr", expression) } } } } }```     sandbox',     assert' ,  ,     : ``Sandbox.java`` ```java public class Sandbox { public static final String WHITELIST_PATTERNS = "sandboxing.whitelist.patterns"; public static final String VAR_TYPES = "sandboxing.variable.types"; public static final ThreadLocal<Map<String, Object>> COMPILE_OPTIONS = new ThreadLocal<Map<String, Object>>(); public static void main(String[] args) { CompilerConfiguration conf = new CompilerConfiguration(); ImportCustomizer customizer = new ImportCustomizer(); customizer.addStaticStars("java.lang.Math"); ASTTransformationCustomizer astcz = new ASTTransformationCustomizer( singletonMap("extensions", singletonList("SandboxingTypeCheckingExtension.groovy")), CompileStatic.class); conf.addCompilationCustomizers(astcz); conf.addCompilationCustomizers(customizer); Binding binding = new Binding(); binding.setVariable("score", 2.0d); try { Map<String, ClassNode> variableTypes = new HashMap<String, ClassNode>(); variableTypes.put("score", ClassHelper.double_TYPE); Map<String, Object> options = new HashMap<String, Object>(); List<String> patterns = new ArrayList<String>(); // allow method calls on Math patterns.add("java\\.lang\\.Math#"); // allow constructors calls on File patterns.add("File#<init>"); // because we let the user call each/times/... patterns.add("org\\.codehaus\\.groovy\\.runtime\\.DefaultGroovyMethods"); options.put(VAR_TYPES, variableTypes); options.put(WHITELIST_PATTERNS, patterns); COMPILE_OPTIONS.set(options); GroovyShell shell = new GroovyShell(binding, conf); Object result; try { result = shell.evaluate("Eval.me('1')"); // error assert false; } catch (MultipleCompilationErrorsException e) { System.out.println("Successful sandboxing: "+e.getMessage()); } try { result = shell.evaluate("System.exit(-1)"); // error assert false; } catch (MultipleCompilationErrorsException e) { System.out.println("Successful sandboxing: "+e.getMessage()); } try { result = shell.evaluate("((Object)Eval).me('1')"); // error assert false; } catch (MultipleCompilationErrorsException e) { System.out.println("Successful sandboxing: "+e.getMessage()); } try { result = shell.evaluate("new File('/etc/passwd').getText()"); // getText is not allowed assert false; } catch (MultipleCompilationErrorsException e) { System.out.println("Successful sandboxing: "+e.getMessage()); } try { result = shell.evaluate("new File('/etc/passwd').text"); // getText is not allowed assert false; } catch (MultipleCompilationErrorsException e) { System.out.println("Successful sandboxing: "+e.getMessage()); } Double userScore = (Double) shell.evaluate("abs(cos(1+score))"); System.out.println("userScore = " + userScore); } finally { COMPILE_OPTIONS.remove(); } } } 

निष्कर्ष

Groovy JVM. , . , , , . , Groovy, sandboxing' (, , ).

, , . , . , , .

, sandboxing', , — SecureASTCustomizer . , , : secure AST customizer , (, ), ( , ).

, : , , . Groovy . Groovy, , - pull request, - !