regularExpressionProtection नीति

Apigee Edge दस्तावेज़ देखा जा रहा है.
Apigee X दस्तावेज़ पर जाएं. जानकारी

यह क्या है

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

वीडियो

रेगुलर एक्सप्रेशन सुरक्षा नीति के बारे में ज़्यादा जानने के लिए, नीचे दिए गए वीडियो देखें.

वीडियो ब्यौरा
एसक्यूएल इंजेक्शन के ज़रिए होने वाले हमलों से सुरक्षा करना (नया एज) New Edge के यूज़र इंटरफ़ेस (यूआई) में रेगुलर एक्सप्रेशन सुरक्षा नीति का इस्तेमाल करके, एसक्यूएल इंजेक्शन के ज़रिए होने वाले हमलों से सुरक्षित रहें.
एसक्यूएल इंजेक्शन (E2EE) के हमलों से सुरक्षा (क्लासिक EDGE) क्लासिक Edge यूज़र इंटरफ़ेस (यूआई) में रेगुलर एक्सप्रेशन सुरक्षा नीति का इस्तेमाल करके एसक्यूएल इंजेक्शन के दौरान होने वाले हमलों से सुरक्षित रहें.

सैंपल

GitHub

GitHub पर रेगुलर एक्सप्रेशन सुरक्षा सैंपल में बताया गया है कि किसी क्वेरी पैरामीटर की मदद से जारी किए गए, एसक्यूएल इंजेक्शन के दौरान होने वाले संभावित हमलों को कैसे रोका जा सकता है. इसके अलावा, इस उदाहरण में एक सामान्य गड़बड़ी की स्थिति 400 सेट करने का अच्छा तरीका बताया गया है, ताकि हैकर जवाब से काम की जानकारी हासिल न कर सकें.

JavaScript में हमले से सुरक्षा शामिल है

<RegularExpressionProtection name="JsonPathRegExProtection">
    <DisplayName>Regular Expression Protection 1</DisplayName>
    <Source>request</Source>
    <JSONPayload escapeSlashCharacter="true">
       <JSONPath>
          <Expression>$.</Expression>
          <Pattern>&lt;\s*script\b[^&gt;]*&gt;[^&lt;]+&lt;\s*\/\s*script\s*&gt;
          </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>

ऊपर दिया गया उदाहरण दिखाता है कि JavaScript के लिए JSON पेलोड का आकलन करने के लिए regularExpressionProtection नीति का इस्तेमाल कैसे करें. खास तौर पर, <JSONPath>/<Expression> से एक्सट्रैक्ट किए गए कॉन्टेंट का आकलन, <JSONPath>/<Pattern> में रेगुलर एक्सप्रेशन के हिसाब से किया जाता है.

अगर आपके <JSONPath>/<Pattern> के रेगुलर एक्सप्रेशन में एक्सएमएल रिज़र्व किए गए वर्ण (", &, ', <, या .) शामिल हैं, तो आपको इसे नीति की एक्सएमएल कॉन्फ़िगरेशन फ़ाइल में शामिल करने से पहले एक्सएमएल में एन्कोड करना होगा. उदाहरण के लिए, ऊपर दिए गए सैंपल में, रेगुलर एक्सप्रेशन <\s*script\b[^>]*>[^<]+<\s*\/\s*script\s*> को &lt;\s*script\b[^&gt;]*&gt;[^&lt;]+&lt;\s*\/\s*script\s*&gt; के तौर पर एक्सएमएल कोड में बदला गया है.

इसके अलावा, अगर आपके रेगुलर एक्सप्रेशन में फ़ॉरवर्ड स्लैश (/) का इस्तेमाल किया गया है, तो आपको उन्हें एस्केप करने के लिए, <JSONPayload> escapeSlashCharacter एट्रिब्यूट को true पर सेट करना होगा.

केस-इनसेंसिटिव मैचिंग

केस-इनसेंसिटिव मैचिंग का इस्तेमाल आम तौर पर किया जाता है. यहां दिए गए उदाहरण में बताया गया है कि (?i) कंस्ट्रक्शन का इस्तेमाल करके, रेगुलर एक्सप्रेशन में ऐसा कैसे किया जा सकता है. इस उदाहरण में, DELETE, delete, और Delete सही के तौर पर आकलन करेंगे. 

<Pattern>[\s]*(?i)((delete)|(exec)|(drop\s*table)|(insert)|(shutdown)|(update)|(\bor\b))</Pattern>

रेगुलर एक्सप्रेशन सुरक्षा नीति के बारे में जानकारी

Apigee Edge से, आपको रेगुलर एक्सप्रेशन को कॉन्फ़िगर करने की सुविधा मिलती है. इन रेगुलर एक्सप्रेशन का रनटाइम के दौरान आकलन किया जा सकता है, ताकि कुछ खास पैटर्न को फ़ॉलो करने वाले, कॉन्टेंट लेवल से जुड़े सामान्य खतरों की पहचान की जा सके.

रेगुलर एक्सप्रेशन या रेगुलर एक्सप्रेशन, स्ट्रिंग का ऐसा सेट होता है जो किसी स्ट्रिंग में पैटर्न तय करता है. रेगुलर एक्सप्रेशन की मदद से, पैटर्न के लिए कॉन्टेंट का प्रोग्राम के हिसाब से आकलन किया जा सकता है. उदाहरण के लिए, रेगुलर एक्सप्रेशन का इस्तेमाल करके ईमेल पते का आकलन करके यह पक्का किया जा सकता है कि उसे सही तरीके से स्ट्रक्चर किया गया है या नहीं. ज़्यादा जानकारी के लिए, Java ट्यूटोरियल में रेगुलर एक्सप्रेशन देखें.

regularExpressionProtection का सबसे आम इस्तेमाल, नुकसान पहुंचाने वाले कॉन्टेंट के लिए JSON और एक्सएमएल पेलोड का आकलन करना होता है.

रेगुलर एक्सप्रेशन का इस्तेमाल करके, कॉन्टेंट पर किए जाने वाले सभी हमलों को खत्म नहीं किया जा सकता. सुरक्षा को मज़बूत बनाने के लिए, कई तरीकों का इस्तेमाल किया जाना चाहिए. इस सेक्शन में, कॉन्टेंट को बाहर रखने के लिए सुझाए गए कुछ पैटर्न के बारे में बताया गया है.

शामिल न करने के पैटर्न के उदाहरण

रेगुलर एक्सप्रेशन, नीति की एक्सएमएल कॉन्फ़िगरेशन फ़ाइल में एक्सएमएल कोड में बदले जाने चाहिए.

नाम रेगुलर एक्सप्रेशन
SQL इंजेक्शन 
[\s]*((delete)|(exec)|(drop\s*table)|(insert)|(shutdown)|(update)|(\bor\b))
सर्वर-साइड इन्क्लूज़न इंजेक्शन 
<!--#(include|exec|echo|config|printenv)\s+.*

एक्सएमएल कोड में बदला गया:

&lt;!--#(include|exec|echo|config|printenv)\s+.*
XPath छोटा सिंटैक्स इंजेक्शन 
(/(@?[\w_?\w:\*]+(\[[^]]+\])*)?)+
XPath विस्तृत सिंटैक्स इंजेक्शन 
/?(ancestor(-or-self)?|descendant(-or-self)?|following(-sibling))
JavaScript इंजेक्शन 
<\s*script\b[^>]*>[^<]+<\s*/\s*script\s*>

एक्सएमएल कोड में बदला गया:

&lt;\s*script\b[^&gt;]*&gt;[^&lt;]+&lt;\s*/\s*script\s*&gt;
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

नीति का अंदरूनी नाम. name एट्रिब्यूट की वैल्यू में अक्षर, संख्याएं, स्पेस, हाइफ़न, अंडरस्कोर, और पीरियड शामिल किए जा सकते हैं. इस वैल्यू में 255 से ज़्यादा वर्ण नहीं हो सकते.

इसके अलावा, मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) प्रॉक्सी एडिटर में नीति को आम भाषा में अलग नाम से लेबल करने के लिए, <DisplayName> एलिमेंट का इस्तेमाल करें.

 लागू नहीं ज़रूरी है
continueOnError

इस नीति को false पर सेट करें, ताकि नीति के काम न करने पर गड़बड़ी का मैसेज दिखे. ज़्यादातर नीतियों में, ऐसा आम तौर पर किया जाता है.

किसी नीति के काम न करने पर भी फ़्लो एक्ज़ीक्यूट करने की प्रोसेस को जारी रखने के लिए, true पर सेट करें.

 false ज़रूरी नहीं
enabled

नीति लागू करने के लिए, true पर सेट करें.

नीति को बंद करने के लिए, false पर सेट करें. अगर यह नीति किसी फ़्लो से जुड़ी हुई है, तब भी उसे लागू नहीं किया जाएगा.

 सही ज़रूरी नहीं
async

यह एट्रिब्यूट अब काम नहीं करता.

 false बहिष्कृत

<DisplayName> एलिमेंट

मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) प्रॉक्सी एडिटर में, आम भाषा के अलग नाम से नीति को लेबल करने के लिए, name एट्रिब्यूट का इस्तेमाल करें.

<DisplayName>Policy Display Name</DisplayName>
डिफ़ॉल्ट

लागू नहीं

अगर इस एलिमेंट को छोड़ दिया जाता है, तो नीति के name एट्रिब्यूट की वैल्यू का इस्तेमाल किया जाता है.
मौजूदगी ज़रूरी नहीं
Type String

<सोर्स> एलिमेंट

उस मैसेज को दिखाता है जिससे जानकारी निकालना है.

अगर <Source> एलिमेंट नहीं दिया गया है, तो वैल्यू डिफ़ॉल्ट रूप से message हो जाती है. उदाहरण के लिए, <Source>message</Source>. अगर नीति को message पर सेट किया जाता है, तो अनुरोध के फ़्लो में अटैच किए जाने पर, यह नीति अनुरोध के मैसेज को सोर्स के तौर पर इस्तेमाल करती है. इसी तरह, इस नीति में रिस्पॉन्स फ़्लो के साथ अटैच होने पर, जवाब वाले मैसेज का इस्तेमाल किया जाता है.

अगर सोर्स मैसेज की समस्या को हल नहीं किया जा सकता या वह बिना मैसेज वाले किसी मैसेज में बदल जाता है, तो नीति गड़बड़ी का मैसेज दिखाती है.

<Source>response</Source>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी नहीं
टाइप: String

<ignoreUnresolvedVariables> एलिमेंट

यह नीति तय करती है कि क्या नीति ऐसे वैरिएबल से जुड़ी गड़बड़ी दिखाती है जिसे हल नहीं किया जा सकता.

अगर नीति को false (डिफ़ॉल्ट) पर सेट किया जाता है, तो रिज़ॉल्व न किया जा सकने वाला वैरिएबल मिलने पर, नीति एक गड़बड़ी दिखाती है. अगर इस वैरिएबल को true पर सेट किया जाता है, तो इस वैरिएबल को खाली स्ट्रिंग (शून्य) के तौर पर माना जाता है.

<IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
डिफ़ॉल्ट: false
मौजूदगी: ज़रूरी नहीं
टाइप: बूलियन

<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>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी नहीं
टाइप: लागू नहीं

एट्रिब्यूट

एट्रिब्यूट ब्यौरा डिफ़ॉल्ट मौजूदगी
नाम अनुरोध किए गए उस क्वेरी पैरामीटर का नाम जिससे जानकारी ली जानी है, ताकि उसका आकलन, उपलब्ध कराए गए रेगुलर एक्सप्रेशन के मुकाबले किया जा सके. लागू नहीं ज़रूरी है

<हेडर> एलिमेंट

इस नीति से पता चलता है कि जानकारी को, अनुरोध और रिस्पॉन्स हेडर से निकालना और उपलब्ध कराए गए रेगुलर एक्सप्रेशन के हिसाब से उसका आकलन करना ज़रूरी है. आपको मैच करने के लिए, रेगुलर एक्सप्रेशन पैटर्न तय करने वाला कम से कम एक <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 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> एलिमेंट

XPath के आकलन में इस्तेमाल किए जाने वाले नेमस्पेस के बारे में बताता है.

<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>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी नहीं
टाइप: String

<XMLPayload>/<Namespaces>/<Namespace> एलिमेंट

यह XPath के आकलन में इस्तेमाल किए जाने वाले हर नेमस्पेस के बारे में बताता है.
<Namespaces>
   <Namespace prefix="apigee">http://www.apigee.com</Namespace>
</Namespaces>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी नहीं
टाइप: String

एट्रिब्यूट

एट्रिब्यूट ब्यौरा डिफ़ॉल्ट मौजूदगी
उपसर्ग

दिए गए नेमस्पेस की जानकारी पाने के लिए, प्रीफ़िक्स का इस्तेमाल करता है.

 लागू नहीं ज़रूरी है

<XMLPayload>/<XPath> एलिमेंट

यह बताता है कि किस पाथ का आकलन किया जाना है.
<XPath>
   <Expression>/apigee:Greeting/apigee:User</Expression>
   <Type>string</Type>
   <Pattern>REGEX PATTERN</Pattern>
   <Pattern>REGEX PATTERN</Pattern>
</XPath>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी नहीं
टाइप: लागू नहीं

<XMLPayload>/<XPath>/<Expression> एलिमेंट

वैरिएबल के लिए बनाए गए XPath एक्सप्रेशन के बारे में बताता है. सिर्फ़ XPath 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>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी नहीं
टाइप: String

<XMLPayload>/<XPath>/<Type> एलिमेंट

डेटा टाइप बताता है.
<XPath>
   <Expression>/apigee:Greeting/apigee:User</Expression>
   <Type>string</Type>
   <Pattern>REGEX PATTERN</Pattern>
   <Pattern>REGEX PATTERN</Pattern>
</XPath>
डिफ़ॉल्ट: स्ट्रिंग
मौजूदगी: ज़रूरी नहीं
टाइप: String
मान्य वैल्यू:

स्ट्रिंग. मान्य वैल्यू में string, boolean, int, long, float, double, और nodeset शामिल हैं.

<XMLPayload>/<XPath>/<Pattern> एलिमेंट

रेगुलर एक्सप्रेशन का पैटर्न तय करता है. अगर आपके <Pattern> एलिमेंट के रेगुलर एक्सप्रेशन में एक्सएमएल रिज़र्व किए गए वर्ण (", &, ', <, .) शामिल हैं, तो आपको इसे शामिल करने से पहले एक्सएमएल को कोड में बदलना होगा.

<XPath>
   <Expression>/apigee:Greeting/apigee:User</Expression>
   <Type>string</Type>
   <Pattern>REGEX PATTERN</Pattern>
   <Pattern>REGEX PATTERN</Pattern>
</XPath>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी है
टाइप: String

<JSONPayload> एलिमेंट

इस नीति से पता चलता है कि जानकारी को JSON पेलोड से निकालना और उसका आकलन, दिए गए रेगुलर एक्सप्रेशन के हिसाब से करना होगा.

<JSONPayload>
   <JSONPath>
      <Expression>$.store.book[*].author</Expression>
      <Pattern>REGEX PATTERN</Pattern>
      <Pattern>REGEX PATTERN</Pattern>
   </JSONPath>
</JSONPayload>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी नहीं
टाइप: लागू नहीं

एट्रिब्यूट

एट्रिब्यूट ब्यौरा डिफ़ॉल्ट मौजूदगी
escapeSlashCharacter

<JSONPath>/<Pattern> में, रेगुलर एक्सप्रेशन में किसी भी फ़ॉरवर्ड स्लैश (/) वर्णों को एस्केप करने के लिए, true पर सेट करें.

 सही ज़रूरी नहीं

<JSONPayload>/<JSONPath>/<Expression> एलिमेंट

वैरिएबल के लिए तय किया गया JSONPath एक्सप्रेशन तय करता है.

<JSONPath>
   <Expression>$.store.book[*].author</Expression>
   <Pattern>REGEX PATTERN</Pattern>
   <Pattern>REGEX PATTERN</Pattern>
</JSONPath>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी नहीं
टाइप: String

<JSONPayload>/<JSONPath>/<Pattern> एलिमेंट

रेगुलर एक्सप्रेशन का पैटर्न तय करता है. अगर आपके <Pattern> एलिमेंट के रेगुलर एक्सप्रेशन में एक्सएमएल रिज़र्व किए गए वर्ण (", &, ', < या .) शामिल हैं, तो आपको इसे शामिल करने से पहले एक्सएमएल में कोड में बदलना होगा.

<JSONPath>
   <Expression>$.store.book[*].author</Expression>
   <Pattern>REGEX PATTERN</Pattern>
   <Pattern>REGEX PATTERN</Pattern>
</JSONPath>
डिफ़ॉल्ट: लागू नहीं
मौजूदगी: ज़रूरी है
टाइप: String

गड़बड़ी का रेफ़रंस

यह सेक्शन, इस नीति के ट्रिगर होने पर Edge से सेट किए गए गड़बड़ी कोड और दिखाए गए मैसेज के साथ-साथ गड़बड़ी वाले वैरिएबल के बारे में बताता है. यह जानकारी जानना ज़रूरी है कि क्या आप गड़बड़ियों को ठीक करने के लिए, गड़बड़ी से जुड़े नियम बना रहे हैं. अगर आपको किसी गड़बड़ी को कैप्चर करना है और कस्टम गड़बड़ी को बढ़ाना है, तो नीति के रूट एलिमेंट पर continueOnError="true" एट्रिब्यूट सेट करें. ज़्यादा जानने के लिए, नीति से जुड़ी गड़बड़ियों के बारे में आपके लिए ज़रूरी जानकारी और गड़बड़ियों को ठीक करने के तरीके देखें.

Edge की नीतियों से मिली गड़बड़ियां, एक जैसे फ़ॉर्मैट में होती हैं जैसा कि गड़बड़ी कोड के रेफ़रंस में बताया गया है.

रनटाइम से जुड़ी गड़बड़ियां

नीति के लागू होने पर ये गड़बड़ियां हो सकती हैं.

गड़बड़ी कोड मैसेज
ExecutionFailed regularExpressionProtection चरण के बारे में {0} को लागू नहीं किया जा सका. कारण: {1}
InstantiationFailed regularExpressionProtection के चरण की परिभाषा को इंस्टैंशिएट नहीं किया जा सका {0}
NonMessageVariable चर {0} किसी संदेश का समाधान नहीं करता
SourceMessageNotAvailable {0} RegularExpressionProtection के चरण की परिभाषा के लिए {0}मैसेज उपलब्ध नहीं है {1}
ThreatDetected {0} में रेगुलर एक्सप्रेशन को खतरे का पता चला: रेगुलर एक्सप्रेशन: {1} इनपुट: {2}
VariableResolutionFailed वैरिएबल {0} का समाधान नहीं किया जा सका

डिप्लॉयमेंट से जुड़ी गड़बड़ियां

गड़बड़ी कोड मैसेज समाधान
CannotBeConvertedToNodeset regularExpressionProtection {0}: xpath {1} का परिणाम नोडसेट में रूपांतरित नहीं किया जा सकता. संदर्भ {2}
DuplicatePrefix regularExpressionProtection {0}: डुप्लीकेट प्रीफ़िक्स {1}
EmptyJSONPathExpression regularExpressionProtection {0}: JSONPath के खाली एक्सप्रेशन को खाली करें
EmptyXPathExpression regularExpressionProtection {0}: खाली XPath एक्सप्रेशन
InvalidRegularExpression रेगुलर एक्सप्रेशन प्रोटेक्शन {0}: अमान्य रेगुलर एक्सप्रेशन {1}, कॉन्टेक्स्ट {2}
JSONPathCompilationFailed regularExpressionProtection {0}: jsonpath{1} कंपाइल नहीं किया जा सका. संदर्भ {2}
nonखालीPrefixmappedToEmpty विरोधी रेगुलर एक्सप्रेशन सुरक्षा {0}: खाली प्रीफ़िक्स {1} को खाली यूआरआई पर मैप नहीं किया जा सकता
NoPatternsToEnforce regularExpressionProtection {0}: {1} में लागू करने के लिए कोई पैटर्न नहीं है
NothingToEnforce regularExpressionProtection {0}: यूआरआईPath, QueryParam, हेडर, FormsParam, XMLPayload, और JSONPayload में से कम से कम एक ज़रूरी है
XPathCompilationFailed regularExpressionProtection {0}: xpath {1} को कंपाइल नहीं किया जा सका. संदर्भ {2}

गड़बड़ी वाले वैरिएबल

ये वैरिएबल तब सेट किए जाते हैं, जब इस नीति से कोई गड़बड़ी ट्रिगर होती है. ज़्यादा जानकारी के लिए, नीति से जुड़ी गड़बड़ियों के बारे में आपके लिए ज़रूरी जानकारी देखें.

वैरिएबल जगह उदाहरण
fault.name="fault_name" fault_name, गड़बड़ी का नाम है, जैसा कि ऊपर दी गई टेबल में बताया गया है. fault.name Matches "ThreatDetected"
regularexpressionprotection.policy_name.failed policy_name, उस नीति का उपयोगकर्ता तय किया गया नाम है जिसकी वजह से गड़बड़ी हुई है. regularexpressionprotection.Regular-Expressions-Protection-1.failed = true

स्कीमा

मिलते-जुलते विषय

JSON की खतरे से जुड़ी नीति

एक्सएमएल की खतरे से सुरक्षा की नीति