वेडा न होता चेकमार्कसाठी नियम कसे लिहावेत

अहो हाब्र!

आमच्या कामात, आमची कंपनी बर्‍याचदा विविध स्टॅटिक कोड विश्लेषण साधने (SAST) हाताळते. बॉक्सच्या बाहेर ते सर्व सरासरी काम करतात. अर्थात, हे सर्व प्रकल्प आणि त्यात वापरल्या जाणार्‍या तंत्रज्ञानावर तसेच विश्लेषणाच्या नियमांद्वारे हे तंत्रज्ञान किती चांगले समाविष्ट आहे यावर अवलंबून असते. माझ्या मते, SAST टूल निवडताना सर्वात महत्त्वाचा निकष म्हणजे तुमच्या ऍप्लिकेशन्सच्या वैशिष्ट्यांनुसार सानुकूलित करण्याची क्षमता, म्हणजे, विश्लेषण नियम लिहा आणि बदला किंवा त्यांना अधिक वेळा कस्टम क्वेरी म्हणतात.

आम्ही बर्याचदा चेकमार्क्स वापरतो - एक अतिशय मनोरंजक आणि शक्तिशाली कोड विश्लेषक. या लेखात मी त्यासाठी विश्लेषण नियम लिहिण्याच्या माझ्या अनुभवाबद्दल बोलणार आहे.

सामग्री सारणी

• नोंद

• नियमांवर सामान्य माहिती

• नवशिक्यांसाठी "शब्दकोश".

  • सूचीसह ऑपरेशन्स

  • सर्व वस्तू सापडल्या

  • प्रवाह विश्लेषणासाठी कार्ये

  • फाईलचे नाव/पथ मिळवत आहे

  • अंमलबजावणी परिणाम

  • इतर नियमांचे परिणाम वापरणे

• समस्यांचे निराकरण

  • लॉगिंग

  • लॉगिन समस्या

• लेखन नियम

• निष्कर्ष

नोंद

सुरुवातीला, चेकमार्क्ससाठी प्रश्न लिहिण्याच्या वैशिष्ट्यांबद्दल मी रशियन भाषेतील काही लेखांपैकी एकाची शिफारस करू इच्छितो. हे 2019 च्या शेवटी Habré वर या शीर्षकाखाली प्रकाशित झाले: "हॅलो, चेकमार्क्स!" चेकमार्क्स SAST क्वेरी कशी लिहावी आणि छान भेद्यता कशी शोधावी.

काही चाचणी अर्जासाठी CxQL (चेकमार्क्स क्वेरी लँग्वेज) मध्‍ये पहिली क्‍वेरी कशी लिहायची याचे ते तपशीलवार परीक्षण करते आणि विश्लेषण नियम कसे कार्य करतात याची मूलभूत तत्त्वे दाखवते.

मी त्यात वर्णन केलेल्या गोष्टींची पुनरावृत्ती करणार नाही, जरी काही छेदनबिंदू अद्याप उपस्थित असतील. माझ्या लेखात मी एक प्रकारचा "पाककृतींचा संग्रह" संकलित करण्याचा प्रयत्न करेन, चेकमार्कसह माझ्या कामाच्या दरम्यान मला आलेल्या विशिष्ट समस्यांच्या निराकरणाची यादी. यापैकी अनेक समस्यांवर मला माझ्या मेंदूचा अभ्यास करावा लागला. काहीवेळा दस्तऐवजीकरणात पुरेशी माहिती नव्हती आणि काहीवेळा आवश्यक ते कसे करावे हे समजणे कठीण होते. मला आशा आहे की माझा अनुभव आणि निद्रानाशाच्या रात्री व्यर्थ जाणार नाहीत आणि हा "कस्टम क्वेरी रेसिपीजचा संग्रह" तुमचे काही तास किंवा दोन चेतापेशी वाचवेल. तर, चला सुरुवात करूया!

नियमांवर सामान्य माहिती

प्रथम, पुढे काय होईल हे अधिक चांगल्या प्रकारे समजून घेण्यासाठी काही मूलभूत संकल्पना आणि नियमांसह कार्य करण्याची प्रक्रिया पाहू या. आणि हे देखील कारण दस्तऐवजीकरण याबद्दल काहीही बोलत नाही किंवा संरचनेत खूप पसरलेले आहे, जे फार सोयीस्कर नाही.

1. स्कॅनिंग दरम्यान नियम सुरू करताना निवडलेल्या प्रीसेटवर अवलंबून लागू केले जातात (सक्रिय नियमांचा संच). तुम्ही अमर्यादित प्रीसेट तयार करू शकता आणि त्यांची रचना कशी करायची हे तुमच्या प्रक्रियेच्या वैशिष्ट्यांवर अवलंबून आहे. तुम्ही त्यांना भाषेनुसार गटबद्ध करू शकता किंवा प्रत्येक प्रकल्पासाठी प्रीसेट निवडू शकता. सक्रिय नियमांची संख्या स्कॅनिंगची गती आणि अचूकता प्रभावित करते.

   चेकमार्क्स इंटरफेसमध्ये प्रीसेट सेट करणे

2. नियम CxAuditor नावाच्या विशेष साधनामध्ये संपादित केले जातात. हा एक डेस्कटॉप ऍप्लिकेशन आहे जो चेकमार्क्स चालवणार्‍या सर्व्हरशी कनेक्ट होतो. या साधनामध्ये ऑपरेशनचे दोन प्रकार आहेत: नियम संपादित करणे आणि आधीच केलेल्या स्कॅनच्या परिणामांचे विश्लेषण करणे.

   CxAudit इंटरफेस

3. चेकमार्क्समधील नियम भाषेनुसार विभागलेले आहेत, म्हणजेच प्रत्येक भाषेचे स्वतःचे प्रश्न आहेत. काही सामान्य नियम देखील आहेत जे भाषेची पर्वा न करता लागू होतात, या तथाकथित मूलभूत प्रश्न आहेत. बहुतेक भागांसाठी, मूलभूत प्रश्नांमध्ये इतर नियम वापरत असलेली माहिती शोधणे समाविष्ट असते.

   भाषेनुसार नियमांची विभागणी

4. नियम "एक्झिक्युटेबल" आणि "नॉन-एक्झिक्युटेबल" (एक्झिक्युटेबल आणि नॉट एक्झिक्यूटेबल) आहेत. माझ्या मते अगदी योग्य नाव नाही, पण तेच आहे. मुख्य गोष्ट अशी आहे की "एक्झिक्युटेबल" नियम अंमलात आणण्याचे परिणाम UI मधील स्कॅन परिणामांमध्ये प्रदर्शित केले जातील आणि "नॉन-एक्झिक्युटेबल" नियम फक्त त्यांचे परिणाम इतर विनंत्यांमध्ये वापरण्यासाठी आवश्यक आहेत (सारांशात, फक्त एक कार्य).

   तयार करताना नियम प्रकार निश्चित करणे

5. तुम्ही नवीन नियम तयार करू शकता किंवा विद्यमान नियमांना पूरक/पुन्हा लिहू शकता. नियम पुन्हा लिहिण्यासाठी, तुम्हाला तो ट्रीमध्ये शोधणे आवश्यक आहे, उजवे-क्लिक करा आणि ड्रॉप-डाउन मेनूमधून "ओव्हरराइड" निवडा. येथे हे लक्षात ठेवणे महत्त्वाचे आहे की नवीन नियम सुरुवातीला प्रीसेटमध्ये समाविष्ट केलेले नाहीत आणि सक्रिय नाहीत. त्यांचा वापर सुरू करण्यासाठी तुम्हाला इन्स्ट्रुमेंटमधील "प्रीसेट मॅनेजर" मेनूमध्ये सक्रिय करणे आवश्यक आहे. पुन्हा लिहिलेले नियम त्यांची सेटिंग्ज टिकवून ठेवतात, म्हणजे, नियम सक्रिय असल्यास, तो तसाच राहील आणि लगेच लागू केला जाईल.

   प्रीसेट मॅनेजर इंटरफेसमधील नवीन नियमाचे उदाहरण

6. अंमलबजावणी दरम्यान, विनंत्यांचे "झाड" तयार केले जाते, जे कशावर अवलंबून असते. माहिती गोळा करणारे नियम प्रथम अंमलात आणले जातात आणि जे वापरतात ते दुसरे. अंमलबजावणीचा परिणाम कॅशे केलेला आहे, म्हणून जर विद्यमान नियमाचे परिणाम वापरणे शक्य असेल तर असे करणे चांगले आहे, यामुळे स्कॅनिंग वेळ कमी होईल.

7. नियम वेगवेगळ्या स्तरांवर लागू केले जाऊ शकतात:

• संपूर्ण प्रणालीसाठी - कोणत्याही प्रकल्पाच्या स्कॅनिंगसाठी वापरला जाईल

• संघ स्तरावर (टीम) - फक्त निवडलेल्या संघातील प्रकल्प स्कॅन करण्यासाठी वापरला जाईल.

• प्रकल्प स्तरावर - विशिष्ट प्रकल्पात लागू केले जाईल

  नियम कोणत्या स्तरावर लागू केला जाईल हे निश्चित करणे

नवशिक्यांसाठी "शब्दकोश".

आणि मी काही गोष्टींपासून सुरुवात करेन ज्यामुळे मला प्रश्न पडले आणि मी अनेक तंत्रे देखील दाखवीन ज्यामुळे जीवन लक्षणीयरीत्या सोपे होईल.

सूचीसह ऑपरेशन्स

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

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

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

सर्व वस्तू सापडल्या

स्कॅन केलेल्या भाषेत, चेकमार्क्सने ओळखलेल्या सर्व घटकांची यादी तुम्हाला मिळू शकते (स्ट्रिंग, फंक्शन्स, क्लासेस, पद्धती इ.). ही काही वस्तूंची जागा आहे ज्याद्वारे प्रवेश केला जाऊ शकतो All. म्हणजे विशिष्ट नावाने वस्तू शोधणे searchMe, तुम्ही शोधू शकता, उदाहरणार्थ, सर्व सापडलेल्या वस्तूंवर नावाने:

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

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

परंतु, काही कारणास्तव स्कॅनमध्ये समाविष्ट न केलेल्या दुसर्‍या भाषेत शोधायचे असल्यास (उदाहरणार्थ, Android प्रोजेक्टमध्ये ग्रूवी), तुम्ही व्हेरिएबलद्वारे आमच्या ऑब्जेक्ट स्पेसचा विस्तार करू शकता:

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 टूलमध्ये प्रवेश करू शकत नाही (जे नियम लिहिण्यासाठी वापरले जाते). याची अनेक कारणे असू शकतात, ज्यामध्ये क्रॅश, अचानक विंडोज अपडेट्स, 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 मध्‍ये नियम लिहायला सुरुवात करता, तेव्हा तुमच्‍याकडे अनेकदा काही प्रॉब्लेम सोडवण्‍याची काही जिवंत उदाहरणे आणि सर्वसाधारणपणे क्‍वेरी कशी कार्य करतात याचे वर्णन करण्‍याची काही जिवंत उदाहरणे नसतात.

जे लोक क्वेरी भाषेत जाण्यास सुरुवात करत आहेत त्यांच्यासाठी मी जीवन थोडे सोपे करण्याचा प्रयत्न करेन आणि काही समस्या सोडवण्यासाठी कस्टम क्वेरी वापरण्याची अनेक उदाहरणे देईन. त्यापैकी काही अगदी सामान्य आहेत आणि तुमच्या कंपनीमध्ये बदल न करता व्यावहारिकपणे वापरल्या जाऊ शकतात, इतर अधिक विशिष्ट आहेत, परंतु ते तुमच्या अनुप्रयोगांच्या वैशिष्ट्यांनुसार कोड बदलून देखील वापरले जाऊ शकतात.

तर, आम्हाला बर्‍याचदा ज्या समस्या येतात त्या येथे आहेत:

एक कार्य: नियम अंमलात आणण्याच्या परिणामांमध्ये अनेक प्रवाह आहेत आणि त्यापैकी एक दुसर्‍याचे घरटे आहे, आपण त्यापैकी एक सोडला पाहिजे.

उपाय: खरंच, कधीकधी चेकमार्क्स अनेक डेटा प्रवाह दर्शविते जे ओव्हरलॅप होऊ शकतात आणि इतरांची लहान आवृत्ती असू शकतात. अशा प्रकरणांसाठी एक विशेष पद्धत आहे प्रवाह कमी करा. पॅरामीटरवर अवलंबून, ते सर्वात लहान किंवा सर्वात लांब प्रवाह निवडेल:

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

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

एक कार्य: संवेदनशील डेटाची सूची विस्तृत करा ज्यावर साधन प्रतिक्रिया देते

उपाय: चेकमार्क्सचे मूलभूत नियम आहेत, ज्याचे परिणाम इतर अनेक प्रश्नांद्वारे वापरले जातात. यापैकी काही नियमांना तुमच्या अनुप्रयोगासाठी विशिष्ट डेटासह पूरक करून, तुम्ही तुमचे स्कॅन परिणाम त्वरित सुधारू शकता. तुम्हाला प्रारंभ करण्यासाठी खाली एक उदाहरण नियम आहे:

सामान्य_गोपनीयतेची_उल्लंघन_सूची

संवेदनशील माहिती संग्रहित करण्यासाठी आमच्या ऍप्लिकेशनमध्ये वापरले जाणारे अनेक व्हेरिएबल्स जोडूया:

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

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

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

एक कार्य: पासवर्डसह व्हेरिएबल्सची सूची विस्तृत करा

उपाय: मी कोडमध्ये पासवर्ड परिभाषित करण्याच्या मूलभूत नियमाकडे ताबडतोब लक्ष देण्याची आणि आपल्या कंपनीमध्ये सामान्यतः वापरल्या जाणार्‍या व्हेरिएबल नावांची सूची जोडण्याची शिफारस करतो.

पासवर्ड_गोपनीयता_उल्लंघन_सूची

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);
	}
}

एक कार्य: चेकमार्क्सद्वारे समर्थित नसलेले वापरलेले फ्रेमवर्क जोडा

उपाय: चेकमार्क्समधील सर्व क्वेरी भाषेनुसार विभागल्या आहेत, म्हणून तुम्हाला प्रत्येक भाषेसाठी नियम जोडण्याची आवश्यकता आहे. खाली अशा नियमांची काही उदाहरणे आहेत.

मानक कार्यक्षमतेला पूरक किंवा पुनर्स्थित करणारी लायब्ररी वापरली गेली, तर ती सहजपणे मूलभूत नियमात जोडली जाऊ शकतात. मग ते वापरणारे प्रत्येकजण नवीन परिचयांबद्दल लगेच शिकेल. उदाहरण म्हणून, अँड्रॉइडमध्ये लॉग इन करण्यासाठी लायब्ररी म्हणजे टिंबर आणि लॉगी. मूलभूत पॅकेजमध्ये, नॉन-सिस्टम कॉल ओळखण्यासाठी कोणतेही नियम नाहीत, त्यामुळे पासवर्ड किंवा सत्र अभिज्ञापक लॉगमध्ये आल्यास, आम्हाला त्याबद्दल माहिती नसते. चेकमार्क्सच्या नियमांमध्ये अशा पद्धतींची व्याख्या जोडण्याचा प्रयत्न करूया.

लॉगिंगसाठी टिंबर लायब्ररी वापरणारे चाचणी कोड उदाहरण:

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);

आणि तुम्ही शेजारच्या नियमात देखील जोडू शकता, परंतु हे थेट Android मध्ये लॉग इन करण्याशी संबंधित आहे:

AndroidLog_Outputs शोधा

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

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

तसेच, जर Android ऍप्लिकेशन्स वापरतात कार्यव्यवस्थापक असिंक्रोनस कामासाठी, टास्कमधून डेटा मिळवण्यासाठी एक पद्धत जोडून चेकमार्कला याबद्दल माहिती देणे ही चांगली कल्पना आहे. getInputData:

AndroidRead शोधा

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

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

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

एक कार्य: iOS प्रकल्पांसाठी plist मध्ये संवेदनशील डेटा शोधत आहे

उपाय: iOS अनेकदा विविध व्हेरिएबल्स आणि मूल्ये संग्रहित करण्यासाठी .plist विस्तारासह विशेष फाइल्स वापरते. या फायलींमध्ये पासवर्ड, टोकन, की आणि इतर संवेदनशील डेटा संग्रहित करण्याची शिफारस केलेली नाही, कारण ते कोणत्याही समस्येशिवाय डिव्हाइसमधून काढले जाऊ शकतात.

प्लिस्ट फाइल्समध्ये अशी वैशिष्ट्ये आहेत जी उघड्या डोळ्यांना दिसत नाहीत, परंतु चेकमार्क्ससाठी महत्त्वपूर्ण आहेत. चला एक नियम लिहू जो आम्हाला आवश्यक असलेला डेटा शोधेल आणि कुठेतरी पासवर्ड किंवा टोकन नमूद केले आहेत का ते आम्हाला सांगेल.

बॅकएंड सेवेसह संप्रेषणासाठी टोकन असलेल्या अशा फाइलचे उदाहरण:

<?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 मध्ये माहिती शोधत आहे

उपाय: XML सह कार्य करण्यासाठी आणि मूल्ये, टॅग, विशेषता आणि बरेच काही शोधण्यासाठी चेकमार्क्समध्ये अतिशय सोयीस्कर कार्ये आहेत. परंतु, दुर्दैवाने, दस्तऐवजीकरणात एक त्रुटी होती ज्यामुळे एकही उदाहरण कार्य करत नाही. दस्तऐवजाच्या नवीनतम आवृत्तीमध्ये हा दोष दूर केला गेला आहे हे असूनही, आपण दस्तऐवजांच्या पूर्वीच्या आवृत्त्या वापरत असल्यास सावधगिरी बाळगा.

दस्तऐवजीकरणातील एक चुकीचे उदाहरण येथे आहे:

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

अंमलबजावणीच्या प्रयत्नाच्या परिणामी, आम्हाला एक त्रुटी प्राप्त होईल All अशी कोणतीही पद्धत नाही... आणि हे खरे आहे, कारण XML सह कार्य करण्यासाठी फंक्शन्स वापरण्यासाठी एक विशेष, स्वतंत्र ऑब्जेक्ट स्पेस आहे - cxXPath. एचटीटीपी ट्रॅफिक वापरण्याची अनुमती देणारी Android मध्ये सेटिंग शोधण्यासाठी योग्य क्वेरी असे दिसते:

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

चला त्याकडे थोडे अधिक तपशीलाने पाहू, कारण सर्व फंक्शन्सची वाक्यरचना सारखीच आहे, आपण एक शोधून काढल्यानंतर, आपल्याला फक्त आपल्याला आवश्यक असलेले एक निवडण्याची आवश्यकता आहे. तर, अनुक्रमे पॅरामीटर्सनुसार:

• "*.xml"- शोधण्यासाठी फाइल्सचा मुखवटा

• 8 — ज्या भाषेसाठी नियम लागू केला आहे त्या भाषेचा आयडी

• "cleartextTrafficPermitted"xml मध्ये विशेषता नाव

• "true" — या गुणधर्माचे मूल्य

• false - शोधताना नियमित अभिव्यक्तीचा वापर

• true — म्हणजे केसकडे दुर्लक्ष करून शोध केला जाईल, म्हणजेच केस-संवेदनशील

उदाहरण म्हणून, आम्ही एक नियम वापरला जो सुरक्षेच्या दृष्टिकोनातून चुकीची ओळखतो, Android मधील नेटवर्क कनेक्शन सेटिंग्ज जे 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>

एक कार्य: फाइल नाव/पथानुसार परिणाम मर्यादित करा

उपाय: Android साठी मोबाइल ऍप्लिकेशनच्या विकासाशी संबंधित मोठ्या प्रकल्पांपैकी एकामध्ये, आम्हाला अस्पष्ट सेटिंग निर्धारित करणार्‍या नियमाचे चुकीचे सकारात्मक मुद्दे आढळले. वस्तुस्थिती अशी आहे की फाईलमध्ये नियमबाह्य बॉक्स शोधतो 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);
		}
	}
}

हा दृष्टिकोन अगदी सार्वत्रिक आणि केवळ Android अनुप्रयोगांसाठीच नाही तर इतर प्रकरणांसाठी देखील उपयुक्त असू शकतो जेव्हा आपल्याला निकाल विशिष्ट फाइलचा आहे की नाही हे निर्धारित करणे आवश्यक आहे.

एक कार्य: सिंटॅक्स पूर्णपणे समर्थित नसल्यास तृतीय पक्ष लायब्ररीसाठी समर्थन जोडा

उपाय: कोड लिहिण्याच्या प्रक्रियेत वापरल्या जाणार्‍या विविध फ्रेमवर्कची संख्या फक्त चार्टच्या बाहेर आहे. अर्थात, चेकमार्क्सला त्यांच्या अस्तित्वाबद्दल नेहमीच माहिती नसते आणि आमचे कार्य हे समजून घेण्यासाठी शिकवणे आहे की विशिष्ट पद्धती या फ्रेमवर्कशी संबंधित आहेत. काहीवेळा हे या वस्तुस्थितीमुळे गुंतागुंतीचे असते की फ्रेमवर्क फंक्शनची नावे वापरतात जी खूप सामान्य असतात आणि विशिष्ट लायब्ररीशी विशिष्ट कॉलचे संबंध स्पष्टपणे निर्धारित करणे अशक्य आहे.

अडचण अशी आहे की अशा लायब्ररींची वाक्यरचना नेहमीच योग्यरित्या ओळखली जात नाही आणि मोठ्या संख्येने खोटे सकारात्मक न मिळण्यासाठी तुम्हाला प्रयोग करावे लागतील. स्कॅनिंग अचूकता सुधारण्यासाठी आणि समस्येचे निराकरण करण्यासाठी अनेक पर्याय आहेत:

• पहिला पर्याय, आम्हाला खात्री आहे की लायब्ररी एका विशिष्ट प्रकल्पात वापरली जाते आणि संघ स्तरावर नियम लागू करू शकते. परंतु जर संघाने वेगळा दृष्टीकोन घेण्याचे ठरवले किंवा अनेक लायब्ररी वापरल्या ज्यामध्ये फंक्शनची नावे ओव्हरलॅप होतात, तर आम्हाला असंख्य खोट्या सकारात्मक गोष्टींचे फारसे आनंददायी चित्र मिळू शकते.

• दुसरा पर्याय म्हणजे लायब्ररी स्पष्टपणे आयात केलेल्या फाइल्स शोधणे. या दृष्टीकोनातून, आम्हाला खात्री आहे की आम्हाला आवश्यक असलेली लायब्ररी या फाईलमध्ये वापरली गेली आहे.

• आणि तिसरा पर्याय म्हणजे वरील दोन्ही पद्धती एकत्र वापरणे.

उदाहरण म्हणून, अरुंद वर्तुळात सुप्रसिद्ध असलेली लायब्ररी पाहू हुशार स्काला प्रोग्रामिंग भाषेसाठी, म्हणजे कार्यक्षमता शाब्दिक मूल्ये विभाजित करणे. सर्वसाधारणपणे, SQL क्वेरीमध्ये पॅरामीटर्स पास करण्यासाठी, तुम्ही ऑपरेटर वापरणे आवश्यक आहे $, जे डेटाला प्रीफॉर्म केलेल्या SQL क्वेरीमध्ये बदलते. अर्थात, हे जावामधील तयार विधानाचे थेट अॅनालॉग आहे. परंतु, जर तुम्हाला एसक्यूएल क्वेरी डायनॅमिकली तयार करायची असेल, उदाहरणार्थ, तुम्हाला टेबलची नावे पास करायची असल्यास, तुम्ही ऑपरेटर वापरू शकता #$, जे थेट डेटाला क्वेरीमध्ये बदलेल (जवळजवळ स्ट्रिंग जोडणी सारखे).

नमुना कोड:

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

स्प्लिसिंग लिटरल व्हॅल्यूज आणि स्किप ऑपरेटर्सचा वापर कसा शोधायचा हे चेकमार्कला अद्याप माहित नाही #$, म्हणून संभाव्य 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 पद्धतींचे संयोजन हे निर्धारित करण्यात मदत करेल की असुरक्षिततेचे शोषण करणारी कार्ये कोडमध्ये वापरली जात नाहीत.

परंतु काहीवेळा, विशेषत: जावास्क्रिप्टचा विचार करताना, हे पूर्णपणे क्षुल्लक कार्य असू शकत नाही. खाली एक उपाय आहे, कदाचित आदर्श नाही, परंतु तरीही घटकातील भेद्यतेचे उदाहरण वापरून कार्य करत आहे 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-पिनिंगची पडताळणी करण्यासाठी अॅप्लिकेशन्ससाठी, विशेषत: मोबाइलसाठी, प्रमाणपत्रे किंवा की वापरणे असामान्य नाही. सुरक्षिततेच्या दृष्टीकोनातून, कोडमध्ये अशा गोष्टी संग्रहित करणे ही सर्वोत्तम सराव नाही. चला एक नियम लिहिण्याचा प्रयत्न करूया जो रेपॉजिटरीमध्ये समान फायली शोधेल:

// Найдем все сертификаты по маске файла
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