היי האבר!
אין אונדזער אַרבעט, אונדזער פירמע דילז זייער אָפט מיט פאַרשידן מכשירים פֿאַר סטאַטיק קאָד אַנאַליסיס (SAST). אויס פון די קעסטל זיי אַלע אַרבעט דורכשניטלעך. פון קורס, עס אַלע דעפּענדס אויף די פּרויעקט און די טעקנאַלאַדזשיז געניצט אין עס, ווי געזונט ווי די טעקנאַלאַדזשיז זענען באדעקט דורך די כּללים פון אַנאַליסיס. אין מיין מיינונג, איינער פון די מערסט וויכטיק קרייטיריאַ ווען טשוזינג אַ SAST געצייַג איז די פיייקייט צו קאַסטאַמייז עס צו די ספּעסיפיקס פון דיין אַפּלאַקיישאַנז, ניימלי, שרייַבן און טוישן אַנאַליסיס כּללים אָדער, ווי זיי זענען מער אָפט גערופן, Custom Queries.
מיר רובֿ אָפט נוצן Checkmarx - אַ זייער טשיקאַווע און שטאַרק קאָד אַנאַליזער. אין דעם אַרטיקל איך וועל רעדן וועגן מיין דערפאַרונג פון שרייבן אַנאַליסיס כּללים פֿאַר עס.
טיש פון אינהאַלט
פּאָזיציע
צו אָנהייבן מיט, איך וואָלט ווי צו רעקאָמענדירן איינער פון די ווייניק אַרטיקלען אין רוסיש וועגן די פֿעיִקייטן פון שרייבן קוויריז פֿאַר טשעקמאַרקס. עס איז ארויס אויף Habré אין די סוף פון 2019 אונטער דעם טיטל: .
עס יגזאַמאַנז אין דעטאַל ווי צו שרייַבן די ערשטער פֿראגן אין CxQL (Checkmarx Query Language) פֿאַר עטלעכע פּראָבע אַפּלאַקיישאַן און ווייַזן די גרונט פּרינסאַפּאַלז פון ווי אַנאַליסיס כּללים אַרבעט.
איך וועל נישט איבערחזרן וואָס איז דיסקרייבד אין עס, כאָטש עטלעכע ינטערסעקשאַנז וועט זיין פאָרשטעלן. אין מיין אַרטיקל איך וועל פּרובירן צו זאַמלען אַ מין פון "זאַמלונג פון רעסאַפּיז", אַ רשימה פון סאַלושאַנז צו ספּעציפיש פראבלעמען וואָס איך געפּלאָנטערט בעשאַס מיין אַרבעט מיט טשעקמאַרקס. איך האט צו געשטעל מיין סייכל איבער פילע פון די פראבלעמען. מאל עס איז געווען ניט גענוג אינפֿאָרמאַציע אין די דאַקיומענטיישאַן, און מאל עס איז אַפֿילו שווער צו פֿאַרשטיין ווי צו טאָן וואָס איז פארלאנגט. איך האָפֿן אַז מיין דערפאַרונג און שלאָף נעכט וועט נישט זיין אַרויסגעוואָרפן, און די "זאַמלונג פון קאַסטאַמייזד קוועסץ רעסאַפּיז" וועט ראַטעווען איר אַ ביסל שעה אָדער אַ פּאָר פון נערוו סעלז. אַזוי, לאָזן ס אָנהייבן!
אַלגעמיינע אינפֿאָרמאַציע וועגן די כּללים
ערשטער, לאָמיר קוקן אין אַ ביסל יקערדיק קאַנסעפּס און דעם פּראָצעס פון ארבעטן מיט די כּללים, פֿאַר אַ בעסער פארשטאנד פון וואָס וועט פּאַסירן ווייַטער. און אויך ווייַל די דאַקיומענטיישאַן טוט נישט זאָגן עפּעס וועגן דעם אָדער איז זייער פאַרשפּרייטן אין די סטרוקטור, וואָס איז נישט זייער באַקוועם.
-
די כּללים זענען געווענדט בעשאַס סקאַנינג דיפּענדינג אויף די פּריסעט אויסגעקליבן אין אָנהייב (אַ סכום פון אַקטיוו כּללים). איר קענען מאַכן אַ אַנלימאַטאַד נומער פון פּרעסעץ, און פּונקט ווי צו סטרוקטור זיי דעפּענדס אויף די ספּעסיפיקס פון דיין פּראָצעס. איר קענען גרופּע זיי דורך שפּראַך אָדער אויסקלייַבן פּרעסעץ פֿאַר יעדער פּרויעקט. די נומער פון אַקטיוו כּללים אַפעקץ די גיכקייַט און אַקיעראַסי פון סקאַנינג.
באַשטעטיקן פּריסעט אין די Checkmarx צובינד -
די כּללים זענען עדיטיד אין אַ ספּעציעל געצייַג גערופן CxAuditor. דאָס איז אַ דעסקטאַפּ אַפּלאַקיישאַן אַז קאַנעקץ צו אַ סערווער פליסנדיק טשעקמאַרקס. דער געצייַג האט צוויי מאָדעס פון אָפּעראַציע: עדיטינג כּללים און אַנאַלייזינג די רעזולטאַטן פון אַ שוין דורכגעקאָכט יבערקוקן.
CxAudit צובינד -
כּללים אין טשעקמאַרקס זענען צעטיילט דורך שפּראַך, דאָס איז, יעדער שפּראַך האט זייַן אייגענע גאַנג פון פֿראגן. עס זענען אויך עטלעכע גענעראַל כּללים וואָס אַפּלייז ראַגאַרדלאַס פון שפּראַך, דאָס זענען די אַזוי גערופענע יקערדיק פֿראגן. פֿאַר די רובֿ טייל, יקערדיק קוויריז אַרייַנציען זוכן פֿאַר אינפֿאָרמאַציע וואָס אנדערע כּללים נוצן.
דיטיילד כּללים לויט שפּראַך -
כּללים זענען "עקסעקוטאַבלע" און "ניט-עקסעקוטאַבלע" (עקסעקוטיד און ניט עקסעקוטיד). נישט גאַנץ די ריכטיק נאָמען, אין מיין מיינונג, אָבער דאָס איז וואָס עס איז. די דנאָ שורה איז אַז דער רעזולטאַט פון עקסאַקיוטינג "עקסעקוטאַבלע" כּללים וועט זיין געוויזן אין די יבערקוקן רעזולטאַטן אין די וי, און "ניט-עקסעקוטאַבלע" כּללים זענען דארף בלויז צו נוצן זייער רעזולטאַטן אין אנדערע ריקוועס (אין עסאַנס, נאָר אַ פֿונקציע).
דיטערמאַנינג די הערשן טיפּ ווען קריייטינג -
איר קענען שאַפֿן נייַע כּללים אָדער העסאָפע / רירייט יגזיסטינג. אין סדר צו רירייט אַ הערשן, איר דאַרפֿן צו געפֿינען עס אין דעם בוים, רעכט גיט און סעלעקטירן "אָוועררייד" פון די קאַפּ-אַראָפּ מעניו. עס איז וויכטיק צו געדענקען דאָ אַז די נייַע כּללים זענען נישט טכילעס אַרייַנגערעכנט אין די פּרעסעץ און זענען נישט אַקטיוו. צו אָנהייבן ניצן זיי, איר דאַרפֿן צו אַקטאַווייט זיי אין די "פּריסעט מאַנאַגער" מעניו אין די קיילע. ריריטן כּללים האַלטן זייער סעטטינגס, דאָס איז, אויב די הערשן איז אַקטיוו, עס וועט בלייבן אַזוי און וועט זיין געווענדט מיד.
בייַשפּיל פון אַ נייַע הערשן אין די פּריסעט מאַנאַגער צובינד -
בעשאַס דורכפירונג, אַ "בוים" פון ריקוועס איז געבויט, וואָס דעפּענדס אויף וואָס. די כּללים וואָס קלייַבן אינפֿאָרמאַציע זענען עקסאַקיוטאַד ערשטער, און די וואס נוצן עס רגע. דער דורכפירונג רעזולטאַט איז קאַשט, אַזוי אויב עס איז מעגלעך צו נוצן די רעזולטאַטן פון אַ יגזיסטינג הערשן, עס איז בעסער צו טאָן דאָס, דאָס וועט רעדוצירן די סקאַנינג צייט.
-
כּללים קענען זיין געווענדט אין פאַרשידענע לעוועלס:
-
פֿאַר די גאנצע סיסטעם - וועט זיין געניצט פֿאַר קיין סקאַנינג פון קיין פּרויעקט
-
אויף די מאַנשאַפֿט מדרגה (מאַנשאַפֿט) - וועט נאָר זיין גענוצט צו יבערקוקן פּראַדזשעקס אין די אויסגעקליבן מאַנשאַפֿט.
-
אויף די פּרויעקט מדרגה - וועט זיין געווענדט אין אַ ספּעציפיש פּרויעקט
באַשטימען די מדרגה אין וואָס די הערשן וועט זיין געווענדט
"ווערטערבוך" פֿאַר ביגינערז
און איך וועל אָנהייבן מיט אַ ביסל זאכן וואָס געפֿירט מיר פֿראגן, און איך וועט אויך ווייַזן אַ נומער פון טעקניקס וואָס וועט באטייטיק פאַרפּאָשעטערן לעבן.
אַפּעריישאַנז מיט רשימות
- вычитание одного из другого (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");ניצן די רעזולטאַטן פון אנדערע כּללים
כּללים אין טשעקמאַרקס קענען זיין גערופֿן אַנאַלאָג צו פאַנגקשאַנז אין אַ רעגולער פּראָגראַממינג שפּראַך. ווען איר שרייבן אַ הערשן, איר קען נוצן די רעזולטאַטן פון אנדערע פֿראגן. פֿאַר בייַשפּיל, עס איז ניט דאַרפֿן צו זוכן פֿאַר אַלע מעטאָד רופט אין די קאָד יעדער מאָל, נאָר רופן די געבעטן הערשן:
// Получаем результат выполнения другого правила
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;
פֿאַר טשעקמאַרקס נאָך 8.6:
// Проверяем, что есть залогиненые пользователи, выполнив запрос в БД
SELECT COUNT(*) FROM LoggedinUser WHERE (ClientType = 'Audit');
// Если что-то есть, а на самом деле даже если и нет, попробовать выполнить запрос
DELETE FROM [CxDB].[dbo].LoggedinUser WHERE (ClientType = 'Audit');שרייבט כללים
איצט מיר באַקומען צו די מערסט טשיקאַווע טייל. ווען איר אָנהייבן שרייבן כּללים אין CxQL, וואָס איר אָפט פעלן איז נישט אַזוי פיל דאַקיומענטיישאַן ווי עטלעכע לעבעדיק ביישפילן פון סאַלווינג זיכער פּראָבלעמס און דיסקרייבינג דעם פּראָצעס פון אָנפֿרעג אָפּעראַציע אין אַלגעמיין.
איך וועל פּרובירן צו מאַכן לעבן אַ ביסל גרינגער פֿאַר די וואס אָנהייבן צו ונטערטוקנ זיך אין די אָנפֿרעג שפּראַך און געבן עטלעכע ביישפילן פון ניצן Custom Queries צו סאָלווע זיכער פּראָבלעמס. עטלעכע פון זיי זענען גאַנץ גענעראַל און קענען זיין געוויינט אין דיין פירמע פּראַקטאַקלי אָן ענדערונגען, אנדערע זענען מער ספּעציפיש, אָבער זיי קענען אויך זיין געוויינט דורך טשאַנגינג די קאָד צו פּאַסן די ספּעסיפיקס פון דיין אַפּלאַקיישאַנז.
אַזוי, דאָ זענען די פראבלעמען וואָס מיר האָבן מערסט אָפט געפּלאָנטערט:
אַרבעט: עס זענען עטלעכע פלאָוז אין די רעזולטאַטן פון עקסאַקיוטינג די הערשן און איינער פון זיי איז אַ נעסטינג פון אנדערן, איר מוזן לאָזן איינער פון זיי.
לייזונג: טאַקע, מאל Checkmarx ווייַזן עטלעכע דאַטן פלאָוז וואָס קען אָוווערלאַפּ און זיין אַ פאַרקירצט ווערסיע פון אנדערע. עס איז אַ ספּעציעל אופֿן פֿאַר אַזאַ קאַסעס רעדוסעפלאָוו. דעפּענדינג אויף דעם פּאַראַמעטער, עס וועט אויסקלייַבן די שאָרטיסט אָדער לאָנגעסט לויפן:
// Оставить только длинные Flow
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceSmallFlow);
// Оставить только короткие Flow
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceBigFlow);אַרבעט: יקספּאַנד די רשימה פון שפּירעוודיק דאַטן צו וואָס די געצייַג ריאַקץ
לייזונג: Checkmarx האט יקערדיק כּללים, די רעזולטאַטן פון וואָס זענען געניצט דורך פילע אנדערע פֿראגן. דורך סאַפּלאַמענטינג עטלעכע פון די כּללים מיט ספּעציפיש דאַטן פֿאַר דיין אַפּלאַקיישאַן, איר קענען גלייך פֿאַרבעסערן דיין יבערקוקן רעזולטאַטן. ונטער איז אַ ביישפּיל הערשן צו באַקומען איר סטאַרטעד:
General_privacy_violation_list
לאָמיר לייגן עטלעכע וועריאַבאַלז וואָס זענען געניצט אין אונדזער אַפּלאַקיישאַן צו קראָם שפּירעוודיק אינפֿאָרמאַציע:
// Получаем результат выполнения базового правила
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
לייזונג: אַלע פֿראגן אין טשעקמאַרקס זענען צעטיילט דורך שפּראַך, אַזוי איר דאַרפֿן צו לייגן כּללים פֿאַר יעדער שפּראַך. ונטער זענען עטלעכע ביישפילן פון אַזאַ כּללים.
אויב לייברעריז זענען געניצט וואָס דערגאַנג אָדער פאַרבייַטן נאָרמאַל פאַנגקשאַנאַליטי, זיי קענען זיין לייכט מוסיף צו די גרונט הערשן. דערנאָך אַלעמען וואס ניצט עס וועט מיד לערנען וועגן די נייַע ינטראַדאַקשאַנז. ווי אַ בייַשפּיל, לייברעריז פֿאַר לאָגינג אין אַנדרויד זענען געהילץ און לאָגי. אין די יקערדיק פּעקל, עס זענען קיין כּללים צו ידענטיפיצירן ניט-סיסטעם קאַללס, אַזוי אויב אַ פּאַראָל אָדער סעסיע ידענטיפיער קומט אין די קלאָץ, מיר וועלן נישט וויסן וועגן אים. לאָמיר פּרובירן צו לייגן דעפֿיניציעס פון אַזאַ מעטהאָדס צו די טשעקמאַרקס כּללים.
טעסט קאָד בייַשפּיל וואָס ניצט די געהילץ ביבליאָטעק פֿאַר לאָגינג:
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");
}
}און דאָ איז אַ ביישפּיל פון אַ בעטן פֿאַר טשעקמאַרקס, וואָס וועט לאָזן איר צו לייגן אַ דעפֿיניציע פון רופן געהילץ מעטהאָדס ווי אַ אַרויסגאַנג פונט פֿאַר דאַטן פון די אַפּלאַקיישאַן:
געפֿינען אַנדרויד אַוטפּוץ
// Получаем результат выполнения базового правила
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()
);אויך, אויב אַנדרויד אַפּלאַקיישאַנז נוצן פֿאַר ייסינגקראַנאַס אַרבעט, עס איז אַ גוטע געדאַנק צו אויך מיטטיילן Checkmarx וועגן דעם דורך אַדינג אַ מעטאָד צו באַקומען דאַטן פֿון די אַרבעט getInputData:
FindAndroidRead
// Получаем результат выполнения базового правила
result = base.Find_Android_Read();
// Дополняем вызовом функции getInputData, которая используется в WorkManager
CxList getInputData = All.FindByShortName("getInputData");
// Добавляем к конечному результату
result.Add(getInputData.GetMembersOfTarget());אַרבעט: זוכן פֿאַר שפּירעוודיק דאַטן אין פּליסט פֿאַר יאָס פּראַדזשעקס
לייזונג: יאָס אָפט ניצט ספּעציעל טעקעס מיט די .פּליסט געשפּרייט צו קראָם פאַרשידן וועריאַבאַלז און וואַלועס. סטאָרינג פּאַסווערדז, טאָקענס, קיז און אנדערע שפּירעוודיק דאַטן אין די טעקעס איז נישט רעקאַמענדיד, ווייַל זיי קענען זיין יקסטראַקטיד פון די מיטל אָן קיין פראבלעמען.
פּליסט טעקעס האָבן פֿעיִקייטן וואָס זענען נישט קלאָר ווי דער טאָג פֿאַר די נאַקעט אויג, אָבער זענען וויכטיק צו טשעקמאַרקס. זאל ס שרייַבן אַ הערשן וואָס וועט זוכן פֿאַר די דאַטן מיר דאַרפֿן און זאָגן אונדז אויב פּאַסווערדז אָדער טאָקענס זענען דערמאנט ערגעץ.
אַ ביישפּיל פון אַזאַ אַ טעקע, וואָס כּולל אַ סימען פֿאַר קאָמוניקאַציע מיט די באַקענד דינסט:
<?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>און אַ כלל פֿאַר טשעקמאַרקס, וואָס האט עטלעכע נואַנסיז וואָס זאָל זיין גענומען אין חשבון ווען שרייבן:
// Используем результат выполнения правила по поиску файлов 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. דאָס איז ווי די ריכטיק אָנפֿרעג קוקט ווי צו געפֿינען אַ באַשטעטיקן אין אַנדרויד וואָס אַלאַוז די נוצן פון הטטפּ פאַרקער:
// Правильный вариант с использованием cxXPath
result = cxXPath.FindXmlAttributesByNameAndValue("*.xml", 8, "cleartextTrafficPermitted", "true", false, true);זאל ס קוק אין עס אין אַ ביסל מער דעטאַל, זינט די סינטאַקס פֿאַר אַלע פאַנגקשאַנז איז ענלעך, נאָך איר האָבן פיגיערד איינער, איר נאָר דאַרפֿן צו אויסקלייַבן דעם איינער איר דאַרפֿן. אַזוי, סאַקווענטשאַלי לויט די פּאַראַמעטערס:
-
"*.xml"- מאַסקע פון טעקעס צו זיין געזוכט -
8— איד פון דער שפראך אויף וועלכן דער הערשן איז געווענדט -
"cleartextTrafficPermitted"- אַטריביוט נאָמען אין xml -
"true"- די ווערט פון דעם אַטריביוט -
false- נוצן פון רעגולער אויסדרוק ווען זוכן -
true- מיטל אַז די זוכן וועט זיין דורכגעקאָכט יגנאָרינג פאַל, דאָס איז, פאַל-ינסענסיטיוו
ווי אַ בייַשפּיל, מיר געוויינט אַ הערשן וואָס יידענאַפייד פאַלש, פֿון אַ זיכערהייט פונט פון מיינונג, נעץ קשר סעטטינגס אין אַנדרויד וואָס לאָזן קאָמוניקאַציע מיט די סערווער דורך די הטטפּ פּראָטאָקאָל. בייַשפּיל פון אַ באַשטעטיקן מיט אַן אַטריביוט 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 אָנפֿרעג, פֿאַר בייַשפּיל, אויב איר דאַרפֿן צו פאָרן טיש נעמען, איר קענען נוצן די אָפּעראַטאָר #$, וואָס וועט גלייך פאַרבייַטן די דאַטן אין די אָנפֿרעג (כּמעט ווי שטריקל קאַנקאַטאַניישאַן).
מוסטער קאָד:
// В общем случае - значения, контролируемые пользователем
val table = "coffees"
sql"select * from #$table where name = $name".as[Coffee].headOptionCheckmarx קען נאָך נישט וויסן ווי צו דעטעקט די נוצן פון ספּליסינג ליטעראַל וואַלועס און סקיפּס אָפּערייטערז #$, אַזוי לאָזן אונדז פּרובירן צו לערנען עס צו ידענטיפיצירן פּאָטענציעל סקל ינדזשעקשאַנז און הויכפּונקט די רעכט ערטער אין די קאָד:
// Находим все импорты
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));
}אַרבעט: זוכן פֿאַר געוויינט שפּירעוודיק פאַנגקשאַנז אין עפֿן מקור לייברעריז
לייזונג: פילע קאָמפּאַניעס נוצן עפֿן מקור מאָניטאָרינג מכשירים (אָסאַ פיר) צו דעטעקט די נוצן פון שפּירעוודיק ווערסיעס פון לייברעריז אין דעוועלאָפּעד אַפּלאַקיישאַנז. מאל עס איז ניט מעגלעך צו דערהייַנטיקן אַזאַ אַ ביבליאָטעק צו אַ זיכער ווערסיע. אין עטלעכע קאַסעס עס זענען פאַנגקשאַנאַל לימיטיישאַנז, אין אנדערע עס איז קיין זיכער ווערסיע. אין דעם פאַל, אַ קאָמבינאַציע פון SAST און OSA פּראַקטיסיז וועט העלפֿן צו באַשליסן אַז די פאַנגקשאַנז וואָס פירן צו עקספּלויטיישאַן פון די וואַלנעראַביליטי זענען נישט געניצט אין דעם קאָד.
אָבער מאל, ספּעציעל ווען איר באַטראַכטן דזשאַוואַסקריפּט, דאָס קען נישט זיין אַ גאָר נישטיק אַרבעט. ונטער איז אַ לייזונג, טאָמער נישט ידעאַל, אָבער נאָך ארבעטן, ניצן די ביישפּיל פון וואַלנעראַביליטיז אין די קאָמפּאָנענט 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");סאָף
איך האָפֿן אַז דער אַרטיקל וועט זיין נוציק פֿאַר יענע וואָס אָנהייבן צו באַקענען זיך מיט די Checkmarx געצייַג. טאָמער יענע וואָס האָבן שוין געשריבן זייער אייגן כּללים פֿאַר אַ לאַנג צייַט, וועט אויך געפֿינען עפּעס נוציק אין דעם פירער.
צום באַדויערן, עס איז דערווייַל אַ פעלן פון אַ מיטל ווו נייַע געדאנקען קענען זיין גיינד בעשאַס דער אַנטוויקלונג פון כּללים פֿאַר טשעקמאַרקס. אַז ס וואָס מיר באשאפן , ווו מיר וועלן פּאָסטן אונדזער אַרבעט אַזוי אַז אַלעמען וואס ניצט CxQL קענען געפֿינען עפּעס נוציק אין עס, און אויך האָבן די געלעגנהייט צו טיילן זייער אַרבעט מיט די קהל. די ריפּאַזאַטאָרי איז אין דעם פּראָצעס פון פילונג און סטראַקטשערינג אינהאַלט, אַזוי מיטארבעטערס זענען באַגריסן!
גוט גליק!
מקור: www.habr.com