regularExpressionProtection नीति

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

यह क्या है

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

वीडियो

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

वीडियो जानकारी
SQL इंजेक्ट किए जाने वाले हमलों से उपयोगकर्ताओं की सुरक्षा करना (नया एज) New Edge के अनुभव यूज़र इंटरफ़ेस (यूआई) में रेगुलर एक्सप्रेशन सुरक्षा नीति का इस्तेमाल करके, SQL इंजेक्शन के हमलों से सुरक्षा करें.
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>&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 के हमले वाले पेलोड का आकलन करने के लिए regularExpressionProtection नीति का इस्तेमाल करने का तरीका बताया गया है. खास तौर पर, <JSONPath>/<Expression> से मिले कॉन्टेंट की जांच करने के लिए, <JSONPath>/<Pattern> में मौजूद रेगुलर एक्सप्रेशन की तुलना की जाती है.

अगर आपके <JSONPath>/<Pattern> के रेगुलर एक्सप्रेशन में XML-रिज़र्व किए गए वर्ण " (", और ', < या .) शामिल हैं, तो आपको इसे नीति एक्सएमएल कॉन्फ़िगरेशन फ़ाइल में शामिल करने से पहले, एक्सएमएल कोड में बदलना होगा. उदाहरण के लिए, ऊपर दिए गए नमूने में, रेगुलर एक्सप्रेशन <\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:\*]+(\[[^]]+\])*)?)+
बड़ा किया गया सिंटैक्स इंजेक्शन 
/?(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 पेलोड के अनुरोध में, 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

इस एट्रिब्यूट के इस्तेमाल पर रोक लगा दी गई है.

 गलत बहिष्कृत

<DisplayName> एलिमेंट

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

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

लागू नहीं

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

<Source> एलिमेंट

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

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

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

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

<इसे अनदेखा न किए गए वैरिएबल> अनदेखा करें

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

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

विशेषताएं

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

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

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

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

विशेषताएं

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

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

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

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

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

डेटाटाइप दिखाता है.
<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> एलिमेंट

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

विशेषताएं

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

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

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

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

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

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

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

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

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

गड़बड़ी कोड मैसेज
एक्ज़ीक्यूशन नहीं हो सका regularExpressionProtection चरण परिभाषा {0}एक्ज़ीक्यूट नहीं की जा सकी. कारण: {1}
इंस्टैंशिएशन फ़ेल regularExpressionProtection चरण परिभाषा को तुरंत चालू नहीं किया जा सका
NonMessageVariable वैरिएबल, मैसेज में मौजूद नहीं है
SourceMessageउपलब्ध नहीं है {0} रेगुलर एक्सप्रेशन एक्सप्रेस-स्टेप डेफ़िनिशन के लिए मैसेज उपलब्ध नहीं है {1}
खतरे का पता चला रेगुलर एक्सप्रेशन खतरे का पता चला: {0}: रेगुलर एक्सप्रेशन: {1} इनपुट: {2}
वैरिएबल रिज़ॉल्यूशन प्रोसेस नहीं हो सका वैरिएबल {0}{0/} को ठीक नहीं किया जा सका

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

गड़बड़ी कोड मैसेज समाधान
BeConvertToToNodeset को नहीं बदला जा सकता regularExpressionProtection: {0}xpath के परिणाम {1} को नोडसेट में बदला नहीं जा सकता. संदर्भ {2}
डुप्लीकेट उपसर्ग regularExpressionProtection: {0} डुप्लीकेट प्रीफ़िक्स {1}
खाली JSONPathExpression regularExpressionProtection: {0}खाली JSONPath एक्सप्रेशन
खाली XPathExpression regularExpressionProtection: खाली XPath एक्सप्रेशन
अमान्य रेगुलर एक्सप्रेशन regularExpressionProtection: {0} अमान्य रेगुलर एक्सप्रेशन {1}, संदर्भ {2}
JSONPathCompilationFailed regularExpressionProtection: {0}jsonpath {1} को कंपाइल नहीं किया जा सका. संदर्भ {2}
NONblankPrefixMapToFreeURI regularExpressionProtection: {0}खाली प्रीफ़िक्स {1} को खाली यूआरआई से मैप नहीं किया जा सकता
कोई पैटर्न लागू नहीं है regularExpressionProtection: {1} में कोई पैटर्न लागू नहीं करना चाहिए
लागू करने के लिए कुछ नहीं regularExpressionProtection: {0}कम से कम एक यूआरआईपाथ, QueryParam, हेडर, FormsParam, XMLPayload, JSONPayload ज़रूरी है
एचटीटीपी कंपाइलेशन 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 से जुड़े खतरों से बचाने की नीति

एक्सएमएल थ्रेट से जुड़ी सुरक्षा नीति