בדיקת fuzz באמצעות libFuzzer

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

מערכת ה-build של Android תומכת ב-fuzzing באמצעות הכללת libFuzzer מפרויקט התשתית של LLVM compiler. LibFuzzer מקושר לספרייה שנבדקת ומטפל בכל הבחירות, המוטציות והדיווחים על קריסות של הקלט שמתרחשים במהלך סשן fuzzing. הכלי של LLVM לזיהוי שגיאות בקוד (sanitizer) עוזר לזהות פגיעה בזיכרון ולמדוד את כיסוי הקוד.

במאמר הזה נספק מבוא ל-libFuzzer ב-Android ונסביר איך לבצע build עם כלי למדידת ביצועים. הוא כולל גם הוראות לכתיבת, להרצה ולהתאמה אישית של כלי fuzzing.

הגדרה ופיתוח

כדי לוודא שיש לכם קובץ אימג' שפועל במכשיר, תוכלו להוריד קובץ אימג' מהמפעל ולבצע איפוס למכשיר. לחלופין, אפשר להוריד את קוד המקור של AOSP ולפעול לפי הדוגמה להגדרה ול-build שבהמשך.

דוגמה להגדרה

בדוגמה הזו, נניח שמכשיר היעד הוא Pixel‏ (taimen) שכבר מוכן לניפוי באגים ב-USB‏ (aosp_taimen-userdebug). אפשר להוריד קובצי בינאריים אחרים של Pixel מ-Driver Binaries. 

mkdir ~/bin
export PATH=~/bin:$PATH
curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo
repo init -u https://android.googlesource.com/platform/manifest -b main
repo sync -c -j8
wget https://dl.google.com/dl/android/aosp/google_devices-taimen-qq1a.191205.008-f4537f93.tgz
tar xvf google_devices-taimen-qq1a.191205.008-f4537f93.tgz
./extract-google_devices-taimen.sh
wget https://dl.google.com/dl/android/aosp/qcom-taimen-qq1a.191205.008-760afa6e.tgz
tar xvf qcom-taimen-qq1a.191205.008-760afa6e.tgz
./extract-qcom-taimen.sh
. build/envsetup.sh
lunch aosp_taimen-userdebug

דוגמה ל-build

השלב הראשון בהרצת מטרות fuzz הוא לקבל קובץ אימג' מערכת חדש. מומלץ להשתמש לפחות בגרסה האחרונה של Android לצורכי פיתוח.

  1. כדי לבצע את ה-build הראשוני, מריצים את הפקודה: 
    m
  2. כדי שתוכלו לבצע את ה-Flash במכשיר, צריך להפעיל אותו במצב Fastboot באמצעות שילוב המקשים המתאים.
  3. פותחים את נעילת האתחול ומעבירים את קובץ האימג' המהדר ב-flash באמצעות הפקודות הבאות. 
    fastboot oem unlock
fastboot flashall

עכשיו המכשיר היעד אמור להיות מוכן ל-fuzzing של libFuzzer.

כתיבת תוכנת fuzzer

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

זוהי פונקציית הבדיקה. 

#include <stdint.h>
#include <stddef.h>
bool FuzzMe(const char *data, size_t dataSize) {
    return dataSize >= 3  &&
           data[0] == 'F' &&
           data[1] == 'U' &&
           data[2] == 'Z' &&
           data[3] == 'Z';  // ← Out of bounds access
}

כדי ליצור ולהריץ את ה-fuzzer לבדיקה:

  1. יעד fuzz מורכב משני קבצים: קובץ build וקוד המקור של יעד ה-fuzz. יוצרים את הקבצים במיקום ליד הספרייה שאתם מבצעים עליה בדיקת fuzzing. נותנים למכשיר ה-fuzzer שם שמתאר את הפעולות שהוא מבצע.
  2. כתיבה של יעד fuzz באמצעות libFuzzer. יעד ה-fuzz הוא פונקציה שמקבלת blob של נתונים בגודל מסוים ומעבירה אותו לפונקציה שרוצים לבצע בה fuzz. הנה כלי fuzzing בסיסי לפונקציית הבדיקה הפגיעה: 
    #include <stddef.h>
#include <stdint.h>

extern "C" int LLVMFuzzerTestOneInput(const char *data, size_t size) {
  // ...
  // Use the data to call the library you are fuzzing.
  // ...
  return FuzzMe(data, size);
}
  3. מבקשים ממערכת ה-build של Android ליצור את קובץ ה-binary של ה-fuzzer. כדי ליצור את ה-fuzzer, מוסיפים את הקוד הזה לקובץ Android.bp: 
    cc_fuzz {
  name: "fuzz_me_fuzzer",
  srcs: [
    "fuzz_me_fuzzer.cpp",
  ],
  // If the fuzzer has a dependent library, uncomment the following section and
  // include it.
  // static_libs: [
  //   "libfoo", // Dependent library
  // ],
  //
  // The advanced features below allow you to package your corpus and
  // dictionary files during building. You can find more information about
  // these features at:
  //  - Corpus: https://llvm.org/docs/LibFuzzer.html#corpus
  //  - Dictionaries: https://llvm.org/docs/LibFuzzer.html#dictionaries
  // These features are not required for fuzzing, but are highly recommended
  // to gain extra coverage.
  // To include a corpus folder, uncomment the following line.
  // corpus: ["corpus/*"],
  // To include a dictionary, uncomment the following line.
  // dictionary: "fuzz_me_fuzzer.dict",
}
  4. כדי להפעיל את ה-fuzzer ביעד (מכשיר): 
    SANITIZE_TARGET=hwaddress m fuzz_me_fuzzer
  5. כדי להפעיל את ה-fuzzer במארח: 
    SANITIZE_HOST=address m fuzz_me_fuzzer

כדי להקל על עצמכם, תוכלו להגדיר כמה משתני מעטפת שמכילים את הנתיב ליעד ה-fuzz ואת שם הקובץ הבינארי (מקובץ ה-build שכתבתם קודם).

export FUZZER_NAME=your_fuzz_target

אחרי ביצוע השלבים האלה, אמור להיווצר לכם fuzzer מובנה. מיקום ברירת המחדל של ה-fuzzer (לדוגמה הזו של build ל-Pixel) הוא:

  • $ANDROID_PRODUCT_OUT/data/fuzz/$TARGET_ARCH/$FUZZER_NAME/$FUZZER_NAME למכשיר.
  • $ANDROID_HOST_OUT/fuzz/$TARGET_ARCH/$FUZZER_NAME/$FUZZER_NAME למארח.

    • הפעלת ה-fuzzer במארח

  • מוסיפים לקובץ ה-build Android.bp: 
    host_supported: true,
     חשוב לציין שאפשר להשתמש באפשרות הזו רק אם הספרייה שאתם רוצים לבצע עליה בדיקת fuzz נתמכת במארח.
  • כדי להריץ את ה-fuzzer במארח, פשוט מריצים את קובץ ה-binary של ה-fuzzer שנוצר: 
    $ANDROID_HOST_OUT/fuzz/x86_64/$FUZZER_NAME/$FUZZER_NAME

    • הפעלת ה-fuzzer במכשיר

    אנחנו רוצים להעתיק את זה למכשיר שלך באמצעות adb.

    1. כדי להעלות את הקבצים האלה לספרייה במכשיר, מריצים את הפקודות הבאות: 
      adb root
adb sync data
    2. מריצים את ה-fuzzer לבדיקה במכשיר באמצעות הפקודה הבאה: 
      adb shell /data/fuzz/$(get_build_var TARGET_ARCH)/$FUZZER_NAME/$FUZZER_NAME \
  /data/fuzz/$(get_build_var TARGET_ARCH)/$FUZZER_NAME/corpus

    הפלט יהיה דומה לפלט לדוגמה שבהמשך. 

    INFO: Seed: 913963180
INFO: Loaded 2 modules   (16039 inline 8-bit counters): 16033 [0x7041769b88, 0x704176da29), 6 [0x60e00f4df0, 0x60e00f4df6),
INFO: Loaded 2 PC tables (16039 PCs): 16033 [0x704176da30,0x70417ac440), 6 [0x60e00f4df8,0x60e00f4e58),
INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
INFO: A corpus is not provided, starting from an empty corpus
#2	INITED cov: 5 ft: 5 corp: 1/1b exec/s: 0 rss: 24Mb
#10	NEW    cov: 6 ft: 6 corp: 2/4b lim: 4 exec/s: 0 rss: 24Mb L: 3/3 MS: 3 CopyPart-ChangeByte-InsertByte-
#712	NEW    cov: 7 ft: 7 corp: 3/9b lim: 8 exec/s: 0 rss: 24Mb L: 5/5 MS: 2 InsertByte-InsertByte-
#744	REDUCE cov: 7 ft: 7 corp: 3/7b lim: 8 exec/s: 0 rss: 25Mb L: 3/3 MS: 2 ShuffleBytes-EraseBytes-
#990	REDUCE cov: 8 ft: 8 corp: 4/10b lim: 8 exec/s: 0 rss: 25Mb L: 3/3 MS: 1 ChangeByte-
==18631==ERROR: HWAddressSanitizer: tag-mismatch on address 0x0041e00b4183 at pc 0x0060e00c5144
READ of size 1 at 0x0041e00b4183 tags: f8/03 (ptr/mem) in thread T0
    #0 0x60e00c5140  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0xf140)
    #1 0x60e00ca130  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x14130)
    #2 0x60e00c9b8c  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x13b8c)
    #3 0x60e00cb188  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x15188)
    #4 0x60e00cbdec  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x15dec)
    #5 0x60e00d8fbc  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x22fbc)
    #6 0x60e00f0a98  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x3aa98)
    #7 0x7041b75d34  (/data/fuzz/arm64/lib/libc.so+0xa9d34)

[0x0041e00b4180,0x0041e00b41a0) is a small allocated heap chunk; size: 32 offset: 3
0x0041e00b4183 is located 0 bytes to the right of 3-byte region [0x0041e00b4180,0x0041e00b4183)
allocated here:
    #0 0x70418392bc  (/data/fuzz/arm64/lib/libclang_rt.hwasan-aarch64-android.so+0x212bc)
    #1 0x60e00ca040  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x14040)
    #2 0x60e00c9b8c  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x13b8c)
    #3 0x60e00cb188  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x15188)
    #4 0x60e00cbdec  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x15dec)
    #5 0x60e00d8fbc  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x22fbc)
    #6 0x60e00f0a98  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x3aa98)
    #7 0x7041b75d34  (/data/fuzz/arm64/lib/libc.so+0xa9d34)
    #8 0x60e00c504c  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0xf04c)
    #9 0x70431aa9c4  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x519c4)

Thread: T1 0x006700006000 stack: [0x007040c55000,0x007040d4ecc0) sz: 1023168 tls: [0x000000000000,0x000000000000)
Thread: T0 0x006700002000 stack: [0x007fe51f3000,0x007fe59f3000) sz: 8388608 tls: [0x000000000000,0x000000000000)
Memory tags around the buggy address (one tag corresponds to 16 bytes):
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   08  00  cf  08  dc  08  cd  08  b9  08  1a  1a  0b  00  04  3f
=> 27  00  08  00  bd  bd  2d  07 [03] 73  66  66  27  27  20  f6 <=
   5b  5b  87  87  03  00  01  00  4f  04  24  24  03  39  2c  2c
   05  00  04  00  be  be  85  85  04  00  4a  4a  05  05  5f  5f
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
Tags for short granules around the buggy address (one tag corresponds to 16 bytes):
   04  ..  ..  cf  ..  dc  ..  cd  ..  b9  ..  ..  3f  ..  57  ..
=> ..  ..  21  ..  ..  ..  ..  2d [f8] ..  ..  ..  ..  ..  ..  .. <=
   ..  ..  ..  ..  9c  ..  e2  ..  ..  4f  ..  ..  99  ..  ..  ..
See https://clang.llvm.org/docs/HardwareAssistedAddressSanitizerDesign.html#short-granules for a description of short granule tags
Registers where the failure occurred (pc 0x0060e00c5144):
    x0  f8000041e00b4183  x1  000000000000005a  x2  0000000000000006  x3  000000704176d9c0
    x4  00000060e00f4df6  x5  0000000000000004  x6  0000000000000046  x7  000000000000005a
    x8  00000060e00f4df0  x9  0000006800000000  x10 0000000000000001  x11 00000060e0126a00
    x12 0000000000000001  x13 0000000000000231  x14 0000000000000000  x15 000e81434c909ede
    x16 0000007041838b14  x17 0000000000000003  x18 0000007042b80000  x19 f8000041e00b4180
    x20 0000006800000000  x21 000000000000005a  x22 24000056e00b4000  x23 00000060e00f5200
    x24 00000060e0128c88  x25 00000060e0128c20  x26 00000060e0128000  x27 00000060e0128000
    x28 0000007fe59f16e0  x29 0000007fe59f1400  x30 00000060e00c5144
SUMMARY: HWAddressSanitizer: tag-mismatch (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0xf140)
MS: 1 ChangeByte-; base unit: e09f9c158989c56012ccd88111b82f778a816eae
0x46,0x55,0x5a,
FUZ
artifact_prefix='./'; Test unit written to ./crash-0eb8e4ed029b774d80f2b66408203801cb982a60
Base64: RlVa

    בפלט לדוגמה, הקריסה נגרמה על ידי fuzz_me_fuzzer.cpp בשורה 10:

          data[3] == 'Z';  // :(

    זוהי קריאה ישירה מחוץ למגבלות אם אורך המחרוזת data הוא 3.

    אחרי שמפעילים את ה-fuzzer, לרוב הפלט גורם לקריסה והקלט הפוגע נשמר בקורפוס ומקבל מזהה. בפלט לדוגמה, הערך הוא crash-0eb8e4ed029b774d80f2b66408203801cb982a60.

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

    adb pull /data/fuzz/arm64/fuzz_me_fuzzer/corpus/CRASH_ID
     לתשומת ליבכם: כדי ש-testcases יישמרו בספרייה הנכונה, אפשר להשתמש בתיקיית corpus (כמו בדוגמה שלמעלה) או להשתמש בארגומנט artifact_prefix (למשל, ‎-artifact_prefix=/data/fuzz/where/my/crashes/go‎).

    כשמבצעים בדיקת fuzzing במארח, פרטי הקריסה מופיעים בתיקיית הקריסה בתיקייה המקומית שבה פועל ה-fuzzer.

    יצירת כיסוי קווים

    כיסוי שורות שימושי מאוד למפתחים, כי הם יכולים לזהות אזורים בקוד שלא מכוסים ולעדכן את ה-fuzzers בהתאם כדי לטפל באזורים האלה במהלך פעולות fuzzing עתידיות.

    1. כדי ליצור דוחות כיסוי של fuzzer, מבצעים את השלבים הבאים : 
      CLANG_COVERAGE=true NATIVE_COVERAGE_PATHS='*' make ${FUZZER_NAME}

    2. אחרי שמעבירים את ה-fuzzer ואת יחסי התלות שלו למכשיר, מריצים את יעד ה-fuzz עם LLVM_PROFILE_FILE באופן הבא: 
      DEVICE_TRACE_PATH=/data/fuzz/$(get_build_var TARGET_ARCH)/${FUZZER_NAME}/data.profraw
adb shell LLVM_PROFILE_FILE=${DEVICE_TRACE_PATH} /data/fuzz/$(get_build_var TARGET_ARCH)/${FUZZER_NAME}/${FUZZER_NAME} -runs=1000

    3. כדי ליצור את דוח הכיסוי, קודם צריך לשלוף את קובץ ה-profraw מהמכשיר ואז ליצור את דוח ה-HTML בתיקייה שנקראת coverage-html, כפי שמתואר בהמשך: 
      adb pull ${DEVICE_TRACE_PATH} data.profraw
llvm-profdata merge --sparse data.profraw --output data.profdata
llvm-cov show --format=html --instr-profile=data.profdata \
  symbols/data/fuzz/$(get_build_var TARGET_ARCH)/${FUZZER_NAME}/${FUZZER_NAME} \
  --output-dir=coverage-html --path-equivalence=/proc/self/cwd/,$ANDROID_BUILD_TOP

    מידע נוסף על libFuzzer זמין במסמכי העזרה של המקור.