ഭ്രാന്ത് പിടിക്കാതെ ചെക്ക്മാർക്സിനായി എങ്ങനെ നിയമങ്ങൾ എഴുതാം

ഹേ ഹബർ!

ഞങ്ങളുടെ ജോലിയിൽ, ഞങ്ങളുടെ കമ്പനി പലപ്പോഴും വിവിധ സ്റ്റാറ്റിക് കോഡ് വിശകലന ടൂളുകൾ (SAST) കൈകാര്യം ചെയ്യുന്നു. ബോക്‌സിന് പുറത്ത് അവയെല്ലാം ശരാശരി പ്രവർത്തിക്കുന്നു. തീർച്ചയായും, ഇതെല്ലാം പ്രോജക്റ്റിനെയും അതിൽ ഉപയോഗിക്കുന്ന സാങ്കേതികവിദ്യകളെയും ആശ്രയിച്ചിരിക്കുന്നു, അതുപോലെ തന്നെ ഈ സാങ്കേതികവിദ്യകൾ വിശകലന നിയമങ്ങൾ എത്രത്തോളം ഉൾക്കൊള്ളുന്നു എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. എന്റെ അഭിപ്രായത്തിൽ, ഒരു SAST ടൂൾ തിരഞ്ഞെടുക്കുമ്പോൾ ഏറ്റവും പ്രധാനപ്പെട്ട ഒരു മാനദണ്ഡം നിങ്ങളുടെ ആപ്ലിക്കേഷനുകളുടെ പ്രത്യേകതകളിലേക്ക് അത് ഇച്ഛാനുസൃതമാക്കാനുള്ള കഴിവാണ്, അതായത്, വിശകലന നിയമങ്ങൾ എഴുതുകയും മാറ്റുകയും ചെയ്യുക അല്ലെങ്കിൽ, അവ പലപ്പോഴും വിളിക്കപ്പെടുന്നതുപോലെ, ഇഷ്‌ടാനുസൃത അന്വേഷണങ്ങൾ.

ഞങ്ങൾ മിക്കപ്പോഴും ചെക്ക്മാർക്സ് ഉപയോഗിക്കുന്നു - വളരെ രസകരവും ശക്തവുമായ കോഡ് അനലൈസർ. ഈ ലേഖനത്തിൽ ഞാൻ അതിനായി വിശകലന നിയമങ്ങൾ എഴുതിയതിന്റെ അനുഭവത്തെക്കുറിച്ച് സംസാരിക്കും.

ഉള്ളടക്ക പട്ടിക

• എൻട്രി

• നിയമങ്ങളെക്കുറിച്ചുള്ള പൊതുവായ വിവരങ്ങൾ

• തുടക്കക്കാർക്കുള്ള "നിഘണ്ടു"

  • ലിസ്റ്റുകളുള്ള പ്രവർത്തനങ്ങൾ

  • കണ്ടെത്തിയ എല്ലാ വസ്തുക്കളും

  • ഫ്ലോ വിശകലനത്തിനുള്ള പ്രവർത്തനങ്ങൾ

  • ഫയലിന്റെ പേര്/പാത്ത് ലഭിക്കുന്നു

  • നിർവ്വഹണ ഫലം

  • മറ്റ് നിയമങ്ങളുടെ ഫലങ്ങൾ ഉപയോഗിക്കുന്നു

• പ്രശ്‌നം പരിഹരിക്കുന്നു

  • ലോഗിംഗ്

  • ലോഗിൻ പ്രശ്നം

• എഴുത്ത് നിയമങ്ങൾ

• തീരുമാനം

എൻട്രി

ആരംഭിക്കുന്നതിന്, ചെക്ക്മാർക്‌സിനായി ചോദ്യങ്ങൾ എഴുതുന്നതിന്റെ സവിശേഷതകളെക്കുറിച്ചുള്ള റഷ്യൻ ഭാഷയിലുള്ള കുറച്ച് ലേഖനങ്ങളിൽ ഒന്ന് ശുപാർശ ചെയ്യാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഇത് 2019 അവസാനം ഹബ്രെ എന്ന പേരിൽ പ്രസിദ്ധീകരിച്ചു: "ഹലോ, ചെക്ക്മാർക്സ്!" ഒരു ചെക്ക്മാർക്‌സ് SAST അന്വേഷണം എങ്ങനെ എഴുതാം, കൂടാതെ രസകരമായ കേടുപാടുകൾ കണ്ടെത്താം.

ചില ടെസ്റ്റ് ആപ്ലിക്കേഷനുകൾക്കായി CxQL-ൽ (Checkmarx Query Language) ആദ്യ ചോദ്യങ്ങൾ എങ്ങനെ എഴുതാമെന്ന് ഇത് വിശദമായി പരിശോധിക്കുന്നു, കൂടാതെ വിശകലന നിയമങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ അടിസ്ഥാന തത്വങ്ങൾ കാണിക്കുന്നു.

അതിൽ വിവരിച്ചിരിക്കുന്നത് ഞാൻ ആവർത്തിക്കില്ല, എന്നിരുന്നാലും ചില കവലകൾ ഇപ്പോഴും ഉണ്ടായിരിക്കും. എന്റെ ലേഖനത്തിൽ, ചെക്ക്മാർക്സുമായുള്ള എന്റെ ജോലിയിൽ ഞാൻ നേരിട്ട നിർദ്ദിഷ്ട പ്രശ്നങ്ങൾക്കുള്ള പരിഹാരങ്ങളുടെ ഒരു ലിസ്റ്റ് "പാചകങ്ങളുടെ ശേഖരം" സമാഹരിക്കാൻ ഞാൻ ശ്രമിക്കും. ഈ പ്രശ്‌നങ്ങളിൽ പലതിലും എനിക്ക് എന്റെ മസ്തിഷ്കത്തെ ചലിപ്പിക്കേണ്ടിവന്നു. ചിലപ്പോൾ ഡോക്യുമെന്റേഷനിൽ മതിയായ വിവരങ്ങൾ ഇല്ലായിരുന്നു, ചിലപ്പോൾ ആവശ്യമുള്ളത് എങ്ങനെ ചെയ്യണമെന്ന് മനസിലാക്കാൻ പോലും ബുദ്ധിമുട്ടായിരുന്നു. എന്റെ അനുഭവവും ഉറക്കമില്ലാത്ത രാത്രികളും വെറുതെയാകില്ലെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു, കൂടാതെ ഈ "ഇഷ്‌ടാനുസൃത അന്വേഷണ പാചകക്കുറിപ്പുകളുടെ ശേഖരം" നിങ്ങളെ കുറച്ച് മണിക്കൂറുകളോ അല്ലെങ്കിൽ കുറച്ച് നാഡീകോശങ്ങളോ സംരക്ഷിക്കും. അതിനാൽ, നമുക്ക് ആരംഭിക്കാം!

നിയമങ്ങളെക്കുറിച്ചുള്ള പൊതുവായ വിവരങ്ങൾ

ആദ്യം, അടുത്തതായി എന്ത് സംഭവിക്കും എന്നതിനെക്കുറിച്ചുള്ള മികച്ച ധാരണയ്ക്കായി, കുറച്ച് അടിസ്ഥാന ആശയങ്ങളും നിയമങ്ങളുമായി പ്രവർത്തിക്കുന്ന പ്രക്രിയയും നോക്കാം. ഡോക്യുമെന്റേഷൻ ഇതിനെക്കുറിച്ച് ഒന്നും പറയുന്നില്ല അല്ലെങ്കിൽ ഘടനയിൽ വളരെ വ്യാപിച്ചിരിക്കുന്നതിനാൽ, അത് വളരെ സൗകര്യപ്രദമല്ല.

1. തുടക്കത്തിൽ തിരഞ്ഞെടുത്ത പ്രീസെറ്റ് (ഒരു കൂട്ടം സജീവ നിയമങ്ങൾ) അനുസരിച്ച് സ്കാനിംഗ് സമയത്ത് നിയമങ്ങൾ പ്രയോഗിക്കുന്നു. നിങ്ങൾക്ക് പരിധിയില്ലാത്ത പ്രീസെറ്റുകൾ സൃഷ്ടിക്കാൻ കഴിയും, അവ എങ്ങനെ രൂപപ്പെടുത്തണം എന്നത് നിങ്ങളുടെ പ്രക്രിയയുടെ പ്രത്യേകതകളെ ആശ്രയിച്ചിരിക്കുന്നു. നിങ്ങൾക്ക് അവയെ ഭാഷ അനുസരിച്ച് ഗ്രൂപ്പുചെയ്യാം അല്ലെങ്കിൽ ഓരോ പ്രോജക്റ്റിനും പ്രീസെറ്റുകൾ തിരഞ്ഞെടുക്കാം. സജീവമായ നിയമങ്ങളുടെ എണ്ണം സ്കാനിംഗിന്റെ വേഗതയെയും കൃത്യതയെയും ബാധിക്കുന്നു.

   ചെക്ക്മാർക്സ് ഇന്റർഫേസിൽ പ്രീസെറ്റ് സജ്ജീകരിക്കുന്നു

2. CxAuditor എന്ന പ്രത്യേക ടൂളിലാണ് നിയമങ്ങൾ എഡിറ്റ് ചെയ്യുന്നത്. ചെക്ക്മാർക്സ് പ്രവർത്തിക്കുന്ന സെർവറിലേക്ക് കണക്ട് ചെയ്യുന്ന ഒരു ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനാണിത്. ഈ ഉപകരണത്തിന് രണ്ട് പ്രവർത്തന രീതികളുണ്ട്: നിയമങ്ങൾ എഡിറ്റുചെയ്യലും ഇതിനകം നടത്തിയ സ്കാനിന്റെ ഫലങ്ങൾ വിശകലനം ചെയ്യലും.

   CxAudit ഇന്റർഫേസ്

3. ചെക്ക്മാർക്‌സിലെ നിയമങ്ങൾ ഭാഷയനുസരിച്ച് വിഭജിച്ചിരിക്കുന്നു, അതായത്, ഓരോ ഭാഷയ്ക്കും അതിന്റേതായ ചോദ്യങ്ങളുണ്ട്. ഭാഷ പരിഗണിക്കാതെ പ്രയോഗിക്കുന്ന ചില പൊതു നിയമങ്ങളും ഉണ്ട്, ഇവയാണ് അടിസ്ഥാന ചോദ്യങ്ങൾ എന്ന് വിളിക്കപ്പെടുന്നവ. മിക്കവാറും, അടിസ്ഥാന അന്വേഷണങ്ങളിൽ മറ്റ് നിയമങ്ങൾ ഉപയോഗിക്കുന്ന വിവരങ്ങൾക്കായി തിരയുന്നത് ഉൾപ്പെടുന്നു.

   ഭാഷ അനുസരിച്ച് നിയമങ്ങൾ വിഭജിക്കുന്നു

4. "എക്സിക്യൂട്ടബിൾ", "നോൺ എക്സിക്യൂട്ടബിൾ" (നിർവഹിച്ചതും നടപ്പിലാക്കാത്തതും) എന്നിവയാണ് നിയമങ്ങൾ. തികച്ചും ശരിയായ പേരല്ല, എന്റെ അഭിപ്രായത്തിൽ, പക്ഷേ അതാണ്. "എക്‌സിക്യൂട്ടബിൾ" നിയമങ്ങൾ നടപ്പിലാക്കുന്നതിന്റെ ഫലം യുഐയിലെ സ്‌കാൻ ഫലങ്ങളിൽ പ്രദർശിപ്പിക്കും, മറ്റ് അഭ്യർത്ഥനകളിൽ അവയുടെ ഫലങ്ങൾ ഉപയോഗിക്കുന്നതിന് മാത്രമേ "എക്‌സിക്യൂട്ടബിൾ" നിയമങ്ങൾ ആവശ്യമുള്ളൂ (സാരാംശത്തിൽ, ഒരു പ്രവർത്തനം മാത്രം).

   സൃഷ്ടിക്കുമ്പോൾ റൂൾ തരം നിർണ്ണയിക്കുന്നു

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

ചുമതല: ഉപകരണം പ്രതികരിക്കുന്ന സെൻസിറ്റീവ് ഡാറ്റയുടെ ലിസ്റ്റ് വികസിപ്പിക്കുക

പരിഹാരം: ചെക്ക്മാർക്സിന് അടിസ്ഥാന നിയമങ്ങളുണ്ട്, അതിന്റെ ഫലങ്ങൾ മറ്റ് നിരവധി അന്വേഷണങ്ങൾ ഉപയോഗിക്കുന്നു. ഈ നിയമങ്ങളിൽ ചിലത് നിങ്ങളുടെ ആപ്ലിക്കേഷനുമായി ബന്ധപ്പെട്ട ഡാറ്റയുമായി സപ്ലിമെന്റ് ചെയ്യുന്നതിലൂടെ, നിങ്ങളുടെ സ്കാൻ ഫലങ്ങൾ ഉടനടി മെച്ചപ്പെടുത്താനാകും. നിങ്ങൾ ആരംഭിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണ നിയമം ചുവടെയുണ്ട്:

General_privacy_violation_list

സെൻസിറ്റീവ് വിവരങ്ങൾ സംഭരിക്കുന്നതിന് ഞങ്ങളുടെ ആപ്ലിക്കേഷനിൽ ഉപയോഗിക്കുന്ന നിരവധി വേരിയബിളുകൾ ചേർക്കാം:

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

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

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

ചുമതല: പാസ്‌വേഡുകൾ ഉപയോഗിച്ച് വേരിയബിളുകളുടെ ലിസ്റ്റ് വികസിപ്പിക്കുക

പരിഹാരം: കോഡിലെ പാസ്‌വേഡുകൾ നിർവചിക്കുന്നതിനും നിങ്ങളുടെ കമ്പനിയിൽ സാധാരണയായി ഉപയോഗിക്കുന്ന വേരിയബിൾ പേരുകളുടെ ഒരു ലിസ്റ്റ് ചേർക്കുന്നതിനുമുള്ള അടിസ്ഥാന നിയമം ഉടനടി ശ്രദ്ധിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു.

Password_privacy_violation_list

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

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

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

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

ചുമതല: ചെക്ക്മാർക്സ് പിന്തുണയ്ക്കാത്ത ഉപയോഗിച്ച ചട്ടക്കൂടുകൾ ചേർക്കുക

പരിഹാരം: ചെക്ക്മാർക്സിലെ എല്ലാ ചോദ്യങ്ങളും ഭാഷ അനുസരിച്ച് വിഭജിച്ചിരിക്കുന്നു, അതിനാൽ നിങ്ങൾ ഓരോ ഭാഷയ്ക്കും നിയമങ്ങൾ ചേർക്കേണ്ടതുണ്ട്. അത്തരം നിയമങ്ങളുടെ ചില ഉദാഹരണങ്ങൾ ചുവടെയുണ്ട്.

സാധാരണ പ്രവർത്തനങ്ങളെ പൂരകമാക്കുന്നതോ പകരം വെക്കുന്നതോ ആയ ലൈബ്രറികൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, അവ അടിസ്ഥാന നിയമത്തിലേക്ക് എളുപ്പത്തിൽ ചേർക്കാവുന്നതാണ്. അപ്പോൾ അത് ഉപയോഗിക്കുന്ന എല്ലാവരും ഉടൻ തന്നെ പുതിയ ആമുഖങ്ങളെക്കുറിച്ച് പഠിക്കും. ഉദാഹരണമായി, ആൻഡ്രോയിഡിൽ ലോഗിൻ ചെയ്യുന്നതിനുള്ള ലൈബ്രറികൾ തടിയും ലോഗിയുമാണ്. അടിസ്ഥാന പാക്കേജിൽ, നോൺ-സിസ്റ്റം കോളുകൾ തിരിച്ചറിയുന്നതിനുള്ള നിയമങ്ങളൊന്നുമില്ല, അതിനാൽ ഒരു പാസ്‌വേഡോ സെഷൻ ഐഡന്റിഫയറോ ലോഗിൽ പ്രവേശിച്ചാൽ, അതിനെക്കുറിച്ച് ഞങ്ങൾക്ക് അറിയില്ല. ചെക്ക്മാർക്സ് നിയമങ്ങളിൽ അത്തരം രീതികളുടെ നിർവചനങ്ങൾ ചേർക്കാൻ ശ്രമിക്കാം.

ലോഗിംഗിനായി തടി ലൈബ്രറി ഉപയോഗിക്കുന്ന ടെസ്റ്റ് കോഡ് ഉദാഹരണം:

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

നിങ്ങൾക്ക് അയൽ റൂളിലേക്ക് ചേർക്കാനും കഴിയും, എന്നാൽ ഇത് 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. HTTP ട്രാഫിക്കിന്റെ ഉപയോഗം അനുവദിക്കുന്ന Android-ൽ ഒരു ക്രമീകരണം കണ്ടെത്തുന്നതിനുള്ള ശരിയായ അന്വേഷണം ഇങ്ങനെയാണ്:

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

കുറച്ചുകൂടി വിശദമായി നോക്കാം, എല്ലാ ഫംഗ്‌ഷനുകൾക്കുമുള്ള വാക്യഘടന സമാനമായതിനാൽ, നിങ്ങൾ ഒരെണ്ണം കണ്ടെത്തിക്കഴിഞ്ഞാൽ, നിങ്ങൾക്ക് ആവശ്യമുള്ളത് തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്. അതിനാൽ, പാരാമീറ്ററുകൾ അനുസരിച്ച് തുടർച്ചയായി:

• "*.xml"- തിരയേണ്ട ഫയലുകളുടെ മാസ്ക്

• 8 - നിയമം പ്രയോഗിക്കുന്ന ഭാഷയുടെ ഐഡി

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

ചുമതല: ഫയലിന്റെ പേര്/പാത്ത് പ്രകാരം ഫലങ്ങൾ പരിമിതപ്പെടുത്തുക

പരിഹാരം: Android-നായുള്ള ഒരു മൊബൈൽ ആപ്ലിക്കേഷൻ വികസിപ്പിക്കുന്നതുമായി ബന്ധപ്പെട്ട വലിയ പ്രോജക്റ്റുകളിലൊന്നിൽ, അവ്യക്തത ക്രമീകരണം നിർണ്ണയിക്കുന്ന നിയമത്തിന്റെ തെറ്റായ പോസിറ്റീവുകൾ ഞങ്ങൾ നേരിട്ടു. റൂൾ ഔട്ട് ഓഫ് ദി ബോക്സ് ഫയലിൽ തിരയുന്നു എന്നതാണ് വസ്തുത build.gradle ആപ്ലിക്കേഷന്റെ റിലീസ് പതിപ്പിനായി അവ്യക്തത നിയമങ്ങൾ പ്രയോഗിക്കുന്നതിന് ഉത്തരവാദിത്തമുള്ള ഒരു ക്രമീകരണം.

എന്നാൽ വലിയ പദ്ധതികളിൽ ചിലപ്പോൾ ചൈൽഡ് ഫയലുകൾ ഉണ്ടാകും build.gradle, പദ്ധതിയിൽ ഉൾപ്പെടുത്തിയിട്ടുള്ള ലൈബ്രറികളെ പരാമർശിക്കുന്നു. ഈ ഫയലുകൾ അവ്യക്തമാക്കേണ്ടതിന്റെ ആവശ്യകതയെ സൂചിപ്പിക്കുന്നില്ലെങ്കിലും, സമാഹരിക്കുന്ന സമയത്ത് പാരന്റ് അസംബ്ലി ഫയലിന്റെ ക്രമീകരണങ്ങൾ പ്രയോഗിക്കും എന്നതാണ് പ്രത്യേകത.

അതിനാൽ, ലൈബ്രറികളുടേതായ ചൈൽഡ് ഫയലുകളിലെ ട്രിഗറുകൾ മുറിക്കുക എന്നതാണ് ചുമതല. വരിയുടെ സാന്നിധ്യത്താൽ അവ തിരിച്ചറിയാൻ കഴിയും apply 'com.android.library'.

ഫയലിൽ നിന്നുള്ള ഉദാഹരണ കോഡ് build.gradle, ഇത് അവ്യക്തമാക്കേണ്ടതിന്റെ ആവശ്യകത നിർണ്ണയിക്കുന്നു:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 24
    buildToolsVersion "24.0.2"
    defaultConfig {
        ...
    }

    buildTypes {
        release {
            minifyEnabled true
            ...
        }
    }
}

dependencies {
  ...
}

ഫയൽ ഉദാഹരണം build.gradle ഈ ക്രമീകരണം ഇല്ലാത്ത പ്രോജക്റ്റിൽ ഉൾപ്പെടുത്തിയിട്ടുള്ള ഒരു ലൈബ്രറിക്ക്:

apply plugin: 'android-library'

dependencies {
  compile 'com.android.support:support-v4:18.0.+'
}

android {
  compileSdkVersion 14
  buildToolsVersion '17.0.0'
  ...
}

ചെക്ക്മാർക്സിന്റെ നിയമവും:

ProGuardObfuscationNotInUse

// Поиск метода release среди всех методов в Gradle файлах
CxList releaseMethod = Find_Gradle_Method("release");

// Все объекты из файлов build.gradle
CxList gradleBuildObjects = Find_Gradle_Build_Objects();

// Поиск того, что находится внутри метода "release" среди всех объектов из файлов build.gradle
CxList methodInvokesUnderRelease = gradleBuildObjects.FindByType(typeof(MethodInvokeExpr)).GetByAncs(releaseMethod);

// Ищем внутри gradle-файлов строку "com.android.library" - это значит, что данный файл относится к библиотеке и его необходимо исключить из правила
CxList android_library = gradleBuildObjects.FindByName("com.android.library");

// Инициализация пустого массива
List<string> libraries_path = new List<string> {};

// Проходим через все найденные "дочерние" файлы
foreach(CxList library in android_library)
{
    // Получаем путь к каждому файлу
	string file_name_library = library.GetFirstGraph().LinePragma.FileName;
    
    // Добавляем его в наш массив
	libraries_path.Add(file_name_library);
}

// Ищем все вызовы включения обфускации в релизных настройках
CxList minifyEnabled = methodInvokesUnderRelease.FindByShortName("minifyEnabled");

// Получаем параметры этих вызовов
CxList minifyValue = gradleBuildObjects.GetParameters(minifyEnabled, 0);

// Ищем среди них включенные
CxList minifyValueTrue = minifyValue.FindByShortName("true");

// Немного магии, если не нашли стандартным способом :D
if (minifyValueTrue.Count == 0) {
	minifyValue = minifyValue.FindByAbstractValue(abstractValue => abstractValue is TrueAbstractValue);
} else {
    // А если всё-таки нашли, то предыдущий результат и оставляем
	minifyValue = minifyValueTrue;	
}

// Если не нашлось таких методов
if (minifyValue.Count == 0)
{
    // Для более корректного отображения места срабатывания в файле ищем или buildTypes или android
	CxList tempResult = All.NewCxList();
	CxList buildTypes = Find_Gradle_Method("buildTypes");
	if (buildTypes.Count > 0) {
		tempResult = buildTypes;
	} else {
		tempResult = Find_Gradle_Method("android");
	}
	
	// Для каждого из найденных мест срабатывания проходим и определяем, дочерний или основной файлы сборки
	foreach(CxList res in tempResult)
	{
        // Определяем, в каком файле был найден buildType или android методы
		string file_name_result = res.GetFirstGraph().LinePragma.FileName;
        
        // Если такого файла нет в нашем списке "дочерних" файлов - значит это основной файл и его можно добавить в результат
		if (libraries_path.Contains(file_name_result) == false){
			result.Add(res);
		}
	}
}

ഈ സമീപനം തികച്ചും സാർവത്രികവും Android ആപ്ലിക്കേഷനുകൾക്ക് മാത്രമല്ല, ഒരു പ്രത്യേക ഫയലിന്റെ ഫലമാണോ എന്ന് നിങ്ങൾ നിർണ്ണയിക്കേണ്ട മറ്റ് സന്ദർഭങ്ങളിലും ഉപയോഗപ്രദമാകും.

ചുമതല: വാക്യഘടന പൂർണ്ണമായി പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ ഒരു മൂന്നാം കക്ഷി ലൈബ്രറിക്ക് പിന്തുണ ചേർക്കുക

പരിഹാരം: കോഡ് എഴുതുന്ന പ്രക്രിയയിൽ ഉപയോഗിക്കുന്ന വിവിധ ചട്ടക്കൂടുകളുടെ എണ്ണം ചാർട്ടുകൾക്ക് പുറത്താണ്. തീർച്ചയായും, ചെക്ക്മാർക്സിന് അവരുടെ അസ്തിത്വത്തെക്കുറിച്ച് എല്ലായ്പ്പോഴും അറിയില്ല, ചില രീതികൾ ഈ ചട്ടക്കൂടിൽ പ്രത്യേകമായി ഉൾപ്പെട്ടതാണെന്ന് മനസ്സിലാക്കാൻ അതിനെ പഠിപ്പിക്കുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല. ചട്ടക്കൂടുകൾ വളരെ സാധാരണമായ ഫംഗ്‌ഷൻ പേരുകൾ ഉപയോഗിക്കുന്നതും ഒരു പ്രത്യേക ലൈബ്രറിയിലേക്കുള്ള ഒരു പ്രത്യേക കോളിന്റെ ബന്ധം അവ്യക്തമായി നിർണ്ണയിക്കാൻ കഴിയാത്തതും ചിലപ്പോൾ ഇത് സങ്കീർണ്ണമാക്കുന്നു.

അത്തരം ലൈബ്രറികളുടെ വാക്യഘടന എല്ലായ്പ്പോഴും ശരിയായി തിരിച്ചറിയപ്പെടുന്നില്ല എന്നതാണ് ബുദ്ധിമുട്ട്, കൂടാതെ ധാരാളം തെറ്റായ പോസിറ്റീവുകൾ ലഭിക്കാതിരിക്കാൻ നിങ്ങൾ പരീക്ഷണം നടത്തേണ്ടതുണ്ട്. സ്കാനിംഗ് കൃത്യത മെച്ചപ്പെടുത്തുന്നതിനും പ്രശ്നം പരിഹരിക്കുന്നതിനും നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്:

• ആദ്യ ഓപ്ഷൻ, ലൈബ്രറി ഒരു നിർദ്ദിഷ്‌ട പ്രോജക്‌റ്റിൽ ഉപയോഗിക്കുന്നുണ്ടെന്നും ടീം തലത്തിൽ നിയമം പ്രയോഗിക്കാമെന്നും ഞങ്ങൾക്ക് ഉറപ്പായും അറിയാം. എന്നാൽ ടീം മറ്റൊരു സമീപനം സ്വീകരിക്കാൻ തീരുമാനിക്കുകയോ ഫംഗ്‌ഷൻ പേരുകൾ ഓവർലാപ്പ് ചെയ്യുന്ന നിരവധി ലൈബ്രറികൾ ഉപയോഗിക്കുകയോ ചെയ്‌താൽ, നിരവധി തെറ്റായ പോസിറ്റീവുകളുടെ വളരെ മനോഹരമല്ലാത്ത ചിത്രം നമുക്ക് ലഭിക്കും.

• ലൈബ്രറി വ്യക്തമായി ഇറക്കുമതി ചെയ്ത ഫയലുകൾക്കായി തിരയുക എന്നതാണ് രണ്ടാമത്തെ ഓപ്ഷൻ. ഈ സമീപനത്തിലൂടെ, നമുക്ക് ആവശ്യമുള്ള ലൈബ്രറി ഈ ഫയലിൽ കൃത്യമായി ഉപയോഗിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പിക്കാം.

• മുകളിലുള്ള രണ്ട് സമീപനങ്ങളും ഒരുമിച്ച് ഉപയോഗിക്കുക എന്നതാണ് മൂന്നാമത്തെ ഓപ്ഷൻ.

ഒരു ഉദാഹരണമായി, ഇടുങ്ങിയ സർക്കിളുകളിൽ അറിയപ്പെടുന്ന ഒരു ലൈബ്രറി നോക്കാം സ്ലിക്ക് സ്കാല പ്രോഗ്രാമിംഗ് ഭാഷയ്ക്ക്, അതായത്, പ്രവർത്തനക്ഷമത ലിറ്ററൽ മൂല്യങ്ങൾ വിഭജിക്കുന്നു. പൊതുവേ, ഒരു SQL അന്വേഷണത്തിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറാൻ, നിങ്ങൾ ഓപ്പറേറ്റർ ഉപയോഗിക്കണം $, ഇത് മുൻകൂട്ടി തയ്യാറാക്കിയ SQL അന്വേഷണത്തിലേക്ക് ഡാറ്റയെ മാറ്റിസ്ഥാപിക്കുന്നു. അതായത്, വാസ്തവത്തിൽ, ഇത് ജാവയിൽ തയ്യാറാക്കിയ പ്രസ്താവനയുടെ നേരിട്ടുള്ള അനലോഗ് ആണ്. പക്ഷേ, നിങ്ങൾക്ക് ചലനാത്മകമായി ഒരു 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