🥇Quomodo scribere praecepta pro Checkmarx sine insanis

Heus Habr!

In nostro opere, societas nostra saepissime de variis instrumentorum staticorum codice analysis (SAST). Ex arca omnia operantur mediocris. Totum sane pendet a propositis ac technologiae in eo adhibitis, tum quemadmodum hae technologiae analyseos regulas obumbrant. In sententia mea, unum ex maximis indiciis, cum SAST instrumentum eligendo facultas est ut mos eam in specialibus applicationibus tuis, scilicet analysin scribere et mutare regulas vel, ut frequentius vocantur, Custom Queries.

Plerumque Checkmarx utimur - codice analyser valde interesting et potens. In hoc articulo loquar de experientia mea scribendae analyseos regulas pro eo.

ostium

Incipiendum est, unum e paucis articulis Russicis de notis scribendi quaestionibus pro Checkmarx commendare velim. Editum est in Habre sub fine anni 2019 sub titulo: "Salve, Checkmarx!" Quomodo scribere interrogationem SAST Checkmarx et vulnerabilitates frigidas invenies.

Singillatim examinat quomodo primos queries in CxQL (Checkmarx Query Language) perscrutatur et demonstrat principia fundamentalia quomodo operantur analysis regulae.

Non repetam quae in eo descripta sunt, licet intersectiones aliquae adhuc adsint. In articulo meo conabor scribere quandam "collectionem recipes", elenchum solutionum ad problemata specifica, quae in opere meo cum Checkmarx incidi. Multis ex his quaestionibus cerebrum meum excruciandum habui. Aliquando in documentis notitia satis non erat, interdum etiam difficile erat intellectu facere quod opus erat. Spero experientiam meam et noctes vigilias frustra non fore, et haec "collectio Custom Queries recipes" paucis horis te servabit vel duas cellulas nervorum servabit. Incipiamus igitur!

Generalis notitia de regulis

Primum inspiciamus paucas notiones praecipuas et processum operandi cum regulis, ad melius intelligendum quid deinde fiet. Et etiam quia documenta de hoc nihil dicit vel valde diffunditur in structura, quod minus commodum est.

Regulae applicantur in scandendo secundum initium temporis selecti (statuto regulae activae). Numerum numerorum indefinitorum creare potes, et prorsus quomodo eas conformare a speciebus processus tui pendeat. Eos lingua lingua coniungere vel praesidia selecta pro singulis propositis potes. Numerus regulae activae celeritatem ac diligentiam inspiciendi afficit.

Profecta est fermentum in Checkmarx interface
Regulae in speciali instrumento nomine CxAuditor editos sunt. Haec application escritica est quae cum servo currens Checkmarx nectit. Hoc instrumentum duos modos operandi habet: regulas edere et eventus lustrare iam peracti.

CxAudit interface
Regulae in Checkmarx lingua divisae sunt, id est, unaquaeque lingua suam seriem queriarum habet. Sunt etiam quaedam regulae generales quae neglegentiam linguae adhibent, hae quaestiones fundamentales sic dictae sunt. Utplurimum, interrogationes fundamentales implicant inquisitionem informationum qua aliae regulae utuntur.

Regulas dividens per linguam
Regulae sunt "Executable" et "Non-executable" (Executum et non Executum). Non satis recte, mea quidem sententia, sed illud quale est. Infima linea est ut effectus exsecutionis regulae "Execubiles" ostendantur in vestigationibus proventuum in UI, et regulae "non-exsecubiles" tantum requiruntur ad usus proventus in aliis petitionibus (re vera functiones iustae sunt. ).

Determinans regulae genus cum creando
Potes novas regulas vel supplementum/rescribe entium creare. Ut regulam rescribas, debes eam in arbore invenire, ius-click et "Override" ex tabula gutta-down. Illud hic memorare interest novas regulas initio notarum non in praesidiis includi neque activas esse. Ut utendo incipias, debes eos movere in "Preset Manager" in instrumento menu. Rescripta regulae suos ordines retinent, id est, si regula activa fuit, manebit et statim applicabitur.

Exemplum novae regulae in Praeset Procurator interface
In executione aedificatur "arbor" petitionum, quae ex iis pendet. Praecepta, quae notitias inferunt, exercentur primo, et qui eo utuntur secundo. Exsecutio consecuta est conditivo, ut, si fieri potest ut eventus regulae exsistentis uti, melius est hoc facere, hoc tempus intuens reducet.
Regulae diversimode applicari possunt:

Tota enim ratio - pro quavis inceptivis inspectione adhibebitur
In gradu turmae (Team) - tantum utendum est ut incepta in quadrigis delectis scan.
In gradu project - applicabitur in projecto specifico

Determinans gradum ad quem applicabitur regula

"Dictionary" pro incipientibus

Et incipiam a paucis quae me interrogaverunt, et nonnullas quoque artes ostendemus quae vitam significanter simpliciorem reddent.

Res cum lists

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

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

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

Omnes inventi items

Intra linguam lustratam, indicem potes accipere elementorum absolute omnium quae Checkmarx notavit (chordas, functiones, classes, modos etc.). Hoc est aliquod spatium rerum quae per accessum possunt All. Hoc est, quaerere rem nomine proprio searchMeexplorare potes, exempli gratia, nomine per omnia objecta inventa;

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

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

Sed, si alia lingua quaerere debes quod aliqua de causa in scan non inclusa est (exempli gratia groovy in an Android project), potest obiectum nostrum dilatare spatium per variabilem;

result = AllMembers.All.FindByName("searchMe");

Functiones pro fluunt analysis

Haec munera in multis regulis adhibentur et hic parum fallax est scheda quid significent;

// Какие данные second влияют на first.
// Другими словами - ТО (second) что влияет на  МЕНЯ (first).
result = first.DataInfluencedBy(second);

// Какие данные first влияют на second.
// Другими словами - Я (first) влияю на ТО (second).
result = first.DataInfluencingOn(second);

Questus lima nomen tuum / iter

Plures sunt attributa quae ex eventibus quaesiti obtineri possunt (nomen tabellae in qua ingressum repertum est, filum, etc.), sed documenta non dicit quomodo ea obtinenda et utenda sunt. Ut ergo hoc facias, opus est ad proprietatem LinePragma accedere et obiecta quae opus sunt intus in ea locabuntur;

// Для примера найдем все методы
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);

Valet observatio FileName etiam viam ad tabella continet, quoniam methodo usi sumus GetFirstGraph.

Effectus exsecutionis

Est variabilis specialis intus CxQL resultquae redit exsequendi regulam tuam scriptam. Statim initialized est et intermedias eventus in illum scribere potes, eas mutans et expoliens ut laboras. Sed, si nulla assignatio huic variabili vel functioni sit intra regulam return- effectus exsecutio nulla semper erit.

Sequens quaesitum exitum consecutionis nihil nobis reddet et semper vacua erit;

// Находим элементы foo
CxList libraries = All.FindByName("foo");

Sed, dato exsecutioni eventum magico variabili, videbimus quid haec vocatio ad nos redit;

// Находим элементы foo
CxList libraries = All.FindByName("foo");

// Выводим, как результат выполнения правила
result = libraries

// Или еще короче
result = All.FindByName("foo");

Usura eventus aliarum regularum

Regulae in Checkmarx vocari possunt analoga ad functiones in lingua programmandi regulari. Cum regulam scribo, eventum aliarum quaesitionum bene uti potes. Exempli gratia, non est necesse quaerere omnem methodum vocat in codice quotiescumque, modo regulam desideratam vocamus;

// Получаем результат выполнения другого правила
CxList methods = Find_Methods();

// Ищем внутри метод foo. 
// Второй параметр false означает, что ищем без чувствительности к регистру
result = methods.FindByShortName("foo", false);

Hic aditus permittit ut codicem minuas et signanter regulam exsecutionis temporis minuas.

inuentorum

Logging

Cum opus est cum instrumento, interdum non potest statim scribere quaesitum quaesitum et experiri debes, dum varias optiones quaerit. Tali casu instrumentum colligationis praebet, quod hoc modo appellatur;

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

// Формируем строку и отправляем в лог
cxLog.WriteDebugMessage (“number of DOM elements =” + All.Count);

Sed memoria dignum est hunc modum modo inputare acceptum filumita non poterit poni totum album elementorum inventarum ex prima operatione. Secunda optio, quae ad debugging adhibetur, est variabilis notae notae subinde assignare result eventum rei quaesitum et vide quid eveniat. Accessus hic non admodum commoda est: opus certe est nullas esse overrides vel operationes cum hoc in codice after result vel simpliciter codicem infra explanare. Vel potes, sicut me, oblivisci plurium talium vocatorum ex prompta regula et admiratione quare nihil operatur.

Commodius modus est vocare modum return cum debita parametri. In hoc casu finis erit regulae exsecutio, et videre poterimus quid ex iis quae scripsimus;

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

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

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

Quaestio login

Cum condiciones sunt, cum instrumentum CxAudit (quod ad regulas scribere adhibetur). Multae causae sunt ob hoc, incluso fragore, repentino Fenestrae updates, BSOD et aliis condicionibus inopinatis quae extra nostram potestatem sunt. Hic, interdum incohata est sessionis datorum, quae te impedit quominus iterum colligationem. Ut reficere, plures interrogationes currere debes:

Nam Checkmarx ante 8.6;

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

Nam Checkmarx post 8.6;

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

Praecepta scribo

Nunc ad partem maxime interesting venimus. Cum scribere regulas in CxQL incipias, id quod saepe cares, documenta non tam sunt quam exempla quaedam viva solvendi aliquas difficultates et de processu describendi quomodo inquisitiones generaliter operantur.

Vitam paulo facilius efficere conabor iis qui in linguam interrogationem intendere incipiunt et plura exempla dabunt utendi Custom Queries ad certas quaestiones solvendas. Quaedam ex eis sunt omnino generales et in tuo collegio uti possunt paene sine mutationibus, aliae magis specificae, sed etiam possunt adhiberi mutato codice ad commoda specialia applicationum tuarum.

Hic itaque problemata saepissime occurrunt;

Negotium: Plures fluxiones sunt in exsequendis regulae et una earum est nidificatio alterius, unum ex illis relinquendum est.

solution: Re vera, interdum Checkmarx plures notitias fluxiones ostendit quae aliudque possunt esse et versio aliorum abbreviata. Est modus specialis in talibus casibus ReduceFlow. Secundum modulum eliget brevissimum vel longissimum fluxum;

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

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

Negotium: Expande elenchum notitiarum sensitivarum ad quam instrumentum reagit

solution: Checkmarx regulas fundamentales habet, quarum eventus a multis aliis quaestionibus adhibentur. Quaedam ex his regulis cum notitia specifica ad applicationem adhibendo, statim scan proventus tuos emendare potes. Infra exemplum est regula ut incipias:

General_privacy_violation_list

Plura adiungamus variabiles, quae in applicatione nostra ad informationes sensitivas reponendas adhibentur:

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

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

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

Negotium: Expand the list of variables with passwords

solution: Statim commendare animum ad regulam fundamentalem ad tesseras definiendas in codice, eique addendo indicem nominum variabilium quae in tuo comitatu communiter adhibentur.

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

Negotium: Addendi usus compages quae non praebentur per Checkmarx

solution: Omnes queries in Checkmarx lingua divisae sunt, ut regulas cuiusque linguae addere debes. Infra exempla quaedam eiusmodi praecepta sunt.

Si bibliothecae adhibitae sunt quae complementum vel functionem vexillum substituunt, facile ad regulam fundamentalem addi possunt. Tunc omnes qui ea utitur, de novis principiis statim cognoscet. Exemplum, bibliothecae loging in Android sunt Materies et Loggi. In involucro fundamentali nullae sunt regulae vocationis non systematis cognoscendi, unde si tesseram seu sessionem identifier in ligno ingreditur, non novimus. Studeamus definitiones talium methodorum ad regulas Checkmarx addere.

Testi codicis exemplum, quo materia bibliothecae ad logging utitur:

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

Et hic est exemplum petitionis Checkmarx, quod licebit addere definitionem modos appellandi materias ut punctum exitus pro notitia ex applicatione:

FindAndroidOutputs

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

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

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

Et potest etiam regulam finitimam addere, sed hoc directe pertinet ad colligationem in Android:

FindAndroidLog_Outputs

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

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

Etiam si applicationes Android WorkManager ad opus asynchronum, utilem est ad Checkmarx insuper certiorem de hac re addendo methodum parandi ex negotio dato. getInputData:

FindAndroidRead

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

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

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

Negotium: Quaerendo sensitivas notitias in plist pro iOS inceptis

solution: iOS saepe fasciculis specialibus utitur cum extensione .plis ad varias variabiles et valores reponendas. Tesserae, tesserae, signa, claves et alia notitia sensitiva in his fasciculis non commendatur, cum e artificio sine ullis quaestionibus extrahi possint.

Tabulae plistarum notas habent quae oculo nudo non patent, sed magni momenti sunt ad Checkmarx. Regulam scribamus quae notitias quaerimus quae nobis necessariae sunt et indicemus nobis si alicubi nominentur tesserae vel tesserae.

Exemplum tale fasciculi, in quo tesseram communicationis cum servitio backenario continet:

<?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>

Et regula pro Checkmarx, quod plures habet nuances, quae ratio habenda est cum scripto:

// Используем результат выполнения правила по поиску файлов 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);

Negotium: Inveniens notitia in XML

solution: Checkmarx valde commoda habet munera ad operandum cum XML et quaerendo valores, tags, attributa et plura. Sed, proh dolor, error fuit in documentis, qui nullum exemplum operatur. Quamvis hic defectus in recentissima documentorum versione eliminatus sit, cave si documentorum versionibus prioribus uteris.

Hic falsum exemplum e documentis est:

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

Ex incepto exsecutionis, errorem accipiemus All nulla talis methodus est. cxXPath. Hoc est quod recta interrogatione videtur invenire occasum in Android qui usum HTTP negotiationis permittit:

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

Inspiciamus eam paulo subtilius, cum syntaxis omnium functionum sit similis, postquam unam figurasti, tunc tantum debes eligere unum quem debes. Sic, continue secundum parametri;

"*.xml"- larva files quaerenda
8 - id linguae pro qua regula adhibetur
"cleartextTrafficPermitted"- attributum nomen in XML
"true" - de valore huius attributi
false - cum investigatione uti expressio iusto
true - significat investigationem faciendam neglecto casu, id est, insensibili casu

Exemplum, regulam usi sumus quae falsa agnoscit, ex parte securitatis, nexus retis in MASCULINUS qui communicationem cum servo per protocollum HTTP permittunt. Exemplum occasum continens attributum cleartextTrafficPermitted cum significatione 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>

Negotium: Terminus eventus lima nomen/via

solution: In una ex magnis inceptis ad progressionem applicationis mobilis pro Android pertinentibus, falsis positivis regulae obfuscationis occasum invenimus. Re vera regula e archa percontationes in tabella build.gradle dispositio responsalis applicandi regulas obfuscationum applicationis ad solutionem versionis.

Sed in magnis inceptis interdum pueri sunt files build.gradlequae pertinent ad bibliothecas inclusa. Proprium est quod, etiamsi obfuscationum necessitatem non indicaverint, obitus conventus parentis in compilatione applicabuntur.

Ita munus est abscindere triggers in fasciculis infantum quae ad bibliothecas pertinent. Possunt invenire coram linea apply 'com.android.library'.

Exemplum ex codice file build.gradlequae determinat obfuscatione opus;

apply plugin: 'com.android.application'

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

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

dependencies {
  ...
}

Exemplum documenti build.gradle pro bibliotheca inclusa in project, quod hic occasus non habet:

apply plugin: 'android-library'

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

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

Regula autem ad 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);
		}
	}
}

Aditus hic potest esse satis universalis et utilis non solum applicationibus MASCULINUS, sed etiam in aliis casibus cum debes determinare an effectus ad certum fasciculum pertineat.

Negotium: Adde subsidium pro tertia parte bibliothecae si syntaxin plene non sustinetur

solution: Numerus variarum tabularum quae in scribendo codice adhibentur simpliciter e chartis. Utique, Checkmarx non semper scit de eorum exsistentia, ac nobis opus est docere id intelligere quasdam methodos ad hoc ambitum pertinere specie. Interdum hoc perplexum est ex eo quod compages vocabulorum functionum functionum sunt valde usitata et impossibile est sine ambiguitate determinare relationem cuiusdam vocationis ad certam bibliothecam.

Difficultas est quia syntaxin talium bibliothecarum non semper recte agnoscitur et experimentum debetis ad vitandum magnum numerum positivorum falsorum acquirere. Plures optiones ad accurationem explorandam meliores sunt et problema solvendum:

Prima optio, certo scimus bibliothecam in speciali consilio adhibitam esse et regulam in gradu quadrigis applicare posse. Sed si turma diversam accessionem capere voluerit vel pluribus bibliothecis utitur in quibus functionis nomina aliudque satagunt, possumus non valde iucundam picturam plurium falsorum positivorum accipere.
Secunda optio est quaerere tabulas in quibus bibliotheca aperte importata est. Hac accessione certo possumus bibliothecam nobis necessariam in hoc fasciculo accurate esse adhibitam.
Et tertia optio est utendi duobus propinquis.

Exemplum, inspiciamus bibliothecam notissimam in circulis angustis lubricus pro Scala lingua programmandi, scilicet functionality Splicing Literal Values. In genere, ut ambitum ad interrogationem SQL transeas, operator utere debes $, quae in quaestionem SQL formatam substituit. Id est, re vera, est recta analoga Paratae Paratae in Java. Sed, si dynamice opus est interrogationi SQL construere, verbi gratia, si nomina tabularum transire debes, operante uti potes. #$, quae notitias in interrogationem (fere quasi concatenationem chordarum) substituet.

Exemplum codicem:

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

Checkmarx nondum scit usum deprehendere valorum litterarum Splicing et operariorum vagatur #$conemur docere eam cognoscere injectiones potentiales SQL et recta loca in codice illustrare:

// Находим все импорты
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));
}

Negotium: Quaere munera vulnerabilia adhibita in bibliothecarum Open-Source

solution: Multae societates adhibent instrumenta vigilantia Open-Source (OSA praxis) ad detectionem usus versionum vulnerabilium bibliothecarum in applicationibus elaboratis. Aliquando non potest talem bibliothecam renovare ad versionem securam. In quibusdam limitationes sunt functiones, in aliis nulla omnino tuta litera. Hoc in casu, coniunctio exercitiorum SAST et OSA statuere adiuvabit munera quae abusionem ducunt ad vulnerabilitatem in codice usus non sunt.

Aliquando autem, praesertim cum JavaScript considerans, hoc munus omnino leve esse non potest. Infra solutio, fortasse non idealis, sed tamen operans, exemplo vulnerabilitatum in componentibus lodash in modis template и *set.

Exempla experimenti potentialiter codicem vulnerabilem in pagina 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!'

Et connectens directe in 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>

Omnes methodos vulnerabiles quaerimus, qui in nuditatibus recensentur;

// Ищем все строки: в которых встречается строка 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));

Negotium: Investigationes testimoniales in applicatione haerent

solution: Non raro applicationes, praesertim mobiles, adhibendi sunt testimoniales vel claves ad diversos ministrantes accedere vel SSL-Pinning comprobandum. Ex perspectiva securitatis, talia in codice recondens praxis non est. Studeamus regulam scribere quae similes tabellas in promptuario quaeram:

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

Negotium: Inveniens suspectus signa in applicatione

solution: Saepius necesse est ut indices suspectos revocet vel alia indicia magni momenti quae in codice adsit. Scilicet intra fontem codicem recondere non utilem, sed variantur condiciones. Gratias CxQL queries, talia reperire perfacile est;

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

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

conclusio,

Spero hunc articulum utilem esse iis qui incipiunt notos eorum cum instrumento Checkmarx. Fortassis qui suas regulas scripserunt diu in hoc duce aliquid utile reperient.

Infeliciter, nunc subsidii defectus est ubi novae notiones colligendae sunt per evolutionem regularum pro Checkmarx. Ideo nos creavit repositio in Githububi operam dabimus ut quisque qui CxQL utitur, aliquid in eo utile invenire possit, ac etiam opportunitatem laboris sui cum communitate communicandi. Repositorium est in processu contenti implendi et structurae, sic adiuvantia sunt grata!

Спасибо за внимание!

Source: www.habr.com

Quomodo scribere praecepta pro Checkmarx sine insanis