ProHoster > බ්ලොග් > පරිපාලනය > පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?

පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?

හෙලෝ, හබ්ර්!

අපගේ කාර්යයේදී, අපගේ සමාගම බොහෝ විට විවිධ ස්ථිතික කේත විශ්ලේෂණ මෙවලම් (SAST) සමඟ කටයුතු කරයි. කොටුවෙන් පිටත, ඔවුන් සියල්ලන්ම සාමාන්යයෙන් වැඩ කරති. ඇත්ත වශයෙන්ම, ඒ සියල්ල රඳා පවතින්නේ ව්‍යාපෘතිය සහ එහි භාවිතා කරන තාක්ෂණයන් මෙන්ම මෙම තාක්ෂණයන් විශ්ලේෂණ නීති මගින් කෙතරම් හොඳින් ආවරණය වී ඇත්ද යන්න මතය. මගේ මතය අනුව, SAST මෙවලමක් තෝරාගැනීමේදී වැදගත්ම නිර්ණායකයක් වන්නේ එය ඔබගේ යෙදුම්වල විශේෂතා වලට රිසිකරණය කිරීමේ හැකියාවයි, එනම් විශ්ලේෂණ නීති ලිවීම සහ වෙනස් කිරීම හෝ, ඒවා බොහෝ විට හඳුන්වන පරිදි, අභිරුචි විමසුම්.

පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?

අපි බොහෝ විට භාවිතා කරන්නේ Checkmarx - ඉතා රසවත් හා බලවත් කේත විශ්ලේෂකය. මෙම ලිපියෙන් මම ඒ සඳහා විශ්ලේෂණ නීති ලිවීමේ මගේ අත්දැකීම් ගැන කතා කරමි.

පටුන

පිවිසුම්

ආරම්භ කිරීම සඳහා, චෙක්මාක්ස් සඳහා විමසුම් ලිවීමේ විශේෂාංග පිළිබඳව රුසියානු භාෂාවෙන් ලිපි කිහිපයෙන් එකක් නිර්දේශ කිරීමට මම කැමැත්තෙමි. එය 2019 අවසානයේ Habré හි මාතෘකාව යටතේ ප්‍රකාශයට පත් කරන ලදී: "හෙලෝ, චෙක්මාක්ස්!" Checkmarx SAST විමසුමක් ලියන්නේ කෙසේද සහ සිසිල් දුර්වලතා සොයා ගන්නේ කෙසේද.

එය සමහර පරීක්ෂණ යෙදුම් සඳහා CxQL (Checkmarx Query Language) හි පළමු විමසුම් ලියන ආකාරය විස්තරාත්මකව පරීක්ෂා කරන අතර විශ්ලේෂණ රීති ක්‍රියා කරන ආකාරය පිළිබඳ මූලික මූලධර්ම පෙන්වයි.

සමහර මංසන්ධි තවමත් පවතිනු ඇතත්, එහි විස්තර කර ඇති දේ මම නැවත නොකියමි. මගේ ලිපියෙන් මම චෙක්මාක්ස් සමඟ වැඩ කිරීමේදී මා මුහුණ දුන් විශේෂිත ගැටළු සඳහා විසඳුම් ලැයිස්තුවක් "වට්ටෝරු එකතුවක්" සම්පාදනය කිරීමට උත්සාහ කරමි. මෙම ගැටලු බොහොමයක් ගැන මගේ මොළය අවුල් කිරීමට මට සිදු විය. සමහර විට ලේඛනවල ප්රමාණවත් තොරතුරු නොතිබූ අතර, සමහර විට අවශ්ය දේ කරන්නේ කෙසේද යන්න තේරුම් ගැනීමට පවා අපහසු විය. මගේ අත්දැකීම් සහ නිදි නැති රාත්‍රීන් නිෂ්ඵල නොවනු ඇතැයි මම බලාපොරොත්තු වෙමි, මෙම "අභිරුචි විමසුම් වට්ටෝරු එකතුව" ඔබට පැය කිහිපයක් හෝ ස්නායු සෛල කිහිපයක් ඉතිරි කර දෙනු ඇත. ඉතින්, අපි පටන් ගනිමු!

රීති පිළිබඳ සාමාන්ය තොරතුරු

පළමුව, ඊළඟට කුමක් සිදුවේද යන්න පිළිබඳ වඩා හොඳ අවබෝධයක් සඳහා මූලික සංකල්ප කිහිපයක් සහ නීති සමඟ වැඩ කිරීමේ ක්රියාවලිය දෙස බලමු. තවද ලේඛන මේ ගැන කිසිවක් නොකියන නිසා හෝ ව්‍යුහය තුළ ඉතා ව්‍යාප්ත වී ඇති නිසා එය එතරම් පහසු නොවේ.

  1. ආරම්භයේදී තෝරාගත් පෙරසිටුවට අනුව (ක්‍රියාකාරී නීති මාලාවක්) ස්කෑන් කිරීමේදී නීති යොදනු ලැබේ. ඔබට අසීමිත පෙරසිටුවක් නිර්මාණය කළ හැකි අතර, ඒවා නිවැරදිව සකස් කරන්නේ කෙසේද යන්න ඔබේ ක්‍රියාවලියේ විශේෂතා මත රඳා පවතී. ඔබට ඒවා භාෂාවෙන් සමූහගත කිරීමට හෝ එක් එක් ව්‍යාපෘතිය සඳහා පෙරසිටුවීම් තෝරාගත හැක. ක්රියාකාරී නීති ගණන ස්කෑන් කිරීමේ වේගය සහ නිරවද්යතාවයට බලපායි.

    පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?Checkmarx අතුරුමුහුණත තුළ පෙරසිටුවක් සැකසීම

  2. CxAuditor නම් විශේෂ මෙවලමක් තුළ නීති සංස්කරණය කරනු ලැබේ. මෙය Checkmarx ධාවනය වන සේවාදායකයකට සම්බන්ධ වන ඩෙස්ක්ටොප් යෙදුමකි. මෙම මෙවලම මෙහෙයුම් ආකාර දෙකක් ඇත: නීති සංස්කරණය කිරීම සහ දැනටමත් සිදු කරන ලද ස්කෑන් ප්රතිඵල විශ්ලේෂණය කිරීම.

    පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?CxAudit අතුරුමුහුණත

  3. චෙක්මාක්ස් හි රීති භාෂාවෙන් බෙදනු ලැබේ, එනම් සෑම භාෂාවකටම තමන්ගේම විමසුම් කට්ටලයක් ඇත. භාෂාව කුමක් වුවත් අදාළ වන පොදු නීති කිහිපයක් ද ඇත, මේවා ඊනියා මූලික විමසුම් වේ. බොහෝ දුරට, මූලික විමසුම්වලට වෙනත් නීති භාවිතා කරන තොරතුරු සෙවීම ඇතුළත් වේ.

    පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?භාෂාව අනුව නීති බෙදීම

  4. රීති "ක්‍රියාත්මක කළ හැකි" සහ "ක්‍රියාත්මක කළ නොහැකි" (ක්‍රියාත්මක කරන ලද සහ ක්‍රියාත්මක නොකළ) වේ. මගේ මතය අනුව නිවැරදි නම නොවේ, නමුත් එය එයයි. අවසාන කරුණ නම්, "ක්‍රියාත්මක කළ හැකි" රීති ක්‍රියාත්මක කිරීමේ ප්‍රතිඵලය UI හි ස්කෑන් ප්‍රතිඵලවල දර්ශනය වන අතර, "ක්‍රියාත්මක කළ නොහැකි" රීති අවශ්‍ය වන්නේ ඒවායේ ප්‍රතිඵල වෙනත් ඉල්ලීම් (සාරයෙන්, හුදෙක් කාර්යයක්) භාවිතා කිරීමට පමණි.

    පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?නිර්මාණය කිරීමේදී රීති වර්ගය තීරණය කිරීම

  5. ඔබට නව නීති නිර්මාණය කිරීමට හෝ පවතින ඒවා අතිරේක/නැවත ලිවීමට හැකිය. රීතියක් නැවත ලිවීම සඳහා, ඔබ එය ගසෙහි සොයා ගත යුතුය, දකුණු-ක්ලික් කර පතන මෙනුවෙන් "අතික්‍රමණය කරන්න" තෝරන්න. මෙහිදී මතක තබා ගැනීම වැදගත් වන්නේ නව නීති පෙරසිටුවීම්වලට මුලින් ඇතුළත් කර නොමැති අතර ඒවා සක්‍රීය නොවන බවයි. ඒවා භාවිතා කිරීම ආරම්භ කිරීම සඳහා, ඔබ උපකරණයේ "පෙරසිටුවන කළමනාකරු" මෙනුවෙහි ඒවා සක්රිය කළ යුතුය. නැවත ලියන ලද රීති ඒවායේ සැකසුම් රඳවා තබා ගනී, එනම් රීතිය සක්‍රිය නම්, එය එසේ පවතිනු ඇති අතර වහාම ක්‍රියාත්මක වේ.

    පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?Preset Manager අතුරුමුහුණතෙහි නව රීතියක උදාහරණය

  6. ක්රියාත්මක කිරීමේදී, ඉල්ලීම් "ගසක්" ගොඩනගා ඇති අතර, එය කුමක් මත රඳා පවතී. තොරතුරු රැස් කරන නීති පළමුව ක්‍රියාත්මක වන අතර එය භාවිතා කරන අය දෙවනුව ක්‍රියාත්මක වේ. ක්රියාත්මක කිරීමේ ප්රතිඵලය හැඹිලිගත කර ඇත, එබැවින් පවතින රීතියක ප්රතිඵල භාවිතා කිරීමට හැකි නම්, එසේ කිරීම වඩා හොඳය, මෙය ස්කෑන් කිරීමේ කාලය අඩු කරයි.

  7. විවිධ මට්ටම්වල නීති යෙදිය හැකිය:

  • සම්පූර්ණ පද්ධතිය සඳහා - ඕනෑම ව්යාපෘතියක් ස්කෑන් කිරීම සඳහා භාවිතා කරනු ඇත

  • කණ්ඩායම් මට්ටමින් (කණ්ඩායම) - තෝරාගත් කණ්ඩායමේ ව්‍යාපෘති පරිලෝකනය කිරීමට පමණක් භාවිතා කරනු ඇත.

  • ව්‍යාපෘති මට්ටමින් - නිශ්චිත ව්‍යාපෘතියක යෙදෙනු ඇත

    පිස්සුවකින් තොරව Checkmarx සඳහා නීති ලියන්නේ කෙසේද?රීතිය යෙදිය යුතු මට්ටම තීරණය කිරීම

ආරම්භකයින් සඳහා "ශබ්දකෝෂය"

මට ප්‍රශ්න ඇති කළ කරුණු කිහිපයකින් මම ආරම්භ කරමි, සහ ජීවිතය සැලකිය යුතු ලෙස සරල කරන ශිල්පීය ක්‍රම ගණනාවක් ද මම පෙන්වන්නම්.

ලැයිස්තු සමඟ මෙහෙයුම්

- вычитание одного из другого (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 මෙවලම වෙත ප්‍රවේශ විය නොහැකි අවස්ථා තිබේ (එය රීති ලිවීමට භාවිතා කරයි). බිඳ වැටීම්, හදිසි වින්ඩෝස් යාවත්කාලීන කිරීම්, BSOD සහ අපගේ පාලනයෙන් ඔබ්බට ගිය වෙනත් අනපේක්ෂිත තත්වයන් ඇතුළුව මේ සඳහා බොහෝ හේතු තිබිය හැකිය. මෙම අවස්ථාවෙහිදී, සමහර විට දත්ත සමුදායේ නිම නොකළ සැසියක් ඇත, එය ඔබට නැවත ලොග් වීම වළක්වයි. එය නිවැරදි කිරීමට, ඔබ විමසුම් කිහිපයක් ධාවනය කළ යුතුය:

8.6 ට පෙර Checkmarx සඳහා:

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

8.6 න් පසු Checkmarx සඳහා:

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

ලිවීමේ නීති

දැන් අපි වඩාත් රසවත් කොටස වෙත යමු. ඔබ CxQL හි නීති ලිවීමට පටන් ගත් විට, ඔබට බොහෝ විට අඩු වන්නේ යම් යම් ගැටළු විසඳීම සහ විමසුම් පොදුවේ ක්‍රියා කරන ආකාරය පිළිබඳ ක්‍රියාවලිය විස්තර කිරීම සඳහා ජීවමාන උදාහරණ කිහිපයක් තරම් ලියකියවිලි නොවේ.

විමසුම් භාෂාවට කිමිදෙන්නට පටන් ගන්නා අයට ජීවිතය ටිකක් පහසු කිරීමට මම උත්සාහ කරමි, සමහර ගැටළු විසඳීම සඳහා අභිරුචි විමසුම් භාවිතා කිරීම පිළිබඳ උදාහරණ කිහිපයක් දෙන්න. ඒවායින් සමහරක් තරමක් සාමාන්‍ය වන අතර ප්‍රායෝගිකව ඔබේ සමාගම තුළ වෙනස්කම් නොමැතිව භාවිතා කළ හැකිය, අනෙක් ඒවා වඩාත් නිශ්චිත ය, නමුත් ඒවා ඔබේ යෙදුම්වල විශේෂතාවලට සරිලන පරිදි කේතය වෙනස් කිරීමෙන් ද භාවිතා කළ හැකිය.

ඉතින්, අපි බොහෝ විට මුහුණ දුන් ගැටළු මෙන්න:

අභියෝගය: රීතිය ක්‍රියාත්මක කිරීමේ ප්‍රතිඵලවල ප්‍රවාහ කිහිපයක් ඇති අතර ඒවායින් එකක් තවත් එකක කූඩුවකි, ඔබ ඒවායින් එකක් අත්හැරිය යුතුය.

විසඳුම: ඇත්ත වශයෙන්ම, සමහර විට 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 හි ඇති සියලුම විමසුම් භාෂාවෙන් බෙදනු ලැබේ, එබැවින් ඔබ එක් එක් භාෂාව සඳහා රීති එකතු කළ යුතුය. එවැනි නීති සඳහා උදාහරණ කිහිපයක් පහත දැක්වේ.

සම්මත ක්‍රියාකාරීත්වයට අනුපූරකව හෝ ප්‍රතිස්ථාපනය කරන පුස්තකාල භාවිතා කරන්නේ නම්, ඒවා පහසුවෙන් මූලික රීතියට එකතු කළ හැක. එවිට එය භාවිතා කරන සෑම කෙනෙකුම නව හැඳින්වීම් ගැන වහාම ඉගෙන ගනු ඇත. උදාහරණයක් ලෙස, ඇන්ඩ්‍රොයිඩ් ලොග් වීම සඳහා පුස්තකාල වන්නේ දැව සහ ලොගී ය. මූලික පැකේජයේ, පද්ධති නොවන ඇමතුම් හඳුනා ගැනීම සඳහා නීති නොමැත, එබැවින් මුරපදයක් හෝ සැසි හඳුනාගැනීමක් ලොගයට ඇතුල් වුවහොත්, අපි ඒ ගැන නොදනිමු. එවැනි ක්‍රම පිළිබඳ අර්ථ දැක්වීම් චෙක්මාක්ස් රීතිවලට එක් කිරීමට උත්සාහ කරමු.

ලොග් කිරීම සඳහා දැව පුස්තකාලය භාවිතා කරන පරීක්ෂණ කේත උදාහරණය:

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

චෙක්මාර්ක්ස් සඳහා වන ඉල්ලීමක උදාහරණයක් මෙන්න, එය යෙදුමෙන් දත්ත සඳහා පිටවීමේ ලක්ෂ්‍යයක් ලෙස දැව ක්‍රම ඇමතීම පිළිබඳ අර්ථ දැක්වීමක් එක් කිරීමට ඔබට ඉඩ සලසයි:

FindAndroidOutputs

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

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

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

ඔබට අසල්වැසි රීතියට ද එකතු කළ හැකිය, නමුත් මෙය ඇන්ඩ්‍රොයිඩ් වෙත පිවිසීමට කෙලින්ම සම්බන්ධ වේ:

FindAndroidLog_Outputs

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

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

එසේම, Android යෙදුම් භාවිතා කරන්නේ නම් වැඩ කළමණාකරු අසමමුහුර්ත වැඩ සඳහා, කාර්යයෙන් දත්ත ලබා ගැනීම සඳහා ක්‍රමයක් එක් කිරීමෙන් චෙක්මාක්ස් වෙත මේ පිළිබඳව අතිරේකව දැනුම් දීම හොඳ අදහසකි. getInputData:

FindAndroidRead

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

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

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

අභියෝගය: iOS ව්‍යාපෘති සඳහා plist හි සංවේදී දත්ත සොයමින්

විසඳුම: 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>

ලිවීමේදී සැලකිල්ලට ගත යුතු සූක්ෂ්මතා කිහිපයක් ඇති චෙක්මාක්ස් සඳහා රීතියක්:

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

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

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

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

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

අභියෝගය: XML හි තොරතුරු සොයා ගැනීම

විසඳුම: Checkmarx XML සමඟ වැඩ කිරීමට සහ අගයන්, ටැග්, ගුණාංග සහ තවත් දේ සෙවීම සඳහා ඉතා පහසු කාර්යයන් ඇත. එහෙත්, අවාසනාවකට, ලේඛනගත කිරීමේදී දෝෂයක් ඇති වූ අතර, ඒ නිසා එක උදාහරණයක්වත් ක්රියා නොකරයි. ලේඛනයේ නවතම අනුවාදයේ මෙම දෝෂය ඉවත් කර ඇති බවක් තිබියදීත්, ඔබ ලේඛනවල පෙර අනුවාද භාවිතා කරන්නේ නම් ප්‍රවේශම් වන්න.

මෙන්න ලේඛනයෙන් වැරදි උදාහරණයක්:

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

ක්රියාත්මක කිරීමේ උත්සාහයේ ප්රතිඵලයක් ලෙස, අපට දෝෂයක් ලැබෙනු ඇත All එවැනි ක්රමයක් නොමැත ... XML සමඟ වැඩ කිරීම සඳහා ශ්රිතයන් භාවිතා කිරීම සඳහා විශේෂ, වෙනම වස්තු අවකාශයක් ඇති බැවින් මෙය සත්යයකි - cxXPath. ඇන්ඩ්‍රොයිඩ් හි HTTP ගමනාගමනය භාවිතා කිරීමට ඉඩ සලසන සැකසුම සොයා ගැනීමට නිවැරදි විමසුම පෙනෙන්නේ මෙයයි:

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

අපි එය තව ටිකක් විස්තරාත්මකව බලමු, සියලුම කාර්යයන් සඳහා වාක්‍ය ඛණ්ඩය සමාන බැවින්, ඔබ එකක් හදුනාගත් පසු, ඔබට අවශ්‍ය එකක් තෝරා ගැනීමට අවශ්‍ය වේ. එබැවින්, පරාමිතීන් අනුව අනුපිළිවෙලින්:

  • "*.xml"- සෙවිය යුතු ගොනු ආවරණය

  • 8 - රීතිය යෙදෙන භාෂාවේ id

  • "cleartextTrafficPermitted"- xml හි ගුණාංග නාමය

  • "true" - මෙම ගුණාංගයේ වටිනාකම

  • false - සෙවීමේදී නිත්‍ය ප්‍රකාශන භාවිතය

  • true — එයින් අදහස් වන්නේ නඩුව නොසලකා හරිමින් සෙවීම සිදු කරනු ඇති බවයි, එනම්, සිද්ධි සංවේදී නොවන

උදාහරණයක් ලෙස, අපි ආරක්ෂිත දෘෂ්ටි කෝණයකින් වැරදි ලෙස හඳුනා ගන්නා රීතියක් භාවිතා කළෙමු, HTTP ප්‍රොටෝකෝලය හරහා සේවාදායකය සමඟ සන්නිවේදනය කිරීමට ඉඩ දෙන Android හි ජාල සම්බන්ධතා සැකසුම්. උපලක්ෂණයක් අඩංගු සැකසුමක උදාහරණය 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'
  ...
}

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

මෙම ප්‍රවේශය ඇන්ඩ්‍රොයිඩ් යෙදුම් සඳහා පමණක් නොව, ප්‍රති result ලය නිශ්චිත ගොනුවකට අයත් දැයි තීරණය කිරීමට අවශ්‍ය වූ විට වෙනත් අවස්ථා සඳහාද විශ්වීය හා ප්‍රයෝජනවත් විය හැකිය.

අභියෝගය: සින්ටැක්ස් සම්පුර්ණයෙන් සහය නොදක්වන්නේ නම් තෙවන පාර්ශවීය පුස්තකාලයක් සඳහා සහය එක් කරන්න

විසඳුම: කේතය ලිවීමේ ක්‍රියාවලියේදී භාවිතා කරන විවිධ රාමු ගණන ප්‍රස්ථාරයෙන් බැහැර ය. ඇත්ත වශයෙන්ම, චෙක්මාර්ක්ස් ඔවුන්ගේ පැවැත්ම ගැන සෑම විටම නොදන්නා අතර, අපගේ කර්තව්යය වන්නේ ඇතැම් ක්රම මෙම රාමුවට විශේෂයෙන් අයත් වන බව තේරුම් ගැනීමට එය ඉගැන්වීමයි. රාමු ඉතා සුලභ වන ශ්‍රිත නාම භාවිතා කිරීම සහ නිශ්චිත පුස්තකාලයකට විශේෂිත ඇමතුමක සම්බන්ධතාවය නිසැකව තීරණය කළ නොහැකි වීම නිසා සමහර විට මෙය සංකීර්ණ වේ.

දුෂ්කරතාවය වන්නේ එවැනි පුස්තකාලවල වාක්‍ය ඛණ්ඩය සෑම විටම නිවැරදිව හඳුනා නොගැනීම සහ ව්‍යාජ ධනාත්මක විශාල සංඛ්‍යාවක් ලබා නොගැනීම සඳහා ඔබ අත්හදා බැලීම් කළ යුතු බවයි. ස්කෑන් කිරීමේ නිරවද්‍යතාවය වැඩි දියුණු කිරීමට සහ ගැටළුව විසඳීමට විකල්ප කිහිපයක් තිබේ:

  • පළමු විකල්පය, පුස්තකාලය නිශ්චිත ව්‍යාපෘතියක භාවිතා කරන බවත් කණ්ඩායම් මට්ටමින් රීතිය යෙදිය හැකි බවත් අපි නිසැකවම දනිමු. නමුත් කණ්ඩායම වෙනස් ප්‍රවේශයක් ගැනීමට තීරණය කරන්නේ නම් හෝ ශ්‍රිත නාමයන් අතිච්ඡාදනය වන පුස්තකාල කිහිපයක් භාවිතා කරන්නේ නම්, අපට අසත්‍ය ධනාත්මක බොහෝ දේ පිළිබඳ එතරම් ප්‍රසන්න චිත්‍රයක් ලබා ගත හැකිය.

  • දෙවන විකල්පය වන්නේ පුස්තකාලය පැහැදිලිව ආනයනය කර ඇති ගොනු සෙවීමයි. මෙම ප්‍රවේශය සමඟ, අපට අවශ්‍ය පුස්තකාලය මෙම ගොනුවේ හරියටම භාවිතා කර ඇති බවට අපට සහතික විය හැකිය.

  • තුන්වන විකල්පය වන්නේ ඉහත ප්‍රවේශ දෙක එකට භාවිතා කිරීමයි.

උදාහරණයක් ලෙස, පටු කවයන් තුළ හොඳින් දන්නා පුස්තකාලයක් දෙස බලමු සිනිඳුයි Scala ක්‍රමලේඛන භාෂාව සඳහා, එනම්, ක්‍රියාකාරීත්වය වාක්‍ය අගයන් බෙදීම. සාමාන්යයෙන්, SQL විමසුමකට පරාමිති යැවීමට, ඔබ ක්රියාකරු භාවිතා කළ යුතුය $, පෙර සැකසූ SQL විමසුමකට දත්ත ආදේශ කරයි. එනම්, ඇත්ත වශයෙන්ම, එය ජාවා හි සූදානම් කළ ප්‍රකාශයේ සෘජු ප්‍රතිසමයකි. නමුත්, ඔබට SQL විමසුමක් ගතිකව ගොඩ නැගීමට අවශ්‍ය නම්, උදාහරණයක් ලෙස, ඔබට වගු නම් සම්මත කිරීමට අවශ්‍ය නම්, ඔබට ක්‍රියාකරු භාවිතා කළ හැක. #$, එය සෘජුවම දත්ත විමසුමට ආදේශ කරනු ඇත (ආසන්න වශයෙන් තන්තු සම්බන්ධ කිරීම වැනි).

උදාහරණ කේතය:

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

Splicing Literal Values ​​සහ skips operators භාවිතය හඳුනා ගන්නේ කෙසේදැයි Checkmarx තවමත් දන්නේ නැත. #$, එබැවින් විභව SQL එන්නත් හඳුනා ගැනීමට සහ කේතයේ නිවැරදි ස්ථාන ඉස්මතු කිරීමට එය ඉගැන්වීමට උත්සාහ කරමු:

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

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

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

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

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

අභියෝගය: විවෘත-මූලාශ්‍ර පුස්තකාලවල භාවිතා කළ හැකි අවදානම් කාර්යයන් සඳහා සොයන්න

විසඳුම: සංවර්ධිත යෙදුම්වල පුස්තකාලවල අවදානමට ලක්විය හැකි අනුවාද භාවිතය හඳුනා ගැනීමට බොහෝ සමාගම් විවෘත මූලාශ්‍ර නිරීක්ෂණ මෙවලම් (OSA ප්‍රායෝගිකව) භාවිතා කරයි. සමහර විට එවැනි පුස්තකාලයක් ආරක්ෂිත අනුවාදයකට යාවත්කාලීන කළ නොහැක. සමහර අවස්ථාවලදී ක්රියාකාරී සීමාවන් ඇත, අනෙක් ඒවා කිසිසේත් ආරක්ෂිත අනුවාදයක් නොමැත. මෙම අවස්ථාවෙහිදී, SAST සහ OSA පරිචයන් වල සංකලනයක් මගින් අවදානම් සූරාකෑමට තුඩු දෙන කාර්යයන් කේතයේ භාවිතා නොවන බව තීරණය කිරීමට උපකාරී වේ.

නමුත් සමහර විට, විශේෂයෙන්ම JavaScript සලකා බැලීමේදී, මෙය සම්පූර්ණයෙන්ම සුළු කාර්යයක් නොවිය හැකිය. පහත දැක්වෙන්නේ සංරචකයේ ඇති දුර්වලතා පිළිබඳ උදාහරණය භාවිතා කරමින් සමහර විට පරමාදර්ශී නොවන නමුත් කෙසේ වෙතත් ක්‍රියාත්මක වන විසඳුමකි lodash ක්රම තුළ template и *set.

JS ගොනුවක අවදානමට ලක්විය හැකි කේත පරීක්ෂා කිරීමේ උදාහරණ:

/**
 * Template example
 */

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


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

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

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

සහ html වෙත කෙලින්ම සම්බන්ධ වන විට:

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

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

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

අපි අවදානම් ලෙස ලැයිස්තුගත කර ඇති අපගේ සියලුම අවදානම් ක්‍රම සොයමින් සිටිමු:

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

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


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

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

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

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

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

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

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

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

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

අභියෝගය: යෙදුම තුළ අන්තර්ගත සහතික සඳහා සෙවීම

විසඳුම: යෙදුම්, විශේෂයෙන්ම ජංගම ඒවා, විවිධ සේවාදායක වෙත ප්‍රවේශ වීමට හෝ SSL-Pinning සත්‍යාපනය කිරීමට සහතික හෝ යතුරු භාවිතා කිරීම සාමාන්‍ය දෙයක් නොවේ. ආරක්ෂක දෘෂ්ටිකෝණයකින්, එවැනි දේවල් කේතය තුළ ගබඩා කිරීම හොඳම භාවිතය නොවේ. ගබඩාවේ සමාන ගොනු සොයන රීතියක් ලිවීමට උත්සාහ කරමු:

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

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

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

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

අභියෝගය: යෙදුමේ අවදානමට ලක් වූ ටෝකන සොයා ගැනීම

විසඳුම: කේතයේ ඇති සම්මුති ටෝකන හෝ වෙනත් වැදගත් තොරතුරු අවලංගු කිරීම බොහෝ විට අවශ්ය වේ. ඇත්ත වශයෙන්ම, ඒවා මූල කේතය තුළ ගබඩා කිරීම හොඳ අදහසක් නොවේ, නමුත් තත්වයන් වෙනස් වේ. CxQL විමසුම් වලට ස්තූතියි, මෙවැනි දේවල් සොයා ගැනීම ඉතා පහසු ය:

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

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

නිගමනය

චෙක්මාක්ස් මෙවලම සමඟ දැන හඳුනා ගැනීම ආරම්භ කරන අයට මෙම ලිපිය ප්‍රයෝජනවත් වනු ඇතැයි මම බලාපොරොත්තු වෙමි. සමහර විට දිගු කලක් තිස්සේ තමන්ගේම නීති ලියා ඇති අය ද මෙම මාර්ගෝපදේශයෙහි ප්රයෝජනවත් යමක් සොයා ගනු ඇත.

අවාසනාවකට, චෙක්මාක්ස් සඳහා නීති සකස් කිරීමේදී නව අදහස් උකහා ගත හැකි සම්පතක හිඟයක් දැනට පවතී. ඒකයි අපි නිර්මාණය කළේ Github මත ගබඩාව, CxQL භාවිතා කරන සෑම කෙනෙකුටම එහි ප්‍රයෝජනවත් දෙයක් සොයා ගැනීමට හැකි වන පරිදි අපි අපගේ වැඩ පළ කරන තැන, සහ ඔවුන්ගේ වැඩ ප්‍රජාව සමඟ බෙදා ගැනීමට ද අවස්ථාව ලැබේ. ගබඩාව අන්තර්ගතය පිරවීම සහ ව්‍යුහගත කිරීමේ ක්‍රියාවලියක පවතී, එබැවින් දායකයින් සාදරයෙන් පිළිගනිමු!

Спасибо!

මූලාශ්රය: www.habr.com

අදහස් එක් කරන්න