GenerateJWS नीति

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

क्या

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

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

वीडियो

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

सैंपल

• HS256 एल्गोरिदम से हस्ताक्षर किया गया अटैच किया गया JWS जनरेट करना
• RS256 एल्गोरिदम का इस्तेमाल करके, हस्ताक्षर किया गया अलग किया गया JWS जनरेट करना

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

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

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

header.payload.signature

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

<Payload> एलिमेंट का इस्तेमाल करके, बिना कोड में बदले गए JWS पेलोड की जानकारी दें. इस उदाहरण में, एक वैरिएबल में पेलोड शामिल है. इस नीति के लागू होने पर, 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 सिग्नेचर जनरेट करने के लिए, RSA निजी कुंजी की ज़रूरत होती है. इसे PEM-encoded फ़ॉर्म में उपलब्ध कराना ज़रूरी है.

डिटैच किए गए JWS में, JWS से पेलोड हटा दिया जाता है:

header..signature

<Payload> एलिमेंट का इस्तेमाल करके, बिना कोड में बदले गए JWS पेलोड की जानकारी दें. इस नीति के ट्रिगर होने पर, Edge, JWS हेडर और पेलोड को कोड में बदलता है. इसके बाद, इनका इस्तेमाल कोड में बदले गए हस्ताक्षर को जनरेट करने के लिए करता है. हालांकि, जनरेट किए गए JWS में पेलोड शामिल नहीं होता है. VerifyJWS नीति के <DetachedContent> एलिमेंट का इस्तेमाल करके, पेलोड को VerifyJWS नीति में पास करने की ज़िम्मेदारी आपकी है.

<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 जनरेट करने के लिए इस्तेमाल की गई कुंजी के बारे में बताने वाले एलिमेंट, चुने गए एल्गोरिदम पर निर्भर करते हैं. इस बारे में यहां दी गई टेबल में बताया गया है:

<SecretKey>
  <Value ref="private.secretkey"/>
  <Id>1918290</Id>
</SecretKey>

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

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

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

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

ऐसे एट्रिब्यूट जो टॉप-लेवल के एलिमेंट पर लागू होते हैं

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

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

<DisplayName>

<DisplayName>Policy Display Name</DisplayName>

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

<Algorithm>

<Algorithm>algorithm-here</Algorithm>

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

<AdditionalHeaders/Claim>

<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 पर सेट करें. डिफ़ॉल्ट: false.

<CriticalHeaders>

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

or:

<CriticalHeaders ref=’variable_containing_headers’/>

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

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

रनटाइम के दौरान, VerifyJWS नीति, crit हेडर की जांच करती है. crit हेडर में शामिल हर हेडर के लिए, यह जांच करता है कि VerifyJWS नीति के <KnownHeaders> एलिमेंट में भी वह हेडर शामिल हो. अगर VerifyJWS नीति को crit हेडर में कोई ऐसा हेडर मिलता है जो <KnownHeaders> में शामिल नहीं है, तो VerifyJWS नीति लागू नहीं होगी.

<DetachContent>

<DetachContent>true|false</DetachContent>

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

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

header.payload.signature

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

header..signature

डिटैच किए गए पेलोड के साथ, यह आपकी ज़िम्मेदारी है कि आप VerifyJWS नीति को ओरिजनल अनकोड किया गया पेलोड पास करें. इसके लिए, VerifyJWS नीति के <DetachedContent> एलिमेंट का इस्तेमाल करें.

<IgnoreUnresolvedVariables>

<IgnoreUnresolvedVariables>true|false</IgnoreUnresolvedVariables>

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

<OutputVariable>

<OutputVariable>JWS-variable</OutputVariable>

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

<Payload>

<Payload ref="flow-variable-name-he>re&quo<t; /

o>r

Payloadpay<load-val>ue/Payload

यह रॉ, अनकोड किया गया JWS पेलोड दिखाता है. पेलोड या स्ट्रिंग वाला कोई वैरिएबल तय करें.

<PrivateKey/Id>

<PrivateKey>
  <Id ref="flow-variable-name-h>e<re"/
/>Privat<eKey

or

>Pri<va>teKey
  Idyour-id-<val>u<e-here/Id
/>PrivateKey

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

<PrivateKey/Password>

<PrivateKey>
  <Password ref="private.privatekey-passw>o<rd"/
/>PrivateKey

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

<PrivateKey/Value>

<PrivateKey>
  <Value ref="private.variable-name-h>e<re"/
/>PrivateKey

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

<SecretKey/Id>

<SecretKey>
  <Id ref="flow-variable-name-h>e<re"/
>/Secre<tKey

or
>
Se<cr>etKey
  Idyour-id-<val>u<e-here/Id
>/SecretKey

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

<SecretKey/Value>

<SecretKey>
  <Value ref="private.your-variable-n>a<me"/
>/SecretKey

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

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

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

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

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

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

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

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

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

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

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

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

गड़बड़ी के रिस्पॉन्स का उदाहरण

गड़बड़ी ठीक करने के लिए, सबसे सही तरीका यह है कि गड़बड़ी के 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>