VerifyJWS policy

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

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

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

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

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

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

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

דוגמאות

אימות של JWS מצורף שנחתם באמצעות האלגוריתם HS256

מדיניות לדוגמה שמאמתת קובץ JWS מצורף שנחתם באמצעות אלגוריתם ההצפנה HS256, ‏ HMAC באמצעות סכום ביקורת SHA-256. קובץ ה-JWS מועבר בבקשת ה-proxy באמצעות פרמטר טופס בשם JWS. המפתח כלול במשתנה בשם private.secretkey.

קובץ JWS מצורף מכיל את הכותרת, המטען הייעודי (payload) והחתימה המקודדים:

header.payload.signature

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

<VerifyJWS name="JWS-Verify-HS256">
    <DisplayName>JWS Verify HS256</DisplayName>
    <Algorithm>HS256</Algorithm>
    <Source>request.formparam.JWS</Source>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <SecretKey>
        <Value ref="private.secretkey"/>
    </SecretKey>
</VerifyJWS>

המדיניות כותבת את הפלט שלה למשתני הקשר, כך שמדיניות או תנאים עוקבים ב-proxy ל-API יכולים לבדוק את הערכים האלה. רשימת המשתנים שמוגדרים על ידי המדיניות הזו מופיעה במאמר משתני זרימה.

אימות של JWS מנותק שנחתם באמצעות אלגוריתם RS256

מדיניות לדוגמה שמאמתת JWS מנותק שנחתם באמצעות אלגוריתם RS256. כדי לבצע אימות, צריך לספק את המפתח הציבורי. ה-JWS מועבר בבקשת ה-proxy באמצעות פרמטר טופס בשם JWS. המפתח הציבורי כלול במשתנה שנקרא public.publickey.

ב-JWS מנותק, המטען הייעודי מושמט מה-JWS:

header..signature

אתם צריכים להעביר את מטען הנתונים למדיניות VerifyJWS על ידי ציון שם המשתנה שמכיל את מטען הנתונים ברכיב <DetachedContent>. התוכן שצוין ב-<DetachedContent> חייב להיות בפורמט המקורי הלא מקודד שבו הוא היה כשנוצר החתימה של JWS.

<VerifyJWS name="JWS-Verify-RS256">
    <DisplayName>JWS Verify RS256</DisplayName>
    <Algorithm>RS256</Algorithm>
    <Source>request.formparam.JWS</Source>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <PublicKey>
        <Value ref="public.publickey"/>
    </PublicKey>
    <DetachedContent>private.payload</DetachedContent>
</VerifyJWS>

המדיניות כותבת את הפלט שלה למשתני הקשר, כך שמדיניות או תנאים עוקבים ב-proxy ל-API יכולים לבדוק את הערכים האלה. רשימת המשתנים שמוגדרים על ידי המדיניות הזו מופיעה במאמר משתני זרימה.

הגדרת הרכיבים המרכזיים

הרכיבים שבהם משתמשים כדי לציין את המפתח שמשמש לאימות ה-JWS תלויים באלגוריתם שנבחר, כפי שמוצג בטבלה הבאה:

אלגוריתם אלמנטים מרכזיים
HS* 
<SecretKey>
  <Value ref="private.secretkey"/>
</SecretKey>
RS*, ES*, PS* 
<PublicKey>
  <Value ref="rsa_public_key"/>
</PublicKey>

או:

<PublicKey>
  <JWKS ref="jwks_val_ref_or_url"/>
</PublicKey>
*מידע נוסף על דרישות המפתח זמין במאמר מידע על אלגוריתמים להצפנת חתימות.

הפניה לרכיב

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

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

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

<VerifyJWS 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>HS256</Algorithm>

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

אפשר לציין כמה ערכים ולהפריד ביניהם באמצעות פסיקים. לדוגמה, HS256,‏ HS512 או RS256,‏ PS256. עם זאת, אי אפשר לשלב אלגוריתמים של HS* עם אלגוריתמים אחרים, או אלגוריתמים של ES* עם אלגוריתמים אחרים, כי הם דורשים סוג מפתח ספציפי. אפשר לשלב בין אלגוריתמים של RS* ו-PS*.

ברירת מחדל לא רלוונטי
נוכחות חובה
סוג מחרוזת של ערכים מופרדים בפסיקים
ערכים אפשריים ‫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 מכילה את צמדי המפתח/ערך הנוספים שצוינו, ושהערכים של הטענות שצוינו תואמים.

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

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

מחרוזת (ברירת מחדל), מספר, ערך בוליאני או מפה.

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

רכיב <Claim> מקבל את המאפיינים הבאים:

  • ‫name – (חובה) שם התלונה.
  • ‫ref – (אופציונלי) השם של משתנה של זרימת עבודה. אם המדיניות קיימת, היא תשתמש בערך של המשתנה הזה כמאפיין. אם מציינים גם מאפיין ref וגם ערך הצהרה מפורש, ערך ברירת המחדל הוא הערך המפורש, והמערכת משתמשת בו אם משתנה הזרימה שאליו מתבצעת ההפניה לא נפתר.
  • ‫type – (אופציונלי) אחד מהערכים הבאים: string (ברירת מחדל), number,‏ boolean או map
  • ‫array – (אופציונלי) מגדירים את הערך true כדי לציין אם הערך הוא מערך של סוגים. ברירת מחדל: ‫false.

<DetachedContent>

<DetachedContent>variable-name-here</DetachedContent>

‫JWS שנוצר עם מטען תוכן הוא מהצורה:

header.payload.signature

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

header..signature

במקרה של מטען ייעודי מנותק, אתם צריכים להעביר את המטען הייעודי למדיניות VerifyJWS באמצעות הרכיב <DetachedContent>. המטען הייעודי של התוכן שצוין צריך להיות בפורמט המקורי הלא מקודד שבו הוא היה כשחתימת ה-JWS נוצרה.

המדיניות מחזירה שגיאה במקרים הבאים:

  • ‫<DetachedContent> מצוין כש-JWS לא מכיל מטען ייעודי (payload) של תוכן מנותק (קוד השגיאה הוא steps.jws.ContentIsNotDetached).
  • הפרמטר <DetachedContent> מושמט וב-JWS יש מטען תוכן מנותק (קוד השגיאה הוא steps.jws.InvalidSignature).
ברירת מחדל N/A
נוכחות אופציונלי
סוג הפניה למשתנה

<IgnoreCriticalHeaders>

<IgnoreCriticalHeaders>true|false</IgnoreCriticalHeaders>

מגדירים את הערך כ-false אם רוצים שהמדיניות תציג שגיאה כשכותרת כלשהי שמופיעה בכותרת crit של JWS לא מופיעה ברכיב <KnownHeaders>. אם מגדירים את הערך כ-True, המדיניות VerifyJWS מתעלמת מהכותרת crit.

אחת הסיבות להגדרת הרכיב הזה כ-true היא אם אתם נמצאים בסביבת בדיקה ולא רוצים שהמדיניות תיכשל בגלל כותרת חסרה.

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

<IgnoreUnresolvedVariables>

<IgnoreUnresolvedVariables>true|false</IgnoreUnresolvedVariables>

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

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

<KnownHeaders>

<KnownHeaders>a,b,c</KnownHeaders>

or:

<KnownHeaders ref='variable_containing_headers'/>

המדיניות GenerateJWS משתמשת ברכיב <CriticalHeaders> כדי לאכלס את הכותרת crit באסימון. לדוגמה:

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

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

אפשר גם להגדיר את מדיניות VerifyJWS כך שתתעלם מהכותרת crit על ידי הגדרת הרכיב <IgnoreCriticalHeaders> לערך true.

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

<PublicKey/JWKS>

<!-- Specify the JWKS. -->
<PublicKey>
   <JWKS>jwks-value-here</JWKS>
</PublicKey>

or:

<!-- Specify a variable containing the JWKS. -->
<PublicKey>
   <JWKS ref="public.jwks"/>
</PublicKey>

or:

<!-- Specify a public URL that returns the JWKS.
The URL is static, meaning you cannot set it using a variable. -->
<PublicKey>
   <JWKS uri="jwks-url"/>
</PublicKey>

מציינים ערך בפורמט JWKS ‏ (RFC 7517) שמכיל קבוצה של מפתחות ציבוריים. השימוש מותר רק אם האלגוריתם הוא אחד מהאלגוריתמים הבאים: RS256/RS384/RS512,‏ PS256/PS384/PS512 או ES256/ES384/ES512.

אם ל-JWS הנכנס יש מזהה מפתח שקיים בקבוצת ה-JWKS, המדיניות תשתמש במפתח הציבורי הנכון כדי לאמת את חתימת ה-JWS. פרטים על התכונה הזו זמינים במאמר שימוש ב-JSON Web Key Set‏ (JWKS) כדי לאמת JWS.

אם מאחזרים את הערך מכתובת URL ציבורית, מערכת Apigee שומרת את JWKS במטמון למשך 300 שניות. כשהמטמון פג תוקף, מערכת Apigee מאחזרת שוב את JWKS.

ברירת מחדל לא רלוונטי
נוכחות כדי לאמת JWS באמצעות אלגוריתם RSA, צריך להשתמש ברכיב JWKS או ברכיב Value.
סוג String
ערכים אפשריים משתנה של זרימת נתונים, ערך מחרוזת או כתובת URL.

<PublicKey/Value>

<PublicKey>
   <Value ref="public.publickey"/>
</PublicKey>
-or-
<PublicKey>
    <Value>
    -----BEGIN PUBLIC KEY-----
    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw2kPrRzcufvUNHvTH/WW
    Q0UrCw5c0+Y707KX3PpXkZGbtTT4nvU1jC0d1lHV8MfUyRXmpmnNxJHAC2F73IyN
    C5TBtXMORc+us7A2cTtC4gZV256bT4h3sIEMsDl0Joz9K9MPzVPFxa1i0RgNt06n
    Xn/Bs2UbbLlKP5Q1HPxewUDEh0gVMqz9wdIGwH1pPxKvd3NltYGfPsUQovlof3l2
    ALvO7i5Yrm96kknfFEWf1EjmCCKvz2vjVbBb6mp1ZpYfc9MOTZVpQcXSbzb/BWUo
    ZmkDb/DRW5onclGzxQITBFP3S6JXd4LNESJcTp705ec1cQ9Wp2Kl+nKrKyv1E5Xx
    DQIDAQAB
    -----END PUBLIC KEY-----
    </Value>
</PublicKey>

מציינת את המפתח הציבורי שמשמש לאימות החתימה ב-JWS. משתמשים במאפיין ref כדי להעביר את המפתח במשתנה של זרימת עבודה, או מציינים את המפתח בקידוד PEM ישירות. השימוש מותר רק אם האלגוריתם הוא אחד מהבאים: RS256/RS384/RS512,‏ PS256/PS384/PS512 או ES256/ES384/ES512.

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

<SecretKey>

<SecretKey encoding="base16|hex|base64|base64url" >
  <Value ref="private.your-variable-name"/>
</SecretKey>

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

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

ילדים של <SecretKey>

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

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

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

<SecretKey encoding="base64" >
  <Value ref="private.secretkey"/>
</SecretKey>

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

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

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

<SecretKey>
  <Value ref="private.my-secret-variable"/>
</SecretKey>

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

<Source>

<Source>JWS-variable</Source>

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

ברירת מחדל request.header.authorization (מידע חשוב על ברירת המחדל מופיע בהערה שלמעלה).
נוכחות אופציונלי
סוג String
ערכים אפשריים שם של משתנה בתהליך עבודה ב-Apigee.

<Type>

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

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

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

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

אם הפעולה מצליחה, כללי המדיניות Verify JWS ו-Decode JWS מגדירים משתני הקשר לפי התבנית הבאה:

jws.{policy_name}.{variable_name}

לדוגמה, אם שם המדיניות הוא verify-jws, האלגוריתם שצוין ב-JWS יישמר במשתנה ההקשר הזה של המדיניות: jws.verify-jws.header.algorithm

שם המשתנה תיאור
decoded.header.name הערך שניתן לניתוח ב-JSON של כותרת במטען הייעודי (payload). משתנה אחד מוגדר לכל כותרת במטען הייעודי (payload). אפשר גם להשתמש במשתני הזרימה header.name, אבל המשתנה המומלץ לגישה לכותרת הוא
header.algorithm אלגוריתם החתימה שבו נעשה שימוש ב-JWS. לדוגמה, RS256,‏ HS384 וכן הלאה. מידע נוסף זמין במאמר בנושא פרמטר הכותרת(אלגוריתם).
header.kid מזהה המפתח, אם הוא נוסף כשנוצר ה-JWS. כדי לאמת JWS, אפשר לעיין גם במאמר בנושא סקירה כללית של כללי מדיניות JWT ו-JWS, בקטע 'שימוש ב-JSON Web Key Set ‏(JWKS)'. מידע נוסף זמין במאמר בנושא פרמטר הכותרת(מזהה המפתח).
header.type הערך של סוג הכותרת. מידע נוסף זמין במאמר בנושא פרמטר הכותרת(Type).
header.name הערך של הכותרת שצוין השם שלה (רגילה או נוספת). אחד מהם יוגדר לכל כותרת נוספת בחלק של הכותרת ב-JWS.
header-json הכותרת בפורמט JSON.
payload מטען הייעודי (payload) של JWS אם יש לו מטען ייעודי מצורף. אם המטען הייעודי מנותק, המשתנה הזה ריק.
valid במקרה של VerifyJWS, המשתנה הזה יהיה true אם החתימה אומתה, והשעה הנוכחית היא לפני תפוגת האסימון ואחרי הערך notBefore של האסימון, אם הם קיימים. אחרת, הפלט הוא False.

במקרה של DecodeJWS, המשתנה הזה לא מוגדר.

הפניה לשגיאה

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

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

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

קוד תקלה סטטוס HTTP מתרחש כאשר
steps.jws.AlgorithmInTokenNotPresentInConfiguration 401 מתרחש כשבמדיניות האימות יש כמה אלגוריתמים
steps.jws.AlgorithmMismatch 401 האלגוריתם שצוין בכותרת על ידי מדיניות Generate לא תאם לאלגוריתם שצוין במדיניות Verify. האלגוריתמים שצוינו צריכים להיות זהים.
steps.jws.ContentIsNotDetached 401 ‫<DetachedContent> מצוין כש-JWS לא מכיל מטען ייעודי (payload) של תוכן מנותק.
steps.jws.FailedToDecode 401 המדיניות לא הצליחה לפענח את ה-JWS. יכול להיות ש-JWS פגום.
steps.jws.InsufficientKeyLength 401 למפתח קטן מ-32 בייטים לאלגוריתם HS256
steps.jws.InvalidClaim 401 אם יש טענה חסרה או חוסר התאמה בין טענות, או אם יש כותרת חסרה או חוסר התאמה בין כותרות.
steps.jws.InvalidCurve 401 העקומה שצוינה על ידי המפתח לא תקפה לאלגוריתם של עקומה אליפטית.
steps.jws.InvalidJsonFormat 401 נמצא JSON לא תקין בכותרת JWS.
steps.jws.InvalidJws 401 השגיאה הזו מתרחשת כשאימות החתימה של JWS נכשל.
steps.jws.InvalidPayload 401 המטען הייעודי (payload) של JWS לא תקין.
steps.jws.InvalidSignature 401 ‫<DetachedContent> מושמט, ול-JWS יש מטען ייעודי (payload) של תוכן מנותק.
steps.jws.KeyIdMissing 401 מדיניות Verify משתמשת ב-JWKS כמקור למפתחות ציבוריים, אבל ה-JWS החתום לא כולל מאפיין kid בכותרת.
steps.jws.KeyParsingFailed 401 לא הייתה אפשרות לנתח את המפתח הציבורי מפרטי המפתח שצוינו.
steps.jws.MissingPayload 401 מטען הייעודי (payload) של JWS חסר.
steps.jws.NoAlgorithmFoundInHeader 401 מתרחשת כש-JWS משמיט את כותרת האלגוריתם.
steps.jws.NoMatchingPublicKey 401 מדיניות Verify משתמשת ב-JWKS כמקור למפתחות ציבוריים, אבל kid ב-JWS החתום לא מופיע ב-JWKS.
steps.jws.UnhandledCriticalHeader 401 כותרת שנמצאה על ידי מדיניות Verify JWS בכותרת crit לא מופיעה ב-KnownHeaders.
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>