GenerateJWS नीति

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

यह क्या है

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

JWS के हिस्सों के बारे में जानने और उन्हें एन्क्रिप्ट (सुरक्षित) और साइन करने के तरीके के बारे में जानने के लिए, RFC7515 देखें.

वीडियो

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

सैंपल

HS256 एल्गोरिदम की मदद से साइन किया गया, अटैच किया गया JWS जनरेट करें

यह उदाहरण नीति, अटैच किया गया JWS जनरेट करती है और HS256 एल्गोरिदम का इस्तेमाल करके उसे साइन करती है. हस्ताक्षर करने और उसकी पुष्टि करने के लिए, HS256 शेयर की गई जानकारी का इस्तेमाल करता है.

अटैच किए गए JWS में, कोड में बदला गया हेडर, पेलोड, और सिग्नेचर शामिल है:

header.payload.signature

डिटैच किया गया कॉन्टेंट जनरेट करने के लिए, <DetachContent> को 'सही है' पर सेट करें. JWS के स्ट्रक्चर और फ़ॉर्मैट के बारे में ज़्यादा जानकारी के लिए, JWS/JWT के हिस्से देखें.

रॉ और बिना कोड में बदले गए JWS पेलोड के बारे में बताने के लिए, <Payload> एलिमेंट का इस्तेमाल करें. इस उदाहरण में, वैरिएबल में पेलोड शामिल है. जब नीति से जुड़ी इस कार्रवाई को ट्रिगर किया जाता है, तब Edge, JWS हेडर और पेलोड को कोड में बदल देता है. इसके बाद, JWS को डिजिटल रूप से साइन करने के लिए, वह कोड में बदले गए सिग्नेचर को जोड़ता है.

नीचे दिया गया नीति कॉन्फ़िगरेशन, private.payload वैरिएबल में शामिल पेलोड से JWS बनाता है.

<GenerateJWS name="JWS-Generate-HS256">
    <DisplayName>JWS Generate HS256</DisplayName>
    <Algorithm>HS256</Algorithm>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <SecretKey>
        <Value ref="private.secretkey"/>
        <Id>1918290</Id>
    </SecretKey>
    <Payload ref="private.payload" />
    <OutputVariable>jws-variable</OutputVariable>
</GenerateJWS>

RS256 एल्गोरिदम की मदद से, साइन किया गया अलग JWS जनरेट करें

उदाहरण के लिए दी गई यह नीति, अलग JWS को जनरेट करती है और RS256 एल्गोरिदम का इस्तेमाल करके उस पर साइन करती है. RS256 सिग्नेचर जनरेट होने पर, आरएसए निजी कुंजी का इस्तेमाल किया जाता है. यह कुंजी, PEM के कोड में बदले गए फ़ॉर्म में दी जानी चाहिए.

अलग किया गया JWS, JWS से पेलोड को हटा देता है:

header..signature

रॉ और बिना कोड में बदले गए JWS पेलोड के बारे में बताने के लिए, <Payload> एलिमेंट का इस्तेमाल करें. इस नीति के ट्रिगर होने पर, Edge, JWS हेडर और पेलोड को कोड में बदल देता है. साथ ही, कोड में बदले गए सिग्नेचर को जनरेट करने के लिए उनका इस्तेमाल करता है. हालांकि, जनरेट किया गया JWS पेलोड को छोड़ देता है. यह आपको तय करना होता है कि पेलोड को ConfirmJWS नीति के <DetachedContent> एलिमेंट का इस्तेमाल करके पास किया जाए.

<GenerateJWS name="JWS-Generate-RS256">
    <DisplayName>JWS Generate RS256</DisplayName>
    <Algorithm>RS256</Algorithm>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <PrivateKey>
        <Value ref="private.privatekey"/>
        <Password ref="private.privatekey-password"/>
        <Id ref="private.privatekey-id"/>
    </PrivateKey>
    <Payload ref="private.payload" />
    <DetachContent>true</DetachContent>
    <OutputVariable>jws-variable</OutputVariable>
</GenerateJWS>

मुख्य एलिमेंट सेट करना

JWS को जनरेट करने वाली कुंजी तय करने के लिए इस्तेमाल किए जाने वाले एलिमेंट, चुने गए एल्गोरिदम पर निर्भर करते हैं. जैसा कि इस टेबल में दिखाया गया है:

एल्‍गोरि‍दम मुख्य एलिमेंट
HS{256/384/512}* 
<SecretKey>
  <Value ref="private.secretkey"/>
  <Id>1918290</Id>
</SecretKey>
RS/PS/ES{256/384/512}* 
<PrivateKey>
  <Value ref="private.privatekey"/>
  <Password ref="private.privatekey-password"/>
  <Id ref="private.privatekey-id"/>
</PrivateKey>

<Password> और <Id> एलिमेंट ज़रूरी नहीं हैं.
*अहम शर्तों के बारे में ज़्यादा जानने के लिए, सिग्नेचर एन्क्रिप्शन एल्गोरिदम के बारे में जानकारी देखें.

JWS जनरेट करने के लिए एलिमेंट रेफ़रंस

नीति के रेफ़रंस से, JWS नीति जनरेट करने के एलिमेंट और एट्रिब्यूट के बारे में जानकारी मिलती है.

ध्यान दें: आपके एन्क्रिप्शन एल्गोरिदम के आधार पर, कॉन्फ़िगरेशन कुछ-कुछ अलग होगा. इस्तेमाल के खास उदाहरणों से जुड़े कॉन्फ़िगरेशन की जानकारी देने वाले उदाहरण देखने के लिए, सैंपल देखें.

टॉप-लेवल एलिमेंट पर लागू होने वाले एट्रिब्यूट

<GenerateJWS name="JWS" continueOnError="false" enabled="true" async="false">

ये एट्रिब्यूट, नीति के सभी पैरंट एलिमेंट के लिए एक जैसे होते हैं.

एट्रिब्यूट जानकारी डिफ़ॉल्ट मौजूदगी
नाम नीति का अंदरूनी नाम. नाम में इस्तेमाल किए जाने वाले वर्ण, इन तक सीमित हैं: A-Z0-9._\-$ %. हालांकि, Edge मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) अतिरिक्त पाबंदियां लागू करता है. जैसे, उन वर्णों को अपने-आप हटाना जो अक्षर और अंक नहीं हैं.

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

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

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

 false ज़रूरी नहीं
चालू किया गया नीति लागू करने के लिए, true पर सेट करें.

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

 सही ज़रूरी नहीं
async यह एट्रिब्यूट अब काम नहीं करता. false बहिष्कृत

<DisplayName>

<DisplayName>Policy Display Name</DisplayName>

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

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

<Algorithm>

<Algorithm>algorithm-here</Algorithm>

टोकन पर हस्ताक्षर करने के लिए, एन्क्रिप्ट (सुरक्षित) करने का एल्गोरिदम तय करता है.

डिफ़ॉल्ट लागू नहीं
मौजूदगी ज़रूरी है
स्ट्रीम किस तरह की है स्ट्रिंग
मान्य वैल्यू HS256, HS384, HS512, RS256, RS384, RS512, ES256, ES384, ES512, PS256, PS384, PS512

<additionalHeaders/दावा>

<AdditionalHeaders>
    <Claim name='claim1'>explicit-value-of-claim-here</Claim>
    <Claim name='claim2' ref='variable-name-here'/>
    <Claim name='claim3' ref='variable-name-here' type='boolean'/>
    <Claim name='claim4' ref='variable-name' type='string' array='true'/>
 </AdditionalHeaders>

JWS के हेडर में अतिरिक्त दावे के नाम/वैल्यू पेयर को जोड़ता है.

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

<Claim> एलिमेंट में ये एट्रिब्यूट शामिल होते हैं:

  • name - (ज़रूरी है) दावे का नाम.
  • ref - (ज़रूरी नहीं) फ़्लो वैरिएबल का नाम. अगर यह वैल्यू मौजूद है, तो नीति इस वैरिएबल की वैल्यू को दावे के तौर पर इस्तेमाल करेगी. अगर ref एट्रिब्यूट और साफ़ तौर पर दावे की वैल्यू, दोनों के बारे में बताया गया है, तो अश्लील वैल्यू को डिफ़ॉल्ट माना जाता है. इसका इस्तेमाल तब किया जाता है, जब रेफ़र किए गए फ़्लो वैरिएबल से जुड़ी गड़बड़ी का पता नहीं चलता हो.
  • type - (ज़रूरी नहीं) इनमें से कोई एक: स्ट्रिंग (डिफ़ॉल्ट), संख्या, बूलियन या मैप
  • array - (ज़रूरी नहीं) यह बताने के लिए कि वैल्यू, टाइप का कलेक्शन है या नहीं, true पर सेट करें. डिफ़ॉल्ट: 'गलत'.

<CriticalHeaders>

<CriticalHeaders>a,b,c</CriticalHeaders>

or:

<CriticalHeaders ref=’variable_containing_headers’/>

JWS में ज़रूरी हेडर, क्रिट जोड़ता है. crit हेडर, हेडर के नामों की कैटगरी है. यह ज़रूरी है कि JWS रिसीवर को इसकी जानकारी मिले और उसकी पहचान की जाए. उदाहरण के लिए:

{
  “typ: “...”,
  “alg” : “...”,
  “crit” : [ “a”, “b”, “c” ],
}

रनटाइम के दौरान, VerifyJWS नीति क्रिट हेडर की जांच करती है. crit हेडर में दिए गए हर हेडर के लिए, यह जांच करता है कि VerifyJWS नीति का <KnownHeaders> एलिमेंट भी उस हेडर को शामिल करता है या नहीं. पुष्टि करने के लिएJWS नीति को crit में मिलने वाला ऐसा कोई भी हेडर जो <KnownHeaders> में भी शामिल नहीं है, पुष्टि करने वाली JWS नीति फ़ेल हो जाती है.

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

<DetachContent>

<DetachContent>true|false</DetachContent>

इस नीति से तय होता है कि अलग किए गए पेलोड के साथ JWS को जनरेट करना है या नहीं, <DetachContent>true</DetachContent>, या नहीं, <DetachContent>false</DetachContent>.

'गलत है' के तौर पर सेट करने पर, डिफ़ॉल्ट तौर पर जनरेट किया गया JWS इस फ़ॉर्म में होता है:

header.payload.signature

अगर आपने डिटैच्ड पेलोड बनाने के लिए 'सही' तय किया है, तो जनरेट किया गया JWS पेलोड को छोड़ देता है और इस फ़ॉर्म में होता है:

header..signature

अलग किए गए पेलोड के साथ, कोड में न बदली गई मूल पेलोड को पुष्टि करें JWS नीति में भेजने की ज़िम्मेदारी आपकी है. ऐसा करने के लिए, verificationJWS नीति के <DetachedContent> एलिमेंट का इस्तेमाल करें.

डिफ़ॉल्ट false
मौजूदगी ज़रूरी नहीं
स्ट्रीम किस तरह की है बूलियन
मान्य वैल्यू सही या गलत

<IgnoreUnresolvedVariables>

<IgnoreUnresolvedVariables>true|false</IgnoreUnresolvedVariables>

अगर नीति में बताए गए किसी भी रेफ़र किए गए वैरिएबल को ठीक नहीं किया जा सकता, तो नीति से गड़बड़ी होने की सूचना मिलने पर, 'गलत' पर सेट करें. किसी भी हल न किए जा सकने वाले वैरिएबल को खाली स्ट्रिंग के तौर पर मेज़र करने के लिए, 'सही' पर सेट करें.

डिफ़ॉल्ट false
मौजूदगी ज़रूरी नहीं
स्ट्रीम किस तरह की है बूलियन
मान्य वैल्यू सही या गलत

<OutputVariable>

<OutputVariable>JWS-variable</OutputVariable>

इससे पता चलता है कि इस नीति के तहत जनरेट की गई JWS को कहां रखा जाएगा. डिफ़ॉल्ट रूप से, इसे फ़्लो वैरिएबल jws.POLICYNAME.generated_jws में रखा जाता है.

डिफ़ॉल्ट jws.POLICYNAME.generated_jws
मौजूदगी ज़रूरी नहीं
स्ट्रीम किस तरह की है स्ट्रिंग (एक फ़्लो वैरिएबल का नाम)

<Payload>

<Payload ref="flow-variable-name-here" />

or

<Payload>payload-value</Payload>

यह नीति का रॉ और बिना कोड में बदले गए JWS पेलोड के बारे में जानकारी देती है. पेलोड या स्ट्रिंग वाला कोई वैरिएबल डालें.

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

<PrivateKey/Id>

<PrivateKey>
  <Id ref="flow-variable-name-here"/>
</PrivateKey>

or

<PrivateKey>
  <Id>your-id-value-here</Id>
</PrivateKey>

JWS हेडर में शामिल करने के लिए कुंजी आईडी (बच्चे) तय करता है. इसका इस्तेमाल सिर्फ़ तब करें, जब एल्गोरिदम RS256/RS384/RS512, PS256/PS384/PS512 या ES256/ES384/ES512 में से कोई एक हो.

डिफ़ॉल्ट लागू नहीं
मौजूदगी ज़रूरी नहीं
स्ट्रीम किस तरह की है स्ट्रिंग
मान्य वैल्यू फ़्लो वैरिएबल या स्ट्रिंग

<PrivateKey/Password>

<PrivateKey>
  <Password ref="private.privatekey-password"/>
</PrivateKey>

ज़रूरत पड़ने पर, निजी पासकोड को डिक्रिप्ट करने के लिए, नीति के लिए इस्तेमाल किया जाने वाला पासवर्ड तय करें. फ़्लो वैरिएबल में कुंजी पास करने के लिए, ref एट्रिब्यूट का इस्तेमाल करें. इसका इस्तेमाल सिर्फ़ तब करें, जब एल्गोरिदम RS256/RS384/RS512, PS256/PS384/PS512 या ES256/ES384/ES512 में से कोई एक हो.

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

ध्यान दें: आपको एक फ़्लो वैरिएबल तय करना होगा. Edge, नीति के उस कॉन्फ़िगरेशन को अमान्य मानकर अस्वीकार कर देगा जिसमें पासवर्ड को सादे टेक्स्ट में बताया गया है. फ़्लो वैरिएबल में प्रीफ़िक्स "private" होना चाहिए. उदाहरण के लिए, private.mypassword

<PrivateKey/Value>

<PrivateKey>
  <Value ref="private.variable-name-here"/>
</PrivateKey>

यह नीति, PEM से कोड में बदली गई ऐसी निजी कुंजी के बारे में बताती है जिसका इस्तेमाल JWS को साइन करने के लिए किया जाता है. फ़्लो वैरिएबल में कुंजी पास करने के लिए, ref एट्रिब्यूट का इस्तेमाल करें. सिर्फ़ तब इस्तेमाल करें, जब एल्गोरिदम RS256/RS384/RS512, PS256/PS384/PS512 या ES256/ES384/ES512 में से एक हो.

डिफ़ॉल्ट लागू नहीं
मौजूदगी RS256 एल्गोरिदम का इस्तेमाल करके, JWS जनरेट करने के लिए ज़रूरी है.
स्ट्रीम किस तरह की है स्ट्रिंग
मान्य वैल्यू एक फ़्लो वैरिएबल, जिसमें एक स्ट्रिंग है. यह PEM-एन्कोडेड आरएसए निजी कुंजी की वैल्यू को दिखाती है.

ध्यान दें: फ़्लो वैरिएबल में प्रीफ़िक्स "private" होना चाहिए. उदाहरण के लिए, private.mykey

<SecretKey/आईडी>

<SecretKey>
  <Id ref="flow-variable-name-here"/>
</SecretKey>

or

<SecretKey>
  <Id>your-id-value-here</Id>
</SecretKey>

एचएमएसी एल्गोरिदम की मदद से साइन किए गए JWS हेडर में शामिल करने के लिए, कुंजी आईडी (बच्चे) से जुड़ी जानकारी तय करता है. इसका इस्तेमाल सिर्फ़ तब करें, जब एल्गोरिदम HS256/HS384/HS512 में से एक हो.

डिफ़ॉल्ट लागू नहीं
मौजूदगी ज़रूरी नहीं
स्ट्रीम किस तरह की है स्ट्रिंग
मान्य वैल्यू फ़्लो वैरिएबल या स्ट्रिंग

<SecretKey/Value>

<SecretKey>
  <Value ref="private.your-variable-name"/>
</SecretKey>

एचएमएसी एल्गोरिदम की मदद से, टोकन की पुष्टि करने या उन पर हस्ताक्षर करने के लिए इस्तेमाल की जाने वाली सीक्रेट कुंजी देता है. इसका इस्तेमाल सिर्फ़ तब करें, जब एल्गोरिदम HS256/HS384/HS512 में से एक हो. फ़्लो वैरिएबल में कुंजी पास करने के लिए, ref एट्रिब्यूट का इस्तेमाल करें.

Edge, HS256/HS384/HS512 एल्गोरिदम के लिए, ज़रूरी वैल्यू को कम से कम लागू करता है. HS256 के लिए कुंजी की लंबाई कम से कम 32 बाइट होनी चाहिए, HS384 के लिए यह 48 बाइट और HS512 के लिए 64 बाइट होनी चाहिए. कम क्षमता वाली कुंजी का इस्तेमाल करने से रनटाइम में गड़बड़ी होती है.

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

ध्यान दें: अगर कोई फ़्लो वैरिएबल है, तो उसका प्रीफ़िक्स "private" होना चाहिए. उदाहरण के लिए, private.mysecret

फ़्लो वैरिएबल

JWS जनरेट करने की नीति, फ़्लो वैरिएबल सेट नहीं करती.

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

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

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

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

गड़बड़ी का कोड एचटीटीपी कोड स्थिति कब होता है
steps.jws.GenerationFailed 401 यह नीति, JWS को जनरेट नहीं कर सकी.
steps.jws.InsufficientKeyLength 401 HS256 एल्गोरिदम के लिए, 32 बाइट से कम की कुंजी के लिए
steps.jws.InvalidClaim 401 ऐसा दावा जो मौजूद नहीं है या दावे से मेल नहीं खाता, या हेडर या हेडर मेल नहीं खाता.
steps.jws.InvalidCurve 401 कुंजी से तय किया गया कर्व, एलिप्टिक कर्व एल्गोरिदम के लिए मान्य नहीं है.
steps.jws.InvalidJsonFormat 401 JWS हेडर में अमान्य JSON मिला.
steps.jws.InvalidPayload 401 JWS पेलोड अमान्य है.
steps.jws.InvalidSignature 401 <DetachedContent> को हटाया गया है और JWS में अलग कॉन्टेंट पेलोड है.
steps.jws.KeyIdMissing 401 पुष्टि करने की नीति के तहत, सार्वजनिक कुंजियों के लिए सोर्स के तौर पर JWKS का इस्तेमाल किया जाता है. हालांकि, साइन की गई JWS नीति के हेडर में kid प्रॉपर्टी शामिल नहीं होती.
steps.jws.KeyParsingFailed 401 सार्वजनिक कुंजी को दी गई कुंजी से पार्स नहीं किया जा सका.
steps.jws.MissingPayload 401 JWS पेलोड मौजूद नहीं है.
steps.jws.NoAlgorithmFoundInHeader 401 ऐसा तब होता है, जब JWS इस एल्गोरिदम हेडर को छोड़ देता है.
steps.jws.SigningFailed 401 GeneJWS में, HS384 या HS512 एल्गोरिदम के कम से कम साइज़ से कम वाली कुंजी के लिए
steps.jws.UnknownException 401 एक अज्ञात अपवाद हुआ.
steps.jws.WrongKeyType 401 कुंजी का गलत प्रकार बताया गया. उदाहरण के लिए, अगर आपने एलिप्टिक कर्व एल्गोरिदम के लिए आरएसए कुंजी या आरएसए एल्गोरिदम के लिए कोई कर्व कुंजी तय की है.

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

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

गड़बड़ी का नाम कब होता है
InvalidAlgorithm सिर्फ़ ये वैल्यू मान्य हैं: RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384, ES512, HS256, HS384, HS512.

EmptyElementForKeyConfiguration

FailedToResolveVariable

InvalidConfigurationForActionAndAlgorithmFamily

InvalidConfigurationForVerify

InvalidEmptyElement

InvalidFamiliesForAlgorithm

InvalidKeyConfiguration

InvalidNameForAdditionalClaim

InvalidNameForAdditionalHeader

InvalidPublicKeyId

InvalidPublicKeyValue

InvalidSecretInConfig

InvalidTypeForAdditionalClaim

InvalidTypeForAdditionalHeader

InvalidValueForElement

InvalidValueOfArrayAttribute

InvalidVariableNameForSecret

MissingConfigurationElement

MissingElementForKeyConfiguration

MissingNameForAdditionalClaim

MissingNameForAdditionalHeader

 डिप्लॉयमेंट की दूसरी संभावित गड़बड़ियां.

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

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

वैरिएबल जगह उदाहरण
fault.name="fault_name" fault_name, गड़बड़ी का नाम है, जैसा कि ऊपर रनटाइम की गड़बड़ियां टेबल में दिया गया है. गड़बड़ी का नाम, गड़बड़ी के कोड का आखिरी हिस्सा होता है. fault.name Matches "TokenExpired"
JWS.failed सफल न होने पर, JWS नीतियां एक ही वैरिएबल सेट करती हैं. jws.JWS-Policy.failed = true

गड़बड़ी के जवाब का उदाहरण

गड़बड़ी को ठीक करने के लिए, सबसे सही तरीका यह है कि आप गड़बड़ी के रिस्पॉन्स के errorcode वाले हिस्से को फंसा दें. faultstring के टेक्स्ट पर भरोसा न करें, क्योंकि यह बदल सकता है.

गड़बड़ी के नियम का उदाहरण

<FaultRules>
    <FaultRule name="JWS Policy Errors">
        <Step>
            <Name>JavaScript-1</Name>
            <Condition>(fault.name Matches "TokenExpired")</Condition>
        </Step>
        <Condition>JWS.failed=true</Condition>
    </FaultRule>
</FaultRules>