Поиск клонов в исходном коде

Поиск клонов в исходном коде — анализ исходного кода с помощью различных алгоритмов, с целью обнаружения клонированного кода, который может иметь вредоносный характер.

Введение

В настоящее время производителями выпускается огромное количество программных продуктов. К сожалению, известен исходный код не каждого продукта. А в неисследованной программе могут быть скрыты функции, имеющие вредоносный характер. На анализ только одного исполняемого файла у исследователя уйдут многие месяцы, а возможно и годы (в зависимости от размера файла). Такие большие затраты неэффективны и не допустимы. Именно поэтому актуальна задача автоматического анализа исполняемого кода. При наличии инструментов для поиска клонированного кода, исследователю не придётся анализировать участки кода уже исследованные ранее или являющиеся стандартными библиотеками. Данные инструменты смогут находить вредоносные программы в коде, сравнивая их с ранее проанализированными двоичными файлами вредоносных программ.

Способы анализа исходного кода

Существует множество способов поиска клонированного кода, но в основном они подразделяются на синтаксические, структурные и семантические. У каждого подхода есть свои достоинства и недостатки. В научных работах и на практике в настоящее время чаще используется комбинированный подход, который позволяет получить более точный результат. Для упрощения анализа используются, так называемые отпечатки(fingerprint). Отпечатком называется информация, особым образом собранная из исследуемого программного объекта и пригодная для сравнения с другими подобными отпечатками. Данная информация представляет собой уникальное и компактное представление функциональности кода. Алгоритм получения отпечатков - это процедура, которая произвольному элементу данных большого размера ставит в соответствие гораздо более короткую битовую строку. Функции, которые выполняют эквивалентные задачи должны быть представлены похожими отпечатками. Кроме того, результирующие отпечатки должны быть устойчивы к несоответствиям на уровне байтов и терпимы к незначительным изменениям в функции. Также, вероятность возникновения конфликта между отпечатками различных функций должна быть минимальной. То есть не должны возникать ситуации, когда для различных по смыслу функций генерируются идентичные отпечатки. В терминологии отпечатков, перед разработчиком стоят следующие вопросы: каким образом сгенерировать отпечаток, как сравнивать два отпечатка и каким образом оценить результаты.

Структурный подход

Сравнение различных вариантов одного и того же исполняемого файла затрудняется тем, что один и тот же исходный код в зависимости от компилятора преобразуется в различные представления на уровне сборки. Так например, в зависимости от настроек оптимизации компилятора на идентичные инструкции могут назначаться различные регистры. В зависимости от того, как компилятор моделирует конвейер, отдельные инструкции могут быть переупорядочены. Вместо того, чтобы сосредоточиться на конкретных инструкциях уровня сборки структурный подход рассматривает код как граф потока управления, граф потока данных. Одним из основных недостатков данного подхода является то, что структура кода не устойчива к архитектурным изменениям, версионным изменениям, обфускации.

Синтаксический подход

Существуют алгоритмы, опирающиеся исключительно на синтаксическое сходство. Большая часть алгоритмов использует именно синтаксический подход, поскольку определение семантической схожести является намного более сложной задачей. Основной недостаток данного подхода - полное игнорирование структуры программы. Также, синтаксический анализ, как и структурный, не учитывает архитектурные и версионные изменения, обфускацию.

Семантический подход

Синтаксический анализ имеет дело с внешними, текстовыми конструкциями. Семантика же, ориентированная на содержательную интерпретацию, имеет дело с внутренним представлением, то есть смыслом объектов, описанных в программе. При семантическом подходе код рассматривается как последовательность байтов и инструкций.

Алгоритмы анализа исходного кода

Алгоритм Хескела

Один из алгоритмов, использующих синтаксический подход. Две программы представляются в виде строк токенов. Алгоритм ищет наибольшую общую подпоследовательность двух строк, до тех пор, пока она не будет меньше некоторого, наперёд заданного нижнего порога. Далее оценивается процент вхождения одной программы в другую. Основным достоинством этого алгоритма является его линейная сложность. Основной недостаток - полное игнорирование структурных свойств сравниваемых программ. Также возможно совпадение токенизированного представления программ (представление, которое сохраняет существенные признаки программы, и скрывает легко изменяемые), но отсутствие совпадения в исходном коде. Алгоритм также может использоваться для создания зашифрованной версии файла в виде различий между собой и каким-либо заданным файлом, что позволяет восстановить исходный файл из файлов различия и заданного файла.

BinDiff

Один из инструментов, использующих лишь структурное сходство. BinDiff сравнивает двоичные файлы как направленные графы. Эта программа использует в качестве алгоритма сравнения упрощенный способ распознавания изоморфизма графов потока управления, так как, вообще говоря, задача изоморфизма является NP полной.

Общая идея данного подхода заключается в следующем: Даны две исполняемые программы, для каждой из которых строится граф. В каждом графе создается набор узлов, состоящих из двух элементов (по одному от каждой программы), которые могут быть использованы для представления одних и тех же элементов в обоих исполняемых файлах. Эти узлы используются для создания других итеративно, до тех пор пока мы не получим отображение, которое нельзя улучшить. После того, как мы сопоставили максимально возможное количество функций, мы можем начать сопоставлять блоки таким же образом. Поскольку у нас уже есть изоморфизм, который позволяет нам получить две связанные функции, нам достаточно рассматривать соответствия между парами узлов из каждого графа. Дальше данная операция продолжается для все большего числа узлов.

Для построения изоморфизма вводятся такие понятия, как селектор и свойство.

• Селектор - отображение, которое для заданного узла А из одного графа и набора узлов из другого графа возвращает либо один из элементов данного набора, либо пустое множество. Оcновной целью селектора является выбрать из заданного набора наиболее похожий на А узел. В случае если существует несколько узлов, одинаково похожих на А селектор возвращает пустое множество. Интуитивно понятно, что вероятность возврата селектором пустого набора возрастает с увеличением входных наборов.
• Свойство π - отображение, которое переводит два графа в подмножество их узлов: $\pi (A,B)\longrightarrow (A^{'n},B^{'n}),A^{'n}\subset A^{n},B^{'n}\subset B^{n}$. Это делается с целью уменьшить размер набора, используемого селектором, что увеличивает вероятность того, что селектор вернет не пустое множество.

Создание узлов.

Если дан селектор s, то изоморфизм $p:A^{n}\longrightarrow B^{n}$, можно построить задав начальный изоморфизм $p_{1}$, который затем будет последовательно улучшаться, пока это возможно. Начальный изоморфизм $p_{1}:A^{n}\longrightarrow B^{n}$ строится простым образом с помощью селектора: $p_{1}(x)\longrightarrow s(x,B^{n})$. Это определение можно улучшить в случае, если нам задан набор свойств. Пусть $\Pi =${ $\pi _{1},...,\pi _{j}$} - заданный набор свойств. Тогда улучшенный начальный изоморфизм можно построить следующим образом:

    for $\pi \in \Pi$do
        (K, L) $\longleftarrow$$\pi (A,B)$;
        for $x\in K$do
            define $p_{1}(x)\longrightarrow s(x,L)$ 
        end
    end

Добавление узлов.

Если дан начальный изоморфизм $p_{1}$, дальнейшие улучшенные изморфизмы можно построить по следующему алгоритму:

    Input: $p_{n-1},s,A,B$
    Result: $p_{n}$
    $S\longleftarrow${ $x\in A^{n}|_{n-1}\neq \oslash$};
    for $x\in S$do
        P $\longleftarrow$up$(x)$
        K $\longleftarrow$up$(p_{n-1}(x))$;
        for $y\in P$do
            if $s(y,K)\neq \varnothing$then
                define $p_{n}(y)\longrightarrow s(y,K)$ 
            end
        end
    end

Приведенный выше алгоритм извлекает узлы, для которых $p_{n-1}$ имеет не пустое отображение, а затем рассматривает только узлы наборов, которые являются прямыми ”родителями” узла, и отображение этих "родителей" с помощью изоморфизма $p_{n-1}$. Поскольку эти наборы значительно меньше, чем наборы, рассмотренные ранее, шансы на то, что s вернет непустой результат, увеличиваются.

Применение.

Данный изоморфизм может использоваться для переноса восстановленной информации между различными дизассемблированными файлами, восстановления изменений, внесенных обновлениями безопасности и обнаружения кражи кода. Наиболее интересными применениями в области защиты информации является анализ вредоносных программ, поскольку анализ семейства троянов или вирусов может быть сведен к анализу различий между модификациями, и извлечении подробностей о уже установленных уязвимостях, в случаях когда разработчик обновления безопасности отказывается раскрывать детали.

BinSign

Основной целью BinSign является предоставление точного и масштабируемого решения для снятия отпечатков двоичного кода. Данный алгоритм анализирует как структурные, так и семантические свойства. Для генерации отпечатка сначала извлекаются глобальные особенности функции такие как, количество и размер аргументов, константы, возвращаемое значения, строки, ссылки, количество базовых блоков. Далее на основе графа потока управления строятся tracelet’ы. Каждый tracelet состоит из пары связанных блоков, каждый из блоков обладает своими особенностями: количество инструкций, группы инструкций, константы, количество констант. Таким образом, учитываются структурные особенности. Далее генерируется отпечаток, пригодный для сравнения. Данный отпечаток имеет множество применений, таких как идентификация компилятора, идентификация библиотечной функции, анализ авторства, обнаружение клонов, обнаружение уязвимостей, анализ происхождения, обнаружение и классификация вредоносных программ и т.д.

Tracelet

Алгоритм для вычисления сходства между функциями. Основная задача состоит в том, чтобы правильно определить понятие сходства, которое выходит за рамки прямого синтаксического сопоставления и способно находить измененные версии кода, а не только точные совпадения. Алгоритм основан на разложении функции в tracelets - краткий фрагмент трассы исполнения компьютерной программы, используемый в автоматизированных системах, пытающихся понять и оптимизировать исходный код. Для установления сходства применяется простой механизм перезаписи. Этот механизм выравнивает данные, чтобы сопоставить регистры и адреса памяти между tracelet'ами, устраняя различия между tracelet'ами, которые в остальном похожи.

Алгоритм для оценки сходства двух функций.

Рассмотрим общую структуру алгоритма сравнения (принцип работы используемых функций будет рассмотрен далее):

    Input: $T,R$- функции, которые нужно сравнить (target, reference)
           $NM$- метод нормировки
           $k$-  длина tracelet
           $\alpha ,\beta$- пороговые значения
    Output: $IsMatch$- можно ли считать функции одинаковыми
            $SimilarityScore$- оценка сходства
    Alghoritm $FunctionsMatchScore(T,R,NM,k,\alpha ,\beta )$
        RefTracelets = ExtractTracelets(R,k)
        TargetTracelets = ExtractTracelets(T,k)
        MatchCount = 0
        foreach $r\in RefTargets$do
            foreach $t\in TargetSelects$do
                AlignedInsts = AlignTracelets(r, t)
                t' = RewriteTracelet( AlignedInsts, r, t)
                S = CalcScore(r, t')
                RIdent = CalcScore(r, r)
                TIdent = CalcScore(t', t')
                if $Norm(S,RIdent,TIdent,NM)>\beta$then
                    MatcCount++
            end
        end
        SimilarityScore = MathCount / |RefTracelets|
        IsMath = SimilarityScore $>\alpha$   

Алгоритм начинается с разложения каждой из двух функций в набор из tracelet'ов длины k (функция ExtractTracelets). Мы рассматриваем каждый tracelet как ограниченную последовательность инструкций без промежуточных переходов. После того, как каждая функция была представлена в виде набора tracelet'ов, начинается попарное сравнения tracelet'ов. Сравнение производится следующим образом: сначала пары traceletов сравниваются с помощью функции AlignTracelets, затем t tracelet перезаписывается с учетом r. Сходство tracelet вычисляется с помощью функции CalcScore. Два tracelets считаются одинаковыми если их показатель сходства выше порогового значения $\beta$. Наконец, две функции считаются похожими, если их оценка сходства превышает пороговое значение $\alpha$.

Разложение функции на tracelets.

Tracelet извлекаются рекурсивно из узлов графа потока управления. Для того, чтобы извлечь все tracelet от определенного узла в графе потока управления, необходимо вычислить все tracelet от какого-либо дочернего узла, а затем использовать декартово произведение между узлом и вычисленными tracelet.

    Input: $G=\langle B,E\rangle$-  граф потока управления
           $k$-  длина tracelet
    Output: $T$- список всех tracelet в графе
    Alghoritm $ExtractTracelets(G,k)$
        result = $\oslash$
        foreach $b\in B$do
           result $\bigcup =$Extract(b, k)
        end
        return result

    Function $Extract(b,k)$
        bCode = {stripJumps(b)}
    if k = 1 then 
        return bCode
    else
        return $\bigcup _{\{b'|(b,b')\in E\}}bCode\times Extract(b',k-1)$
    end

Данный алгоритм использует вспомогательную функцию StripJumps. Эта функция принимает последовательность инструкций, в которой инструкция перехода может отображаться как последняя инструкция, и возвращает последовательность без инструкции перехода.

Алгоритм для оценки сходства двух tracelets.

В данном алгоритме каждая инструкция сборки рассматривается как буква (например, pop eax; является буквой). Составляется специальная таблица соответствий, которая на самом деле является мерой сходства между инструкциями сборки. При этом очень высокая оценка дается при идеальном совпадении.

    Input: $T,R$-  tracelets, которые нужно сравнить (target, reference)
    Output: $Score$- оценка сходства данных tracelets
    Alghoritm $CalcScore(T,R)$
        A = InitMAtrix(|T|, |R|)
        for $i=|T|;i>0;i--$do
           for $j=|R|;j>0;j--$do
               A[i, j] = Max(Sim(T[i], R[j]) + A[i+1, j+1],
                             A[i+1, j],
                             A[i, j+1])
           end
        end
        Score = A[0, 0]       

Сходство между инструкциями вычисляется с помощью следующей формулы: $Sim(c,c')={\begin{cases}2+|\{i|args(c)[i]=args(c')[i]\}|,&{\text{ SameKind(c, c') }}\\-1,&{\text{otherwise}}\end{cases}}$, где $c,c'$- инструкции, которые нужно сравнить. Мы вычисляем оценку, подсчитывая количество совпадающих аргументов, а также даем 2 «балла» за то, что «виды» совпадают. Если инструкции не совпадают, то формула возвращает отрицательный результат.

Перезапись заданного кода с учетом другого кода.

Для дальнейшего улучшения процесса сопоставления используется перераспределение аргументов и метод перезаписи.

    Input: $AlignedInstr$-  набор записей с выровненными инструкциями
    $T,R$-  tracelets, которые нужно сравнить (target, reference)
    Output: $T'$- измененный код
    Alghoritm $RewriteTracelet(T,R)$
        foreach $(t,r)\in AlignedInsts$do
           for $i=1;i<|args(t)|;i++$do
               $s_{t}=args(t)[i]$
               $s_{r}=args(r)[i]$
               $nv=newVarName(s_{t})$
               $\varphi =\varphi \land (nv=s_{r})$
               if $s_{t}\in read(t)\ and\ lastWrite(s_{t})\neq \perp$then
                  $\varphi =\varphi \land (nv=lastWrite(s_{t}))$
               else if $s_{t}\in write(t)$then
                  $lastWrite(s_{t})=nv$
           end
        end
        $vmap=solve(\varphi ,symbols(R))$
        foreach $t\in T$do
           $t'=t$
           foreach $s_{t}\in t$do
               if $(s_{t})\in vmap$then
                   $t'=t'[s_{t}\mapsto vmap(s_{t})]$
               end
           end
           $T'.append(t')$
        end          

Сначала мы перебираем выровненные пары команд из T и R. Для каждой пары команд выполнено $|args(r)|=|args(t)|$(достигается путем применения AlignTracelets). Для каждой пары выровненных аргументов мы абстрагируем аргумент в T tracelet'e. Это делается с помощью newVarName, который генерирует уникальные имена временных переменных в соответствии с типом аргумента. Затем создаётся перекрестное ограничение между новой переменной и значением аргумента из r инструкции, которое добавляется к ограничению $\varphi$. После с помощью функции read(t) мы узнаем используется ли аргумент $s_{t}$для чтения. Затем алгоритм использует вспомогательную структуру данных lastWrite($s_{t}$) для определения имени последней временной переменной, в которую записан аргумент $s_{t}$. Создается ограничение данных от последней записи в чтение. В противном случае, алгоритм с помощью функции write(t) проверяет является ли $s_{t}$командой записи и обновляет значение lastWrite($s_{t}$). Наконец, после создания всех переменных и ограничений, вызывается функция solve, которая разрешит все конфликты и вернет минимальное решение, необходимое чтобы переписать tracelet.