הבנת שיחות מערכת לינוקס עם הפקודה strace

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

שימוש אופייני בפקודה strace

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

strace ls /tmp

עם זאת, לרוב ישנם תהליכים שמתחילים הרבה יותר מוקדם וממשיכים לעבוד ברקע. עקב בעיות כלשהן, ייתכן שתרצה לאסוף מידע נוסף הקשור לתהליכים כאלה. אתה יכול לצרף רצועה לכל יישום פועל על ידי מתן מזהה התהליך של התהליך ל- -עמ' פָּרָמֶטֶר:

strace -p 2759

תְפוּקָה:

עקוב אחר חוטים ומזלגות של אפליקציה

עם strace, אתה יכול לבדוק את כל השרשורים ותהליכים צאצאים אחרים שהם מזלג של היישום באמצעות -ו דֶגֶל.

strace -f -p 2759

תְפוּקָה:

בדוק שיחות מערכת מסוימות עם strace

פלט ה-strace ברירת המחדל יכול להיות די צפוף לעקוב לפעמים. אם ברצונך לעקוב רק אחר שיחות מערכת מסוימות, תוכל לעשות זאת באמצעות -ה פָּרָמֶטֶר:

strace -f -e trace=פתח, כתוב, סגור, התחבר,בחר -עמ' 19770

כדי לעקוב רק אחר קריאות מערכת הקשורות לפעולות קבצים, השתמש -e trace=file:

strace -e trace=file -p 19770

כדי לסנן רק קריאות מערכת הקשורות לרשת, ציין -e trace=רשת בפקודה:

strace -e trace=network -p 19770

קבל מידע על זמן בשניות

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

strace -tt ls /tmp

אסוף נתונים סטטיסטיים על שיחות מערכת

עם ה -ג פרמטר, אתה יכול לאסוף נתונים סטטיסטיים על קריאות מערכת כל עוד אתה רוצה:

strace -f -c -p 19770

שמור יומנים לקובץ

אם אתה מפעיל strace במשך זמן רב וברצונך לבחון את היומנים שהתקבלו בפירוט רב יותר מאוחר יותר, תצטרך לשמור את היומנים. עם ה -o פרמטר אתה יכול לציין את הקובץ שבו strace אמור לשמור את היומנים:

strace -f -o /tmp/strace.log -e trace=file ls /tmp

תהליך חסימת ptrace

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

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

ptrace וביטחון

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

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

אתה יכול לשלוט בתגובה לקריאת מערכת ptrace באמצעות /proc/sys/kernel/yama/ptrace_scope קוֹבֶץ. כברירת מחדל, הקובץ הזה כותב ערך של 0.

הערכים הבאים מקובלים:

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

לאחרונה, כמה הפצות לינוקס החלו להגדיר את ערך ברירת המחדל של ptrace_scope קובץ, שתואר לעיל, ל 1. לפיכך, עם הגבלות על פעולות Ptrace, ניתנת סביבת עבודה בטוחה יותר בכל המערכת.

באמצעות מסלול לדוגמה

רשום את הבקשה לדוגמה למטה עם השם ministrace.c. לאחר מכן תוכל להרכיב אותו עם הפקודה הבאה:

gcc-oמשרדמשרד.c

קוד:

#לִכלוֹל <sys/ptrace.h>
#לִכלוֹל <sys/reg.h>
#לִכלוֹל <sys/wait.h>
#לִכלוֹל <sys/types.h>
#לִכלוֹל <unistd.h>
#לִכלוֹל <stdlib.h>
#לִכלוֹל <stdio.h>
#לִכלוֹל <errno.h>
#לִכלוֹל <מחרוזת.ח>
intwait_for_syscall(ילד_pid_t)
	{
int סטָטוּס;
בזמן (1) {
 ptrace (PTRACE_SYSCALL, ילד, 0, 0);
 waitpid (ילד, &סטטוס, 0);
 if (WIFSTOPPED(סטטוס) && WSTOPSIG(סטטוס) & 0x80)
לַחֲזוֹר0;
 if (WIFEXITED(סטטוס))
לַחֲזוֹר1;
 }
	}
intלעשות_ילד(int argc, לְהַשְׁחִיר **argv)
	{
לְהַשְׁחִיר *args [argc+1];
 memcpy (args, argv, argc * sizeof(לְהַשְׁחִיר*));
 args[argc] = ריק;
 ptrace (PTRACE_TRACEME);
לַהֲרוֹג(getpid(), SIGSTOP);
לַחֲזוֹר execvp (args[0], args);
	}
intdo_trace(ילד_pid_t)
	{
int סטטוס, syscall, retval;
 waitpid (ילד, &סטטוס, 0);
 ptrace (PTRACE_SETOPTIONS, צאצא, 0, PTRACE_O_TRACESYSGOOD);
בזמן(1) {
אם (wait_for_syscall (ילד) != 0) לשבור;
syscall = ptrace (PTRACE_PEEKUSER, ילד, sizeof(ארוך)*ORIG_RAX);
 fprintf (stderr, "syscall(%d) = ", syscal);
אם (wait_for_syscall (ילד) != 0) לשבור;
retval = ptrace (PTRACE_PEEKUSER, ילד, sizeof(ארוך)*RAX);
 fprintf (stderr, "%d
", retval);
 }
לַחֲזוֹר0;
	}
intרָאשִׁי(int argc, לְהַשְׁחִיר **argv)
	{
 אם (argc < 2) {
 fprintf (stderr, "שימוש: %s prog args
", argv[0]);
יְצִיאָה(1);
 }
 pid_t child = fork();
 if (ילד == 0) {
לַחֲזוֹר do_child (argc-1, argv+1);
 } אַחֵר {
לַחֲזוֹר do_trace (ילד);
 }
	}

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

אתה יכול להשתמש ב-strace למטרות רבות

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

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

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

צור מערכת הפעלה משלך עם לינוקס מאפס [Linux]

קרא הבא