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

<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>

इससे यह तय होता है कि JWS को डिटैच किए गए पेलोड <DetachContent>true</DetachContent> के साथ जनरेट करना है या नहीं <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-here" />

or

<Payload>payload-value</Payload>

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

<PrivateKey/Id>

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

or

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

यह JWS हेडर में शामिल करने के लिए, कुंजी आईडी (kid) के बारे में बताता है. इसका इस्तेमाल सिर्फ़ तब करें, जब एल्गोरिदम 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 में से कोई एक हो.

<PrivateKey/Value>

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

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

<SecretKey/Id>

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

or

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

इस विकल्प का इस्तेमाल करके, एचएमएसी एल्गोरिदम से साइन किए गए JWS के हेडर में शामिल करने के लिए, कुंजी आईडी (kid) तय किया जाता है. इसका इस्तेमाल सिर्फ़ तब करें, जब एल्गोरिदम 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 बाइट होनी चाहिए. कमज़ोर कुंजी का इस्तेमाल करने पर, रनटाइम में गड़बड़ी होती है.

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

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>