आपको Apigee Edge दस्तावेज़ दिख रहा है.
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
इस पेज पर जाएं
Apigee X दस्तावेज़. जानकारी

क्या
किसी मैसेज से जानकारी निकालता है (उदाहरण के लिए, यूआरआई पाथ, क्वेरी पैरामीटर, हेडर, फ़ॉर्म पैरामीटर, वैरिएबल, एक्सएमएल पेलोड या JSON पेलोड) के बारे में जानकारी. साथ ही, उस कॉन्टेंट का पहले से तय रेगुलर एक्सप्रेशन के आधार पर आकलन करता है एक्सप्रेशन के बारे में भी बताया गया है. अगर किसी तय किए गए रेगुलर एक्सप्रेशन का आकलन 'सही' के तौर पर होता है, तो इस मैसेज को खतरा है और उसे अस्वीकार कर दिया गया है.
वीडियो
रेगुलर एक्सप्रेशन सुरक्षा नीति के बारे में ज़्यादा जानने के लिए ये वीडियो देखें.
वीडियो | ब्यौरा |
---|---|
सुरक्षा करना एसक्यूएल इंजेक्शन अटैक के ख़िलाफ़ (New Edge) | इसमें रेगुलर एक्सप्रेशन सुरक्षा नीति का इस्तेमाल करके, SQL इंजेक्शन के हमलों से सुरक्षा दी जाती है पर जाएं. |
सुरक्षा करना एसक्यूएल इंजेक्शन अटैक के ख़िलाफ़ (क्लासिक एज) | इसमें रेगुलर एक्सप्रेशन सुरक्षा नीति का इस्तेमाल करके, SQL इंजेक्शन के दौरान होने वाले हमलों से सुरक्षा दी जाती है क्लासिक एज यूज़र इंटरफ़ेस (यूआई) की इमेज. |
सैंपल
GitHub
रेगुलर एक्सप्रेशन-सुरक्षा GitHub पर सैंपल दिया गया है. इसमें दिखाया गया है कि कैसे क्वेरी पैरामीटर की तरह नहीं है. साथ ही, यह नमूना सामान्य 400 गड़बड़ी की स्थिति सेट की जा सकती है, ताकि हैकर, जवाब से काम की जानकारी हासिल न कर सकें.
JavaScript में हमले से सुरक्षा शामिल है
<RegularExpressionProtection name="JsonPathRegExProtection"> <DisplayName>Regular Expression Protection 1</DisplayName> <Source>request</Source> <JSONPayload escapeSlashCharacter="true"> <JSONPath> <Expression>$</Expression> <Pattern><\s*script\b[^>]*>[^<]+<\s*\/\s*script\s*> </Pattern> <Pattern>n\s*\\\\\s*slash</Pattern> <Pattern>n\s*\/\s*slash</Pattern> <Pattern>n\s*\\"\s*quotes</Pattern> <Pattern>n\s*\\b\s*space</Pattern> <Pattern>n\s*\\f\s*forwardfeed</Pattern> <Pattern>n\s*\\n\s*newline</Pattern> <Pattern>n\s*\\r\s*carria</Pattern> <Pattern>n\s*\\t\s*tab</Pattern> <Pattern>n\s*\\uFFFF\s*hex</Pattern> </JSONPath> </JSONPayload> </RegularExpressionProtection>
ऊपर दिए गए उदाहरण में बताया गया है कि अपने विज्ञापनों का आकलन करने के लिए, RegularExpressionProtection नीति का इस्तेमाल कैसे करें
JavaScript के लिए JSON पेलोड में हमले शामिल हैं. खास तौर पर, इस टूल की मदद से निकाली गई
<JSONPath>
/<Expression>
का आकलन इसके आधार पर किया जाता है
<JSONPath>
/<Pattern>
में रेगुलर एक्सप्रेशन.
अगर रेगुलर एक्सप्रेशन
<JSONPath>
/<Pattern>
में एक्सएमएल-रिज़र्व्ड वर्ण शामिल हैं
(", &, ', < या .) का इस्तेमाल करके, नीति को एक्सएमएल में शामिल करने से पहले, आपको उसे एक्सएमएल-एन्कोड करना होगा
कॉन्फ़िगरेशन फ़ाइल है. उदाहरण के लिए, ऊपर दिए गए नमूने में, रेगुलर एक्सप्रेशन
<\s*script\b[^>]*>[^<]+<\s*\/\s*script\s*>
रहा है
एक्सएमएल कोड में इस फ़ॉर्मैट में बदलाव किया गया है
<\s*script\b[^>]*>[^<]+<\s*\/\s*script\s*>
.
इसके अलावा, अगर आपके रेगुलर एक्सप्रेशन में फ़ॉरवर्ड स्लैश (/) शामिल हैं, तो आपको
<JSONPayload>
escapeSlashCharacter
सेट करके
एट्रिब्यूट की वैल्यू true
को दें.
केस-इनसेंसिटिव मैचिंग
केस-इनसेंसिटिव मैचिंग करने के लिए, यह सामान्य इस्तेमाल का उदाहरण है. यहां एक उदाहरण दिया गया है, जिसमें बताया गया है कि
इसे कंस्ट्रक्ट (?i)
का इस्तेमाल करके रेगुलर एक्सप्रेशन में पूरा करें. इसमें
उदाहरण के लिए, DELETE
, delete
, और Delete
सही का मूल्यांकन करें.
<Pattern>[\s]*(?i)((delete)|(exec)|(drop\s*table)|(insert)|(shutdown)|(update)|(\bor\b))</Pattern>
रेगुलर एक्सप्रेशन सुरक्षा नीति के बारे में
Apigee Edge की मदद से, ऐसे रेगुलर एक्सप्रेशन कॉन्फ़िगर किए जा सकते हैं जिन्हें रनटाइम के दौरान एपीआई ट्रैफ़िक के हिसाब से आकलन किया जाता है, ताकि कॉन्टेंट लेवल के कुछ सामान्य खतरों की पहचान की जा सके तय पैटर्न.
रेगुलर एक्सप्रेशन या कम शब्दों में रेगुलर एक्सप्रेशन, स्ट्रिंग का एक सेट होता है जो स्ट्रिंग में एक पैटर्न तय करता है. रेगुलर एक्सप्रेशन की मदद से, कॉन्टेंट को प्रोग्राम के हिसाब से बनाया जा सकता है पैटर्न के लिए मूल्यांकन किया जाता है. रेगुलर एक्सप्रेशन का इस्तेमाल करके, उदाहरण के लिए किसी ईमेल पते का आकलन किया जा सकता है ताकि यह पक्का किया जा सके कि इसका स्ट्रक्चर सही है. ज़्यादा जानकारी के लिए, सामान्य देखें Java ट्यूटोरियल में एक्सप्रेशन.
JSON और XML का इवैलुएशन करना, regularExpressionProtection का सबसे ज़्यादा इस्तेमाल करता है नुकसान पहुंचाने वाले कॉन्टेंट के लिए पेलोड.
कोई भी रेगुलर एक्सप्रेशन, कॉन्टेंट पर आधारित सभी हमलों को खत्म नहीं कर सकता. साथ ही, एक से ज़्यादा तरीकों को मज़बूत सुरक्षा चालू करने के लिए जोड़ा जाएगा. यह सेक्शन जिसमें कॉन्टेंट शामिल नहीं है.
एक्सक्लूज़न का उदाहरण पैटर्न
नीति की एक्सएमएल कॉन्फ़िगरेशन फ़ाइल में, रेगुलर एक्सप्रेशन का एक्सएमएल कोड में बदलना ज़रूरी है.
नाम | रेगुलर एक्सप्रेशन |
---|---|
SQL इंजेक्शन |
[\s]*((delete)|(exec)|(drop\s*table)|(insert)|(shutdown)|(update)|(\bor\b)) |
सर्वर-साइड शामिल करने का इंजेक्शन |
<!--#(include|exec|echo|config|printenv)\s+.* एक्सएमएल कोड में बदला गया: <!--#(include|exec|echo|config|printenv)\s+.* |
एसएएमएल के छोटे किए गए सिंटैक्स इंजेक्शन |
(/(@?[\w_?\w:\*]+(\[[^]]+\])*)?)+ |
OAuth का बड़ा किया गया सिंटैक्स इंजेक्शन |
/?(ancestor(-or-self)?|descendant(-or-self)?|following(-sibling)) |
JavaScript इंजेक्शन |
<\s*script\b[^>]*>[^<]+<\s*/\s*script\s*> एक्सएमएल कोड में बदला गया: <\s*script\b[^>]*>[^<]+<\s*/\s*script\s*> |
Java अपवाद इंजेक्शन |
.*?Exception in thread.* |
एक्सएमएल या JSON पेलोड के साथ अनुरोध में कॉन्टेंट-टाइप हेडर सेट करें
रेगुलर एक्सप्रेशन सुरक्षा नीति के पेलोड में ये चीज़ें शामिल हो सकती हैं एलिमेंट:
-
<XMLPayload>
एलिमेंट: इससे पता चलता है कि जानकारी को एक एक्सएमएल पेलोड है और दिए गए रेगुलर एक्सप्रेशन के हिसाब से इसका आकलन किया गया है.अगर इस नीति में
<XMLPayload>
का इस्तेमाल किया जाता है, तो अनुरोध काContent-Type
हेडर, एक्सएमएल कॉन्टेंट-टाइप होना चाहिए, जैसेapplication/xml
याtext/xml
. -
<JSONPayload>
एलिमेंट: इससे पता चलता है कि जानकारी को एक्सट्रैक्ट करना ज़रूरी है को, JSON पेलोड से निकालकर, दिए गए रेगुलर एक्सप्रेशन से उसका आकलन किया जाता है.अगर इस नीति में
<JSONPayload>
का इस्तेमाल किया जाता है, तोContent-Type
अनुरोध का हेडर, JSON कॉन्टेंट का टाइप होना चाहिए, जैसे किapplication/json
.
आम तौर पर, एक्सएमएल या JSON में से किसी एक को स्वीकार करने के लिए, एपीआई डिज़ाइन किया जाता है. हालांकि, ऐसी स्थिति पैदा हो सकती है
जहां एपीआई ने दोनों को स्वीकार किया. इसके बाद, रेगुलर एक्सप्रेशन की सुरक्षा की नीति बनाई जा सकती है
जो <XMLPayload>
और <JSONPayload>
, दोनों एलिमेंट का इस्तेमाल करता है.
मान के आधार पर किसी खास अनुरोध के लिए सिर्फ़ एक ही एलिमेंट लागू होगा
Content-Type
हेडर.
एलिमेंट का रेफ़रंस
एलिमेंट का रेफ़रंस, RegularExpressionProtection के एलिमेंट और एट्रिब्यूट के बारे में बताता है की नीति देखें.
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1"> <DisplayName>Regular Expression Protection 1</DisplayName> <Source>response</Source> <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables> <URIPath> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </URIPath> <QueryParam name="a-query-param"> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </QueryParam> <Header name="a-header"> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </Header> <FormParam name="a-form-param"> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </FormParam> <Variable name="request.content"> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </Variable> <XMLPayload> <Namespaces> <Namespace prefix="apigee">http://www.apigee.com</Namespace> </Namespaces> <XPath> <Expression>/apigee:Greeting/apigee:User</Expression> <Type>string</Type> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </XPath> </XMLPayload> <JSONPayload> <JSONPath> <Expression>$.store.book[*].author</Expression> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </JSONPath> </JSONPayload> </RegularExpressionProtection>
<RegularExpressionProtection> एट्रिब्यूट
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
यहां दी गई टेबल में, ऐसे एट्रिब्यूट के बारे में बताया गया है जो नीति के सभी पैरंट एलिमेंट में एक जैसे होते हैं:
एट्रिब्यूट | ब्यौरा | डिफ़ॉल्ट | मौजूदगी |
---|---|---|---|
name |
नीति का अंदरूनी नाम. इसके अलावा, नीति को लेबल करने के लिए, |
लागू नहीं | ज़रूरी है |
continueOnError |
किसी नीति के काम न करने पर, गड़बड़ी दिखाने के लिए नीति के लागू होने के बाद भी फ़्लो को एक्ज़ीक्यूट करने के लिए, इसे |
गलत | वैकल्पिक |
enabled |
नीति को लागू करने के लिए, नीति को बंद करने के लिए, |
सही | वैकल्पिक |
async |
यह एट्रिब्यूट अब काम नहीं करता. |
गलत | बहिष्कृत |
<DisplayName> एलिमेंट
इस कॉलम में नीति को लेबल करने के लिए, name
एट्रिब्यूट के साथ-साथ इस्तेमाल करें
मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) प्रॉक्सी एडिटर, जिसका नाम अलग और सामान्य भाषा में है.
<DisplayName>Policy Display Name</DisplayName>
डिफ़ॉल्ट |
लागू नहीं अगर आप इस एलिमेंट को छोड़ देते हैं, तो नीति की |
---|---|
मौजूदगी | वैकल्पिक |
टाइप | स्ट्रिंग |
<Source> एलिमेंट
यह उस मैसेज को दिखाता है जिससे जानकारी निकालने की ज़रूरत है.
अगर <Source>
एलिमेंट को छोड़ा जाता है, तो वैल्यू डिफ़ॉल्ट रूप से इस पर सेट होती है
message
. उदाहरण के लिए, <Source>message</Source>
. जब इस पर सेट किया गया हो
message
, यह नीति किसी अनुरोध के साथ अटैच होने पर, अनुरोध वाले मैसेज का इस्तेमाल सोर्स के तौर पर करती है
फ़्लो. इसी तरह, रिस्पॉन्स फ़्लो से अटैच किए जाने पर यह नीति, रिस्पॉन्स मैसेज का इस्तेमाल करती है.
अगर सोर्स मैसेज की समस्या हल नहीं हो पा रही है या उसका समाधान मैसेज नहीं है, तो नीति कोई गड़बड़ी दिखाता है.
<Source>response</Source>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | स्ट्रिंग |
<IgnoreUnresolvedVariables> एलिमेंट
यह तय करता है कि क्या नीति उस समय कोई गड़बड़ी दिखाती है, जब उसे ऐसा वैरिएबल मिलता है हल नहीं किया जा सकता.
अगर नीति को false
(डिफ़ॉल्ट तौर पर) पर सेट किया जाता है, तो नीति के तहत गड़बड़ी का मैसेज तब दिखता है, जब किसी समस्या को हल न किया जा सकता हो
चर मिला है. अगर वैल्यू को true
पर सेट किया जाता है, तो ऐसे वैरिएबल को खाली माना जाता है जिसे हल नहीं किया गया हो
स्ट्रिंग (शून्य).
<IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
डिफ़ॉल्ट: | गलत |
मौजूदगी: | वैकल्पिक |
टाइप: | बूलियन |
<URIPath> एलिमेंट
इससे पता चलता है कि जानकारी को अनुरोध यूआरआई पाथ से निकालना और उसका मूल्यांकन करना ज़रूरी है
के लिए आपके कीवर्ड का इस्तेमाल किया जा सकता है. आपको कम से कम एक जानकारी देनी होगी
<Pattern>
एलिमेंट, जो मैच करने के लिए रेगुलर एक्सप्रेशन पैटर्न बताता है.
<URIPath> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </URIPath>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | लागू नहीं |
<QueryParam> एलिमेंट
इससे पता चलता है कि जानकारी को अनुरोध क्वेरी पैरामीटर से निकालना चाहिए और
का आकलन करके उसका मिलान किया जा सकता है. आपको कम से कम एक जानकारी देनी होगी
<Pattern>
एलिमेंट, जो मैच करने के लिए रेगुलर एक्सप्रेशन पैटर्न बताता है.
<QueryParam name="a-query-param"> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </QueryParam>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | लागू नहीं |
विशेषताएं
एट्रिब्यूट | ब्यौरा | डिफ़ॉल्ट | मौजूदगी |
---|---|---|---|
नाम | अनुरोध के उस क्वेरी पैरामीटर का नाम जिससे जानकारी हासिल करनी है दिए गए रेगुलर एक्सप्रेशन का इस्तेमाल करके जांच की जा सकती है. | लागू नहीं | ज़रूरी है |
<Header> एलिमेंट
इससे पता चलता है कि जानकारी को अनुरोध और रिस्पॉन्स हेडर से लिया जाना चाहिए और
का आकलन करके उसका मिलान किया जा सकता है. आपको कम से कम एक जानकारी देनी होगी
<Pattern>
एलिमेंट, जो मैच करने के लिए रेगुलर एक्सप्रेशन पैटर्न बताता है.
<Header name="a-header"> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </Header>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | लागू नहीं |
विशेषताएं
एट्रिब्यूट | ब्यौरा | डिफ़ॉल्ट | मौजूदगी |
---|---|---|---|
नाम |
अनुरोध का नाम और रिस्पॉन्स हेडर, जिससे जानकारी निकाली जानी है का इस्तेमाल किया जा सकता है. |
लागू नहीं | ज़रूरी है |
<FormParam> एलिमेंट
इससे पता चलता है कि जानकारी को अनुरोध फ़ॉर्म पैरामीटर से निकालना और उसका मूल्यांकन करना ज़रूरी है
के लिए आपके कीवर्ड का इस्तेमाल किया जा सकता है. आपको कम से कम एक जानकारी देनी होगी
<Pattern>
एलिमेंट, जो मैच करने के लिए रेगुलर एक्सप्रेशन पैटर्न बताता है.
<FormParam name="a-form-param"> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </FormParam>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | लागू नहीं |
विशेषताएं
एट्रिब्यूट | ब्यौरा | डिफ़ॉल्ट | मौजूदगी |
---|---|---|---|
नाम |
अनुरोध फ़ॉर्म पैरामीटर का नाम जिससे जानकारी निकाली जानी है दिए गए रेगुलर एक्सप्रेशन का इस्तेमाल करके जांच की जा सकती है. |
लागू नहीं | ज़रूरी है |
<Variable> एलिमेंट
इससे पता चलता है कि जानकारी को दिए गए वैरिएबल से निकाला जाना चाहिए और उनका आकलन रेगुलर एक्सप्रेशन दिए गए हैं.
<Variable name="request.content"> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </Variable>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | लागू नहीं |
विशेषताएं
एट्रिब्यूट | ब्यौरा | डिफ़ॉल्ट | मौजूदगी |
---|---|---|---|
नाम |
उस वैरिएबल का नाम जिससे आकलन के लिए जानकारी हासिल करनी है के लिए आपके कीवर्ड का इस्तेमाल किया जा सकता है. |
लागू नहीं | ज़रूरी है |
<XMLPayload> एलिमेंट
इससे पता चलता है कि जानकारी को किसी एक्सएमएल पेलोड से एक्सट्रैक्ट किया जाना चाहिए और उसका आकलन रेगुलर एक्सप्रेशन दिए गए हैं.
<XMLPayload> <Namespaces> <Namespace prefix="apigee">http://www.apigee.com</Namespace> </Namespaces> <XPath> <Expression>/apigee:Greeting/apigee:User</Expression> <Type>string</Type> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </XPath> </XMLPayload>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | लागू नहीं |
<XMLPayload>/<Namespaces> एलिमेंट
यह तय करती है कि उन नेमस्पेस के बारे में कैसे बताया जाए जिनका इस्तेमाल एक्स पाथ का आकलन करने के लिए किया जाना है.
<XMLPayload> <Namespaces> <Namespace prefix="apigee">http://www.apigee.com</Namespace> </Namespaces> <XPath> <Expression>/apigee:Greeting/apigee:User</Expression> <Type>string</Type> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </XPath> </XMLPayload>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | स्ट्रिंग |
<XMLPayload>/<Namespaces>/<Namespace> एलिमेंट
हर नेमस्पेस को तय करता है, का इस्तेमाल किया जाएगा.<Namespaces> <Namespace prefix="apigee">http://www.apigee.com</Namespace> </Namespaces>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | स्ट्रिंग |
विशेषताएं
एट्रिब्यूट | ब्यौरा | डिफ़ॉल्ट | मौजूदगी |
---|---|---|---|
उपसर्ग |
किसी दिए गए नेमस्पेस को सही करने में मदद करने के लिए, प्रीफ़िक्स देता है. |
लागू नहीं | ज़रूरी है |
<XMLPayload>/<XPath> एलिमेंट
OAuth तय करती है का आकलन किया जा सकता है.<XPath> <Expression>/apigee:Greeting/apigee:User</Expression> <Type>string</Type> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </XPath>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | लागू नहीं |
<XMLPayload>/<XPath>/<Expression> एलिमेंट
इस वैरिएबल के लिए तय किया गया एक्स पाथ एक्सप्रेशन तय करता है. सिर्फ़ OAuth 1.0 एक्सप्रेशन समर्थित हैं. उदाहरण के लिए,<Expression>/company/employee[@age>=$request.header.age]</Expression>
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
ऐसे कर्मचारियों की जानकारी एक्सट्रैक्ट करता है जिनकी उम्र यहां दी गई वैल्यू से ज़्यादा या उसके बराबर है
request.header.age
.<XPath> <Expression>/apigee:Greeting/apigee:User</Expression> <Type>string</Type> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </XPath>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | स्ट्रिंग |
<XMLPayload>/<XPath>/<Type> एलिमेंट
डेटा टाइप तय करता है.<XPath> <Expression>/apigee:Greeting/apigee:User</Expression> <Type>string</Type> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </XPath>
डिफ़ॉल्ट: | स्ट्रिंग |
मौजूदगी: | वैकल्पिक |
टाइप: | स्ट्रिंग |
मान्य वैल्यू: |
स्ट्रिंग. मान्य वैल्यू में |
<XMLPayload>/<XPath>/<Pattern> एलिमेंट
रेगुलर एक्सप्रेशन पैटर्न के बारे में बताता है. अगर रेगुलर एक्सप्रेशन में
आपके<Pattern>
एलिमेंट में, एक्सएमएल के लिए रिज़र्व किए गए वर्ण (", &, ', < या
.) तो उसे शामिल करने से पहले आपको उसे एक्सएमएल-एन्कोड करना होगा.
<XPath> <Expression>/apigee:Greeting/apigee:User</Expression> <Type>string</Type> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </XPath>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | ज़रूरी है |
टाइप: | स्ट्रिंग |
<JSONPayload> एलिमेंट
इससे पता चलता है कि जानकारी को JSON पेलोड से निकाला जाना चाहिए और उसका आकलन रेगुलर एक्सप्रेशन दिए गए हैं.
<JSONPayload> <JSONPath> <Expression>$.store.book[*].author</Expression> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </JSONPath> </JSONPayload>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | लागू नहीं |
विशेषताएं
एट्रिब्यूट | ब्यौरा | डिफ़ॉल्ट | मौजूदगी |
---|---|---|---|
escapeSlashCharacter |
रेगुलर में किसी भी फ़ॉरवर्ड स्लैश (/) वर्ण से बचने के लिए |
सही | वैकल्पिक |
<JSONPayload>/<JSONPath>/<Expression> एलिमेंट
वैरिएबल के लिए तय किया गया JSONPath एक्सप्रेशन तय करता है.
<JSONPath> <Expression>$.store.book[*].author</Expression> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </JSONPath>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | वैकल्पिक |
टाइप: | स्ट्रिंग |
<JSONPayload>/<JSONPath>/<Pattern> एलिमेंट
रेगुलर एक्सप्रेशन पैटर्न के बारे में बताता है. अगर आपके
<Pattern>
एलिमेंट में एक्सएमएल के लिए रिज़र्व किए गए वर्ण (", &, ', < या .) शामिल हैं.
शामिल करने से पहले आपको उसे एक्सएमएल-एन्कोड करना होगा.
<JSONPath> <Expression>$.store.book[*].author</Expression> <Pattern>REGEX PATTERN</Pattern> <Pattern>REGEX PATTERN</Pattern> </JSONPath>
डिफ़ॉल्ट: | लागू नहीं |
मौजूदगी: | ज़रूरी है |
टाइप: | स्ट्रिंग |
गड़बड़ी का रेफ़रंस
This section describes the error codes and messages returned and fault variables
set by Edge when this policy triggers an error. This information is important to know if
you are developing fault rules to handle faults. If you want to capture an error and raise your own
custom error, set the continueOnError="true"
attribute on the policy root element.
To learn more, see
What you need to know about policy errors and Handling
faults.
Errors returned from Edge policies follow a consistent format as described in the Error code reference.
Runtime errors
These errors can occur when the policy executes.
Error Code | Message |
---|---|
ExecutionFailed | Failed to execute the RegularExpressionProtection StepDefinition {0}. Reason: {1} |
InstantiationFailed | Failed to instantiate the RegularExpressionProtection StepDefinition {0} |
NonMessageVariable | Variable {0} does not resolve to a Message |
SourceMessageNotAvailable | {0} message is not available for RegularExpressionProtection StepDefinition {1} |
ThreatDetected | Regular Expression Threat Detected in {0}: regex: {1} input: {2} |
VariableResolutionFailed | Failed to resolve variable {0} |
Deployment errors
Error Code | Message | Fix |
---|---|---|
CannotBeConvertedToNodeset | RegularExpressionProtection {0}: Result of xpath {1} cannot be converted to nodeset. Context {2} | build |
DuplicatePrefix | RegularExpressionProtection {0}: Duplicate prefix {1} | build |
EmptyJSONPathExpression | RegularExpressionProtection {0}: Empty JSONPath expression | build |
EmptyXPathExpression | RegularExpressionProtection {0}: Empty XPath expression | build |
InvalidRegularExpression | RegularExpressionProtection {0}: Invalid Regular Expression {1}, Context {2} | build |
JSONPathCompilationFailed | RegularExpressionProtection {0}: Failed to compile jsonpath {1}. Context {2} | build |
NONEmptyPrefixMappedToEmptyURI | RegularExpressionProtection {0}: Non-empty prefix {1} cannot be mapped to empty uri | build |
NoPatternsToEnforce | RegularExpressionProtection {0}: No patterns to enforce in {1} | build |
NothingToEnforce | RegularExpressionProtection {0}: at least one of URIPath, QueryParam, Header, FormParam, XMLPayload, JSONPayload is mandatory | build |
XPathCompilationFailed | RegularExpressionProtection {0}: Failed to compile xpath {1}. Context {2} | build |
Fault variables
These variables are set when this policy triggers an error. For more information, see What you need to know about policy errors.
Variables | Where | Example |
---|---|---|
fault.name="fault_name" |
fault_name is the name of the fault, as listed in the table above. | fault.name Matches "ThreatDetected" |
regularexpressionprotection.policy_name.failed |
policy_name is the user-specified name of the policy that threw the fault. | regularexpressionprotection.Regular-Expressions-Protection-1.failed = true |