תוכן העניינים
מערכות מחשוב מודרניות כוללות לרוב רכיבי מעבד ומחשב גרפי אינטגרליים המשתפים זיכרון ומשאבי מיקרו-ארכיטקטורה. בעוד שאינטגרציה זו מספקת תועלות ביצועים משמעותיות, היא גם מביאה סיכונים משמעותיים בצורה של ערוצים צדדיים וערוצי כיסוי. אלה מאפשרים לתוקפים להוציא מידע בין-מרכיבי, על ידי עקיפת בידוד תהליכים מסורתי.
פוסט זה מציע סקירה טכנית מעמיקה של ערוצי כיסוי בין-מרכיבים על מעבדים אינטגרליים, במיוחד התמקדות באלה המנצלות רכיבי מיקרו-ארכיטקטורה משותפים—מטמונים, ניבוי ענפים ואחרים. נחקר רקעים תאורטיים, היתכנות בעולם האמיתי, הדגמות קוד ואסטרטגיות הקלה נוכחיות. בין אם אתה מתחיל באבטחה או חוקר מתקדם, מדריך זה יכסה מודלי איום, הוכחות תפיסתיות מעשיות, ופרקטיקות הגנה מיטביות.
ערוץ כיסוי הוא נתיב תקשורת שלא נועד להעברת מידע. בתחום המחשוב, המושג משמש לעיתים להצביע על מצבים בהם תהליך אחד (המשדר, או "תהליך גבוה") מעביר במכוון מידע לתהליך אחר (המקבל, או "תהליך נמוך") בדרך שאסורה על ידי מדיניות האבטחה.
ערוצי כיסוי אינם מוגבלים לתעבורת רשת. קיימים רבים בשכבות המערכת הנמוכות, כולל ערוצי אחסון (שימוש בקבצים, זמן זיכרון, וכו') וערוצי זמן (הבדלים בזמינות משאבים).
מעבדים ומחשבים גרפיים מודרניים משתמשים במשאבים משותפים לצורך נוחות:
כאשר שני תהליכים משתפים אותם, הם יכולים לאותת מידע באמצעות שינויים במצב או בזמני החומרה המשותפים, אפילו כאשר לא מותרת תקשורת ישירה.
הערוצים המוכרים ביותר הם מבוססי מטמון:
שתי התקפות אלו מנצלות את הטבע המשותף של המטמונים מרובדים במעבד, במיוחד המטמון ברמה האחרונה (LLC).
מעבדים מודרניים משתמשים בניבוי ענפים להאצת ביצועים. מנבאים אלו הם משותפים בין תהליכים ולעיתים קרובות גם בין ליבות. אם משדר מאמן את המנבא, המקבל יכול לבדוק ולצפות בשינויים בתחזיות, מה שמאפשר העברת נתונים.
ראו: "ערוצי כיסוי דרך ניבוי ענפים: מחקר היתכנות"
מערכות משולבות CPU-GPU משתפות DRAM ולעיתים גם רכיבים עדינים יותר (למשל, LLC, נתיבי מערכות). שיתוף המשאבים בין המרכיבים הללו פותח וקטורי התקפה חדשים ובלתי נחקרים ברובם:
מחקרים אקדמיים בודקים התקפות בהן ה-CPU וה-GPU, או תהליכים שונים שרצים על כל אחד מהם, יוצרים ערוץ כיסוי דרך שורות מטמון או רוחב פס זיכרון משותפים (Leaky Buddies).
clflush).נקודה מרכזית: הבדלים בזמנים חושפים את פעולות המשדר.
בשימוש בעיקר בסביבות ענן, בהן לא תמיד יש זיכרון משותף.
ראו "ערוצי כיסוי דרך ניבוי ענפים: מחקר היתכנות" להדגמת התקפה.
התחילו באיסוף מידע על מטמון המעבד וניבוי ענפים.
# רשימת פרטי מטמון המעבד
lscpu | grep -i cache
# מתקדם: פריסת גודל המטמון ישירות
cat /proc/cpuinfo | grep -E 'cache size|model name'
# רשימת ספריות משותפות שממופות על ידי תהליך
pidof firefox # לדוגמה
cat /proc/<pid>/maps | grep r-xp | grep 'lib'
# Python: חיפוש באזורים משותפים לאובייקט
import os
pid = <your_pid>
with open(f"/proc/{pid}/maps") as f:
for line in f:
if 'lib' in line and 'r-xp' in line:
print(line.strip())
// gcc -O2 -o flush_reload flush_reload.c
#include <stdio.h>
#include <stdint.h>
#include <x86intrin.h>
uint64_t measure_access_time(volatile char *addr) {
uint64_t start = __rdtscp(&start);
*(volatile char *)addr;
uint64_t end = __rdtscp(&end);
return end - start;
}
int main() {
char *ptr = ...; // מפה לאובייקט משותף
while (1) {
_mm_clflush(ptr); // משדר: או פסוח עבור מקבל
uint64_t t = measure_access_time(ptr);
printf("Access time: %lu\n", t);
}
}
import ctypes
import time
# שלבו ספריות משותפות/קובץ, למשל, דרך mmap
libc = ctypes.CDLL("libc.so.6")
address = ctypes.c_void_p(...)
def measure_access_time(addr):
t1 = time.perf_counter_ns()
dummy = ctypes.c_char.from_address(addr.value)
val = dummy.value
t2 = time.perf_counter_ns()
return t2 - t1
while True:
t = measure_access_time(address)
print(f"Access time: {t}ns")
// קוד פסאודו עבור משדר ומקבל בהתקפת ערוץ ניבוי ענפים
// ביט מידע לתקשורת: 0 או 1
// משדר: עיישר מנבא ענפים
if (bit_to_send == 1) {
for (int i = 0; i < 1000; i++) { if (cond) foo(); }
} else {
for (int i = 0; i < 1000; i++) { if (!cond) foo(); }
}
// מקבל: מדוד זמן מיזימה של תחזית ענף
uint64_t t1 = rdtscp();
if (cond) foo();
uint64_t t2 = rdtscp();
uint64_t elapsed = t2 - t1;
if (elapsed > THRESHOLD) decode as bit 1 else 0;
הערה: אין הגנה מושלמת—עסקות כוללות ביצועים/אבטחה.
אלו מייצגות קבוצת על של ערוצים צדדיים/כיסוי, מנצלות ביצוע ספקולטיבי (Spectre, Meltdown) והוראות אחרות שבוצעו בזמן חולף כדי לדלוף מצב דרך ערוצים מיקרו-ארכיטקטוריים:
ראו את סדרת הרצאות "ערוצים צדדיים וביצוע חולף" לפירוק חזותי/תזמוני.
perf stat ...)# מעקב על מיזוג מטמון ותחזיות שגויות בענפים
sudo perf stat -e cache-misses,branch-misses ./your_app
import psutil
# מעקב על שימוש מטמון ויתרת CPU של כל תהליך לאורך זמן
for proc in psutil.process_iter(['pid', 'name', 'cpu_percent']):
print(proc.info)
ערוצי כיסוי בין-מרכיבים מדגישים סיכון קריטי ומתמשך באבטחת מיקרו-ארכיטקטורה. ככל שהמעבדים והמחשבים הגרפיים הופכים ליותר משולבים, הגבול שמעליו ניתן לדלוף מידע סודי מתרחב, מהמטמונים המשותפים של ה-CPU ועד למנבאי ענפים מתוחכמים ומשאבי CPU-GPU משותפים.
ההגנות דורשות מאמצים מתוך תיאום בין חומרה, מערכת ההפעלה, ותוכנה—ותמיד כוללים עלויות בביצועים. ככל שההתקפה מעמיקה יותר, כך ההחלטה נהיית קשה יותר.
לחוקרים, להמשיך למנות, לדגם, ולהקל על טכניקות חדשות של ערוצי כיסוי בין-מרכיבים הוא תהליך מתמשך. לארגונים, תכנון מודלים איום ותודעת מצב הם חיוניים.
למחקרים והודעות פגיעות האחרונות, עקוב באופן תדיר אחרי אתרים אקדמיים/כנסיים מאובטחים והנחיות CVE.
אם מצאתם את התוכן הזה בעל ערך, תארו לעצמכם מה תוכלו להשיג עם תוכנית ההכשרה המקיפה והאליטיסטית שלנו בת 47 שבועות. הצטרפו ליותר מ-1,200 סטודנטים ששינו את הקריירה שלהם בעזרת טכניקות יחידה 8200.