ઉન્મત્ત થયા વિના ચેકમાર્ક્સ માટે નિયમો કેવી રીતે લખવા

હે હબર!

અમારા કાર્યમાં, અમારી કંપની ઘણી વાર વિવિધ સ્ટેટિક કોડ એનાલિસિસ ટૂલ્સ (SAST) સાથે વ્યવહાર કરે છે. બૉક્સની બહાર તેઓ બધા સરેરાશ કામ કરે છે. અલબત્ત, તે બધું પ્રોજેક્ટ અને તેમાં વપરાતી તકનીકો તેમજ વિશ્લેષણના નિયમો દ્વારા આ તકનીકીઓ કેટલી સારી રીતે આવરી લેવામાં આવે છે તેના પર આધાર રાખે છે. મારા મતે, SAST ટૂલ પસંદ કરતી વખતે સૌથી મહત્વપૂર્ણ માપદંડો પૈકી એક છે તેને તમારી એપ્લિકેશનની વિશિષ્ટતાઓ અનુસાર કસ્ટમાઇઝ કરવાની ક્ષમતા, એટલે કે, વિશ્લેષણના નિયમો લખવા અને બદલવા અથવા, જેમને વધુ વખત કસ્ટમ ક્વેરીઝ કહેવામાં આવે છે.

અમે મોટેભાગે ચેકમાર્ક્સનો ઉપયોગ કરીએ છીએ - એક ખૂબ જ રસપ્રદ અને શક્તિશાળી કોડ વિશ્લેષક. આ લેખમાં હું તેના માટે વિશ્લેષણ નિયમો લખવાના મારા અનુભવ વિશે વાત કરીશ.

સમાવિષ્ટોનું કોષ્ટક

• પરિચય

• નિયમો પર સામાન્ય માહિતી

• નવા નિશાળીયા માટે "શબ્દકોષ".

  • યાદીઓ સાથે કામગીરી

  • બધી વસ્તુઓ મળી

  • પ્રવાહ વિશ્લેષણ માટે કાર્યો

  • ફાઇલનું નામ/પાથ મેળવી રહ્યાં છીએ

  • એક્ઝેક્યુશન પરિણામ

  • અન્ય નિયમોના પરિણામોનો ઉપયોગ કરીને

• સમસ્યાઓનું નિરાકરણ

  • લોગીંગ

  • લૉગિન સમસ્યા

• લેખન નિયમો

• નિષ્કર્ષ

પરિચય

શરૂઆતમાં, હું ચેકમાર્ક્સ માટે પ્રશ્નો લખવાની વિશેષતાઓ વિશે રશિયનમાં થોડા લેખોમાંથી એકની ભલામણ કરવા માંગુ છું. તે શીર્ષક હેઠળ 2019 ના અંતમાં હેબ્રે પર પ્રકાશિત થયું હતું: "હેલો, ચેકમાર્ક્સ!" ચેકમાર્ક્સ 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");

પરંતુ, જો તમારે બીજી ભાષામાં શોધવાની જરૂર હોય કે જે કોઈ કારણસર સ્કેન (ઉદાહરણ તરીકે, એન્ડ્રોઇડ પ્રોજેક્ટમાં ગ્રુવી) શામેલ ન હોય, તો તમે વેરીએબલ દ્વારા અમારી ઑબ્જેક્ટ સ્પેસને વિસ્તૃત કરી શકો છો:

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

એક કાર્ય: પાસવર્ડ્સ સાથે ચલોની સૂચિ વિસ્તૃત કરો

ઉકેલ: હું કોડમાં પાસવર્ડને વ્યાખ્યાયિત કરવા માટેના મૂળભૂત નિયમ પર તરત જ ધ્યાન આપવાની અને તમારી કંપનીમાં સામાન્ય રીતે ઉપયોગમાં લેવાતા ચલ નામોની સૂચિ ઉમેરવાની ભલામણ કરીશ.

Password_privacy_violation_list

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

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

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

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

એક કાર્ય: વપરાયેલ ફ્રેમવર્ક ઉમેરો કે જે ચેકમાર્ક્સ દ્વારા સમર્થિત નથી

ઉકેલ: ચેકમાર્ક્સમાં તમામ પ્રશ્નો ભાષા દ્વારા વિભાજિત કરવામાં આવે છે, તેથી તમારે દરેક ભાષા માટે નિયમો ઉમેરવાની જરૂર છે. નીચે આવા નિયમોના કેટલાક ઉદાહરણો છે.

જો લાઇબ્રેરીઓનો ઉપયોગ પ્રમાણભૂત કાર્યક્ષમતાને પૂરક અથવા બદલતો હોય, તો તે સરળતાથી મૂળભૂત નિયમમાં ઉમેરી શકાય છે. પછી દરેક વ્યક્તિ જે તેનો ઉપયોગ કરે છે તે તરત જ નવા પરિચય વિશે શીખી જશે. ઉદાહરણ તરીકે, એન્ડ્રોઇડમાં લોગીંગ કરવા માટેની લાઇબ્રેરીઓ ટિમ્બર અને લોગી છે. મૂળભૂત પેકેજમાં, બિન-સિસ્ટમ કૉલ્સને ઓળખવા માટે કોઈ નિયમો નથી, તેથી જો કોઈ પાસવર્ડ અથવા સત્ર ઓળખકર્તા લોગમાં આવે છે, તો અમને તેના વિશે જાણ થશે નહીં. ચાલો ચેકમાર્ક્સના નિયમોમાં આવી પદ્ધતિઓની વ્યાખ્યા ઉમેરવાનો પ્રયાસ કરીએ.

ટેસ્ટ કોડ ઉદાહરણ કે જે લોગીંગ માટે ટિમ્બર લાઇબ્રેરીનો ઉપયોગ કરે છે:

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 માં લોગીંગ સાથે છે:

FindAndroidLog_Outputs

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

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

ઉપરાંત, જો એન્ડ્રોઇડ એપ્લિકેશનનો ઉપયોગ થાય છે વર્ક મેનેજર અસુમેળ કાર્ય માટે, કાર્યમાંથી ડેટા મેળવવા માટેની પદ્ધતિ ઉમેરીને આ વિશે ચેકમાર્ક્સને વધુમાં જાણ કરવી એ સારો વિચાર છે. getInputData:

FindAndroidRead

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

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

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

એક કાર્ય: iOS પ્રોજેક્ટ્સ માટે plist માં સંવેદનશીલ ડેટા શોધી રહ્યાં છીએ

ઉકેલ: iOS ઘણીવાર વિવિધ વેરિયેબલ્સ અને મૂલ્યોને સ્ટોર કરવા માટે .plist એક્સ્ટેંશન સાથે ખાસ ફાઇલોનો ઉપયોગ કરે છે. આ ફાઇલોમાં પાસવર્ડ્સ, ટોકન્સ, કીઝ અને અન્ય સંવેદનશીલ ડેટા સ્ટોર કરવાની ભલામણ કરવામાં આવતી નથી, કારણ કે તે કોઈપણ સમસ્યા વિના ઉપકરણમાંથી કાઢી શકાય છે.

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 માં સેટિંગ શોધવા માટે આ યોગ્ય ક્વેરી જેવો દેખાય છે જે HTTP ટ્રાફિકનો ઉપયોગ કરવાની મંજૂરી આપે છે:

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

ચાલો તેને થોડી વધુ વિગતમાં જોઈએ, કારણ કે તમામ કાર્યો માટેનું વાક્યરચના સમાન છે, તમે એક શોધી કાઢ્યા પછી, તમારે ફક્ત તમને જોઈતી એક પસંદ કરવાની જરૂર છે. તેથી, ક્રમશઃ પરિમાણો અનુસાર:

• "*.xml"- શોધવા માટેની ફાઇલોનો માસ્ક

• 8 — જે ભાષા માટે નિયમ લાગુ કરવામાં આવ્યો છે તેનું id

• "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>

એક કાર્ય: ફાઇલ નામ/પાથ દ્વારા પરિણામોને મર્યાદિત કરો

ઉકેલ: એન્ડ્રોઇડ માટે મોબાઇલ એપ્લિકેશનના વિકાસથી સંબંધિત મોટા પ્રોજેક્ટ્સમાંના એકમાં, અમને નિયમોના ખોટા હકારાત્મકતા મળ્યા છે જે અસ્પષ્ટતા સેટિંગને નિર્ધારિત કરે છે. હકીકત એ છે કે નિયમ આઉટ ઓફ બોક્સ ફાઇલમાં શોધે છે 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 ક્વેરી માં ડેટાને બદલે છે. એટલે કે, હકીકતમાં, તે જાવામાં તૈયાર નિવેદનનું સીધું એનાલોગ છે. પરંતુ, જો તમારે ગતિશીલ રીતે 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