קל לארגן דפים בעזרת אוספים
אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.
Scudo הוא מנהל זיכרון דינמי במצב משתמש, או מנהל ערימת, שנועד להיות עמיד בפני נקודות חולשה שקשורות לערימת זיכרון (כמו overflow של מאגר מבוסס-ערימה, שימוש אחרי שחרור ושחרור כפול) תוך שמירה על הביצועים. הוא מספק את הרכיבים הסטנדרטיים של הקצאה והקצאה (כמו
malloc ו-free), וכן את רכיבי C++ (כמו חדש ו-Delete).
מאז השקת Android 11, נעשה שימוש ב-scudo לכל הקוד המקורי (חוץ ממכשירים עם נפח זיכרון נמוך, שבהם עדיין נעשה שימוש ב-jemalloc). בזמן הריצה, Scudo מטפל בכל ההקצאות והביטולים של זיכרון אשכול מקומי לכל קובצי ההפעלה והספריות שתלויות בהם, והתהליך מופסק אם מזוהה פגיעה או התנהגות חשודה באשכול.
אפשר להפעיל או להשבית את הפחתת העומס הנוספת במקצה באמצעות האפשרויות שמתוארות בהמשך.
התאמה אישית
אפשר להגדיר חלק מהפרמטרים של המקצה על בסיס תהליך, בכמה דרכים:
סטטית: מגדירים פונקציית __scudo_default_options בתוכנית שמחזירה את מחרוזת האפשרויות לניתוח. אב הטיפוס של הפונקציה הזו צריך להיות: extern "C" const char
*__scudo_default_options().
דינמי: משתמשים במשתנה הסביבה SCUDO_OPTIONS שמכיל את מחרוזת האפשרויות לניתוח. אפשרויות שהוגדרו באופן כזה מבטלות כל הגדרה שנוצרה באמצעות __scudo_default_options.
אלו האפשרויות הזמינות.
אפשרות
ברירת המחדל ל-64 ביט
ברירת מחדל של 32 ביט
תיאור
QuarantineSizeKb
256
64
הגודל (ב-KB) של המרחב לכליאת קבצים שמשמש לעיכוב הפעולה בפועל של ביטול ההקצאה של קטעי קוד. ערך נמוך יותר עשוי לצמצם את השימוש בזיכרון, אבל להפחית את היעילות של הפחתת העומס. ערך שלילי יגרום להפעלת הגדרות ברירת המחדל. הגדרת הערך של השדה הזה ושל השדה ThreadLocalQuarantineSizeKb לאפס משביתה את הבידוד לחלוטין.
QuarantineChunksUpToSize
2048
512
הגודל (בבייטים) עד שבו אפשר להעביר קטעי קוד ל-quarantine.
ThreadLocalQuarantineSizeKb
64
16
הגודל (ב-KB) של השימוש במטמון לכל חוט כדי להפחית את העומס בבידוד הגלובלי.
ערך נמוך יותר עשוי להפחית את השימוש בזיכרון, אבל עלול להגדיל את המאבק על המרחב המבודד הגלובלי. הגדרה של הערך הזה ושל הערך QuarantineSizeKb לאפס משביתה את הבידוד לחלוטין.
DeallocationTypeMismatch
false
false
הפעלת דיווח על שגיאות ב-malloc/delete, new/free, new/delete[]
DeleteSizeMismatch
true
true
הפעלת דיווח על שגיאות במקרה של אי-התאמה בין הגדלים של הרשאות ה-new וה-delete.
ZeroContents
false
false
הפעלת תוכן של אפס קטעים במהלך הקצאה וביטול הקצאה.
allocator_may_return_null
false
false
מציין שהמקצה יכול להחזיר null כשמתרחשת שגיאה שניתן לשחזר, במקום לסיים את התהליך.
hard_rss_limit_mb
0
0
כשה-RSS של התהליך מגיע למגבלה הזו, התהליך מסתיים.
soft_rss_limit_mb
0
0
כשה-RSS של התהליך מגיע למגבלה הזו, הקצאות נוספות נכשלות או מחזירות את הערך null (בהתאם לערך של allocator_may_return_null), עד שה-RSS יורד שוב כדי לאפשר הקצאות חדשות.
allocator_release_to_os_interval_ms
5000
לא רלוונטי
השפעה רק על מנהל זיכרון בנפח 64 ביט. אם הערך מוגדר, המערכת תנסה לפנות זיכרון לא מנוצל למערכת ההפעלה, אבל לא בתדירות גבוהה יותר מהמרווח הזה (במילי-שניות).
אם הערך של המאפיין הוא שלילי, המערכת לא משחררת את הזיכרון למערכת ההפעלה.
abort_on_error
true
true
אם ההגדרה הזו מוגדרת, הכלי יפעיל את abort() במקום את _exit() אחרי הדפסת הודעת השגיאה.
אימות
בשלב זה אין בדיקות CTS ספציפיות ל-Scudo. במקום זאת, צריך לוודא שבדיקות CTS עוברות עם או בלי הפעלת Scudo בקובץ בינארי נתון, כדי לוודא שהוא לא משפיע על המכשיר.
פתרון בעיות
אם מתגלה בעיה שלא ניתן לשחזר, המקצה מציג הודעת שגיאה למתואר השגיאה הסטנדרטי ולאחר מכן מסיים את התהליך.
נתוני מעקב ה-stack שמובילים לסיום הפעילות מתווספים ליומן המערכת.
הפלט בדרך כלל מתחיל ב-Scudo ERROR: ואחריו סיכום קצר של הבעיה, יחד עם הנחיות.
ריכזנו כאן רשימה של הודעות השגיאה הנוכחיות והסיבות האפשריות שלהן:
corrupted chunk header: אימות סכום הביקורת של כותרת הקטע נכשל. הסיבה לכך היא אחת משתי אפשרויות: הכותרת נכתבה מחדש (חלקית או באופן מלא), או שהמעצבת שהועברה לפונקציה היא לא מקטע.
race on chunk header: שני שרשורים שונים מנסים לבצע מניפולציה על אותה כותרת בו-זמנית. בדרך כלל, זהו סימן לתנאי מרוץ או לחוסר נעילה כללי בזמן ביצוע פעולות בחלק הזה.
invalid chunk state: הקטע לא במצב הצפוי לפעולה מסוימת. לדוגמה, הוא לא הוקצה כשניסיתם לפנות אותו, או שהוא לא הועבר לבידוד כשניסיתם למחזר אותו. הסיבה העיקרית לשגיאה הזו היא ביטול כפול של משאב.
misaligned pointer: דרישות ההתאמה הבסיסיות נאכפות באופן חזק: 8 בייטים בפלטפורמות של 32 ביט ו-16 בייטים בפלטפורמות של 64 ביט.
אם מצביע שהוענק לפונקציות שלנו לא תואם לתנאים האלה, סימן שהצבע שהוענק לאחת מהפונקציות לא מיושר.
allocation type mismatch: כשהאפשרות הזו מופעלת, פונקציית הקצאה מחדש (deallocation) שנקראת על מקטע צריכה להתאים לסוג הפונקציה שנקראת כדי להקצות אותו.
אי-התאמה כזו עלולה לגרום לבעיות אבטחה.
invalid sized delete: כשמשתמשים באופרטור המחיקה בגודל C++14 והבדיקה האופציונלית מופעלת, יש אי-התאמה בין הגודל שהוענק כשביטלו את ההקצאה של מקטע הנתונים לבין הגודל שהתבקש כשהקציתם אותו.
בדרך כלל זוהי בעיה במהדר או בלבול בסוגים של האובייקט שרוצים לבטל את ההקצאה שלו.
RSS limit exhausted: חרגתם ממספר הפריטים המקסימלי ב-RSS שצוין.
דוגמאות התוכן והקוד שבדף הזה כפופות לרישיונות המפורטים בקטע רישיון לתוכן. Java ו-OpenJDK הם סימנים מסחריים או סימנים מסחריים רשומים של חברת Oracle ו/או של השותפים העצמאיים שלה.
עדכון אחרון: 2025-07-27 (שעון UTC).
[[["התוכן קל להבנה","easyToUnderstand","thumb-up"],["התוכן עזר לי לפתור בעיה","solvedMyProblem","thumb-up"],["סיבה אחרת","otherUp","thumb-up"]],[["חסרים לי מידע או פרטים","missingTheInformationINeed","thumb-down"],["התוכן מורכב מדי או עם יותר מדי שלבים","tooComplicatedTooManySteps","thumb-down"],["התוכן לא עדכני","outOfDate","thumb-down"],["בעיה בתרגום","translationIssue","thumb-down"],["בעיה בדוגמאות/בקוד","samplesCodeIssue","thumb-down"],["סיבה אחרת","otherDown","thumb-down"]],["עדכון אחרון: 2025-07-27 (שעון UTC)."],[],[],null,["# Scudo is a dynamic user-mode memory allocator, or *heap* allocator, designed\nto be resilient against heap-related vulnerabilities (such as [heap-based buffer\noverflow](https://cwe.mitre.org/data/definitions/122.html), [use after free](https://cwe.mitre.org/data/definitions/416.html),\nand [double free](https://cwe.mitre.org/data/definitions/415.html))\nwhile maintaining performance. It provides the standard C allocation and\ndeallocation primitives (such as [malloc](http://pubs.opengroup.org/onlinepubs/009695399/functions/malloc.html) and free), as well as the C++ primitives (such as new and delete).\n\nScudo is more of a mitigation than a fully fledged memory error\ndetector like [AddressSanitizer (ASan)](/docs/security/test/sanitizers#addresssanitizer).\n\nSince the Android 11 release, scudo is used for all native code\n(except on low-memory devices, where jemalloc is still used). At runtime, all native heap\nallocations and deallocations are serviced by Scudo for all executables and their library\ndependencies, and the process is aborted if a corruption or suspicious\nbehavior is detected in the heap.\n\nScudo is [open source](https://github.com/llvm/llvm-project/tree/main/compiler-rt/lib/scudo) and part of LLVM's compiler-rt project. Documentation is\navailable at \u003chttps://llvm.org/docs/ScudoHardenedAllocator.html\u003e. The Scudo runtime ships\nas part of the Android toolchain and support was added to [Soong and Make](https://android.googlesource.com/platform/build/soong/)\nto allow for easy enabling of the allocator in a binary.\n\nYou can enable or disable extra mitigation within\nthe allocator using the options described below.\n\nCustomization\n-------------\n\nSome parameters of the allocator can be defined on a per-process basis\nthrough several ways:\n\n- **Statically:** Define a `__scudo_default_options` function in the program that returns the options string to be parsed. This function must have the following prototype: `extern \"C\" const char\n *__scudo_default_options()`.\n- **Dynamically:** Use the environment variable `SCUDO_OPTIONS` containing the options string to be parsed. Options defined this way override any definition made through `__scudo_default_options`.\n\nThe following options are available.\n| **Note:** Frontend options have a different name format than backend options.\n\n| Option | 64-bit default | 32-bit default | Description |\n|---------------------------------------|----------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `QuarantineSizeKb` | `256` | `64` | The size (in KB) of quarantine used to delay the actual deallocation of chunks. A lower value may reduce memory usage but decrease the effectiveness of the mitigation; a negative value falls back to the defaults. Setting both this and `ThreadLocalQuarantineSizeKb` to zero disables the quarantine entirely. |\n| `QuarantineChunksUpToSize` | `2048` | `512` | The size (in bytes) up to which chunks can be quarantined. |\n| `ThreadLocalQuarantineSizeKb` | `64` | `16` | The size (in KB) of per-thread cache use to offload the global quarantine. A lower value may reduce memory usage but might increase contention on the global quarantine. Setting both this and `QuarantineSizeKb` to zero disables the quarantine entirely. |\n| `DeallocationTypeMismatch` | `false` | `false` | Enables error reporting on malloc/delete, new/free, new/delete\\[\\] |\n| `DeleteSizeMismatch` | `true` | `true` | Enables error reporting on mismatch between sizes of new and delete. |\n| `ZeroContents` | `false` | `false` | Enables zero chunk contents on allocation and deallocation. |\n| `allocator_may_return_null` | `false` | `false` | Specifies that the allocator can return null when a recoverable error occurs, instead of terminating the process. |\n| `hard_rss_limit_mb` | `0` | `0` | When the process's RSS reaches this limit, the process terminates. |\n| `soft_rss_limit_mb` | `0` | `0` | When the process's RSS reaches this limit, further allocations fail or return `null` (depending on the value of `allocator_may_return_null`), until the RSS goes back down to allow for new allocations. |\n| `allocator_release_to_os_interval_ms` | `5000` | N/A | Only affects a 64-bit allocator. If set, tries to release unused memory to the OS, but not more often than this interval (in milliseconds). If the value is negative, memory isn't released to the OS. |\n| `abort_on_error` | `true` | `true` | If set, the tool calls `abort()` instead of `_exit()` after printing the error message. |\n\nValidation\n----------\n\nCurrently, there are no CTS tests specifically for Scudo. Instead, make sure\nthat CTS tests pass with or without Scudo enabled for a given binary to verify\nthat it doesn't impact the device.\n\nTroubleshooting\n---------------\n\nIf a non-recoverable issue is detected, the allocator\ndisplays an error message to the standard error descriptor and then terminates the process.\nStack traces that lead to the termination are added in the system log.\nThe output usually starts with `Scudo ERROR:` followed by a\nshort summary of the problem along with any pointers.\n| **Note:** Again, Scudo is meant to be a mitigation. Consider using ASan to determine the root cause of the issue.\n\nHere is a list of the current error messages and their potential\ncauses:\n\n- `corrupted chunk header`: The checksum verification of the chunk header has failed. This is likely due to one of two things: the header was overwritten (partially or totally), or the pointer passed to the function is not a chunk.\n- `race on chunk header`: Two different threads are attempting to manipulate the same header at the same time. This is usually symptomatic of a race-condition or general lack of locking when performing operations on that chunk.\n- `invalid chunk state`: The chunk isn't in the expected state for a given operation, for example, it's not allocated when trying to free it, or it's not quarantined when trying to recycle it. A double free is the typical reason for this error.\n- `misaligned pointer`: Basic alignment requirements are strongly enforced: 8 bytes on 32-bit platforms and 16 bytes on 64-bit platforms. If a pointer passed to our functions does not fit those, the pointer passed to one of the functions is out of alignment.\n- `allocation type mismatch`: When this option is enabled, a deallocation function called on a chunk has to match the type of function that was called to allocate it. This type of mismatch can introduce security issues.\n- `invalid sized delete`: When the C++14 sized delete operator is used, and the optional check is enabled, there's a mismatch between the size that was passed when deallocating a chunk and the size that was requested when allocating it. This is typically a compiler issue or a [type confusion](https://cwe.mitre.org/data/definitions/843.html) on the object being deallocated.\n- `RSS limit exhausted`: The maximum RSS optionally specified has been exceeded.\n\n\nIf you're debugging a crash in the OS itself, you can use a\n[HWASan OS build](/devices/tech/debug/hwasan). If you're\ndebugging a crash in an app, it's possible to use a\n[HWASan app build](https://developer.android.com/ndk/guides/hwasan) too."]]
