GenerateJWS policy

מדיניות ניתנת להרחבה

הדף הזה רלוונטי ל-Apigee ול-Apigee Hybrid.

לעיון במסמכי התיעוד של Apigee Edge

המדיניות GenerateJWS יוצרת JWS חתום, עם קבוצה של טענות שאפשר להגדיר. לאחר מכן אפשר להחזיר את ה-JWS ללקוחות, להעביר אותו ליעדי קצה עורפיים או להשתמש בו בדרכים אחרות. מידע נוסף זמין במאמר סקירה כללית על מדיניות JWS ו-JWT.

מידע על החלקים של JWS ועל האופן שבו הם מוצפנים ונחתמים זמין ב-RFC7515.

המדיניות הזו היא מדיניות שניתנת להרחבה, והשימוש בה עשוי להשפיע על העלויות או על הניצול, בהתאם לרישיון שלכם ל-Apigee. למידע על סוגי מדיניות והשלכות השימוש, אפשר לעיין במאמר בנושא סוגי מדיניות.

דוגמאות

יצירת JWS חתום באמצעות HS256

מדיניות לדוגמה שיוצרת JWS שנחתם באמצעות האלגוריתם HS256. ‫HS256 מסתמך על סוד משותף גם לחתימה וגם לאימות החתימה. ה-JWS הזה משתמש בתוכן 'מצורף', כלומר הכותרת, המטען הייעודי (payload) והחתימה המקודדים מחוברים באמצעות נקודה כדי ליצור את ה-JWS הסופי:

[header].[payload].[signature]

משתמשים ברכיב <Payload> כדי לציין את מטען ה-JWS הגולמי שלא עבר קידוד. בדוגמה הזו, משתנה מכיל את המטען הייעודי (payload). כשמופעלת פעולת המדיניות הזו, מערכת Apigee מקודדת את הכותרת ואת מטען הייעודי (payload) של JWS, ואז מוסיפה את החתימה המקודדת כדי לחתום על JWS באופן דיגיטלי.

הגדרת המדיניות שבהמשך יוצרת JWS ממטען ייעודי (payload) שכלול במשתנה my-payload, ומאחסנת את ה-JWS שמתקבל במשתנה output-variable.

<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="my-payload"/>
    <OutputVariable>output-variable</OutputVariable>
</GenerateJWS>

יצירת JWT בחתימת HS256

בדוגמה הזו נוצר גם JWS עם תוכן מצורף שנחתם באמצעות האלגוריתם HS256. במקרה הזה, המטען הייעודי (payload) הוא JSON. הגדרת הכותרת typ ל-JWT תוביל ליצירת JWS חתום שהוא גם JWT חתום. (מידע נוסף)

הגדרת המדיניות שבהמשך יוצרת JWS ממטען ייעודי שנמצא במשתנה json-content, ושומרת את ה-JWS שנוצר במשתנה output-variable. התוצאה תהיה JWT חתום אם ורק אם המשתנה json-content מכיל מטען ייעודי בפורמט JSON, והמאפיינים במטען הייעודי בפורמט JSON תקפים ל-JWT. לדוגמה, המאפיין exp, אם הוא קיים, חייב להכיל ערך מספרי. המאפיין aud, אם הוא קיים, חייב להיות מחרוזת או מערך של מחרוזות. וכן הלאה. לפרטים על הערכים התקפים להצהרות JWT, אפשר לעיין ב-IETF RFC7519.

<GenerateJWS name="JWS-Generate-HS256-JWT">
    <Algorithm>HS256</Algorithm>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <SecretKey>
        <Value ref="private.secretkey"/>
    </SecretKey>
    <Payload ref="json-content"/>
    <AdditionalHeaders>
        <Claim name="typ">JWT</Claim>
    </AdditionalHeaders>
    <OutputVariable>output-variable</OutputVariable>
</GenerateJWS>

יצירת JWS מנותק

מדיניות לדוגמה שיוצרת JWS עם תוכן מנותק, שנחתם באמצעות האלגוריתם RS256. יצירת חתימת RS256 מסתמכת על מפתח פרטי RSA, שצריך לספק בפורמט PEM.

ב-JWS עם תוכן מנותק, המטען הייעודי (payload) מושמט מה-JWS שנוצר:

[header]..[signature]

משתמשים ברכיב <Payload> כדי לציין את מטען ה-JWS הגולמי שלא עבר קידוד. כשהמדיניות הזו מופעלת, Apigee מקודד את הכותרת ואת מטען הייעודי (payload) של JWS, ואז משתמש בהם כדי ליצור את החתימה המקודדת. עם זאת, ב-JWS שנוצר לא מופיע המטען הייעודי (payload) המקודד מתוך ה-JWS שעבר סריאליזציה. האפשרות הזו שימושית כשהתוכן החתום גדול או בינארי (למשל תמונה או PDF), או גם וגם. כדי לאפשר אימות, צריך להעביר לצד המאמת את שני האלמנטים: את חתימת ה-JWS ואת המטען הייעודי שנכלל בתוכן החתום. אם אתם משתמשים במדיניות VerifyJWS כדי לאמת את ה-JWS, אתם יכולים לציין את המשתנה שמכיל את המטען הייעודי (payload) באמצעות הרכיב <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="my-payload"/>
    <DetachContent>true</DetachContent>
    <OutputVariable>output-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> הם אופציונליים.
*מידע נוסף על דרישות המפתח זמין במאמר מידע על אלגוריתמים להצפנת חתימות.

הפניה לרכיב של Generate JWS

ההפניה למדיניות מתארת את האלמנטים והמאפיינים של מדיניות Generate JWS.

הערה: ההגדרה תשתנה במידה מסוימת בהתאם לאלגוריתם ההצפנה שבו משתמשים. בדוגמאות מוסבר איך להגדיר תרחישי שימוש ספציפיים.

מאפיינים שחלים על הרכיב ברמה העליונה

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

המאפיינים הבאים משותפים לכל רכיבי ההורה של המדיניות.

מאפיין תיאור ברירת מחדל נוכחות
name השם הפנימי של המדיניות. התווים שאפשר להשתמש בהם בשם מוגבלים ל:A-Z0-9._\-$ %. עם זאת, בממשק המשתמש של Apigee יש הגבלות נוספות, כמו הסרה אוטומטית של תווים שהם לא אלפאנומריים.

אופציונלי, אפשר להשתמש ברכיב <displayname></displayname> כדי לתת למדיניות שם אחר בשפה טבעית בכלי לעריכת ה-proxy בממשק המשתמש של Apigee.

 לא רלוונטי חובה
continueOnError מגדירים את הערך false כדי להחזיר שגיאה אם המדיניות נכשלת. זו התנהגות צפויה ברוב המקרים.

הגדרה ל-true מאפשרת להמשיך את הביצוע של התהליך גם אחרי שמדיניות נכשלת.

 FALSE אופציונלי
מופעל כדי לאכוף את המדיניות, צריך להגדיר את הערך true.

מגדירים את הערך false כדי להשבית את המדיניות. המדיניות לא תיאכף גם אם היא תישאר מצורפת לזרימה.

 TRUE אופציונלי
אסינכרוני המאפיין הזה הוצא משימוש. FALSE הוצא משימוש

<DisplayName>

<DisplayName>Policy Display Name</DisplayName>

משתמשים בו בנוסף למאפיין name כדי לתת למדיניות תווית בכלי לעריכת ה-proxy בממשק המשתמש של Apigee, עם שם אחר בשפה טבעית.

ברירת מחדל אם לא מציינים את הרכיב הזה, המערכת משתמשת בערך של מאפיין השם של המדיניות.
נוכחות אופציונלי
סוג String

<Algorithm>

<Algorithm>algorithm-here</Algorithm>

מציין את אלגוריתם ההצפנה לחתימה על האסימון.

ברירת מחדל לא רלוונטי
נוכחות חובה
סוג String
ערכים אפשריים ‫HS256, ‏ HS384, ‏ HS512, ‏ RS256, ‏ RS384, ‏ RS512, ‏ ES256, ‏ ES384, ‏ ES512, ‏ PS256, ‏ PS384, ‏ PS512

<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 – (אופציונלי) אחד מהערכים הבאים: string (ברירת מחדל), number,‏ boolean או map
  • ‫array – (אופציונלי) מגדירים את הערך true כדי לציין אם הערך הוא מערך של סוגים. ברירת מחדל: ‫false.

<CriticalHeaders>

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

or:

<CriticalHeaders ref="variable_containing_headers"/>

הוספת הכותרת הקריטית, crit, ל-JWS. הכותרת crit היא מערך של שמות כותרות שצריכים להיות מוכרים ומזוהים על ידי המקבל של JWS. לדוגמה, אפשר להשתמש ברכיב ההגדרה הזה כדי ליצור כותרת JWS, שאחרי פענוח שלה נראית כך:

{
  "typ": "...",
  "alg" : "...",
  "hyb" : "some-value-here",
  "crit" : [ "hyb" ],
}

כותרת ה-JWS הזו מציינת שפרמטר הכותרת hyb הוא בעל חשיבות קריטית, וכל מי שמקבל את ה-JWS חייב להבין את המשמעות והערך של הפרמטר הזה.

לפי IETF RFC 7515, הנמען של JWS צריך לדחות את ה-JWS כלא תקין אם הוא לא מבין פרמטר אחד או יותר שמפנים אליהם בפרמטר crit. ב-Apigee, מדיניות VerifyJWS פועלת בהתאם להתנהגות הזו. לכל פרמטר שמפורט בפרמטר crit, המערכת בודקת שגם רכיב <KnownHeaders> של מדיניות VerifyJWS מפרט את הפרמטר הזה. אם המדיניות VerifyJWS מוצאת בכותרת crit שדה שלא מופיע גם ב-<KnownHeaders>, היא דוחה את ה-JWS.

ברירת מחדל לא רלוונטי
נוכחות אופציונלי
סוג מערך מופרד בפסיקים של מחרוזת אחת או יותר
ערכים אפשריים מערך או הפניה למשתנה שמכיל את המערך.

<DetachContent>

<DetachContent>true|false</DetachContent>

מציינים אם ליצור את ה-JWS עם מטען ייעודי (payload) מנותק, <DetachContent>true</DetachContent>, או בלי, <DetachContent>false</DetachContent>.

אם מציינים false (ברירת המחדל), ה-JWS שנוצר הוא מהצורה:

[header].[payload].[signature]

אם מציינים את הערך true כדי ליצור JWS עם מטען ייעודי מנותק, המטען הייעודי מושמט מה-JWS שנוצר, והוא בפורמט הבא:

[header]..[signature]

כשמשתמשים ב-JWS עם מטען ייעודי (payload) מנותק, אתם צריכים להעביר את המטען הייעודי המקורי שלא קודד לצד המאמת, יחד עם ה-JWS שעבר סריאליזציה.

ברירת מחדל FALSE
נוכחות אופציונלי
סוג בוליאני
ערכים אפשריים true or false

<IgnoreUnresolvedVariables>

<IgnoreUnresolvedVariables>true|false</IgnoreUnresolvedVariables>

מגדירים את הערך כ-False אם רוצים שהמדיניות תציג שגיאה כשמשתנה כלשהו שמוגדר בה לא ניתן לפתרון. הגדרה ל-true תגרום להתייחסות לכל משתנה שלא ניתן לפתור כמחרוזת ריקה (null).

ברירת מחדל FALSE
נוכחות אופציונלי
סוג בוליאני
ערכים אפשריים true or false

<OutputVariable>

<OutputVariable>output-variable</OutputVariable>

מציינת את השם של משתנה ההקשר שהמדיניות תגדיר עם ה-JWS שנוצר. כברירת מחדל, המדיניות מכניסה את ה-JWS למשתנה ההקשר שנקרא jws.POLICYNAME.generated_jws.

ברירת מחדל jws.POLICYNAME.generated_jws
נוכחות אופציונלי
סוג מחרוזת (שם של משתנה בתהליך)

<Payload>

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

or

<Payload>payload-value</Payload>

מציינים את המטען הייעודי (payload) של JWS בצורה גולמית, ללא קידוד. אפשר לציין משתנה שמכיל את המטען הייעודי או מחרוזת.

ברירת מחדל לא רלוונטי
נוכחות חובה
סוג מחרוזת, מערך בייטים, זרם או כל ייצוג אחר של מטען ה-JWS שלא עבר קידוד.
ערכים אפשריים תבנית הודעה או הפניה למשתנה שמכיל את המטען הייעודי (payload).

אלמנט <PrivateKey>

הפרמטר הזה הוא אופציונלי, והוא משמש רק אם <Algorithm> הוא אחת מהאפשרויות RS*, PS* או ES*. הוא מציין את המפתח הפרטי שמשמש לחתימה, וגם מידע אחר שקשור למפתח הפרטי. משתמשים בו כשהאלגוריתם הוא אלגוריתם אסימטרי.

<PrivateKey>
   <Value ref="private.privatekey"</Value>
</PrivateKey>
ברירת מחדל: לא רלוונטי
נוכחות: זה שינוי אופציונלי. עם זאת, אתם חייבים לכלול בדיוק אחד מהרכיבים <PrivateKey> או <SecretKey>. משתמשים ברכיב <PrivateKey> כשהאלגוריתם הוא RS*,‏ PS* או ES*, וברכיב <SecretKey> כשהאלגוריתם הוא HS*.
סוג: לא רלוונטי

<PrivateKey/Id>

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

or

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

מציין את מזהה המפתח (kid) שייכלל בכותרת ה-JWS.

ברירת מחדל לא רלוונטי
נוכחות אופציונלי
סוג String
ערכים אפשריים משתנה או מחרוזת של זרימת נתונים

<PrivateKey/Password>

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

במקרה הצורך, מציינים את הסיסמה שבה המדיניות צריכה להשתמש כדי לפענח את המפתח הפרטי. משתמשים במאפיין ref כדי להעביר את המפתח במשתנה של זרימת נתונים.

ברירת מחדל לא רלוונטי
נוכחות אופציונלי
סוג String
ערכים אפשריים

הפניה למשתנה של זרימת נתונים. הערה: צריך לציין משתנה של זרימת נתונים עם המאפיין ref. ‫Apigee ידחה הגדרת מדיניות שבה הסיסמה מצוינת בטקסט לא מוצפן, ויסווג אותה כלא חוקית. למשתנה של התהליך חייבת להיות הקידומת 'private'. לדוגמה, private.mypassword

<PrivateKey/Value>

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

מציין מפתח פרטי בקידוד PEM שמשמש לחתימה על JWS. משתמשים במאפיין ref כדי להעביר את המפתח במשתנה של זרימת העבודה.

ברירת מחדל לא רלוונטי
נוכחות חובה להשתמש בפרמטר הזה כשמשתמשים במדיניות כדי ליצור JWS באמצעות אחד מהאלגוריתמים RS*, PS* או ES*.
סוג String
ערכים אפשריים משתנה של זרימת עבודה שמכיל מחרוזת שמייצגת ערך של מפתח פרטי בקידוד PEM.

הערה: למשתנה של הפיד צריך להיות הקידומת 'private'. לדוגמה, private.mykey

<SecretKey>

<SecretKey encoding="base16|hex|base64|base64url" >
  <Id ref="variable-containing-key-id-here">secret-key-id</Id>
  <Value ref="private.variable-here"/>
</SecretKey>

המדיניות הזו מציינת את המפתח הסודי שבו יש להשתמש כשיוצרים JWS שמשתמש באלגוריתם סימטרי (HS*), אחד מהאלגוריתמים HS256,‏ HS384 או HS512.

הרכיב הזה הוא אופציונלי. עם זאת, חובה לכלול בדיוק אחד מהרכיבים <PrivateKey> או <SecretKey>. משתמשים ברכיב <PrivateKey> כשיוצרים חתימת JWS באמצעות אלגוריתם אסימטרי (אחד מהאלגוריתמים RS*, PS* או ES*), ומשתמשים ברכיב <SecretKey> כשיוצרים חתימת JWS באמצעות אלגוריתם סימטרי (אלגוריתם כמו HS*).

ילדים של <SecretKey>

בטבלה הבאה מפורטים רכיבי המשנה והמאפיינים של <SecretKey>:

צאצא נוכחות תיאור
קידוד (מאפיין) אופציונלי

מציין איך המפתח מקודד במשתנה שאליו מתבצעת ההפניה. כברירת מחדל, אם לא מצוין מאפיין encoding, הקידוד של המפתח נחשב ל-UTF-8. הערכים התקינים של המאפיין הם: hex,‏ base16,‏ base64 או base64url. הערכים hex ו-base16 הם מילים נרדפות.

<SecretKey encoding="hex" >
  <Id ref="variable-containing-key-id-here">secret-key-id</Id>
  <Value ref="private.secretkey"/>
</SecretKey>

בדוגמה שלמעלה, מכיוון שהקידוד הוא hex, אם התוכן של המשתנה private.secretkey הוא 494c6f766541504973, המפתח יפוענח כקבוצה של 9 בייטים, שיוצגו בפורמט הקסדצימלי 49 4c 6f 76 65 41 50 49 73.

‫Id (רכיב) אופציונלי

מזהה המפתח. הערך יכול להיות כל מחרוזת. אפשר לציין את הערך כערך טקסט מילולי, או באופן עקיף, באמצעות הפניה למשתנה, באמצעות המאפיין ref.

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

or

<SecretKey>
  <Id>your-id-value-here</Id>
  <Value ref="private.variable-here"/>
</SecretKey>

המדיניות תכלול את מזהה המפתח הזה כהצהרה kid בכותרת של ה-JWS שנוצר.

ערך (רכיב) חובה

מפתח סודי מקודד. מציין את המפתח הסודי שמשמש לחתימה על מטען הייעודי (payload). משתמשים במאפיין ref כדי לספק את המפתח באופן עקיף באמצעות משתנה, כמו private.secret-key .

<SecretKey>
  <Id ref="flow-variable-name-here"/>
  <Value ref="private.my-secret-variable"/>
</SecretKey>

‫Apigee אוכף חוזק מפתח מינימלי לאלגוריתמים HS256/HS384/HS512. אורך המפתח המינימלי עבור HS256 הוא 32 בייטים, עבור HS384 הוא 48 בייטים ועבור HS512 הוא 64 בייטים. שימוש במפתח חלש יותר גורם לשגיאת זמן ריצה.

<Type>

<Type>type-string-here</Type>

אלמנט אופציונלי שהערך המותר היחיד שלו הוא Signed. הערך הזה מציין שמדיניות יוצרת JWS חתום. הערך <Type> מסופק רק כדי להתאים לאלמנט התואם במדיניות GenerateJWT ובמדיניות VerifyJWT (שבה הוא יכול לקבל את אחד מהערכים Signed או Encrypted).

ברירת מחדל לא רלוונטי
נוכחות אופציונלי
סוג String
ערך תקין Signed

משתנים בתהליך

המדיניות Generate JWS לא מגדירה משתני זרימה.

הפניה לשגיאה

בקטע הזה מתוארים קודי התקלה והודעות השגיאה שמוחזרים, ומשתני התקלה שמוגדרים על ידי Apigee כשמדיניות כזו מפעילה שגיאה. חשוב לדעת את המידע הזה אם אתם מפתחים כללי תקלות לטיפול בתקלות. מידע נוסף על שגיאות שקשורות למדיניות ועל טיפול בשגיאות

שגיאות זמן ריצה

השגיאות האלה יכולות להתרחש כשהמדיניות מופעלת.

קוד תקלה סטטוס HTTP מתרחש כאשר
steps.jws.GenerationFailed 401 המדיניות לא הצליחה ליצור את ה-JWS.
steps.jws.InsufficientKeyLength 401 למפתח קטן מ-32 בייטים לאלגוריתם HS256
steps.jws.InvalidClaim 401 אם יש טענה חסרה או חוסר התאמה בין טענות, או אם יש כותרת חסרה או חוסר התאמה בין כותרות.
steps.jws.InvalidCurve 401 העקומה שצוינה על ידי המפתח לא תקפה לאלגוריתם של עקומה אליפטית.
steps.jws.InvalidJsonFormat 401 נמצא JSON לא תקין בכותרת JWS.
steps.jws.InvalidPayload 401 המטען הייעודי (payload) של JWS לא תקין.
steps.jws.InvalidSignature 401 ‫<DetachedContent> מושמט, ול-JWS יש מטען ייעודי (payload) של תוכן מנותק.
steps.jws.KeyIdMissing 401 מדיניות האימות משתמשת ב-JWKS כמקור למפתחות ציבוריים, אבל ה-JWS החתום לא כולל את המאפיין kid בכותרת.
steps.jws.KeyParsingFailed 401 לא הייתה אפשרות לנתח את המפתח הציבורי מפרטי המפתח שצוינו.
steps.jws.MissingPayload 401 מטען הייעודי (payload) של JWS חסר.
steps.jws.NoAlgorithmFoundInHeader 401 מתרחשת כש-JWS משמיט את כותרת האלגוריתם.
steps.jws.SigningFailed 401 ב-GenerateJWS, אם המפתח קטן מהגודל המינימלי לאלגוריתמים HS384 או HS512
steps.jws.UnknownException 401 אירעה חריגה לא ידועה.
steps.jws.WrongKeyType 401 צוין סוג שגוי של מפתח. לדוגמה, אם מציינים מפתח RSA לאלגוריתם של עקומות אליפטיות, או מפתח עקומה לאלגוריתם RSA.

שגיאות בהטמעה

השגיאות האלה יכולות להתרחש כשפורסים שרת proxy שמכיל את המדיניות הזו.

שם השגיאה מתרחש כאשר
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 הוא שם התקלה, כפי שמופיע בטבלה Runtime errors שלמעלה. שם התקלה הוא החלק האחרון של קוד התקלה. 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>