אבטחת אסימוני JWT: למה חתימה בלבד לא מספיקה
אמ;לק
מאמר מקצועי על האתגרים בניהול JWT (אסימוני אימות בשימוש באפליקציות) שדלפו. מומלץ לצוותי פיתוח להטמיע מנגנוני בדיקה וביטול אסימונים כדי למנוע זליגת הרשאות.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: A Valid Signature Isn’t Enough: Attributing and Validating Leaked JWTs

התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
TL;DR
• חתימות אינן מספיקות: בדיקות חתימה באמצעות OIDC מכסות רק 15% מה-JWTs שדלפו, וחתימה חוקית אינה מציינת את השירות שהנפיק את האסימון או האם האסימון הזה עדיין עובד.
• ייחוס: 345 כללים התאימו 86% מתוך כ-2.4 מיליון אסימונים לשירות בעל שם.
• אימות: הפעלה חוזרת של כל אסימון מול API של השירות שלו מצאה 334,762 אסימונים שעדיין תקפים בזמן הבדיקה.
• כיסוי זיהוי: GitGuardian מזהה כעת JWTs מ-14 שירותים ומאמת חלק מהם.
Florent Leroy
מספר ה-JWTs שדלפו גדל מדי שנה: הכמות שנמצאה במאגרי GitHub ציבוריים הוכפלה בין 2025 ל-2026. עקבנו אחר דליפות ה-JWTs חזרה ל-345 שירותים והגענו לתשובה סופית עבור 75% מהאסימונים שיוחסו לשירות. החצי הראשון של פוסט זה הוא מעשי: ניקח Google id_token ונאמת אותו פקודה אחר פקודה, באמצעות curl , jq , openssl וכמה שורות Python. כל שלב מציג את הפקודה והפלט שלה, כך שתוכל להריץ אותן על האסימונים שלך. החצי השני מראה כיצד קנה-מידה זה יושם על 2.4 מיליון JWTs שדלפו.
המצב הנוכחי של JWT
JWTs הם דרך קומפקטית ונפוצה להעברת נתונים בין שני צדדים. הם יושבים במרכז פרוטוקולי אימות כגון OpenID Connect (OIDC), והם ממשיכים לדלוף, בעיקר במאגרים של GitHub.
עם זאת, ספירת ההדלפות לבדה אינה אומרת הרבה. השאלה החשובה היא מה תוקף שמוצא אסימון יכול לעשות איתו: לקרוא נתונים רגישים או להתחזות למשתמש. משמעות הדבר היא להגדיר ולכמת את הבעיה במקום רק למדוד את נפחה. זה מתחיל בפורמט עצמו: ה-JWTs המשמשים בפרוטוקולי אימות הם JSON Web Signatures (JWS).
JWS מבנה
כפי שמוצג באיור למעלה, JWS מורכב משלוש מחרוזות מקודדות ב-base64url המופרדות על ידי נקודות. ה-Header מציין מה מגן על האסימון: אלגוריתם החתימה וה-ID של מפתח החתימה. ה-Payload נושא את הנתונים להעברה, הנקראים Claims. ה-Signature יכול להיות סימטרי או אסימטרי.
ה-Header וה-Payload מקודדים בלבד, לא מוצפנים, ולכן פענוחם מחזיר את הטקסט הגלוי. זהו השלב הראשון בהערכת JWT.
eyJhbGciOiJSUzI1NiIsImtpZCI6Ijk0M2EzYTVkN2Q5MTk2MjVhNDU0ZTQ4OWI3NWMyOWFkYWI1N2FjYmEiLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20iLCJhdWQiOiI0MDc0MDg3MTgxOTIuYXBwcy5nb29nbGV1c2VyY29udGVudC5jb20iLCJpYXQiOjE3NzMxMTA4NTUsImV4cCI6MTc3MzExNDQ1NX0.Fbl-hZPTLnZJaL_igvzp_bnwVKEfyJyekzBiERKsaa4aMuUkL0qnMMB6X3zjfxSRqWZA8UpYWhpDMYq7NEVLMhk7Sj0FD_ug35Xx3q4tnw6v_nk22WhdgB6QOSzCj0ocwQsNIT1J4zbmXNVwZxq7GBUbC9L79H1OvB5C1fdh2lx3cuocCMOyWFhrB_4tUJexXoNYbqVFInHr2upSwHPpvm_6QAYuD2saBpWhDFAkqitof86fgusy4oUPyjHSdqqGTJ8A6I4IdhuSwSfqapIpe3fP0Em70hTdxxmgcG1Qc96eKQB4a1PiLe3Vh6lvIaxTGtjOoQ6utl4X_7ZT8DdJgA
HEADER = { "alg" : "RS256" , "kid" : "943a3a5d7d919625a454e489b75c29adab57acba" , "typ" : "JWT" } PAYLOAD = { "iss" : "https://accounts.google.com" , "aud" : "407408718192.apps.googleusercontent.com" , "iat" : 1773110855 , "exp" : 1773114455 }
עבור JWTs כאלה עם חתימה אסימטרית (לדוגמה RS256), OIDC מציע דרך לאמת אותם.
OIDC
OpenID Connect (OIDC ) הוא פרוטוקול אימות בנוי על OAuth 2.0. זה מאפשר לאפליקציה (הRelying Party, או RP) לאמת משתמש באמצעות Identity Provider (IdP) כגון Google, Microsoft, או Okta.
בסוף התהליך, ה-IdP מנפיק שלושה אסימונים, ושניים מהם הם הנפוצים ביותר במאגרים ציבוריים: ה-id_token וה-access_token . ה-id_token (תמיד JWT) מציין מי נכנס ונועד לשימוש האפליקציה שביקשה אותו, ולא לשליחה ל-API. ה-access_token הוא האישור שאפליקציה מציגה ל-API כדי לגשת למשאבים מוגנים ולקבל מידע נוסף על המשתמש. JWTs המונפקים על ידי IdPs חתומים בצורה א-סימטרית. כדי לאמת את האותנטיות והשלמות של ה-Claims שהתקבלו, ה-RP חייב לאמת את חתימת ה-JWT, מה שמחייב אחזור של המפתחות הציבוריים של ה-IdP.
OIDC מתקן את הדרך למציאתם: כל ספק מגיש מסמך גילוי ב-/.well-known/openid-configuration תחת ה-URL של המנפיק, ומסמך זה מצביע על סט המפתחות שהספק מפרסם כעת. מנגנון זה, הנקרא OIDC discovery, מאפשר לבדוק אסימון על סמך ה-iss שלו בלבד.
אימות ידני של חתימה JWT עם OIDC
האסימון עצמו מציין מי חתם עליו, וגילוי ה-OIDC אומר לנו היכן למצוא את המפתח הציבורי התואם. כדי לבצע את האימות, אנו יכולים לפעול כ-Relying Party המקבל JWT, באמצעות שישה שלבים ידניים:
1. פענח את האסימון
אנו מפענחים את ה-JWT לשני משתנים: אחד עבור הכותרת (Header) ואחד עבור המטען (Payload). קטעי ה-JWT משתמשים ב-base64url (שימוש ב- - ו- _ במקום + ו- / ) ללא ריפוד ה-= בסוף. פקודת ה-base64 הסטנדרטית דוחה זאת, ומכאן הצורך בפונקציית עזר.
JWT= 'eyJhbGciOiJSUzI1NiIsImtpZCI6Ijk0M2Ez...' # base64url -> raw bytes d64() { local s; s=$(tr '_-' '/+' ); while (( ${#s} % 4 )); do s+= '=' ; done; printf '%s' "$s" | base64 -d; } HEADER=$(cut -d. -f1 <<< "$JWT" | d64) PAYLOAD=$(cut -d. -f2 <<< "$JWT" | d64)
הכותרת מספקת את אלגוריתם החתימה ( alg ) ואת המזהה של המפתח שבו נעשה שימוש ( kid ); המטען מספק את המנפיק ( iss ) ואת ה-Claims הזמניים exp (זמן תפוגה) ו- iat (זמן הנפקה).
HEADER = { "alg" : "RS256" , "kid" : "943a3a5d7d919625a454e489b75c29adab57acba" , "typ" : "JWT" } PAYLOAD = { "iss" : "https://accounts.google.com" , "aud" : "407408718192.apps.googleusercontent.com" , "iat" : 1773110855 , "exp" : 1773114455 }
2. בדקו את התביעות
אימות חתימה של אסימון שפג תוקפו הוא חסר טעם, לכן אנו מתחילים עם ה-Claims הזמניים. ה-claim בשם exp נותן את זמן התפוגה בשניות epoch, ואנו משווים אותו לזמן הנוכחי.
jq --argjson now "$(date +%s)" \ '{iss, aud, exp, expired: (.exp < $now), expires_in_s: (.exp - $now)}' <<< "$PAYLOAD"
{ "iss" : "https://accounts.google.com" , "aud" : "XXX.apps.googleusercontent.com" , "exp" : 1773114455 , "expired" : true, "expires_in_s" : -60123456 }
3. בקש מהמנפיק את תצורת ה-OIDC שלו
אנו משתמשים במנגנון הגילוי הסטנדרטי ב-/.well-known/openid-configuration תחת ה-URL של המנפיק. שליפתו הופכת את ה-claim של ה-iss לכתובת של ערכת המפתחות הציבוריים של המנפיק ( jwks_uri ).
ISS=$(jq -r .iss <<< "$PAYLOAD" ) curl -s "$ISS/.well-known/openid-configuration" | jq -r '.issuer, .jwks_uri'
https://accounts.google.com https://www.googleapis.com/oauth2/v3/certs
שדה המנפיק שהוחזר חייב להיות זהה לחלוטין ל-claim של ה-iss; אחרת, מסמך הגילוי אינו מתאר את הישות שממנה האסימון טוען שהגיע.
4. הורד את JWKS ובחר את המפתח שחתם על האסימון הזה
ה-JSON Web Key Set (JWKS) הוא רשימת המפתחות הציבוריים שהמנפיק מפרסם כעת; ה-kid מהכותרת מציין אחד מהם. מנפיקים מחליפים מפתחות אלו באופן קבוע, וזו הסיבה שתגובת ה-HTTP נושאת כותרת Cache-Control: max-age, המציינת כמה זמן ניתן להשתמש בסט המפתחות.
JWKS_URI=$(curl -s "$ISS/.well-known/openid-configuration" | jq -r .jwks_uri) KID=$(jq -r .kid <<< "$HEADER" ) JWK=$(curl -s "$JWKS_URI" | jq -c --arg kid "$KID" '.keys[] | select(.kid == $kid)' ) echo "$JWK"
{ "kty" : "RSA" , "alg" : "RS256" , "use" : "sig" , "kid" : "943a3a5d..." , "n" : "ww0Rlhxc..." , "e" : "AQAB" }
JWK אינו קובץ מפתח מוכן לשימוש. n (המודולוס) ו-e (המעריך) הם שני המספרים השלמים שמהם מורכב מפתח ציבורי מסוג RSA, הכתובים כבייטים גולמיים ומקודדים ב-base64url.
אם אף מפתח אינו תואם ל-kid, לא ניתן לאמת את האסימון בדרך זו: ייתכן שהוא נחתם על ידי מפתח שכבר הוחלף, או שהוא כלל אינו מגיע מהמנפיק הזה.
5. בנה מחדש את המפתח הציבורי
openssl לא יכול לקרוא JWK, לכן אנו משתמשים בסקריפט Python קצר כדי לכתוב את המפתח הציבורי כקובץ PEM סטנדרטי, אותו openssl קורא בשלב הבא.
python3 -c ' import base64, json, sys from cryptography.hazmat.primitives import serialization from cryptography.hazmat.primitives.asymmetric import rsa jwk = json.load(sys.stdin) b64uint = lambda s: int.from_bytes(base64.urlsafe_b64decode(s + "=" * (-len(s) % 4 )), "big" ) key = rsa.RSAPublicNumbers(e=b64uint(jwk[ "e" ]), n=b64uint(jwk[ "n" ])).public_key() sys.stdout.buffer.write(key.public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)) ' <<< "$JWK" > pub.pem
6. אמת את החתימה
אימות החתימה פירושו בנייה מחדש של מה שנחתם, ואז בדיקת החתימה מולו. מה שנחתם הוא שני הקטעים הראשונים המופרדים בנקודה, בדיוק כפי שהם מופיעים באסימון, לכן אנו שומרים אותם כקובץ כפי שהם. הקטע השלישי הוא החתימה עצמה, לכן אנו מפענחים אותו חזרה לבייטים גולמיים לקובץ שני. הפקודה openssl dgst -sha256 -verify מבצעת hashing לקלט החתימה. זה מאשר שהמפתח הפרטי התואם למפתח הציבורי ב-JWKS שלנו הוא שיצר את החתימה.
printf '%s' "${JWT%.*}" > signing_input.bin cut -d. -f3 <<< "$JWT" | d64 > sig.bin openssl dgst -sha256 -verify pub.pem -signature sig.bin signing_input.bin
Verified OK
זה מוכיח שהאסימון הונפק על ידי בעל המפתח הפרטי ולא שונה מאז. זה לא מעיד על כך שהאסימון עדיין שמיש.
מגבלות
לגישה זו יש שתי מגבלות. ניתן לבדוק אותה רק על אסימונים עם חתימה א-סימטרית, המהווים רק 15% מה-JWTs שאנו מזהים, ורק עבור שירותים העוקבים אחר פרוטוקול OIDC. וגם עבור אסימונים שניתן לבדוק, חתימה תקפה היא תשובה חלשה. אימות OIDC מוכיח שאסימון נחתם על ידי מפתח שיכולנו לאחזר, וזה הכל: הוא לא אומר דבר על איזה שירות הנפיק אותו או למי הוא הונפק. זיהוי שעוצר שם הוא רעש. כדי שהתוצאה תהיה שמישה, יש לקשור את האסימון לשירות מזוהה, וזה בדיוק מה שעושה תהליך הייחוס (attribution).
ייחוס (Attribution)
כדי להקצות JWT לשירות, אנו קוראים את המטען שלו כאובייקט JSON ומסתכלים על כמה מהטענות שלו. הנפוצים ביותר הם iss ו-aud.
לאחר ניתוח של כמה מאות JWTs, הצלחנו לשייך את הערכים של שדות ה-iss ו-aud לשירותים. זה עובד עבור ספקי זהות ידועים כגון Google, Apple, OpenAI או AWS, אך גם עבור כלים המארחים את עצמם ומנפיקים אסימונים משלהם.
{ "sub" : "d24c2906-XXXX-XXXX-XXXX-XXXXXXXXXXXX" , "iss" : "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_XXXXXXXXX" , "version" : 2 , "client_id" : "XXXXXXXXXXXXXXXXXXXXXX" , "origin_jti" : "9f6a724f-XXXX-XXXX-XXXX-XXXXXXXXXXXX" , "event_id" : "a2ac1eaa-XXXX-XXXX-XXXX-XXXXXXXXXXXX" , "token_use" : "access" , "scope" : "aws.cognito.signin.user.admin openid profile" , "auth_time" : 1777400328 , "exp" : 1777436613 , "iat" : 1777433013 , "jti" : "53453064-XXXX-XXXX-XXXX-XXXXXXXXXXXX" , "username" : "XXXX@XXX.com" }
שירותים מסוימים אינם מגדירים iss או aud, ומזוהים לפי Claims שרק הם משתמשים בהם: אסימונים של Umami Analytics, למשל, נושאים websiteId, sessionId ו-visitId .
{ "websiteId" : "42388b3e-XXXX-XXXX-XXXX-XXXXXXXXXXXX" , "sessionId" : "21513f22-XXXX-XXXX-XXXX-XXXXXXXXXXXX" , "visitId" : "74dde7b2-XXXX-XXXX-XXXX-XXXXXXXXXXXX" , "iat" : 1773409275 }
כדי להימנע מכתיבת פונקציה ייעודית לכל שירות, אימצנו תחביר חוקים בהשראת Lucene. הוא מאפשר לנו להתאים שדה ספציפי לערך, להשתמש בתווים כלליים ( * ) ובביטויים רגולריים, ולשלב מספר תנאים עם אופרטורים בוליאניים.
iss:/cognito-idp\.[a-z0-9-]+\.amazonaws\.com/
דפוס זה מקצה את התווית aws-cognito לכל JWT שה-claim של ה-iss שלו מכיל cognito-idp ., ולאחריו רצף של אותיות, ספרות או מקפים (אזור ה-AWS), ולאחר מכן .amazonaws.com .
כאן הכלל מבוסס על ה-iss, אך שירותים אחרים מזוהים טוב יותר לפי ה-aud. אדובי, למשל, מנפיקה אסימונים שבהם ה-audience מציין את נקודת הקצה של Adobe IMS:
"aud" : "https://ims-na1.adobelogin.com/c/<client_id>"
יישמנו שיטה זו על כל JWT שזוהה בין 1 במרץ ל-1 בספטמבר 2026: 2,420,381 אסימונים ייחודיים. הכללים מכסים כעת 345 שירותים, והם ייחסו 2,078,336 מאותם אסימונים, או 86% מהם.