GenerateJWS नीति

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

क्या

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

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

वीडियो

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

सैंपल

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

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

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

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

header.payload.signature

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

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

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

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

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

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

पॉलिसी के रेफ़रंस में, 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 हेडर में दिए गए हर हेडर के लिए, यह जांच करता है कि <KnownHeaders> एलिमेंट VerifyJWS नीति में वह हेडर भी शामिल होता है. ऐसा कोई भी हेडर जो VerifyJWS नीति को crit में मिलता है जिसकी जानकारी <KnownHeaders> में भी नहीं दी गई है उसकी वजह से VerifyJWS नीति फ़ेल हो जाती है.

<DetachContent>

<DetachContent>true|false</DetachContent>

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

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

header.payload.signature

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

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

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

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>