איך לכתוב חוקים לצ'קמארקס בלי להשתגע

היי הבר!

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

לרוב אנו משתמשים ב-Checkmarx - מנתח קוד מעניין וחזק מאוד. במאמר זה אדבר על הניסיון שלי בכתיבת כללי ניתוח עבורו.

תוכן העניינים

• כניסה

• מידע כללי על הכללים

• "מילון" למתחילים

  • פעולות עם רשימות

  • כל הפריטים שנמצאו

  • פונקציות לניתוח זרימה

  • מקבל שם/נתיב של הקובץ

  • תוצאת ביצוע

  • שימוש בתוצאות של כללים אחרים

• פיתרון בעיות

  • רישום

  • בעיית כניסה

• חוקי כתיבה

• מסקנה

כניסה

ראשית, ברצוני להמליץ ​​על אחד מהמאמרים הבודדים ברוסית על התכונות של כתיבת שאילתות עבור צ'קמארקס. הוא פורסם באתר Habré בסוף 2019 תחת הכותרת: "שלום, צ'קמרקס!" כיצד לכתוב שאילתת Checkmarx SAST ולמצוא נקודות תורפה מגניבות.

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

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

מידע כללי על הכללים

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

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

   הגדרת Preset בממשק Checkmarx

2. הכללים נערכים בכלי מיוחד בשם CxAuditor. זהו יישום שולחן עבודה שמתחבר לשרת המריץ את Checkmarx. לכלי זה שני מצבי פעולה: עריכת כללים וניתוח תוצאות של סריקה שכבר בוצעה.

   ממשק CxAudit

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

   חלוקת חוקים לפי שפה

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

   קביעת סוג הכלל בעת יצירה

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

   דוגמה לכלל חדש בממשק Preset Manager

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

7. ניתן ליישם כללים ברמות שונות:

• לכל המערכת - ישמש לכל סריקה של כל פרויקט

• ברמת הצוות (Team) - ישמש רק לסריקת פרויקטים בצוות הנבחר.

• ברמת הפרויקט - ייושם בפרויקט ספציפי

  קביעת הרמה שבה יחול הכלל

"מילון" למתחילים

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

פעולות עם רשימות

- вычитание одного из другого (list2 - list1)
* пересечение списков (list1 * list2)
+ сложение списков (list1 + list2)

& (логическое И) - объединяет списки по совпадению (list1 & list2), аналогично пересечению (list1 * list2)
| (логическое ИЛИ) - объединяет списки по широкому поиску (list1 | list2)

Со списками не работает:  ^  &&  ||  %  / 

כל הפריטים שנמצאו

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

// Такой запрос выдаст все элементы
result = All;

// Такой запрос выдаст все элементы, в имени которых присутствует “searchMe“
result = All.FindByName("searchMe");

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

result = AllMembers.All.FindByName("searchMe");

פונקציות לניתוח זרימה

פונקציות אלה משמשות בחוקים רבים והנה דף רמאות קטן של משמעותן:

// Какие данные second влияют на first.
// Другими словами - ТО (second) что влияет на  МЕНЯ (first).
result = first.DataInfluencedBy(second);

// Какие данные first влияют на second.
// Другими словами - Я (first) влияю на ТО (second).
result = first.DataInfluencingOn(second);

מקבל שם/נתיב של הקובץ

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

// Для примера найдем все методы
CxList methods = Find_Methods();

// В методах найдем по имени метод scope
CxList scope = methods.FindByName("scope");

// Таким образом можо получить путь к файлу
string current_filename = scope.GetFirstGraph().LinePragma.FileName;

// А вот таким - строку, где нашлось срабатывание
int current_line = scope.GetFirstGraph().LinePragma.Line;

// Эти параметры можно использовать по разному
// Например получить все объекты в файле
CxList inFile = All.FindByFileName(current_filename);

// Или найти что происходит в конкретной строке
CxList inLine = inFile.FindByPosition(current_line);

כדאי לזכור זאת FileName מכיל למעשה את הנתיב לקובץ, מכיוון שהשתמשנו בשיטה GetFirstGraph.

תוצאת ביצוע

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

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

// Находим элементы foo
CxList libraries = All.FindByName("foo");

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

// Находим элементы foo
CxList libraries = All.FindByName("foo");

// Выводим, как результат выполнения правила
result = libraries

// Или еще короче
result = All.FindByName("foo");

שימוש בתוצאות של כללים אחרים

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

// Получаем результат выполнения другого правила
CxList methods = Find_Methods();

// Ищем внутри метод foo. 
// Второй параметр false означает, что ищем без чувствительности к регистру
result = methods.FindByShortName("foo", false);

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

פיתרון בעיות

רישום

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

// Находим что-то
CxList toLog = All.FindByShortName("log");

// Формируем строку и отправляем в лог
cxLog.WriteDebugMessage (“number of DOM elements =” + All.Count);

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

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

// Находим что-то
CxList toLog = All.FindByShortName("log");

// Выводим результат выполнения
return toLog

//Все, что написано дальше не будет выполнено
result = All.DataInfluencedBy(toLog)

בעיית כניסה

ישנם מצבים שבהם אינך יכול לגשת לכלי CxAudit (שמשמש לכתיבת כללים). יכולות להיות לכך סיבות רבות, כולל קריסות, עדכוני Windows פתאומיים, BSOD ומצבים בלתי צפויים אחרים שאינם בשליטתנו. במקרה זה, לפעמים יש סשן לא גמור במסד הנתונים, שמונע ממך להיכנס שוב. כדי לתקן את זה, עליך להפעיל מספר שאילתות:

עבור צ'קמרקס לפני 8.6:

// Проверяем, что есть залогиненые пользователи, выполнив запрос в БД
SELECT COUNT(*) FROM [CxDB].[dbo].LoggedinUser WHERE [ClientType] = 6;
 
// Если что-то есть, а на самом деле даже если и нет, попробовать выполнить запрос
DELETE FROM [CxDB].[dbo].LoggedinUser WHERE [ClientType] = 6;

עבור Checkmarx לאחר 8.6:

// Проверяем, что есть залогиненые пользователи, выполнив запрос в БД
SELECT COUNT(*) FROM LoggedinUser WHERE (ClientType = 'Audit');
 
// Если что-то есть, а на самом деле даже если и нет, попробовать выполнить запрос
DELETE FROM [CxDB].[dbo].LoggedinUser WHERE (ClientType = 'Audit');

חוקי כתיבה

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

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

אז הנה הבעיות שנתקלנו בהן לרוב:

משימה: יש כמה זרימות בתוצאות של ביצוע הכלל ואחת מהן היא קינון של אחר, עליך לעזוב אחת מהן.

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

// Оставить только длинные Flow
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceSmallFlow);

// Оставить только короткие Flow
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceBigFlow);

משימה: הרחב את רשימת הנתונים הרגישים אליהם הכלי מגיב

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

רשימת_הפרת_פרטיות כללית

בואו נוסיף מספר משתנים המשמשים באפליקציה שלנו לאחסון מידע רגיש:

// Получаем результат выполнения базового правила
result = base.General_privacy_violation_list();

// Ищем элементы, которые попадают под простые регулярные выражения. Можно дополнить характерными для вас паттернами.
CxList personalList = All.FindByShortNames(new List<string> {
	"*securityToken*", "*sessionId*"}, false);

// Добавляем к конечному результату
result.Add(personalList);

משימה: הרחב את רשימת המשתנים עם סיסמאות

פתרון: הייתי ממליץ לשים לב מיד לכלל הבסיסי להגדרת סיסמאות בקוד ולהוסיף לו רשימה של שמות משתנים הנהוגים בחברה שלך.

Password_privacy_violation_list

CxList allStrings = All.FindByType("String"); 
allStrings.Add(All.FindByType(typeof(StringLiteral))); 
allStrings.Add(Find_UnknownReference());
allStrings.Add(All.FindByType(typeof (Declarator)));
allStrings.Add(All.FindByType(typeof (MemberAccess)));
allStrings.Add(All.FindByType(typeof(EnumMemberDecl))); 
allStrings.Add(Find_Methods().FindByShortName("get*"));

// Дополняем дефолтный список переменных
List < string > pswdIncludeList = new List<string>{"*password*", "*psw", "psw*", "pwd*", "*pwd", "*authKey*", "pass*", "cipher*", "*cipher", "pass", "adgangskode", "benutzerkennwort", "chiffre", "clave", "codewort", "contrasena", "contrasenya", "geheimcode", "geslo", "heslo", "jelszo", "kennwort", "losenord", "losung", "losungswort", "lozinka", "modpas", "motdepasse", "parol", "parola", "parole", "pasahitza", "pasfhocal", "passe", "passord", "passwort", "pasvorto", "paswoord", "salasana", "schluessel", "schluesselwort", "senha", "sifre", "wachtwoord", "wagwoord", "watchword", "zugangswort", "PAROLACHIAVE", "PAROLA CHIAVE", "PAROLECHIAVI", "PAROLE CHIAVI", "paroladordine", "verschluesselt", "sisma",
                "pincode",
								"pin"};
								
List < string > pswdExcludeList = new List<string>{"*pass", "*passable*", "*passage*", "*passenger*", "*passer*", "*passing*", "*passion*", "*passive*", "*passover*", "*passport*", "*passed*", "*compass*", "*bypass*", "pass-through", "passthru", "passthrough", "passbytes", "passcount", "passratio"};

CxList tempResult = allStrings.FindByShortNames(pswdIncludeList, false);
CxList toRemove = tempResult.FindByShortNames(pswdExcludeList, false);
tempResult -= toRemove;
tempResult.Add(allStrings.FindByShortName("pass", false));

foreach (CxList r in tempResult)
{
	CSharpGraph g = r.data.GetByIndex(0) as CSharpGraph;
	if(g != null && g.ShortName != null && g.ShortName.Length < 50)
	{
		result.Add(r);
	}
}

משימה: הוסף מסגרות משומשות שאינן נתמכות על ידי Checkmarx

פתרון: כל השאילתות ב-Checkmarx מחולקות לפי שפה, לכן עליך להוסיף כללים לכל שפה. להלן כמה דוגמאות לכללים כאלה.

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

דוגמה לקוד בדיקה המשתמשת בספריית Timber לרישום:

package com.death.timberdemo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import timber.log.Timber;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Timber.e("Error Message");
        Timber.d("Debug Message");

        Timber.tag("Some Different tag").e("And error message");
    }
}

והנה דוגמה לבקשת צ'קמארקס, שתאפשר לך להוסיף הגדרה של קריאה לשיטות Timber כנקודת יציאה לנתונים מהאפליקציה:

FindAndroidOutputs

// Получаем результат выполнения базового правила
result = base.Find_Android_Outputs();

// Дополняем вызовами, которые приходят из библиотеки Timber
CxList timber = All.FindByExactMemberAccess("Timber.*") +
    All.FindByShortName("Timber").GetMembersOfTarget();

// Добавляем к конечному результату
result.Add(timber);

ואתה יכול גם להוסיף לכלל השכן, אבל זה מתייחס ישירות לכניסה לאנדרואיד:

FindAndroidLog_Outputs

// Получаем результат выполнения базового правила
result = base.Find_Android_Log_Outputs();

// Дополняем вызовами, которые приходят из библиотеки Timber
result.Add(
  All.FindByExactMemberAccess("Timber.*") +
  All.FindByShortName("Timber").GetMembersOfTarget()
);

כמו כן, אם יישומי אנדרואיד משתמשים WorkManager עבור עבודה אסינכרונית, מומלץ ליידע את צ'קמארקס על כך בנוסף על ידי הוספת שיטה לקבלת נתונים מהמשימה getInputData:

FindAndroidRead

// Получаем результат выполнения базового правила
result = base.Find_Android_Read();

// Дополняем вызовом функции getInputData, которая используется в WorkManager
CxList getInputData = All.FindByShortName("getInputData");

// Добавляем к конечному результату
result.Add(getInputData.GetMembersOfTarget());

משימה: חיפוש נתונים רגישים ב-plist עבור פרויקטים של iOS

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

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

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>DeviceDictionary</key>
	<dict>
		<key>phone</key>
		<string>iPhone 6s</string>
	</dict>
	<key>privatekey</key>
	<string>MIICXAIBAAKBgQCqGKukO1De7zhZj6+</string>
</dict>
</plist>

וכלל עבור Checkmarx, שיש לו כמה ניואנסים שיש לקחת בחשבון בעת ​​הכתיבה:

// Используем результат выполнения правила по поиску файлов plist, чтобы уменьшить время работы правила и 
CxList plist = Find_Plist_Elements();

// Инициализируем новую переменную
CxList dictionarySettings = All.NewCxList();

// Теперь добавим поиск всех интересующих нас значений. В дальнейшем можно расширять этот список.
// Для поиска значений, как ни странно, используется FindByMemberAccess - поиск обращений к методам. Второй параметр внутри функции, false, означает, что поиск нечувствителен к регистру
dictionarySettings.Add(plist.FindByMemberAccess("privatekey", false));
dictionarySettings.Add(plist.FindByMemberAccess("privatetoken", false));

// Для корректного поиска из-за особенностей структуры plist - нужно искать по типу "If statement"
CxList ifStatements = plist.FindByType(typeof(IfStmt));

// Добавляем в результат, перед этим получив родительский узел - для правильного отображения
result = dictionarySettings.FindByFathers(ifStatements);

משימה: מציאת מידע ב-XML

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

הנה דוגמה לא נכונה מהתיעוד:

// Код работать не будет
result = All.FindXmlAttributesByNameAndValue("*.app", 8, “id”, "error- section", false, true);

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

// Правильный вариант с использованием cxXPath
result = cxXPath.FindXmlAttributesByNameAndValue("*.xml", 8, "cleartextTrafficPermitted", "true", false, true);

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

• "*.xml"- מסכת קבצים לחיפוש

• 8 - מזהה השפה שעבורה חל הכלל

• "cleartextTrafficPermitted"- שם תכונה ב-xml

• "true" - הערך של תכונה זו

• false - שימוש בביטוי רגולרי בעת חיפוש

• true - פירושו שהחיפוש יתבצע תוך התעלמות מרישיות, כלומר, לא תלוי רישיות

כדוגמה, השתמשנו בכלל שמזהה, מבחינה אבטחה, הגדרות חיבור רשת לא נכונות באנדרואיד המאפשרות תקשורת עם השרת באמצעות פרוטוקול HTTP. דוגמה להגדרה המכילה תכונה cleartextTrafficPermitted עם משמעות true:

<network-security-config>
    <domain-config>
        <domain includeSubdomains="true">example.com</domain>
        <trust-anchors>
            <certificates src="@raw/my_ca"/>
        </trust-anchors>
        <domain-config cleartextTrafficPermitted="true">
            <domain includeSubdomains="true">secure.example.com</domain>
        </domain-config>
    </domain-config>
</network-security-config>

משימה: הגבל את התוצאות לפי שם קובץ/נתיב

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

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

לפיכך, המשימה היא לנתק טריגרים בקבצי ילד השייכים לספריות. ניתן לזהות אותם לפי נוכחות הקו apply 'com.android.library'.

קוד לדוגמה מהקובץ build.gradle, הקובע את הצורך בערפול:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 24
    buildToolsVersion "24.0.2"
    defaultConfig {
        ...
    }

    buildTypes {
        release {
            minifyEnabled true
            ...
        }
    }
}

dependencies {
  ...
}

דוגמה לקובץ build.gradle עבור ספרייה הכלולה בפרויקט שאין לה הגדרה זו:

apply plugin: 'android-library'

dependencies {
  compile 'com.android.support:support-v4:18.0.+'
}

android {
  compileSdkVersion 14
  buildToolsVersion '17.0.0'
  ...
}

והכלל עבור צ'קמרקס:

ProGuardObfuscationNotInUse

// Поиск метода release среди всех методов в Gradle файлах
CxList releaseMethod = Find_Gradle_Method("release");

// Все объекты из файлов build.gradle
CxList gradleBuildObjects = Find_Gradle_Build_Objects();

// Поиск того, что находится внутри метода "release" среди всех объектов из файлов build.gradle
CxList methodInvokesUnderRelease = gradleBuildObjects.FindByType(typeof(MethodInvokeExpr)).GetByAncs(releaseMethod);

// Ищем внутри gradle-файлов строку "com.android.library" - это значит, что данный файл относится к библиотеке и его необходимо исключить из правила
CxList android_library = gradleBuildObjects.FindByName("com.android.library");

// Инициализация пустого массива
List<string> libraries_path = new List<string> {};

// Проходим через все найденные "дочерние" файлы
foreach(CxList library in android_library)
{
    // Получаем путь к каждому файлу
	string file_name_library = library.GetFirstGraph().LinePragma.FileName;
    
    // Добавляем его в наш массив
	libraries_path.Add(file_name_library);
}

// Ищем все вызовы включения обфускации в релизных настройках
CxList minifyEnabled = methodInvokesUnderRelease.FindByShortName("minifyEnabled");

// Получаем параметры этих вызовов
CxList minifyValue = gradleBuildObjects.GetParameters(minifyEnabled, 0);

// Ищем среди них включенные
CxList minifyValueTrue = minifyValue.FindByShortName("true");

// Немного магии, если не нашли стандартным способом :D
if (minifyValueTrue.Count == 0) {
	minifyValue = minifyValue.FindByAbstractValue(abstractValue => abstractValue is TrueAbstractValue);
} else {
    // А если всё-таки нашли, то предыдущий результат и оставляем
	minifyValue = minifyValueTrue;	
}

// Если не нашлось таких методов
if (minifyValue.Count == 0)
{
    // Для более корректного отображения места срабатывания в файле ищем или buildTypes или android
	CxList tempResult = All.NewCxList();
	CxList buildTypes = Find_Gradle_Method("buildTypes");
	if (buildTypes.Count > 0) {
		tempResult = buildTypes;
	} else {
		tempResult = Find_Gradle_Method("android");
	}
	
	// Для каждого из найденных мест срабатывания проходим и определяем, дочерний или основной файлы сборки
	foreach(CxList res in tempResult)
	{
        // Определяем, в каком файле был найден buildType или android методы
		string file_name_result = res.GetFirstGraph().LinePragma.FileName;
        
        // Если такого файла нет в нашем списке "дочерних" файлов - значит это основной файл и его можно добавить в результат
		if (libraries_path.Contains(file_name_result) == false){
			result.Add(res);
		}
	}
}

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

משימה: הוסף תמיכה בספריית צד שלישי אם התחביר אינו נתמך במלואו

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

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

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

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

• והאפשרות השלישית היא להשתמש בשתי הגישות לעיל ביחד.

כדוגמה, בואו נסתכל על ספרייה ידועה במעגלים צרים חלקלק עבור שפת התכנות Scala, כלומר, הפונקציונליות שחבור ערכים מילוליים. באופן כללי, כדי להעביר פרמטרים לשאילתת SQL, עליך להשתמש באופרטור $, המחליף נתונים בשאילתת SQL שנוצרה מראש. כלומר, למעשה, זהו אנלוגי ישיר של Prepared Statement בג'אווה. אבל, אם אתה צריך לבנות באופן דינמי שאילתת SQL, למשל, אם אתה צריך להעביר שמות טבלאות, אתה יכול להשתמש באופרטור #$, אשר יחליף ישירות את הנתונים לתוך השאילתה (כמעט כמו שרשור מחרוזת).

קוד לדוגמה:

// В общем случае - значения, контролируемые пользователем
val table = "coffees"
sql"select * from #$table where name = $name".as[Coffee].headOption

צ'קמארקס עדיין לא יודע איך לזהות את השימוש ב- Splicing Literal Values ​​ומדלג על אופרטורים #$, אז בואו ננסה ללמד אותו לזהות הזרקות SQL אפשריות ולהדגיש את המקומות הנכונים בקוד:

// Находим все импорты
CxList imports = All.FindByType(typeof(Import));

// Ищем по имени, есть ли в импортах slick
CxList slick = imports.FindByShortName("slick");

// Некоторый флаг, определяющий, что импорт библиотеки в коде присутствует
// Для более точного определения - можно применить подход с именем файла
bool not_empty_list = false;
foreach (CxList r in slick)
{
    // Если встретили импорт, считаем, что slick используется
	not_empty_list = true;
}

if (not_empty_list) {
    // Ищем вызовы, в которые передается SQL-строка
	CxList sql = All.FindByShortName("sql");
	sql.Add(All.FindByShortName("sqlu"));
	
	// Определяем данные, которые попадают в эти вызовы
	CxList data_sql = All.DataInfluencingOn(sql);
	
	// Так как синтакис не поддерживается, можно применить подход с регулярными выражениями
	// RegExp стоит использовать крайне осторожно и не применять его на большом количестве данных, так как это может сильно повлиять на производительность
	CxList find_possible_inj = data_sql.FindByRegex(@"#$", true, true, true);

    // Избавляемся от лишних срабатываний, если они есть и выводим в результат
	result = find_possible_inj.FindByType(typeof(BinaryExpr));
}

משימה: חפש פונקציות פגיעות בשימוש בספריות קוד פתוח

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

אבל לפעמים, במיוחד כאשר שוקלים JavaScript, ייתכן שזו לא משימה טריוויאלית לחלוטין. להלן פתרון, אולי לא אידיאלי, אבל בכל זאת עובד, תוך שימוש בדוגמה של פגיעויות ברכיב lodash בשיטות template и *set.

דוגמאות לבדיקת קוד שעלול להיות פגיע בקובץ JS:

/**
 * Template example
 */

'use strict';
var _ = require("./node_modules/lodash.js");


// Use the "interpolate" delimiter to create a compiled template.
var compiled = _.template('hello <%= js %>!');
console.log(compiled({ 'js': 'lodash' }));
// => 'hello lodash!'

// Use the internal `print` function in "evaluate" delimiters.

var compiled = _.template('<% print("hello " + js); %>!');
console.log(compiled({ 'js': 'lodash' }));
// => 'hello lodash!'

וכאשר מתחברים ישירות ב-html:

<!DOCTYPE html>
<html>
<head>
    <title>Lodash Tutorial</title>
    <script src="./node_modules/lodash.js"></script>
    <script type="text/javascript">
  // Lodash chunking array
        nums = [1, 2, 3, 4, 5, 6, 7, 8, 9];

        let c1 = _.template('<% print("hello " + js); %>!');
        console.log(c1);

        let c2 = _.template('<% print("hello " + js); %>!');
        console.log(c2);
    </script>
</head>
<body></body>
</html>

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

// Ищем все строки: в которых встречается строка lodash (предполагаем, что это объявление импорта библиотеки
CxList lodash_strings = Find_String_Literal().FindByShortName("*lodash*");

// Ищем все данные: которые взаимодействуют с этими строками
CxList data_on_lodash = All.InfluencedBy(lodash_strings);


// Задаем список уязвимых методов
List<string> vulnerable_methods = new List<string> {"template", "*set"};

// Ищем все наши уязвимые методы, которые перечисленны в уязвимостях и отфильтровываем их только там, где они вызывались
CxList vulnerableMethods = All.FindByShortNames(vulnerable_methods).FindByType(typeof(MethodInvokeExpr));

//Находим все данные: которые взаимодействуют с данными методами
CxList vulnFlow = All.InfluencedBy(vulnerableMethods);

// Если есть пересечение по этим данным - кладем в результат
result = vulnFlow * data_on_lodash;

// Формируем список путей по которым мы уже прошли, чтобы фильтровать в дальнейшем дубли
List<string> lodash_result_path = new List<string> {};

foreach(CxList lodash_result in result)
{
    // Очередной раз получаем пути к файлам
	string file_name = lodash_result.GetFirstGraph().LinePragma.FileName;
	lodash_result_path.Add(file_name);
}

// Дальше идет часть относящаяся к html файлам, так как в них мы не можем проследить откуда именно идет вызов
// Формируем массив путей файлов, чтобы быть уверенными, что срабатывания уязвимых методов были именно в тех файлах, в которых объявлен lodash
List<string> lodash_path = new List<string> {};
foreach(CxList string_lodash in lodash_strings)
{
	string file_name = string_lodash.GetFirstGraph().LinePragma.FileName;
	lodash_path.Add(file_name);
}

// Перебираем все уязвимые методы и убеждаемся, что они вызваны в тех же файлах, что и объявление/включение lodash
foreach(CxList method in vulnerableMethods)
{
	string file_name_method = method.GetFirstGraph().LinePragma.FileName;
	if (lodash_path.Contains(file_name_method) == true && lodash_result_path.Contains(file_name_method) == false){
		result.Add(method);
	}
}

// Убираем все UknownReferences и оставляем самый "длинный" из путей, если такие встречаются
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceSmallFlow) - result.FindByType(typeof(UnknownReference));

משימה: מחפש תעודות המוטמעות באפליקציה

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

// Найдем все сертификаты по маске файла
CxList find_certs = All.FindByShortNames(new List<string> {"*.der", "*.cer", "*.pem", "*.key"}, false);

// Проверим, где в приложении они используются
CxList data_used_certs = All.DataInfluencedBy(find_certs);

// И для мобильных приложений - можем поискать методы, где вызывается чтение сертификатов
// Для других платформ и приложений могут быть различные методы
CxList methods = All.FindByMemberAccess("*.getAssets");

// Пересечение множеств даст нам результат по использованию локальных сертификатов в приложении
result = methods * data_used_certs;

משימה: מציאת אסימונים שנפגעו באפליקציה

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

// Получаем все строки, которые содержатся в коде
CxList strings = base.Find_Strings();

// Ищем среди всех строк нужное нам значение. В примере токен в виде строки "qwerty12345"
result = strings.FindByShortName("qwerty12345");

מסקנה

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

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

תודה לך!

מקור: www.habr.com