yaras

YARA 3.0 мануал

Предисловие
Антивирусные конторы разработали хороший сигнатурный двиг, который грех не использовать в своих продуктах.

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

Тут представлен перевод официального руководства по написанию сигнатур для YARA, он позволяет оценить сложность современных сигнатурных движков и даже использовать их себе во благо!

Скачать YARA  https://plusvic.github.io/yara/

НАПИСАНИЕ СИГНАТУР ДЛЯ YARA под
YARA это инструмент заточенный (но не ограниченный) для исследователей малвари, для идентификации и классификации семплов. С помощью YARA вы можете создавать описания малвари, базирующиеся на текстовых или бинарных шаблонах. Каждое описание (иначе называемое правилом), содержит в себе набор строк и булевых выражений, которые устанавливают логические взаимоотношения. Давайте рассмотрим пример:

 rule silent_banker : banker
{
    meta:
        description = "This is just an example"
        thread_level = 3
        in_the_wild = true
    strings:
        $a = {6A 40 68 00 30 00 00 6A 14 8D 91}
        $b = {8D 4D B0 2B C1 83 C0 27 99 6A 4E 59 F7 F9}
        $c = "UVODFRYSIHLNWPEJXQZAKCBGMT"
    condition:
        $a or $b or $c
} 

Данное правило рассказывает YARA, что любой файл содержащий одну из трёх строк, должен быть детектирован как silent_banker. Это простейший пример, более комплексные и мощные правила могут быть созданы используя wild-cards, регистро-независимые строки, регулярные выражения, специальные операторы и множество других фишек, будут рассмотрены в этом документе!

Начиная с нуля
YARA – это мультиплатформенная программа, работающая на Windows, Linux и Mac OS X. Мы можем найти последнюю версию здесь.

Написание правил
Синтаксис правил похож на язык С. Вот базовый вид правила:

 rule dummy
{
    condition:
       false
} 

Каждое правило начинается со слова “rule”, и следующего за ним названия.
Названия могут содержать любые буквы, цифры, и символ подчеркивания, но цифра не может быть первым символом. Регистр учитывается, а максимальная длина составляет 128 символов. Следующие слова зарезервированы и использоваться (как названия) не могут:

 all	and	any	ascii	at	condition	contains
entrypoint	false	filesize	fullword	for	global	in
import	include	int8	int16	int32	matches	meta
nocase	not	or	of	private	rule	strings
them	true	uint8	uint16	uint32	wide 

Правила обычно состоят из двух частей, строковые определения и условия.
Строковая часть может быть опущена, но условия должны быть всегда.
Каждая строка имеет своё имя, записанное после символа “$”.
Строки могут быть определены в текстовом или шестнадцатеричном виде.

 rule ExampleRule
{
    strings:
        $my_text_string = "text here"
        $my_hex_string = { E2 34 A1 C8 23 FB }
    condition:
        $my_text_string or $my_hex_string
} 

Текстовые строки всегда заключаются в двойные кавычки, шестнадцатеричные в фигурные скобки, и содержат числа разделенные пробелами или идущие непрерывно.
Раздел условий содержит логические выражения, которые используют определённые выше строки.
Комментарии
вы можете добавлять комменты в своих правила, так же как делаете это в языке C.

 /*
    This is a multi-line comment ...
*/
rule CommentExample   // ... and this is single-line comment
{
    condition:
       false  // just an dummy rule, don't do this
} 

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

Шестнадцатеричные строки
Позволяют использовать 3 специальные конструкции, что делает их более гибкими: Wild-cards, jumps и alternatives.

rule WildcardExample
{
    strings:
       $hex_string = { E2 34 ?? C8 A? FB }
    condition:
       $hex_string
}

Вы можете указывать “неизвестной” только одну половину байта.
Wild-cards полезны когда содержимое строки может меняться, но вы знаете длину изменяемых частей. Но так бывает далеко не всегда, поэтому существует:

rule JumpExample
    {
        strings:
           $hex_string = { F4 23 [4-6] 62 B4 }
        condition:
           $hex_string
    }

В этом примере мы имеем парные числа, заключенные в квадратные скобки и разделённые дефисом, этои и есть jump. Он говорится нам, что заместо него может быть любая бинарная строка, длиной от 4 до 6 байт. Любая из следующих строк подходит под это описание

 F4 23 01 02 03 04 62 B4
F4 23 00 00 00 00 00 62 B4
F4 23 15 82 A3 04 45 22 62 B4 

Любой jump [X-Y] должен подчинятся условию 0 <= X <= Y.
В предыдущей версии YARA X и Y не могли быть больше чем 256, но начиная со второй версии лимитов не существует.
Это вполне валидные примеры:

FE 39 45 [0-8] 89 00
FE 39 45 [23-45] 89 00
FE 39 45 [1000-2000] 89 00

Этот ошибочен:

FE 39 45 [10-7] 89 00

Если нам точно известно количество изменяющихся байт мы можем написать единственную цифру:

FE 39 45 [6] 89 00

Начиная со второй версии, вы так же можете использовать неограниченный jump:

FE 39 45 [10-] 89 00
FE 39 45 [-] 89 00

Первый имеет в виду [10-бесконечность], второй [0-бесконечность].
Возможна ситуация, в которой вам понадобится сделать альтернативные варианты фрагментов строки, в этом вам помогут “альтернативные” выражения:

rule AlternativesExample1
{
    strings:
       $hex_string = { F4 23 ( 62 B4 | 56 ) 45 }
    condition:
       $hex_string
}

Это правило срабатывает на строках F42362B445 или F4235645.
Но могут быть заданы и более двух альтернатив, по факту мы не ограничены их количеством и длиной составляющих:

rule AlternativesExample2
{
    strings:
       $hex_string = { F4 23 ( 62 B4 | 56 | 45 ?? 67 ) 45 }
    condition:
       $hex_string
}

Как мы видим, wild-cards могут быть использованы как часть альтернативной последовательности.

Текстовые строки
Задаются так:

rule TextExample
{
    strings:
        $text_string = "foobar"
    condition:
       $text_string
}

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

 \"	Двойная кавычка
\\	Бэкслэш
\t	Горизонтальная табуляция
\n	Новая строка
\xdd	Любой байт в шестнадцатеричной нотации

Регистро-независимые строки
Включается модификатором “nocase”:

rule CaseInsensitveTextExample
{
    strings:
        $text_string = "foobar" nocase
    condition:
       $text_string
}

Теперь это правило описывает строки “Foobar” “FOOBAR” и “fOoBaR”.

Юникод-строки
Модификатор “wide”, для поиска строк в которых на один символ определяется 2 байта:

rule WideCharTextExample
{
    strings:
        $wide_string = "Borland" wide
    condition:
       $wide_string
}

Однако помните, что это модификатор просто “расширяет” байты нашей строки нулями, это работает только с английскими буквами, но никак с национальными кодировками.
Если вы захотите искать строки записанной и в той и в другой кодировке, просто используйте 2 модификатора “ascii” и “wide”:

rule WideCharTextExample
{
    strings:
        $wide_and_ascii_string = "Borland" wide ascii
    condition:
       $wide_and_ascii_string
}

Модификатор “ascii” учитывается по умолчанию, его не нужно писать если мы ищем только ascii-строки.

Поиск полных слов
Модификатор гарантирует, что строка будет совпадать, только если отделена в тексте специальными символами. Для примера работы модификатора: строка “domain” будет найдена в строках “www.my-domain.com” или “www.domain.com”, но не будет в строке “www.mydomain.com”.

Регулярные выражения
Это самая мощная фишка YARA, регулярки записываются как обычные строки, но заключенные в бэкслеш, как в двойные кавычки, точно так же как это делает в Perl:

rule RegExpExample1
{
    strings:
        $re1 = /md5: [0-9a-zA-Z]{32}/
       $re2 = /state: (on|off)/
    condition:
       $re1 and $re2
}

Регулярные выражения могут содержать модификаторы “nocase”, “ascii”, “wide”, и “fullword”. Их значение не изменяется.
YARA используется свой собственный язык регулярных выражений
Он может содержать следующие метасимволы:

\	Экранирует след.метасимволы
^	Начало файла
$	Конец файла
|	Альтернатива
()	Группирование
[]	Класс символов

Следующие квантификаторы хорошо узнаваемы:

*	Ноль или больше раз
+	1 или больше раз
?	0 или 1 раз
{n}	n раз
{n,}	по меньшей мере n раз
{,m}	от нуля до m раз
{n,m}	от n до m раз

Все квантификаторы имеют свои не “жадные” варианты, что определяется добавлением (?)

*? Ноль или больше раз
?? 0 или 1 раз
{n,m}? от n до m раз
etc

Следующие экранированные символы признаются:

\t	Tab (HT, TAB)
\n	New line (LF, NL)
\r	Return (CR)
\n	New line (LF, NL)
\f	Form feed (FF)
\a	Alarm bell
\xNN hexadecimal number

Признанные знаковые классы:

\w "словарные" символы -  буквы, цифры и “_”
\W	НЕ словарные символы
\s	Пробел
\S	НЕ пробельные символы
\d	Цифры
\D	НЕ цифровые символы

УСЛОВИЯ
Условия это не более чем логические (булевы) выражения, такие есть в любом языке программирования. Они могут содержать в себе обычные булевы операции, такие как ( >=, <=, <, >, == и != ).
Для числовых выражений могут быть использованы арифметические (+, -, *, \, %) и битовые (&, |, <<, >>, ~, ^) выражения.
Строковые идентификаторы могут быть использованы в условиях как булевы переменные, значение которых зависит от наличие строки в файле:

rule Example
{
    strings:
        $a = "text1"
        $b = "text2"
        $c = "text3"
        $d = "text4"
    condition:
        ($a or $b) and ($c or $d)
}

Подсчёт строк
Иногда нам нужно знать не только о факте существования строки, но и о том как много раз она появляется в файле или памяти процесса. Это значение определяется через имя переменной, с символом “#” заместо “$”:

rule CountExample
{
    strings:
        $a = "dummy1"
        $b = "dummy2"
    condition:
        #a == 6 and #b > 10
}

Правило срабатывает со всеми файлами в которых строка $a присутствует ровно 6 раз, а строка #b более десяти раз.

Строковое смещение или виртуальный адрес.
В большинстве случаев, когда строки используются в условиях, мы хотели бы знать, есть ли строка вообще где-то в файле. Но в ряде случаем нам необходимо знать если строка в некотором строго-определённом месте.
В данной ситуации оператор “at” это то что нам нужно:

rule AtExample
{
    strings:
        $a = "dummy1"
        $b = "dummy2"
    condition:
        $a at 100 and $b at 200
}

Выражение “$a at 100” истинно, если эта строка найдена в файле по смещению 100(или по виртуальному адресу 100, если мы применим это правило к процессу). Примите к сведению, что offset задётся в десятичной системе счисления. Но шестнадцатеричная запись может быть использована с префиксом “0x”. Также обратите внимание на более высокий приоритет оператора “at” чем у “and”.
В то время как “at” ищет данные по конкретному смещению “in” позволяет искать их в некотором диапазоне:

rule InExample
{
    strings:
        $a = "dummy1"
       $b = "dummy2"
    condition:
       $a in (0..100) and $b in (100..filesize)
}

Здесь строка $a должна быть найдено по смещению от 0 до 100, в то время как строка $b должна быть по смещению от 100 до конца файла.
Вы можете задать смещение для i-го появления строки $a в файле, это делается через запись вида @a[i]. Первичный индекс – единица, так что вторая строка будет найдена по записи @a[2]. Если вы будете искать строку с индексом, которого не существует, результат вернёт значение NaN (Not A Number).

Размер файла.
Строковые идентификаторы далеко не единственные переменные, которые могут появляться в условиях (по-факту, они могут быть заданы вообще без использования строк), существуют специальные переменные, и одна из них это “filesize”, как не сложно догадаться, она определяет размер файла в байтах:

rule FileSizeExample
{
    condition:
       filesize > 200KB
}

Пример так же демонстрирует использование постфикса “KB”, который автоматически умножает значение на константу 1024. Постфикс “MB” умножает её же на 2^20. Оба постифкса могут быть использованы только с десятичными константами. Эта переменная имеет смысл только для файла, никак для процесса.
Точка входа исполнимого файла
Другой специальной переменной является “entrypoint”, если файл Portable Executable (PE) или Executable and Linkable Format (ELF), эта переменная содержит сырое смещение точки входа сканируемого файла. Для процесса там будет содержаться виртуальный адрес.
Эта переменная крайне полезна для детектирования различных пакеров и простых файловых инфекторов:

rule EntryPointExample1
{
    strings:
        $a = { E8 00 00 00 00 }
    condition:
       $a at entrypoint
}
rule EntryPointExample2
{
    strings:
        $a = { 9C 50 66 A1 ?? ?? ?? 00 66 A9 ?? ?? 58 0F 85 }
    condition:
       $a in (entrypoint..entrypoint + 10)
}

Наличие переменной “entrypoint” указывает что правило может быть применено только к исполняемым файлам.

АХТУНГ! переменная “entrypoint” устарела раньше чем вы сумели дочитать этот материал, сейчас вы должны использовать её эквивалент “pe.entry_point” из PE модуля YARA.

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

int8(<смещение или вирт адрес>)
int16(<смещение или вирт адрес>)
int32(<смещение или вирт адрес>)
uint8(<смещение или вирт адрес>)
uint16(<смещение или вирт адрес>)
uint32(<смещение или вирт адрес>)

Для примера, давайте рассмотрим правило определяющие PE-файл:

rule IsPE
{
  condition:
     // MZ сигнатура по смещению 0...
     uint16(0) == 0x5A4D and
     // ... PE сигнатура по смещению 0x3C в MZ хидерах
     uint32(uint32(0x3C)) == 0x00004550
}

Наборы строк
Существуют обстоятельства, в которых необходимо задать условия, что файл имеет в себе конкретное число строк из заданного набора:

rule OfExample1
{
    strings:
        $a = "dummy1"
        $b = "dummy2"
        $c = "dummy3"
    condition:
        2 of ($a,$b,$c)
}

Это правило говорит, что как минимум две строки из набора ($a,$b,$c) должны быть представлены в файле, не важно какие именно из них.
Элементы набора могут как явно быть перечислены, так используя wild cards:

rule OfExample2
{
    strings:
        $foo1 = "foo1"
        $foo2 = "foo2"
        $foo3 = "foo3"
    condition:
        2 of ($foo*)  /* эквивалент 2 of ($foo1,$foo2,$foo3) */
}
rule OfExample3
{
    strings:
        $foo1 = "foo1"
        $foo2 = "foo2"
        $bar1 = "bar1"
        $bar2 = "bar2"
    condition:
        3 of ($foo*,$bar1,$bar2)
}

Вы можете даже использовать “($*)”, для перечисления всех строк внутри вашего правила. Или написать эквивалентный кейворд “them”, для ясности:

rule OfExample4
{
    strings:
        $a = "dummy1"
        $b = "dummy2"
        $c = "dummy3"
    condition:
        1 of them /* эквивалент 1 of ($*) */
}

В примере выше, использовались числовые константы, но на самом деле могут быть использованы любые выражения, их возвращающие, ровно как и кейворды “all” и “any”:

all of them       /* все строки внутри правила*/
any of them       /* любая строка в правиле */
all of ($a*)      /* все строки чей идентификатор начинается с $a */
any of ($a,$b,$c) /* любая из $a,$b или $c*/
1 of ($*)         /* тоже самое что "any of them" */

Использование одного и того же условия для многих строк
Есть другой оператор, очень похожий на “of”, но гораздо более могущественный, это оператор “for..of”:

for expression of string_set : ( boolean_expression )

Это значит: все строки из string_set, которые удовлетворяют условию expression, должны удовлетворять boolean_expression.
!! Другими словами, expression – это условия выбора строки из набора (все, любая из, N строк из), boolean_expression – это условие которое “примеривается” к каждой выбранной строке.
Конечно, boolean_expression мог бы быть любым булевым выражением, таким как же те что описаны в разделе условий, исключая одну важную деталь: здесь вы должны использовать знак доллара $, как обозначение оцениваемой строки:

for any of ($a,$b,$c) : ( $ at entrypoint  )

Символ $ не привязан к конкретной части строки, это будет $a, затем $b, затем $c.
Может быть вы уже догадались, что оператор “of” это специальная версия “for..of”, следующие выражения одинаковы:

any of ($a,$b,$c)
for any of ($a,$b,$c) : ( $ )

Вы также можете использовать символ “#” и “@” для ссылок на число вхождений(“#”) и первое смещение(“@”) каждой строки соответственно.

for all of them : ( # &gt; 3 )
for all of ($a*) : ( @ &gt; @b )

Использование анонимных строк с “of” и “for..of”
Когда после операторов “of” и “for..of” используются “them”, написание идентификатора каждой строки излишне.
Если мы никак не различаем строки, то нам и не нужно выдавать им идентификаторы, в этом случае мы можем использование “анонимные строки”, которые определяются одиночным символом “$”:

rule AnonymousStrings
{
    strings:
        $ = "dummy1"
        $ = "dummy2"
    condition:
        1 of them
}

Перебор остальных строковых вхождений
Как мы писали выше, вхождения строк могут быть перечислены так: @a[i] , где “i” – индекс вхождения.
Иногда нам нужно перечислить все эти смещения и убедится, что они удовлетворяют данным условиям.

rule Occurrences
{
    strings:
        $a = "dummy1"
        $b = "dummy2"
    condition:
        for all i in (1,2,3) : (@a[i] + 10 == @b[i])
}

Это правило говорит, что первые 3 вхождения @b должны быть на расстоянии в 10 байт от первых трёх вхождений строки $a.
Тоже самое условие можно записать так:

for all i in (1..3) : (@a[i] + 10 == @b[i])

Примите во внимание, что мы используем диапазон (1..3) вместе перечисления значений индексов (1,2,3). Конечно, мы не вынуждены использовать константы для задания границ диапазона, мы вполне можем позволить выражение на подобии:

for all i in (1..#a) : (@a[i] &lt; 100)

В этом случае, мы перебираем каждое вхождение строки $a (помните, что #a подразумевает количество её вхождений?).Так же каждое появление $a должно быть внутри первых 100 байт файла.
Если вы захотите чтобы только некоторые вхождения строки удовлетворяли условия, здесь работает такая же логика как в операторе “for..of”:

for any i in (1..#a): ( @a[i] &lt; 100 )
for 2 i in (1..#a): ( @a[i] &lt; 100 )

В итоге,синтаксис этого оператора таков:

for expression identifier in indexes : ( boolean_expression )

Ссылки на другие правила
Когда вы пишете условия, вы можете использовать заранее написанные правила, на манер вызова функции в языках программирования.

rule Rule1
{
    strings:
        $a = "dummy1"
    condition:
        $a
}
rule Rule2
{
    strings:
        $a = "dummy2"
    condition:
        $a and Rule1
}

Как легко заметить, файл будет удовлетворять правило 2, только если он содержит строку “dummy2” и удовлетворяет правило 1. Запомните, что правила необходимо описывать строго ДО их использования.

Больше о правилах!
Есть некоторые аспекты правил, которые не были освещены ранее, но остаются очень важными.
Это: глобальные правила, приватные правила, теги и метаданные.

Глобальные правила
Дают возможность навязывать ограничения на все ваши правила разом. Предположим, что вы хотите чтобы ваши правила игнорировали все файлы, размер которых превышает некий лимит. Вы можете править все правила вручную, или использовать 1 глобальное правило:

global rule SizeLimit
{
    condition:
        filesize &lt; 2MB
}

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

Приватные правила
Это очень простая концепция, это просто правила которые не берутся yara в расчёт, при проверке одного данного файла.
Правила, которые не используются явно могут показаться бесполезными на первый взгляд, но при смешивании с возможностями, предлагаемыми YARA, такими как ссылки на внешние правила, они становятся крайне полезными:

private rule PrivateRuleExample
{
    ...
}

Мы можем использовать для нашего правила оба модификатора “private” и “global”, и оно не будет освещено YARA, но должно будет быть выполненным.

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

rule TagsExample1 : Foo Bar Baz
{
    ...
}
rule TagsExample2 : Bar
{
    ...
}

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

Метаданные
Вы можете использовать в правилах специальный раздел “meta:”, с дополнительной информацией о вашем правиле:

rule MetadataExample
{
    meta:
        my_identifier_1 = "Some string data"
        my_identifier_2 = 24
        my_identifier_3 = true
    strings:
        $my_text_string = "text here"
        $my_hex_string = { E2 34 A1 C8 23 FB }
    condition:
        $my_text_string or $my_hex_string
}

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

Использование модулей
Модули это расширения для ядра YARA. Некоторые модули, такие как “PE module” и ” Cuckoo module” официально поддерживаются YARA, другие вы можете найти на стороне ли написать самостоятельно!
Первым делом, для использования модуля необходимо его импортировать, с помощью
оператора “import”:

import "pe"
import "cuckoo"

После импортирования модуля, мы можем использовать его возможности, всегда через выражение “.” как префикс к любой переменной или функции, экспортируемой модулем, например:

pe.entry_point == 0x1000
cuckoo.http_request(/someregexp/)

Модуль часто оставляет переменные в неопределённом состоянии, например когда переменная не имеет смысла в текущем контексте (“pe.entry_point” при сканировании не исполняемого файла). YARA обрабатывает неопределенные значения, таким образом, чтобы правило не потеряло свой смысл.
Взгляните на это правило:

import "pe"
rule test
{
  strings:
    $a = "some string"
  condition:
    $a and pe.entry_point == 0x1000
}

Если сканируемый файл не является PE-файлом, вы не ожидаете что это правило буде описывать ваш файл, даже если он содержит строки, потому что оба условия (наличие строк и их место на точке входа) должны быть удовлетворены. Однако если эти условия будут изменены на:

$a or pe.entry_point == 0x1000

Мы будем ожидать, что правил сработает если файл содержит эту строки даже если он не является PE-файлом. Именно так YARA ведет себя.
Логика проста: любая арифметическая операция, сравнение, или логическая операция приведет к неопределенным значением, если один из операндов не определён (исключая случай использования OR), то неизвестное значение интерпретируется как false.

Внешние переменные
Внешние переменные позволяют вам создавать правила, которые зависят от переменных извне.

rule ExternalVariableExample1
{
    condition:
       ext_var == 10
}

В таком случае, “ext_var” это внешняя переменная, получающая значение во время исполнения. См. опцию -d в версии для командной строки и параметр externals методов compile и match для yara-python. Внешние переменная могут быть след типов: число, строка и булев тип. Их тип определяется через присвоенное им значение.

rule ExternalVariableExample2
{
    condition:
       bool_ext_var or filesize &lt; int_ext_var
}

Внешние переменные типа строка могут быть использованы с операторами “contains” и “matches”. “contains” возвращает true, если строка содержит внутри себя некую под-строку. Оператор “matches” возвращает true, если строка удовлетворяет регулярное выражение:

rule ExternalVariableExample3
{
    condition:
        string_ext_var contains "text"
}
rule ExternalVariableExample4
{
    condition:
        string_ext_var matches /[a-z]+/
}

Вы можете использовать модификаторы регулярных выражения а также оператор “matches”, например если вы хотите чтобы регулярка из предыдущего примера была безразлична к регистру, мы можете использовать “/[a-z]+/i”. Так же есть модификатор “s”, для однострочного режима, в этом режиме точка соответствует всем символам включая разрывы строк:

rule ExternalVariableExample5
{
    condition:
        /* case insensitive single-line mode */
        string_ext_var matches /[a-z]+/is
}

Подключаемые файлы
Для того чтобы позволить вам более гибкую организацию ваших правил , YARA предоставляет директиву “include”:

include "other.yar"

2 thoughts on “YARA 3.0 мануал

Добавить комментарий