របៀបសរសេរច្បាប់សម្រាប់ Checkmarx ដោយមិនឆ្កួត

ហេហេ!

នៅក្នុងការងាររបស់យើង ក្រុមហ៊ុនរបស់យើងច្រើនតែដោះស្រាយជាមួយឧបករណ៍វិភាគកូដឋិតិវន្តផ្សេងៗ (SAST)។ ចេញពីប្រអប់ពួកគេទាំងអស់ធ្វើការជាមធ្យម។ ជាការពិតណាស់ វាទាំងអស់គឺអាស្រ័យលើគម្រោង និងបច្ចេកវិទ្យាដែលបានប្រើនៅក្នុងវា ក៏ដូចជាថាតើបច្ចេកវិទ្យាទាំងនេះត្រូវបានគ្របដណ្តប់ដោយច្បាប់នៃការវិភាគបានល្អប៉ុណ្ណា។ តាមគំនិតរបស់ខ្ញុំ លក្ខណៈវិនិច្ឆ័យដ៏សំខាន់បំផុតមួយនៅពេលជ្រើសរើសឧបករណ៍ SAST គឺសមត្ថភាពក្នុងការកំណត់វាទៅតាមលក្ខណៈជាក់លាក់នៃកម្មវិធីរបស់អ្នក ពោលគឺសរសេរ និងផ្លាស់ប្តូរច្បាប់នៃការវិភាគ ឬដូចដែលពួកគេត្រូវបានគេហៅថាជាញឹកញាប់ជាង Custom Queries ។

ជាញឹកញាប់បំផុតយើងប្រើ Checkmarx ដែលជាអ្នកវិភាគកូដគួរឱ្យចាប់អារម្មណ៍ និងមានថាមពលខ្លាំង។ នៅក្នុងអត្ថបទនេះខ្ញុំនឹងនិយាយអំពីបទពិសោធន៍របស់ខ្ញុំក្នុងការសរសេរច្បាប់ការវិភាគសម្រាប់វា។

តារាងមាតិកា

• ធាតុ

• ព័ត៌មានទូទៅអំពីច្បាប់

• "វចនានុក្រម" សម្រាប់អ្នកចាប់ផ្តើមដំបូង

  • ប្រតិបត្តិការជាមួយបញ្ជី

  • ធាតុដែលបានរកឃើញទាំងអស់។

  • មុខងារសម្រាប់ការវិភាគលំហូរ

  • ទទួលបានឈ្មោះឯកសារ/ផ្លូវ

  • លទ្ធផលប្រតិបត្តិ

  • ការប្រើប្រាស់លទ្ធផលនៃច្បាប់ផ្សេងទៀត។

• ដោះស្រាយបញ្ហា

  • ការកាប់ឈើ

  • បញ្ហា​ចូល

• ច្បាប់សរសេរ

• សេចក្តីសន្និដ្ឋាន

ធាតុ

ដើម្បីចាប់ផ្តើម ខ្ញុំចង់ណែនាំអត្ថបទមួយក្នុងចំណោមអត្ថបទមួយចំនួនជាភាសារុស្សី អំពីលក្ខណៈពិសេសនៃការសរសេរសំណួរសម្រាប់ Checkmarx ។ វាត្រូវបានបោះពុម្ពនៅលើ Habre នៅចុងឆ្នាំ 2019 ក្រោមចំណងជើងថា: "ជំរាបសួរ Checkmarx!" របៀបសរសេរសំណួរ Checkmarx SAST និងស្វែងរកភាពងាយរងគ្រោះ.

វាពិនិត្យលម្អិតអំពីរបៀបសរសេរសំណួរដំបូងនៅក្នុង CxQL (Checkmarx Query Language) សម្រាប់កម្មវិធីសាកល្បងមួយចំនួន និងបង្ហាញពីគោលការណ៍ជាមូលដ្ឋាននៃរបៀបដែលច្បាប់នៃការវិភាគដំណើរការ។

ខ្ញុំនឹងមិននិយាយឡើងវិញនូវអ្វីដែលបានពិពណ៌នានៅក្នុងវាទេ ទោះបីជាចំនុចប្រសព្វមួយចំនួននឹងនៅតែមានវត្តមានក៏ដោយ។ នៅក្នុងអត្ថបទរបស់ខ្ញុំ ខ្ញុំនឹងព្យាយាមចងក្រងនូវប្រភេទនៃ "ការប្រមូលរូបមន្ត" ដែលជាបញ្ជីនៃដំណោះស្រាយចំពោះបញ្ហាជាក់លាក់ដែលខ្ញុំបានជួបប្រទះក្នុងអំឡុងពេលធ្វើការជាមួយ Checkmarx ។ ខ្ញុំ​ត្រូវ​យក​ចិត្ត​ទុក​ដាក់​លើ​បញ្ហា​ទាំង​នេះ។ ពេលខ្លះមិនមានព័ត៌មានគ្រប់គ្រាន់នៅក្នុងឯកសារទេ ហើយពេលខ្លះវាថែមទាំងពិបាកយល់ពីរបៀបធ្វើអ្វីដែលតម្រូវ។ ខ្ញុំសង្ឃឹមថាបទពិសោធន៍របស់ខ្ញុំ និងយប់ដែលគេងមិនលក់នឹងមិនឥតប្រយោជន៍ទេ ហើយ "ការប្រមូលរូបមន្តសំណួរផ្ទាល់ខ្លួន" នេះនឹងជួយសង្រ្គោះអ្នកពីរបីម៉ោង ឬកោសិកាប្រសាទពីរបី។ ដូច្នេះសូមចាប់ផ្តើម!

ព័ត៌មានទូទៅអំពីច្បាប់

ជាដំបូង សូមក្រឡេកមើលគោលគំនិតជាមូលដ្ឋានមួយចំនួន និងដំណើរការនៃការធ្វើការជាមួយច្បាប់ ដើម្បីយល់កាន់តែច្បាស់អំពីអ្វីដែលនឹងកើតឡើងបន្ទាប់ទៀត។ ហើយ​ក៏​ដោយសារ​ឯកសារ​មិន​និយាយ​អ្វី​អំពី​រឿង​នេះ ឬ​ត្រូវ​បាន​ផ្សព្វផ្សាយ​យ៉ាង​ខ្លាំង​ក្នុង​រចនាសម្ព័ន្ធ​ដែល​មិន​ងាយស្រួល​ខ្លាំង។

1. ច្បាប់ត្រូវបានអនុវត្តកំឡុងពេលស្កេនអាស្រ័យលើការកំណត់ជាមុនដែលបានជ្រើសរើសនៅពេលចាប់ផ្តើម (សំណុំនៃច្បាប់សកម្ម)។ អ្នក​អាច​បង្កើត​ចំនួន​កំណត់​ជាមុន​មិន​កំណត់ ហើយ​របៀប​រៀបចំ​រចនាសម្ព័ន្ធ​ពួកវា​យ៉ាង​ជាក់លាក់​អាស្រ័យ​លើ​ដំណើរការ​ជាក់លាក់​របស់អ្នក។ អ្នកអាចដាក់ជាក្រុមតាមភាសា ឬជ្រើសរើសការកំណត់ជាមុនសម្រាប់គម្រោងនីមួយៗ។ ចំនួននៃច្បាប់សកម្មប៉ះពាល់ដល់ល្បឿន និងភាពត្រឹមត្រូវនៃការស្កេន។

   ការដំឡើងការកំណត់ជាមុននៅក្នុងចំណុចប្រទាក់ Checkmarx

2. ច្បាប់ត្រូវបានកែសម្រួលនៅក្នុងឧបករណ៍ពិសេសមួយហៅថា CxAudit។ នេះគឺជាកម្មវិធីកុំព្យូទ័រដែលភ្ជាប់ទៅម៉ាស៊ីនមេដែលកំពុងដំណើរការ Checkmarx ។ ឧបករណ៍នេះមានរបៀបប្រតិបត្តិការពីរ៖ ច្បាប់កែសម្រួល និងការវិភាគលទ្ធផលនៃការស្កេនដែលបានអនុវត្តរួចហើយ។

   ចំណុចប្រទាក់ CxAudit

3. ច្បាប់នៅក្នុង Checkmarx ត្រូវបានបែងចែកតាមភាសា ពោលគឺភាសានីមួយៗមានសំណុំសំណួរផ្ទាល់ខ្លួន។ វាក៏មានច្បាប់ទូទៅមួយចំនួនដែលអនុវត្តដោយមិនគិតពីភាសា ទាំងនេះគឺជាអ្វីដែលគេហៅថាសំណួរមូលដ្ឋាន។ សម្រាប់ផ្នែកភាគច្រើន សំណួរជាមូលដ្ឋានពាក់ព័ន្ធនឹងការស្វែងរកព័ត៌មានដែលច្បាប់ផ្សេងទៀតប្រើ។

   ការបែងចែកច្បាប់តាមភាសា

4. ច្បាប់គឺ "អាចប្រតិបត្តិបាន" និង "មិនអាចប្រតិបត្តិបាន" (ប្រតិបត្តិ និងមិនត្រូវបានប្រតិបត្តិ)។ មិនមែនជាឈ្មោះត្រឹមត្រូវទេ តាមគំនិតរបស់ខ្ញុំ ប៉ុន្តែនោះជាឈ្មោះ ចំណុចសំខាន់គឺថាលទ្ធផលនៃការអនុវត្តច្បាប់ "អាចប្រតិបត្តិបាន" នឹងត្រូវបានបង្ហាញនៅក្នុងលទ្ធផលស្កេននៅក្នុង UI ហើយច្បាប់ "មិនអាចប្រតិបត្តិបាន" គឺត្រូវការតែដើម្បីប្រើលទ្ធផលរបស់ពួកគេនៅក្នុងសំណើផ្សេងទៀតប៉ុណ្ណោះ (តាមពិតវាគ្រាន់តែជាមុខងារមួយប៉ុណ្ណោះ។ )

   កំណត់ប្រភេទច្បាប់នៅពេលបង្កើត

5. អ្នកអាចបង្កើតច្បាប់ថ្មី ឬបន្ថែម/សរសេរឡើងវិញនូវច្បាប់ដែលមានស្រាប់។ ដើម្បីសរសេរច្បាប់ឡើងវិញ អ្នកត្រូវស្វែងរកវានៅក្នុងមែកធាង ចុចកណ្ដុរស្ដាំ ហើយជ្រើសរើស "បដិសេធ" ពីម៉ឺនុយទម្លាក់ចុះ។ វាជារឿងសំខាន់ក្នុងការចងចាំនៅទីនេះថាច្បាប់ថ្មីមិនត្រូវបានបញ្ចូលក្នុងការកំណត់ជាមុនទេ ហើយមិនសកម្ម។ ដើម្បីចាប់ផ្តើមប្រើពួកវាអ្នកត្រូវធ្វើឱ្យពួកវាសកម្មនៅក្នុងម៉ឺនុយ "កម្មវិធីគ្រប់គ្រងការកំណត់ជាមុន" នៅក្នុងឧបករណ៍។ ច្បាប់ដែលបានសរសេរឡើងវិញរក្សាការកំណត់របស់ពួកគេ ពោលគឺប្រសិនបើច្បាប់សកម្ម វានឹងនៅតែដដែល ហើយនឹងត្រូវបានអនុវត្តភ្លាមៗ។

   ឧទាហរណ៍នៃច្បាប់ថ្មីនៅក្នុងចំណុចប្រទាក់កម្មវិធីគ្រប់គ្រងការកំណត់ជាមុន

6. ក្នុងអំឡុងពេលប្រតិបត្តិ "ដើមឈើ" នៃសំណើត្រូវបានសាងសង់ដែលអាស្រ័យលើអ្វី។ ច្បាប់​ដែល​ប្រមូល​ព័ត៌មាន​ត្រូវ​បាន​ប្រតិបត្តិ​មុន​គេ ហើយ​អ្នក​ដែល​ប្រើ​វា​ទីពីរ។ លទ្ធផល​នៃ​ការ​ប្រតិបត្តិ​ត្រូវ​បាន​ទុក​ក្នុង​ឃ្លាំង​សម្ងាត់ ដូច្នេះ​ប្រសិន​បើ​វា​អាច​ប្រើ​លទ្ធផល​នៃ​ច្បាប់​ដែល​មាន​ស្រាប់ នោះ​វា​ល្អ​ជាង​ក្នុង​ការ​ធ្វើ​ដូច្នេះ វា​នឹង​កាត់​បន្ថយ​ពេល​វេលា​ស្កេន។

7. ច្បាប់អាចត្រូវបានអនុវត្តនៅកម្រិតផ្សេងៗគ្នា៖

• សម្រាប់ប្រព័ន្ធទាំងមូល - នឹងត្រូវបានប្រើសម្រាប់ការស្កេនគម្រោងណាមួយ។

• នៅកម្រិតក្រុម (ក្រុម) - នឹងត្រូវបានប្រើដើម្បីស្កេនគម្រោងនៅក្នុងក្រុមដែលបានជ្រើសរើសប៉ុណ្ណោះ។

• នៅកម្រិតគម្រោង - នឹងត្រូវបានអនុវត្តនៅក្នុងគម្រោងជាក់លាក់មួយ។

  ការកំណត់កម្រិតដែលច្បាប់នឹងត្រូវបានអនុវត្ត

"វចនានុក្រម" សម្រាប់អ្នកចាប់ផ្តើមដំបូង

ហើយខ្ញុំនឹងចាប់ផ្តើមជាមួយនឹងរឿងមួយចំនួនដែលបណ្តាលឱ្យខ្ញុំមានចម្ងល់ ហើយខ្ញុំក៏នឹងបង្ហាញពីបច្ចេកទេសមួយចំនួនដែលនឹងធ្វើឱ្យជីវិតកាន់តែងាយស្រួល។

ប្រតិបត្តិការជាមួយបញ្ជី

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

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

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

ធាតុដែលបានរកឃើញទាំងអស់។

នៅក្នុងភាសាដែលបានស្កេន អ្នកអាចទទួលបានបញ្ជីនៃធាតុទាំងអស់ដែល Checkmarx បានកំណត់អត្តសញ្ញាណ (ខ្សែអក្សរ មុខងារ ថ្នាក់ វិធីសាស្ត្រ។ល។)។ នេះគឺជាចន្លោះមួយចំនួននៃវត្ថុដែលអាចចូលបានតាមរយៈ All. នោះគឺដើម្បីស្វែងរកវត្ថុដែលមានឈ្មោះជាក់លាក់ searchMeឧទាហរណ៍ អ្នកអាចស្វែងរកតាមឈ្មោះតាមវត្ថុដែលបានរកឃើញទាំងអស់៖

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

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

ប៉ុន្តែប្រសិនបើអ្នកត្រូវការស្វែងរកជាភាសាផ្សេងទៀតដែលសម្រាប់ហេតុផលមួយចំនួនមិនត្រូវបានរួមបញ្ចូលក្នុងការស្កេន (ឧទាហរណ៍ groovy នៅក្នុងគម្រោង 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");

ការប្រើប្រាស់លទ្ធផលនៃច្បាប់ផ្សេងទៀត។

ច្បាប់នៅក្នុង 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 ឬគ្រាន់តែ Comment កូដខាងក្រោម។ ឬអ្នកអាចដូចជាខ្ញុំ ភ្លេចលុបការហៅទូរសព្ទបែបនេះចេញពីច្បាប់ដែលត្រៀមរួចជាស្រេច ហើយឆ្ងល់ថាហេតុអ្វីបានជាគ្មានអ្វីដំណើរការ។

មធ្យោបាយងាយស្រួលជាងគឺហៅវិធីសាស្ត្រ return ជាមួយនឹងប៉ារ៉ាម៉ែត្រដែលត្រូវការ។ ក្នុងករណីនេះ ការអនុវត្តច្បាប់នឹងបញ្ចប់ ហើយយើងនឹងអាចដឹងថាអ្វីដែលបានកើតឡើងជាលទ្ធផលនៃអ្វីដែលយើងបានសរសេរ៖

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

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

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

បញ្ហា​ចូល

មានស្ថានភាពនៅពេលដែលអ្នកមិនអាចចូលប្រើឧបករណ៍ CxAudit (ដែលត្រូវបានប្រើដើម្បីសរសេរច្បាប់)។ វាអាចមានហេតុផលជាច្រើនសម្រាប់បញ្ហានេះ រួមទាំងការគាំង ការអាប់ដេតវីនដូភ្លាមៗ BSOD និងស្ថានភាពដែលមិនបានមើលឃើញទុកជាមុនផ្សេងទៀតដែលហួសពីការគ្រប់គ្រងរបស់យើង។ ក្នុងករណីនេះ ជួនកាលមានវគ្គដែលមិនទាន់បញ្ចប់នៅក្នុងមូលដ្ឋានទិន្នន័យ ដែលរារាំងអ្នកពីការចូលម្តងទៀត។ ដើម្បីជួសជុលវា អ្នកត្រូវដំណើរការសំណួរជាច្រើន៖

សម្រាប់ Checkmarx មុន 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 អ្វីដែលអ្នកតែងតែខ្វះគឺមិនមានឯកសារច្រើនដូចឧទាហរណ៍ខ្លះនៃការដោះស្រាយបញ្ហាមួយចំនួន និងការពិពណ៌នាអំពីដំណើរការនៃប្រតិបត្តិការសំណួរជាទូទៅ។

ខ្ញុំនឹងព្យាយាមធ្វើឱ្យជីវិតកាន់តែងាយស្រួលសម្រាប់អ្នកដែលចាប់ផ្តើមចូលទៅក្នុងភាសាសំណួរ ហើយផ្តល់ឧទាហរណ៍មួយចំនួននៃការប្រើប្រាស់ Custom Queries ដើម្បីដោះស្រាយបញ្ហាជាក់លាក់។ ពួកវាមួយចំនួនមានលក្ខណៈទូទៅ ហើយអាចប្រើប្រាស់ក្នុងក្រុមហ៊ុនរបស់អ្នកបានដោយការអនុវត្តដោយគ្មានការផ្លាស់ប្តូរ ខ្លះទៀតមានលក្ខណៈជាក់លាក់ជាង ប៉ុន្តែពួកគេក៏អាចប្រើប្រាស់បានដោយការផ្លាស់ប្តូរកូដឱ្យសមស្របទៅនឹងលក្ខណៈជាក់លាក់នៃកម្មវិធីរបស់អ្នក។

ដូច្នេះ នេះជាបញ្ហាដែលយើងជួបប្រទះញឹកញាប់បំផុត៖

ភារកិច្ច៖ មានលំហូរជាច្រើននៅក្នុងលទ្ធផលនៃការប្រតិបត្តិច្បាប់ ហើយមួយក្នុងចំណោមពួកគេគឺជាសំបុកនៃមួយផ្សេងទៀត អ្នកត្រូវតែទុកមួយក្នុងចំណោមពួកគេ។

ជាដំណោះស្រាយ: ជាការពិតណាស់ ពេលខ្លះ Checkmarx បង្ហាញលំហូរទិន្នន័យជាច្រើនដែលអាចត្រួតលើគ្នា និងជាកំណែខ្លីរបស់អ្នកដទៃ។ មានវិធីសាស្រ្តពិសេសសម្រាប់ករណីបែបនេះ កាត់បន្ថយលំហូរ។ អាស្រ័យលើប៉ារ៉ាម៉ែត្រ វានឹងជ្រើសរើសលំហូរខ្លីបំផុត ឬវែងបំផុត៖

// Оставить только длинные 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);

ភារកិច្ច៖ ពង្រីកបញ្ជីអថេរដោយប្រើពាក្យសម្ងាត់

ជាដំណោះស្រាយ: ខ្ញុំនឹងផ្តល់អនុសាសន៍ភ្លាមៗឱ្យយកចិត្តទុកដាក់លើច្បាប់ជាមូលដ្ឋានសម្រាប់ការកំណត់ពាក្យសម្ងាត់នៅក្នុងកូដ ហើយបន្ថែមទៅវានូវបញ្ជីឈ្មោះអថេរដែលត្រូវបានប្រើជាទូទៅនៅក្នុងក្រុមហ៊ុនរបស់អ្នក។

លេខសម្ងាត់_ឯកជន_ការបំពាន_បញ្ជី

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 ត្រូវបានបែងចែកតាមភាសា ដូច្នេះអ្នកត្រូវបន្ថែមច្បាប់សម្រាប់ភាសានីមួយៗ។ ខាងក្រោមនេះគឺជាឧទាហរណ៍មួយចំនួននៃច្បាប់បែបនេះ។

ប្រសិនបើបណ្ណាល័យត្រូវបានប្រើប្រាស់ដែលបំពេញបន្ថែម ឬជំនួសមុខងារស្តង់ដារ នោះពួកវាអាចត្រូវបានបន្ថែមយ៉ាងងាយស្រួលទៅក្នុងច្បាប់មូលដ្ឋាន។ បន្ទាប់មកអ្នកគ្រប់គ្នាដែលប្រើវានឹងដឹងភ្លាមៗអំពីការណែនាំថ្មី។ ជាឧទាហរណ៍ បណ្ណាល័យសម្រាប់ចូលប្រព័ន្ធ Android គឺ Timber និង Loggi ។ នៅក្នុងកញ្ចប់មូលដ្ឋាន មិនមានច្បាប់សម្រាប់កំណត់អត្តសញ្ញាណការហៅទូរសព្ទដែលមិនមែនជាប្រព័ន្ធទេ ដូច្នេះប្រសិនបើពាក្យសម្ងាត់ ឬឧបករណ៍កំណត់សម័យចូលដល់កំណត់ហេតុ យើងនឹងមិនដឹងអំពីវាទេ។ ចូរយើងព្យាយាមបន្ថែមនិយមន័យនៃវិធីសាស្រ្តបែបនេះទៅនឹងច្បាប់ Checkmarx ។

សាកល្បងឧទាហរណ៍កូដដែលប្រើបណ្ណាល័យ 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");
    }
}

ហើយនេះគឺជាឧទាហរណ៍នៃសំណើសម្រាប់ Checkmarx ដែលនឹងអនុញ្ញាតឱ្យអ្នកបន្ថែមនិយមន័យនៃការហៅវិធីសាស្ត្រ Timber ជាចំណុចចេញសម្រាប់ទិន្នន័យពីកម្មវិធី៖

ស្វែងរកលទ្ធផល Android

// Получаем результат выполнения базового правила
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 ប្រើ អ្នកគ្រប់គ្រងការងារ សម្រាប់ការងារអសមកាល វាជាការប្រសើរក្នុងការជូនដំណឹងដល់ Checkmarx បន្ថែមអំពីបញ្ហានេះ ដោយបន្ថែមវិធីសាស្ត្រដើម្បីទទួលបានទិន្នន័យពីកិច្ចការ។ getInputData:

ស្វែងរក AndroidRead

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

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

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

ភារកិច្ច៖ កំពុងស្វែងរកទិន្នន័យរសើបនៅក្នុងបញ្ជីសម្រាប់គម្រោង 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 ដែលមាន nuances ជាច្រើនដែលគួរត្រូវយកមកពិចារណានៅពេលសរសេរ៖

// Используем результат выполнения правила по поиску файлов 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. នេះ​ជា​អ្វី​ដែល​សំណួរ​ត្រឹមត្រូវ​មើល​ទៅ​ដូច​ជា​ដើម្បី​ស្វែង​រក​ការ​កំណត់​ក្នុង​ប្រព័ន្ធ​ប្រតិបត្តិការ Android ដែល​អនុញ្ញាត​ឱ្យ​ប្រើ​ចរាចរណ៍ HTTP៖

// Правильный вариант с использованием 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'
  ...
}

និងច្បាប់សម្រាប់ Checkmarx:

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 ប៉ុណ្ណោះទេ ប៉ុន្តែវាក៏សម្រាប់ករណីផ្សេងទៀតផងដែរ នៅពេលដែលអ្នកត្រូវកំណត់ថាតើលទ្ធផលជាកម្មសិទ្ធិរបស់ឯកសារជាក់លាក់ដែរឬទេ។

ភារកិច្ច៖ បន្ថែមការគាំទ្រសម្រាប់បណ្ណាល័យភាគីទីបី ប្រសិនបើវាក្យសម្ព័ន្ធមិនត្រូវបានគាំទ្រទាំងស្រុង

ជាដំណោះស្រាយ: ចំនួននៃក្របខ័ណ្ឌផ្សេងៗដែលត្រូវបានប្រើក្នុងដំណើរការនៃការសរសេរកូដគឺគ្រាន់តែចេញពីតារាង។ ជាការពិតណាស់ Checkmarx មិនតែងតែដឹងអំពីអត្ថិភាពរបស់ពួកគេទេ ហើយភារកិច្ចរបស់យើងគឺបង្រៀនវាឱ្យយល់ថាវិធីសាស្រ្តជាក់លាក់ជាកម្មសិទ្ធិរបស់ក្របខ័ណ្ឌនេះ។ ពេលខ្លះវាមានភាពស្មុគស្មាញដោយការពិតដែលថាក្របខ័ណ្ឌប្រើឈ្មោះមុខងារដែលជារឿងធម្មតាបំផុតហើយវាមិនអាចទៅរួចទេក្នុងការកំណត់ដោយមិនច្បាស់លាស់នូវទំនាក់ទំនងនៃការហៅទៅបណ្ណាល័យជាក់លាក់មួយ។

ការលំបាកគឺថាវាក្យសម្ព័ន្ធនៃបណ្ណាល័យបែបនេះមិនតែងតែត្រូវបានទទួលស្គាល់ត្រឹមត្រូវទេហើយអ្នកត្រូវពិសោធន៍ដើម្បីជៀសវាងការទទួលបានចំនួនដ៏ច្រើននៃវិជ្ជមានមិនពិត។ មានជម្រើសជាច្រើនដើម្បីកែលម្អភាពត្រឹមត្រូវនៃការស្កេន និងដោះស្រាយបញ្ហា៖

• ជម្រើសទីមួយ យើងដឹងច្បាស់ថាបណ្ណាល័យត្រូវបានប្រើប្រាស់ក្នុងគម្រោងជាក់លាក់មួយ ហើយអាចអនុវត្តច្បាប់នៅកម្រិតក្រុម។ ប៉ុន្តែប្រសិនបើក្រុមសម្រេចចិត្តយកវិធីសាស្រ្តផ្សេង ឬប្រើបណ្ណាល័យជាច្រើនដែលឈ្មោះមុខងារត្រួតលើគ្នានោះ យើងអាចទទួលបានរូបភាពមិនពិតនៃវិជ្ជមានមិនពិតជាច្រើន

• ជម្រើសទីពីរគឺស្វែងរកឯកសារដែលបណ្ណាល័យត្រូវបាននាំចូលយ៉ាងច្បាស់។ ជាមួយនឹងវិធីសាស្រ្តនេះ យើងអាចប្រាកដថាបណ្ណាល័យដែលយើងត្រូវការគឺត្រូវបានប្រើប្រាស់យ៉ាងពិតប្រាកដនៅក្នុងឯកសារនេះ។

• ហើយជម្រើសទីបីគឺត្រូវប្រើវិធីសាស្រ្តទាំងពីរខាងលើជាមួយគ្នា។

ជាឧទាហរណ៍ សូមក្រឡេកមើលបណ្ណាល័យដែលល្បីក្នុងរង្វង់តូចចង្អៀត រអិល សម្រាប់ភាសាសរសេរកម្មវិធី Scala គឺមុខងារ ការបំបែកតម្លៃព្យញ្ជនៈ. ជាទូទៅ ដើម្បីបញ្ជូនប៉ារ៉ាម៉ែត្រទៅសំណួរ SQL អ្នកត្រូវតែប្រើប្រតិបត្តិករ $ដែលជំនួសទិន្នន័យទៅក្នុងសំណួរ SQL ដែលបានធ្វើទុកជាមុន។ នោះ​គឺ​តាម​ពិត​ទៅ វា​គឺ​ជា analogue ផ្ទាល់​នៃ​សេចក្តី​ថ្លែងការណ៍​ដែល​បាន​រៀបចំ​នៅ​ក្នុង Java ។ ប៉ុន្តែប្រសិនបើអ្នកត្រូវការបង្កើត SQL query ថាមវន្ត ជាឧទាហរណ៍ ប្រសិនបើអ្នកត្រូវការឆ្លងកាត់ឈ្មោះតារាង អ្នកអាចប្រើ operator #$ដែលនឹងជំនួសទិន្នន័យដោយផ្ទាល់ទៅក្នុងសំណួរ (ស្ទើរតែដូចជាការភ្ជាប់ខ្សែអក្សរ)។

កូដគំរូ៖

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

Checkmarx មិនទាន់ដឹងពីរបៀបរកឃើញការប្រើប្រាស់ 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");

សេចក្តីសន្និដ្ឋាន

ខ្ញុំសង្ឃឹមថាអត្ថបទនេះនឹងមានប្រយោជន៍សម្រាប់អ្នកដែលកំពុងចាប់ផ្តើមស្គាល់គ្នាជាមួយឧបករណ៍ Checkmarx ។ ប្រហែល​ជា​អ្នក​ដែល​បាន​សរសេរ​ច្បាប់​ផ្ទាល់​ខ្លួន​ជា​យូរ​មក​ហើយ​ក៏​នឹង​រក​ឃើញ​អ្វី​ដែល​មាន​ប្រយោជន៍​ក្នុង​ការណែនាំ​នេះ​ដែរ។

ជាអកុសល បច្ចុប្បន្នមានការខ្វះខាតធនធាន ដែលគំនិតថ្មីៗអាចត្រូវបានប្រមូលក្នុងអំឡុងពេលបង្កើតច្បាប់សម្រាប់ Checkmarx ។ នោះហើយជាមូលហេតុដែលយើងបានបង្កើត ឃ្លាំងនៅលើ Githubដែលជាកន្លែងដែលយើងនឹងបង្ហោះការងាររបស់យើងដើម្បីឱ្យអ្នករាល់គ្នាដែលប្រើ CxQL អាចស្វែងរកអ្វីដែលមានប្រយោជន៍នៅក្នុងវា ហើយក៏មានឱកាសចែករំលែកការងាររបស់ពួកគេជាមួយសហគមន៍ផងដែរ។ ឃ្លាំងកំពុងដំណើរការបំពេញ និងរៀបចំខ្លឹមសារ ដូច្នេះអ្នករួមចំណែកត្រូវបានស្វាគមន៍!

សូមពិនិត្យមើល!

ប្រភព: www.habr.com