JSON Toolkit

JSON אחד, שני פסקי דין: הבדלים בין פרסרים וגבול האמון של האימות

שורה תחתונה: כשמאמת מקבל מסמך אבל השירות הבא קורס, בדרך כלל שני פרסרים חלקו על אותו טקסט. המאמר משווה מפתחות כפולים, בייטי NUL, UTF-8 לא תקין, NaN ואפסים מובילים על ריצות-זמן אמיתיות, מסביר כיצד CVE-2026-33948 הפך את המחלוקת למשטח תקיפה, ומראה כיצד למנות בורר יחיד לכל גבול.

Advancedכ-6 דקות קריאהפורסם 2026-11-11עודכן 2026-11-11
תמונת שער המציגה שני כלים שמעניקים פסקי דין מנוגדים על אותו מסמך JSON

מעבר אימות מוכיח בדיוק דבר אחד: הטקסט התקבל על ידי אותו פרסר, תחת אותה מדיניות. החליפו פרסר והפסיקה עשויה להתהפך.

התסמין: כלי A עובר, כלי B נפסל

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

נקודות כאלה אינן רבות, אבל כל אחת מהן שכיחה. הטבלה הבאה מתעדת התנהגות אמיתית על קלטים בתדירות גבוהה (נבדק מול Node 22 JSON.parse, json הסטנדרטי של Python 3.11, jq 1.8 ומאמתים מקוונים מוכרים):

קלט Node JSON.parse Python json.loads jq הערות
{"a":1,"a":2} מפתח כפול מקבל, האחרון נשאר מקבל, האחרון נשאר מקבל, האחרון נשאר RFC 8259 אומר רק SHOULD; כל הארבעה מרשים
{"n":NaN} שגיאה מקבל שגיאה ספריית הסטנדרט של Python מקבלת כברירת מחדל — המלכודת השקטה הגדולה
{"n":01} אפס מוביל שגיאה שגיאה שגיאה נפסל באחידות, אך מיקומי השגיאה שונים
"中文" נשמר כבייטי GBK שגיאה או ג'יבריש תלוי בקידוד שגיאה RFC דורש UTF-8, אך פענוח הוא עניין שכבת ה-IO
{"a":1} עם BOM שגיאה מקבל (utf-8-sig) שגיאה מי שמסיר את ה-BOM הוא שקובע
הערות, מרכאות בודדות, פסיק מסיים שגיאה שגיאה שגיאה רק פרסרי JSON5/JSONC מקבלים אותם

הסתכלו על השורה השנייה: json.loads('{"cpu":NaN}') חוקי ב-Python. ספריית הסטנדרט מקבלת בכוונה NaN/Infinity מטעמי תאימות לאחור, ושפופות עבודה רבות ספרו את השורות הזבל האלה כרשומות רגילות בלי להבחין בזיהום. חסימתן דורשת פרמטר parse_constant מפורש — הקוד בהמשך.

מאיפה מגיעים ההבדלים: פערי מפרט ובחירות מימוש

RFC 8259 אינו עמום; המפרט משאיר בכוונה שלושה תחומים "לשיקול המימוש", וכל מימוש ממלא אותם אחרת.

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

שנית, מספרים. הדקדוק קובע רק את הצורה int frac exp; הגודל מופקד בידי המימוש. JavaScript מכריח הכול דרך מספרי IEEE 754 כפולים, ולכן 9007199254740993 הופך ל-...992. jq שומר על ליטרלים עשרוניים בנאמנות מגרסה 1.8, אבל כל חישוב חוזר לכפולים. אותו מסמך עשוי להציג שלושה ערכים שונים בהשוואה, באחסון ובהעברה.

שלישית, UTF-8 ותווים בלתי נראים. המפרט דורש ש-JSON מוחלף יהיה ב-UTF-8, אבל איך קובץ נפתח, האם BOM מוסר ומה עושים עם בייטים לא תקינים — החלטות של שכבת ה-IO. אותו זרם בייטים נותן פסקי דין שונים לפי ש-Python פותח אותו כ-utf-8 או כ-utf-8-sig.

מקור רביעי הוא דיאלקטים סלחניים. JSON5 מתיר הערות, מרכאות בודדות ופסיק מסיים; JSONC מרכך את אותם כללים באקוסיסטם של VS Code. קונפיגורציה שנפרסה בפרסר מקל ו-API שנפרסו בפרסר קפדני — הסטייה הנפוצה ביותר בתוך צוות אחד.

CVE-2026-33948: כשמחלוקת הופכת למשטח תקיפה

הבדלים בין פרסרים הם בדרך כלל מטרד חווייתי. ברגע ש"אימות" ו"פרסור" רצים על שני מימושים שונים, הם הופכים למשטח תקיפה. CVE-2026-33948, שחשף ב-2026, הוא דוגמה מתוך ספר לימוד: jq בגרסאות לפני 1.8.2 הרשה בייטי NUL מוטמעים (\0) בעת קריאת JSON מקובצים, כך שאותו קלט הניב שני פסקי דין — שלב האימות התייחס לתוכן כמסתיים שם, בעוד העיבוד האמיתי המשיך לקרוא הלאה. העקיפה שלמה. ייעוץ האבטחה של GitHub מאשר את התיקון: שדרוג ל-1.8.2.

חלצו את הלקח: בכל שרשרת "מאמתים קודם, מפרסרים אחר כך", אם שני הצעדים משתמשים במימושים או בקונפיגורציות שונות, תוקף יכול ליצור קלט שהמאמת פוסל והפרסר מקבל, ולהבריח payload על פני הבדיקה. אותה מבנה חוזר בשער (gateway) — הטיעון של API7 לכתוב פרסור קפדני לתוך חוזה ה-API הוא שסמנטיקת הפרסור היא חלק מהחוזה, לא התנהגות פרטית של מימוש מסוים. כשהשער דוחה בקשה על פי סט כללים אחד ושירות ה-backend מקבל את אותו גוף בפרסר אחר, החוזה כבר נסדק.

בדיקה עצמית נכנסת בפקודה אחת — ודאו שכל שלב מריץ את אותה גרסת jq, כולל התיקון הזה:

jq --version
# jq-1.7.1  ← פגיע, לשדרג
# jq-1.8.2  ← תוקן

מפתחות כפולים: הערך האחרון בולע את הראשון בשקט

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

import json

text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data)          # {'role': 'admin'}
print("guest" in data.values())  # False: הערך הראשון נעלם

אם הטקסט הזה מזין בדיקת חתימה או החלטת הרשאות, תוקף יכול להוסיף שדה בשם זהה ולכתוב מחדש את ההרשאה, וקוד האימות שלכם רואה רק את הערך הסופי. JSON.parse של Node מתנהג בדיוק כך. כדי לזהות במקום לדרוס בשקט, Python מקבל object_pairs_hook:

from collections import Counter

def reject_dup(pairs):
    counts = Counter(k for k, _ in pairs)
    dup = [k for k, c in counts.items() if c > 1]
    if dup:
        raise ValueError(f"duplicate keys: {dup}")
    return dict(pairs)

data = json.loads('{"a":1,"a":2}', object_pairs_hook=reject_dup)
# ValueError: duplicate keys: ['a']

סעיף 4 של RFC 8259 אומר זאת ישירות: לשם פעולה הדדית, שמות SHOULD היות ייחודיים. העלאת ה-SOULD הזה לכלל אימות עולה מעבר אחד בלבד ומסירה את המקור הנפוץ ביותר ל"שני כלים, שני פסקי דין".

התיקון: בורר אחד לכל גבול

התיקון אינו "לעבור לפרסר קפדני יותר". הוא לתת לכל נקודת גבול מדיניות מפורשת וכתובה — ולוודא שאימות והרצה משתמשים באותה אחת. הטבלה הבאה משמשת כרשימת בדיקה לסקירה:

גבול ברירת מחדל מקלה פסיקה מומלצת קונפיגורציה ייצוגית
מפתחות כפולים האחרון מנצח לדחות object_pairs_hook ב-Python; json/v2 ב-Go דוחה כברירת מחדל
NaN / Infinity Python מקבל לדחות parse_constant ב-Python שמזריק חריגה
חברים לא מוכרים מוזנחים בשקט להכריע לפי החוזה RejectUnknownMembers(true) ב-json/v2 של Go
UTF-8 לא תקין משתנה לפי מימוש לדחות אימות זרם בייטים מפורש בשכבת הפענוח
BOM מי שמסיר קובע להסיר פעם אחת בכניסה utf-8-sig קבוע או הסרה לפני פרסור
אימות והרצה מופרדים כל אחד לעצמו מימוש אחד, קונפיגורציה אחת המאמתים משתמשים חזרה בפרסר הייצור

בצד של Python, כיבוי שתי ברירות המחדל המסוכנות ביותר עולה קריאה אחת:

import json

def _reject(value):
    raise ValueError(f"non-standard constant: {value}")

data = json.loads(
    raw,
    parse_constant=_reject,          # חוסם NaN / Infinity
    object_pairs_hook=reject_dup,    # חוסם מפתחות כפולים
)

encoding/json/v2 ב-Go (בכינוי jsonv2) הופך את כל המדיניות למפורשת: RejectUnknownMembers(true) דוחה שדות לא מוכרים, ושמות כפולים לצד UTF-8 לא תקין נדחים כברירת מחדל. עמוד הפרקטיקות של GopherForge מדויק לגבי הסדר: הגבילו את בייטי הקלט, פענחו תחת מדיניות מפורשת, אמתו את הדומיין ואשרו — ורק אז התירו תופעות לוואי; וכל נתיב כשל צריך להתאמן באמצעות fixture, לא להישפט לפי מחרוזת שגיאה שהשתנתה.

הכניסו את מדיניות הפרסור לחוזים ולקורפוסים

למדיניות דרושה הגנה מסחרור. שתי פעולות מספיקות.

ראשית, כתבו "מה אנחנו מקבלים, מה אנחנו דוחים" בתיעוד הממשק לצד הגדרות השדות. API7 ממליץ על קוד שגיאה יציב כדי שלקוחות יבדילו בין שגיאת חוזה קבועה לכשל תשתית חולף — מפתח כפול שנדחה לא יכול להיראות כמו timeout של השער, אחרת תזמינו סופת ניסיונות חוזרים. אל תשפכו את גוף הבקשה המלא ללוגים: payload גולמי עשוי להכיל אישורי גישה, וחלק מהרצפים הלא תקינים אינם בטוחים להצגה.

שנית, בנו קורפוס דו-משמעות. הפכו כל שורה בטבלה למעלה ל-fixture בדיקה: מפתחות כפולים, מפתחות ברישיות שונה, חברים לא מוכרים, UTF-8 לא תקין, BOM, ערך שני בסוף, קלט ריק. הצהירו על שני דברים ב-CI: קלטים לא תקינים נכשלים בלי לייצר ערך חלקי שמיש, וקלטים מקובלים שורדים מחזור קידוד/פענוד ללא שינוי. כשמשדרגים פרסר, הריצו מחדש דוגמאות בצורת ייצור בסביבה מוגנת במצב השוואה, וסקרו את השינוי בסט הקבלה כשינוי חוזה אמיתי במקום להניח שה-fixture הישנים מכסים הכול.

הפעולות האלה משלימות את אימות JSON ב-CI: צינורות jsonlint, ajv ו-jq, שמסביר כיצד אימות תחביר וסכמה משתלבים בצינור; המאמר הזה מכסה את מה שקודם לצומת הראשון — הפרסר עצמו. סיכוני הזרקה כמו זיהום אב-טיפוס ו-XSS מטופלים ברשימת הסיכונים לאבטחת JSON; בעיות שרשרת אמון ברמת הפרסר — מפתחות כפולים ובייטי NUL — הן בדיוק שכבת האפס של אותה רשימה. לאיתור שגיאות תחביר פשוטות, ראו גבולות דקדוק JSON מתוך RFC 8259.

רשימת בדיקה לפני עלייה לאוויר

  1. יישרו גרסאות פרסר לאורך השרשרת כולה: jq, ריצות-זמן, שער, מאמתים לא-מקוונים — תיקונים מסוג CVE-2026-33948 חייבים להגיע לכל מקום;
  2. דחו במפורש מפתחות כפולים ו-NaN: הכניסו object_pairs_hook ו-parse_constant לעטיפות משותפות, ולעולם אל תקראו ל-json.loads חשוף בקוד עסקי;
  3. הכריעו חברים לא מוכרים לפי מסלול: צרכנים תואמים-קדימה יכולים להתעלם, נקודות קצה של פקודות חייבות להגדיר RejectUnknownMembers;
  4. קורפוס דו-משמעות ב-CI: לפחות 8 fixture, ועוד הרצת השוואה ישן-נגד-חדש לפני כל שדרוג פרסר;
  5. שגיאות ניתנות-לסיווג: קודים נפרדים לשגיאות חוזה ולשגיאות תשתית, חזרו רק על השניות.

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

FAQ

האם מפתחות כפולים הם אכן שגיאה לפי מפרט ה-JSON?

אינם שגיאת תחביר. סעיף 4 של RFC 8259 נוסח כך: שמות SHOULD היות ייחודיים — המלצה, לא חובה — ולכן הפרסרים המרכזיים מקבלים כפילויות ושומרים על הערך האחרון כברירת מחדל. המפרט כן ממליץ על ייחודיות לשם פעולה הדדית. העלאת זה לשגיאת אימות היא החלטת חוזה; זיהוי עולה מעבר אחד.

למה ספריית ה-json של Python מקבלת NaN בעוד ש-JavaScript זורק שגיאה?

ספריית הסטנדרט של Python מקבלת בכוונה NaN ו-Infinity כדי לקרוא מחדש נתונים שהיא היסטורית הפיקה עם אובדן. JSON.parse של ECMAScript מממש את הדקדוק בקפדנות וזורק SyntaxError. העבירו parse_constant ב-Python והם יידחו, ושורת קונפיגורציה אחת מיישרת את שני הריצות-זמן.

אילו גרסאות מושפעות מ-CVE-2026-33948 וכיצד מתקנים?

jq לפני 1.8.2, בעת קריאת JSON מקבצים, מקבל בייטי NUL מוטמעים שגורמים לשלב האימות ולפרסר האמיתי לחלוק על אותו קלט, מה שמאפשר עקיפת אימות. התיקון לפי ייעוץ ה-GitHub הוא שדרוג ל-1.8.2 או ל-build המכיל את ה-commit 6374ae0. נעלו גרסאות בסקריפטים וב-CI, והריצו את קורפוס הדו-משמעות לפני שדרוג.

אני מאמת פעם אחת בכניסה ומשתמש שוב בתוצאה — האם אני עדיין חשוף?

כן, אבל הסיכון מתרכז באותה נקודת כניסה בודדת. אם פרסר הכניסה, הקונפיגורציה והגרסה שלו נעולים, וקורפוס הדו-משמעות מכסה מפתחות כפולים, בייטי NUL ו-UTF-8 — אין בורר שני בתוך השרשרת. הטופולוגיה המסוכנת היא שער על מימוש אחד ושירותים על מימוש אחר, או אימות על פרסר אחד והרצה על אחר — אז פסק הדין נמסר למחלוקת עצמה.

מקורות

כלים מתאימים

מאמרים קשורים

אימות JSON ב-CI: צינור עם jsonlint, ajv ו-jq

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

בינוניכ-10 דקות קריאהעודכן 2026-10-31

צ'קליסט סיכוני אבטחה לעיבוד JSON

JSON.parse עצמו בטוח; הסכנה היא מה שקורה אחריו: מיזוג עמוק, השמה לפי נתיב, הטמעה ב-HTML, עומק וגודל בלתי מוגבלים.

בינוניכ-12 דקות קריאהעודכן 2026-10-30

קריאת גבולות הדקדוק של JSON מתוך RFC 8259

תרגום הפקות הדקדוק של RFC 8259 לשפה פשוטה: אילו תווים רשאים להופיע ישירות, אילו חייבים לעבור escape, והיכן המפרט משאיר מקום בכוונה.

מתחילכ-11 דקות קריאהעודכן 2026-10-30