regularExpressionProtection नीति

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

क्या

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

वीडियो

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

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

सैंपल

GitHub

GitHub पर मौजूद regex-protection सैंपल से पता चलता है कि क्वेरी पैरामीटर के ज़रिए किए गए संभावित एसक्यूएल इंजेक्शन हमलों को कैसे रोका जा सकता है. इसके अलावा, इस सैंपल में सामान्य 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 की वैल्यू true होगी. 

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

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

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

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

RegularExpressionProtection का सबसे ज़्यादा इस्तेमाल, JSON और XML पेलोड में मौजूद नुकसान पहुंचाने वाले कॉन्टेंट का आकलन करने के लिए किया जाता है.

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

बाहर रखने के पैटर्न के उदाहरण

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

नाम रेगुलर एक्सप्रेशन
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 Abbreviated Syntax Injection 
(/(@?[\w_?\w:\*]+(\[[^]]+\])*)?)+
XPath Expanded Syntax Injection 
/?(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 Injection 
.*?Exception in thread.*

XML या JSON पेलोड वाले अनुरोध में Content-Type हेडर सेट करना

रेगुलर एक्सप्रेशन प्रोटेक्शन नीति के पेलोड में ये एलिमेंट शामिल हो सकते हैं:

  • <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 पर सेट करें विफल होता है.

 गलत वैकल्पिक
enabled

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

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

 सही वैकल्पिक
async

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

 गलत बहिष्कृत

&lt;DisplayName&gt; एलिमेंट

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

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

लागू नहीं

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

<Source> एलिमेंट

इससे उस मैसेज के बारे में पता चलता है जिससे जानकारी निकालनी है.

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

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

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

<IgnoreUnresolvedVariables> एलिमेंट

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

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

<IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
डिफ़ॉल्ट: गलत
मौजूदगी: वैकल्पिक
टाइप: बूलियन

<URIPath> एलिमेंट

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

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

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

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

विशेषताएं

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

यह किसी दिए गए नेमस्पेस को क्वालिफ़ाई करने में मदद करने के लिए, प्रीफ़िक्स उपलब्ध कराता है.

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

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

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

<XMLPayload>/<XPath>/<Expression> element

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

<XMLPayload>/<XPath>/<Type> element

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

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

<XMLPayload>/<XPath>/<Pattern> element

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

<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

true पर सेट करें, ताकि <JSONPath>/<Pattern> में मौजूद रेगुलर एक्सप्रेशन में किसी भी फ़ॉरवर्ड स्लैश (/) वर्ण से बचा जा सके.

 सही वैकल्पिक

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

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

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

<JSONPayload>/<JSONPath>/<Pattern> element

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

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

गड़बड़ी की जानकारी

यह सेक्शन, इस नीति के ट्रिगर होने पर 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 थ्रेट प्रोटेक्शन नीति

एक्सएमएल थ्रेट प्रोटेक्शन की नीति