sec - Интернет в облаке

ПРОГРАММА:

ИМЯ

sec - простой коррелятор событий

СИНТАКСИС

сек [--conf = ...]
[--input = знак равно ] ...]
[--input-timeout = ]
[--timeout-script = ]
[--reopen-timeout = ]
[--check-timeout = ]
[--poll-timeout = ]
[--socket-timeout = ]
[--blocksize = ]
[--bufsize = ]
[--evstoresize = ]
[--cleantime = ]
[--log = ]
[--syslog = ]
[--debug = ]
[--pid = ]
[--dump = ]
[--свалки | --nodumpfts]
[--цитирование | --без цитирования]
[--хвост | --notail]
[--от начала | --nofromstart]
[--отсоединить | --nodetach]
[--объединение | --nojointbuf]
[--держать открытым | --nokeepopen]
[--rwfifo | --norwfifo]
[--дочерний срок | --nochildterm]
[--инвенты | --nointevents]
[--intcontexts | --nointcontexts]
[--только тест | --примечательно]
[--помощь] [-?]
[--версия]

ОПИСАНИЕ

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

SEC считывает строки из файлов, именованных каналов или стандартного ввода, сопоставляет строки с
шаблоны (регулярные выражения, подпрограммы Perl и т. д.) для распознавания событий ввода и
коррелирует события в соответствии с правилами в своем файле (файлах) конфигурации. Правила совпадают
против ввода в том порядке, в котором они указаны в файле конфигурации. Если есть два или
больше файлов конфигурации, последовательность правил из каждого файла сопоставляется с вводом (если
явно указано иное). SEC может производить вывод, выполняя внешние программы
(например, snmptrap(1) или почта(1)), записывая в файлы, отправляя данные в TCP и UDP на основе
серверов, вызывая предварительно скомпилированные подпрограммы Perl и т. д.

SEC можно запускать разными способами. Например, следующая командная строка запускает его как
демон, чтобы отслеживать события, добавленные в файл системного журнала / var / log / messages с помощью
правила из /etc/sec/syslog.rules:

/ usr / bin / sec --detach --conf = / etc / sec / syslog.rules \
--input = / var / log / messages

Каждый раз при ротации / var / log / messages открывается новый экземпляр / var / log / messages и
обрабатывается с самого начала. Следующая командная строка запускает SEC в конвейере оболочки,
настраивая его для обработки строк из стандартного ввода и для выхода, когда инструмент / usr / bin / nc
закрывает стандартный вывод и выходит:

/ usr / bin / nc -l 8080 | / usr / bin / sec --notail --input = - \
--conf = / etc / sec / my.conf

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

/ usr / bin / sec --conf = / etc / sec / sshd.rules --input = / var / log / secure

для отслеживания событий sshd в файле / var / log / secure syslog. Также предположим, что
файл конфигурации /etc/sec/sshd.rules содержит следующее правило для корреляции SSH
события неудачного входа в системный журнал:

type = SingleWithThreshold
ptype = RegExp
шаблон = sshd \ [\ d + \]: Ошибка. + для (\ S +) из [\ d.] + порт \ d + ssh2
desc = Три сбоя входа по SSH в течение 1 м для пользователя $ 1
action = pipe '% s' / bin / mail -s 'SSH login alert' root @ localhost
окно = 60
thresh = 3

Команда описания поле правила определяет шаблон для распознавания входных событий, а поле
тип поле определяет его тип (регулярное выражение). Предположим, что пользователь risto не может войти в систему
через SSH, и в / var / log / secure регистрируется следующее сообщение:

16 декабря, 16:24:59 myserver sshd [13685]: сбой пароля для risto от порта 10.12.2.5 41063
ssh2

Это входное сообщение будет соответствовать шаблону регулярного выражения приведенного выше правила, а
переменная соответствия $ 1 будет установлена ​​в строку Ристо (См. Perlre(1) для подробностей). После
совпадение, SEC оценит строку описания операции, заданную с по убыванию поле. Этот
выполняется путем замены $ 1 его текущим значением, что дает Три SSH Войти сбои
одной 1m для пользователь Ристо. Затем SEC проверит, существует ли уже событие.
операция корреляции, идентифицированная этой строкой и запускаемая тем же правилом. Если
операция не найдена, SEC создаст новую операцию для имени пользователя risto, а
Время наступления входного события будет записано в операцию. Обратите внимание, что для
время возникновения события SEC всегда использует текущее время, возвращаемое время(2) система
вызов, * не * метку времени, извлеченную из события. Предположим, что через 25 секунд
наблюдается аналогичное событие сбоя входа в систему SSH для того же имени пользователя. В этом случае
текущая операция будет найдена для строки описания операции Три SSH Войти
сбои одной 1m для пользователь Ристо, и записывается время наступления второго события.
в операцию. Если через 30 секунд происходит третье событие для имени пользователя risto.
По наблюдениям, операция обработала 3 события в течение 55 секунд. Поскольку порог
условие «3 события в течение 60 секунд» (как определено молотить и окно полей) сейчас
удовлетворен, SEC выполнит действие, определенное с помощью действие поле - он будет разветвляться
команду

/ bin / mail -s 'Оповещение о входе через SSH' root @ localhost

с трубкой, подключенной к его стандартному входу. Затем SEC записывает описание операции
string Три SSH Войти сбои одной 1m для пользователь Ристо (удерживается специальной переменной% s)
к стандартному вводу команды через конвейер. Другими словами, предупреждение по электронной почте
отправляется локальному пользователю root. Наконец, поскольку до конца
окно корреляции событий, операция потребует следующего сбоя входа в SSH
события для пользователя risto без каких-либо дальнейших действий и завершаются через 5 секунд.

Приведенный выше пример показывает, что по убыванию поле правила определяет масштаб события
корреляция и влияет на количество операций, созданных правилом. Например, если
мы устанавливаем по убыванию поле к Три SSH Войти сбои одной 1m, пользователь root также будет
предупрежден о 3 событиях сбоя входа в систему SSH для * разных * пользователей в течение 1 минуты. Чтобы
избегать коллизий между операциями, запущенными по разным правилам, идентификатор операции не содержит
только значение, установленное по убыванию поле, но также имя файла правила и номер правила
внутри файла. Например, если файл правил /etc/sec/sshd.rules содержит одно правило

type = SingleWithThreshold
ptype = RegExp
шаблон = sshd \ [\ d + \]: Ошибка. + для (\ S +) из [\ d.] + порт \ d + ssh2
desc = Три сбоя входа по SSH в течение 1 м для пользователя $ 1
action = pipe '% s' / bin / mail -s 'SSH login alert' root @ localhost
окно = 60
thresh = 3

и событие

16 декабря, 16:24:59 myserver sshd [13685]: сбой пароля для risto от порта 10.12.2.5 41063
ssh2

является первым совпадающим событием для указанного выше правила, это событие вызовет новое событие
операция корреляции с идентификатором

/etc/sec/sshd.rules | 0 | Три сбоя входа по SSH в течение 1 м для пользователя risto

(0 - это номер, присвоенный первому правилу в файле, см. ОПЕРАЦИИ КОРРЕЛЯЦИИ СОБЫТИЙ
раздел для получения дополнительной информации).

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

type = SingleWithThreshold
ptype = RegExp
шаблон = sshd \ [\ d + \]: Ошибка. + для (\ S +) из [\ d.] + порт \ d + ssh2
desc = Три сбоя входа по SSH в течение 1 м для пользователя $ 1
действие = событие 3_SSH_LOGIN_FAILURES_FOR_ $ 1
окно = 60
thresh = 3

type = EventGroup
init = создать USER_COUNTING
end = удалить USER_COUNTING
ptype = RegExp
шаблон = 3_SSH_LOGIN_FAILURES_FOR _ (\ S +)
context =! USER_ $ 1_COUNTED
count = псевдоним USER_COUNTING USER_ $ 1_COUNTED
desc = Повторные неудачные попытки входа по SSH для 30 различных пользователей в пределах 1 м.
action = pipe '% s' / bin / mail -s 'SSH login alert' root @ localhost
окно = 60
thresh = 30

Первое правило выглядит почти идентично правилу из предыдущего примера, но его
действие другое поле - после трех сбоев входа в систему SSH для
одно и то же имя пользователя в течение одной минуты с помощью операции корреляции событий, операция будет
испустить синтетическое событие 3_SSH_LOGIN_FAILURES_FOR_ . Хотя синтетические события
создаются SEC, они обрабатываются как обычные события, полученные от источников ввода, и
сопоставляются с правилами. Шаблон регулярного выражения второго правила будет соответствовать
3_SSH_LOGIN_FAILURES_FOR_ событие и начать новую операцию корреляции событий
если таких событий раньше не было. При инициализации операции
создается контекст USER_COUNTING, и когда операция завершается, этот контекст удаляется
(как указано в инициализации и конец поля). Кроме того, каждый раз синтетическое событие для какого-то пользователя
имя соответствует правилу, создается псевдоним контекста для этого имени пользователя (см. считать
поле). Обратите внимание, что это предотвращает дальнейшие совпадения для того же имени пользователя, поскольку синтетический
мероприятие для может соответствовать правилу, только если псевдоним контекста USER_ _COUNTED
* не * существует (по запросу контекст поле; см. КОНТЕКСТЫ И КОНТЕКСТОВЫЕ ВЫРАЖЕНИЯ
раздел для получения дополнительной информации). Операция, запущенная правилом, отправляет предупреждение по электронной почте.
локальному пользователю root, если в течение 30 минуты было зафиксировано 1 синтетических событий (см.
молотить и окно поля). Обратите внимание, что из-за использования USER_ _COUNTED
псевдонимы, все синтетические события относятся к разным именам пользователей. После отправки электронного письма
предупреждение, операция будет продолжаться до тех пор, пока не появится 1-минутное окно корреляции событий.
истекает. По завершении операции удаление контекста USER_COUNTING также
стирает USER_ _COUNTED псевдонимов.

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

ДОПОЛНИТЕЛЬНЫЕ ОПЦИИ

--conf =
расширять к именам файлов (с Perl земной шар() функция) и читать событие
правила корреляции из каждого файла. Несколько --conf параметры можно указать на
командная строка. Каждый раз, когда SEC получает сигнал, который вызывает перезагрузку конфигурации,
переоценивается. См. Также раздел ОБРАБОТКА ВВОДА И ВРЕМЯ
обсуждение порядка обработки правил для нескольких файлов конфигурации.

--input = знак равно ]
расширять к именам файлов (с Perl земной шар()) и используйте
файлы в качестве источников ввода. Входной файл может быть обычным файлом, именованным каналом или
стандартный ввод, если - было указано. Несколько --Вход параметры можно указать на
командная строка. Каждый раз, когда SEC получает ПОДПИСАТЬСЯ or СИГАБРТ сигнал
переоценивается. Если SEC обнаруживает системную ошибку при чтении с входа
файл, он закроет файл (используйте --reopen-тайм-аут возможность повторного открытия
файл). Если задан, SEC настроит контекст каждый раз это
читает строку из входных файлов, соответствующих . Это поможет
Пользователь может писать правила, которые соответствуют данным только из определенных источников ввода. Когда
существует --Вход вариант с указано, он автоматически включит
--intcontexts вариант. См. Раздел ВНУТРЕННИЕ СОБЫТИЯ И КОНТЕКСТЫ для получения дополнительной информации.
Информация.

--input-timeout =, --timeout-script =
если SEC не обнаружила новых данных во входном файле во время секунды
(или файл был закрыт секунды назад), будет
выполняется с параметрами командной строки 1 и . Если свежий
данные снова становятся доступными, будет выполняться из командной строки
параметры 0 и . Обратите внимание, что --input_timeout и
--timeout_script параметры могут использоваться как синонимы для --input-тайм-аут и
--timeout-скрипт, Соответственно.

--reopen-timeout =
если входной файл находится в закрытом состоянии (например, SEC не может открыть файл в
запуск, потому что он еще не был создан), SEC попытается повторно открыть файл
после каждого секунд до успешного открытия. Этот вариант не имеет
смысл, когда - notail опция также указывается. Обратите внимание, что --reopen_timeout is
синоним для --reopen-тайм-аут.

--check-timeout =
если SEC не обнаружила новых данных во входном файле, файл не будет опрошен
(как для статуса, так и для данных) в течение следующего секунд. Обратите внимание, что
--check_timeout это синоним --check-тайм-аут.

--poll-timeout =
вещественное число, указывающее, сколько секунд SEC будет спать, если не было новых данных.
читать из входных файлов. По умолчанию 0.1 секунды. Обратите внимание, что --poll_timeout - это
синоним для --poll-тайм-аут.

--socket-timeout =
если сетевое соединение с удаленным узлом не может быть установлено в пределах
секунд, сдавайся. По умолчанию 60 секунд. Обратите внимание, что
--socket_timeout это синоним --сокет-тайм-аут.

--blocksize =
количество байтов, которое SEC попытается прочитать сразу из входного файла. Дефолт
составляет 1024 (т. е. считывается из входных файлов блоками по 1 КБ).

--bufsize =
установить все входные буферы на удержание линий. Содержание ввода
буферы будут сравниваться с шаблонами, которые являются частью определений правил (т.е.
больше, чем линии могут совпадать по образцу за раз). Если
установлен на 0, SEC определит правильное значение для
путем проверки шаблонов сопоставления событий всех правил SEC. Дефолт
равно 0 (т.е. определять размер входных буферов автоматически).

--evstoresize =
установить верхний предел количества событий в хранилищах контекстных событий.

--cleantime =
интервал времени в секундах, который указывает, как часто корреляция внутренних событий и
контекстные списки обрабатываются для выполнения задач, связанных со временем, и для
удалить устаревшие элементы. См. Раздел «ОБРАБОТКА ВХОДА И ВРЕМЯ» для получения дополнительной информации.
Информация. По умолчанию 1 секунда.

--log =
использовать для регистрации деятельности ТРЦ. Обратите внимание, что если стандартная ошибка SEC
подключенные к терминалу, сообщения также будут регистрироваться там, чтобы облегчить
отладка.

--syslog =
используйте системный журнал для регистрации действий SEC. Все сообщения будут регистрироваться с
средство , например, местный0 (См. системный журнал(3) для возможных значений объекта).
Предупреждение: будьте осторожны при использовании этой опции, если SEC используется для мониторинга системного журнала.
logfiles, поскольку могут возникать зацикливания сообщений.

--debug =
установить уровень детализации журнала для SEC. Установка debuglevel на означает, что все
сообщения уровня и ниже регистрируются (например, если это 3,
сообщения с уровней 1-3 регистрируются). Следующие уровни признаны SEC:
1 - критические сообщения (серьезные сбои, которые приводят к прекращению работы SEC, например, сбой
системный вызов)
2 - сообщения об ошибках (неисправности, требующие внимания, например, неправильное определение правила
в файле конфигурации)
3 - предупреждающие сообщения (возможные неисправности, например, команда, разветвленная из SEC, завершена
с ненулевым кодом выхода)
4 - уведомляющие сообщения (обычные события и прерывания системного уровня, например,
прием сигнала)
5 - информационные сообщения (информация о внешних программах, разветвленных от SEC)
6 - отладочные сообщения (подробная информация обо всех действиях ТРЦ)
Дефолт равно 6 (т.е. регистрировать все). См. Раздел СИГНАЛЫ для
информация о том, как изменить во время выполнения.

--pid =
SEC сохранит свой идентификатор процесса в при запуске.

--dump =
SEC будет использовать в качестве файла дампа для записи данных о производительности и отладке.
См. Раздел СИГНАЛЫ для получения дополнительной информации. По умолчанию /tmp/sec.dump.

- свалки, - нудпфты
если - свалки указана опция, суффикс отметки времени (секунды с начала эпохи)
добавляется к имени файла дампа при создании файла. По умолчанию - нудпфты.

- цитирование, - цитирование
если - цитирование указана опция, строки описания операции, которые
поставляется в командные строки shellcmd, порождатьи cspawn действия будут помещены внутрь
одинарные кавычки. Каждая одиночная кавычка ('), изначально содержащаяся в строках, будет
в маске. Эта опция не позволяет оболочке интерпретировать специальные символы, которые
Строки описания операции могут содержать. По умолчанию - цитирование.

--хвост, - notail
если - notail указана опция, SEC обработает все данные, которые в данный момент
доступны во входных файлах и завершаются после достижения всех EOF. Если весь ввод
полученный из трубы и - notail задана опция, SEC завершается, когда последний
писатель закрывает канал (условие EOF). Обратите внимание, что с именованными каналами - notail
следует использовать с --norwfifo. В --хвост вариант, SEC перейдет в конец
входных файлов и дождитесь поступления новых строк. Каждый входной файл отслеживается как
по его имени и i-узлу, а ротация входного файла выполняется без проблем. Если
входной файл воссоздан или усечен, SEC повторно откроет его и обработает его содержимое
с начала. Если входной файл удален (т.е. есть только i-узел
оставлен без имени), SEC будет держать i-узел открытым и ждать входного файла
отдых. По умолчанию --хвост.

- с самого начала, --nofromstart
эти флаги не имеют значения, когда - notail опция также указывается. При использовании
в сочетании с --хвост (или в одиночку, так как --хвост включен по умолчанию),
- с самого начала заставит SEC читать и обрабатывать входные файлы от начала до
конец, до перехода в режим «хвоста». По умолчанию --nofromstart.

--отсоединить, --nodetach
если --отсоединить опция указана, SEC откажется от
контролируя терминал и становясь демоном при запуске (обратите внимание, что SEC закроет свой
стандартный ввод, стандартный вывод и стандартная ошибка, а также изменить его работу
каталог в корневой каталог). По умолчанию --nodetach.

--jointbuf, --nojointbuf
если --jointbuf указана опция, SEC использует объединенный входной буфер для всех входных данных.
исходники (размер буфера задается параметром --bufsize вариант). В --nojointbuf
опция создает отдельный входной буфер для каждого входного файла и отдельный буфер
для всех синтетических и внутренних событий (размеры всех буферов задаются параметром
--bufsize вариант). В --jointbuf опция позволяет многострочным шаблонам совпадать с линиями
от нескольких источников входного сигнала, а --nojointbuf шаблон ограничивает соответствие
к строкам только из одного источника ввода. См. Раздел ОБРАБОТКА ВХОДА И ВРЕМЯ
больше информации. Если размер входного буфера (ов) равен 1 (либо явно установлен с помощью
--bufsize = 1 или автоматически определяется из правил SEC), --jointbuf опция
включен, в противном случае по умолчанию --nojointbuf.

--держать открытым, --nokeepopen
если --держать открытым задана опция, SEC будет держать входные файлы открытыми через программный
перезапускается. Когда СИГАБРТ сигнал получен, SEC не будет повторно открывать входные файлы
которые были открыты ранее, но будут открывать только входные файлы, которые находятся в
закрытое состояние. В --nokeepopen опция заставляет SEC закрывать и (повторно) открывать все входы
файлы во время мягких перезапусков. По умолчанию --держать открытым.

--rwfifo, --norwfifo
если --norwfifo указана опция, входные файлы именованного канала открываются в режиме чтения
только режим. В этом режиме именованный канал должен быть повторно открыт, когда последний писатель
закрывает трубу, чтобы очистить состояние EOF на трубе. С --rwfifo
опции, входные файлы именованного канала открываются в режиме чтения-записи, хотя SEC никогда не
пишет в трубы. В этом режиме нет необходимости повторно открывать трубу, когда
внешний писатель закрывает его, так как всегда есть хотя бы один писатель на конвейере
и EOF никогда не появится. Следовательно, если - notail вариант был предоставлен,
--norwfifo также следует указать. По умолчанию --rwfifo.

- ребенок, --nochildterm
если - ребенок задана опция, SEC отправит сигнал SIGTERM всем своим
дочерние процессы, когда он завершается или проходит полный перезапуск. По умолчанию
- ребенок.

--события, --nointevents
SEC будет генерировать внутренние события при запуске, когда он получает определенные
сигналы, и когда он завершается изящно. Для соответствия могут быть написаны конкретные правила
эти внутренние события для выполнения специальных задач при запуске SEC,
перезапустите и выключите. См. Раздел ВНУТРЕННИЕ СОБЫТИЯ И КОНТЕКСТЫ для получения дополнительной информации.
Информация. По умолчанию --nointevents.

--intcontexts, --nointcontexts
SEC создаст внутренний контекст при чтении строки из входного файла. Этот
поможет пользователю написать правила, которые соответствуют данным из определенного источника ввода
Только. См. Раздел ВНУТРЕННИЕ СОБЫТИЯ И КОНТЕКСТЫ для получения дополнительной информации. По умолчанию
--nointcontexts.

--testonly, --необычайно
если --testonly опция указана, SEC выйдет сразу после анализа
конфигурационный файл (ы). Если файл (ы) конфигурации не содержал ошибочных правил, SEC
выйдет с 0, иначе с 1. По умолчанию --необычайно.

--Помогите, -?
SEC выведет информацию об использовании и выйдет.

--версия
SEC выведет информацию о версии и выйдет.

Обратите внимание, что параметры могут быть введены как с одинарным тире (-), так и с двойным тире (-),
и как знак равенства (=), так и пробел можно использовать для отделения имени параметра от
значение опции. Например, -conf = и --conf варианты
эквивалент.

КОНФИГУРАЦИЯ FILES

Каждый файл конфигурации SEC состоит из определений правил, разделенных пустыми
строки, пробельные строки и / или строки комментариев. Каждое определение правила состоит из
ключевое слово = поля значений, по одному ключевому слову и значению в каждой строке. Значения нечувствительны к регистру
где регистр символов не важен (например, значения, определяющие типы правил, например,
«Одинокий» и «одинокий» трактуются одинаково). Может использоваться обратная косая черта (\)
в конце строки, чтобы продолжить текущее поле правила в следующей строке. Линии, которые
начинаются со знака числа (#), рассматриваются как комментарии и игнорируются (символы пробела
может предшествовать #). Любая строка комментария, пустая строка, строка с пробелами или конец файла будут
завершить предыдущее определение правила. Для вставки комментариев в определения правил,
рем ключевое слово может быть использовано. Например, следующие строки определяют два правила:

type = Single
rem = это правило соответствует любой строке, содержащей \
три последовательных символа A и записывает строку \
"наблюдались три символа A" для стандартного вывода
ptype = SubStr
шаблон = AAA
desc = Три символа A
action = write - наблюдались три символа A
# Эта строка комментария завершает предыдущее определение правила.
# Следующее правило работает так же, как и предыдущее правило,
# но ищет три последовательных символа B и
# пишет строку "наблюдались три символа B"
# в стандартный вывод
type = Single
ptype = SubStr
шаблон = BBB
desc = Три символа B
action = write - наблюдались три символа B

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

Точки перехода определяются с помощью Продолжить* поля. Допустимые значения для этих полей
составляют:

TakeNext
после того, как событие соответствует правилу, ищите соответствующие правила в конфигурации
файл будет продолжен со следующего правила.

Идти к
после того, как событие соответствует правилу, поиск соответствующих правил будет продолжен с
расположение в файле конфигурации ( должно быть определено с помощью
этикетка ключевое слово в любом месте файла конфигурации * после * текущего правила
определение).

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

EndMatch
после того, как событие соответствует правилу, поиск соответствующих правил заканчивается для * всех *
конфигурационные файлы.

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

type = Single
ptype = SubStr
шаблон = AAA
rem = после совпадения этого правила продолжить с последнего правила
continue = Перейти к lastRule
desc = Три символа A
action = write - наблюдались три символа A

type = Single
ptype = SubStr
шаблон = BBB
rem = после того, как это правило совпадет, не учитывайте следующие правила, \
поскольку 'continue' по умолчанию - 'DontCont'
desc = Три символа B
action = write - наблюдались три символа B

type = Single
ptype = SubStr
pattern = CCC
rem = после совпадения этого правила продолжить со следующего правила
continue = TakeNext
desc = Три символа C
action = write - наблюдались три символа C

label = lastRule

type = Single
ptype = SubStr
шаблон = DDD
desc = Три символа D
action = write - наблюдались три символа D

Для входной строки «AAABBBCCCDDD» этот набор правил записывает строки «три символа A были
наблюдается "и" наблюдались три символа D. "в стандартный вывод. Если строка ввода
«BBBCCCDDD», строка «наблюдались три символа B» выводится на стандартный вывод.
Для строки ввода «CCCDDD» строки «наблюдались три символа C» и «три символа D.
наблюдаемые символы "отправляются на стандартный вывод, в то время как строка ввода" DDD "производит
строка вывода «наблюдались три символа D».

При наличии двух или более файлов конфигурации выполняется сопоставление последовательности правил из каждого файла.
против ввода (если явно не указано иное). Например, предположим, что SEC - это
началось с командной строки

/ usr / bin / sec --input = - \
--conf = / etc / sec / sec1.rules --conf = / etc / sec / sec2.rules

а файл конфигурации /etc/sec/sec1.rules имеет следующее содержимое:

type = Single
ptype = SubStr
шаблон = AAA
desc = Три символа A
action = write - наблюдались три символа A

type = Single
ptype = SubStr
шаблон = BBB
continue = EndMatch
desc = Три символа B
action = write - наблюдались три символа B

Также предположим, что файл конфигурации /etc/sec/sec2.rules имеет следующее содержимое:

type = Single
ptype = SubStr
pattern = CCC
desc = Три символа C
action = write - наблюдались три символа C

Если SEC получает строку "AAABBBCCC" из стандартного ввода, правила из обеих конфигураций
файлы проверяются, и в результате строки «были обнаружены три символа A» и
«Наблюдались три символа C» выводятся на стандартный вывод. Обратите внимание, что правила из
/etc/sec/sec1.rules сначала проверяются на строке ввода, поскольку параметр
--conf = / etc / sec / sec1.rules дан до --conf = / etc / sec / sec2.rules в команде SEC
строка (см. также раздел ОБРАБОТКА ВХОДА И ВРЕМЯ для более подробного обсуждения). Если
SEC получает строку "BBBCCC" из стандартного ввода, второе правило от
/etc/sec/sec1.rules дает совпадение, и строка «наблюдались три символа B»
записывается на стандартный вывод. Поскольку правило содержит continue = EndMatch заявление,
поиск подходящих правил закончится для всех файлов конфигурации, а правила из
/etc/sec/sec2.rules пробовать не будет. Без этого утверждения поиск соответствия
правила будут продолжаться в /etc/sec/sec2.rules, а первое правило будет записывать строку
«наблюдались три символа C» для стандартного вывода.

УЗОРЫ, ШАБЛОН ВИДЫ И МАТЧ ПЕРЕМЕННЫЕ

Паттерны и типы паттернов определяются с помощью шаблон* и ptype * поля правил. Многие модели
типы определяют количество строк N которому соответствует шаблон (если N опущено, 1 - это
предполагается). Если N больше 1, область соответствия устанавливается с помощью --jointbuf и
--nojointbuf параметры. С участием --jointbuf, шаблон используется для сопоставления N последний ввод
строки взяты из объединенного буфера ввода (строки могут поступать из разных источников ввода).
В --nojointbuf, источник последней входной строки идентифицируется, и шаблон
в сочетании с N последние входные строки из входного буфера идентифицированного источника.

SubStr [N]
шаблон - это строка, поиск в которой выполняется в последних N входных строках L1, L2, ..., LN. Если
N больше 1, входные строки объединяются в строку
"L1 L2 ... LN ", и поиск будет выполнен в строке шаблона.
от него. Если строка шаблона найдена во входной строке (строках), шаблон совпадает.
Последовательности обратной косой черты \ t, \ n, \ r, \ s и \ 0 могут использоваться в шаблоне для обозначения
табуляция, новая строка, возврат каретки, пробел и пустая строка,
соответственно, а \\ обозначает саму обратную косую черту. Например, рассмотрим
следующее определение шаблона:

ptype = substr
pattern = Резервное копирование выполнено: \ tsuccess

Шаблон соответствует строкам, содержащим «Резервное копирование выполнено: успех".

Обратите внимание, что поскольку SubStr [N] тип шаблона был разработан для быстрого сопоставления, это
не поддерживает переменные соответствия.

RegExp [N]
pattern - это регулярное выражение Perl (см. Perlre(1) для получения дополнительной информации) для
соответствие последним N входным строкам L1, L2, ..., LN. Если N больше 1, вход
линии объединяются в строку "L1 L2 ... LN ", а
регулярное выражение соответствует этой строке. Если регулярное выражение совпадает,
будут установлены переменные соответствия, и эти переменные соответствия можно будет использовать в других частях
определения правила.

В дополнение к нумерованным переменным соответствия ($ 1, $ 2 и т. Д.) SEC поддерживает именованное соответствие
переменные $ + {name} и переменная $ 0. Переменная $ 0 содержит всю строку
последние N входных строк, совпадающих с регулярным выражением. Именованные переменные соответствия
могут быть созданы в более новых версиях языка регулярных выражений Perl, например,
(? AB | CD) устанавливает $ + {myvar} в AB или CD. Специальная именованная переменная соответствия
$ + {_ inputsrc} создается SEC и содержит имя (имена) входного файла, в которых совпадают строки
пришли из.

Например, следующий шаблон соответствует событию SSH «Подключение от» и
устанавливает $ 0 для всей строки события, и $ 1, и $ + {ip} для IP-адреса
удаленному узлу, $ 2 для номера порта на удаленном узле и $ + {_ inputsrc} для
имя входного файла:

ptype = RegExp
pattern = sshd \ [\ d + \]: подключение из (? [\ d.] +) порт (\ d +)

Кроме того, SEC позволяет кэшировать совпадения и создавать дополнительные именованные совпадения.
переменные через карты переменных, которые определены с помощью varmap * поля. Переменная
карта - это список имя = номер отображения, разделенные точкой с запятой, где имя это
имя для названной переменной и номер идентифицирует пронумерованную переменную соответствия, которая
задается регулярным выражением. Каждое имя должно начинаться с буквы и состоять из
буквы, цифры и символы подчеркивания. После совпадения регулярного выражения имя
переменные, указанные на карте, создаются из соответствующих пронумерованных переменных.
Если одна и та же именованная переменная установлена ​​как из регулярного выражения, так и из переменной
map, карта имеет приоритет.

If имя не следует за знаком равенства и числом в varmap * поле, это
рассматривается как общее имя для всех переменных соответствия и их значений из
удачный матч. Это имя используется для кеширования успешного совпадения по шаблону
- переменные сопоставления и их значения сохраняются в памяти сопоставления с образцом
кеш под имя. Кешированные результаты матчей могут быть повторно использованы Сохраненная копия и NCache
узоры. Обратите внимание, что перед обработкой каждой новой строки ввода предыдущее содержимое
Кэш сопоставления с образцом очищен. Также обратите внимание, что успешное сопоставление с образцом кешируется.
даже если последующая оценка выражения контекста дает FALSE (см. INPUT
Раздел ОБРАБОТКА И ВРЕМЯ для получения дополнительной информации).

Например, рассмотрим следующее определение шаблона:

ptype = регулярное выражение
pattern = (? i) (\ S + \. mydomain). * принтер: тонер \ / мало чернил
varmap = printer_toner_or_ink_low; сообщение = 0; hostname = 1

Шаблон соответствует сообщениям "принтер: заканчивается тонер / чернила" без учета регистра.
с принтеров, принадлежащих .mydomain. Обратите внимание, что имя хоста принтера назначено
$ 1 и $ + {hostname}, а вся строка сообщения назначена $ 0 и
$ + {сообщение}. Имя файла, из которого пришла строка сообщения, назначается
$ + {_ inputsrc}. Также эти переменные и их значения сохраняются в шаблоне.
сопоставьте кеш под именем "printer_toner_or_ink_low".

Следующее определение шаблона дает совпадение, если последние две входные строки
AAA и BBB:

ptype = regexp2
шаблон = ^ AAA \ nBBB $
varmap = aaa_bbb

Обратите внимание, что с --nojointbuf вариант шаблон соответствует только в том случае, если совпадение
строки поступают из * того же * входного файла, а --jointbuf вариант поднимает это
ограничение.

В случае совпадения $ 0 устанавливается на "AAA". BBB "и $ + {_ inputsrc} в файл
имя (я) для совпадающих строк. Кроме того, эти пары «переменная-значение» кэшируются под
назовите "aaa_bbb".

PerlFunc [N]
pattern - это функция Perl для сопоставления последних N входных строк L1, L2, ..., LN. В
Функция Perl компилируется при запуске SEC с Perl Eval() функция и Eval()
должен возвращать ссылку на код, чтобы шаблон был действительным (см. также PERL INTEGRATION
раздел). Функция вызывается в контексте списка Perl и с --jointbuf
option, строки L1, L2, ..., LN и имена соответствующих входных файлов F1, F2,
..., FN передаются функции как параметры:

функция (L1, L2, ..., LN, F1, F2, ..., FN)

Обратите внимание, что с --nojointbuf вариант, функция вызывается с одним файлом
параметр имени F, поскольку строки L1, ..., LN взяты из одного входного файла:

функция (L1, L2, ..., LN, F)

Также обратите внимание, что если входная строка является синтетическим событием, имя входного файла - Perl.
неопределенное значение.

Если функция возвращает несколько значений или одно значение, которое истинно в Perl
логический контекст, шаблон соответствует. Если функция не возвращает значений или один
значение, которое является ложным в логическом контексте Perl (0, пустая строка или неопределенное значение),
шаблон не совпадает. Если шаблон совпадает, возвращаемые значения будут присвоены
для пронумерованных переменных соответствия ($ 1, $ 2 и т. д.). Как и в случае с шаблонами RegExp, $ 0
переменная установлена ​​на совпадающую строку (строки) ввода, переменная $ + {_ inputsrc} установлена ​​на
имена входных файлов и именованные переменные соответствия могут быть созданы из карт переменных.
Например, рассмотрим следующее определение шаблона:

ptype = perlfunc2
шаблон = sub {return ($ _ [0] cmp $ _ [1]); }

Шаблон сравнивает две последние входные строки по строкам ($ _ [1] содержит
последняя строка и $ _ [0] предыдущая), и совпадает, если строки разные.
Обратите внимание, что результат сравнения присваивается $ 1, а две совпадающие строки
объединяются (с символом новой строки между ними) и присваиваются $ 0. В
имена файлов для совпадающих строк назначаются $ + {_ inputsrc}.

Следующий шаблон производит совпадение для любой строки и устанавливает $ 1, $ 2 и $ 3.
переменные в строки «abc», «def» и «ghi», соответственно (также $ 0 устанавливается в
целая строка ввода и $ + {_ inputsrc} к имени входного файла):

ptype = perlfunc
шаблон = sub {return ("abc", "def", "ghi"); }

Следующее определение шаблона дает совпадение, если входная строка не является
синтетическое событие и содержит строку «abc» или «def». Переменная $ 0 - это
устанавливается в соответствующую строку, а $ 1, $ + {file} и $ + {_ inputsrc} устанавливаются в имя
входного файла:

ptype = perlfunc
pattern = sub {if (defined ($ _ [1]) && $ _ [0] = ~ / abc | def /) \
{возврат $ _ [1]; } return 0; }
varmap = file = 1

Наконец, если шаблон функции возвращает одно значение, которое является ссылкой на
Хеш Perl, именованные переменные соответствия создаются из пар ключ-значение в хеше. Для
Например, следующий шаблон соответствует строке, если он содержит строку
«три» или «четыре». Помимо установки $ 0 и $ + {_ inputsrc}, шаблон также
создает переменные соответствия $ + {three} и $ + {four} и устанавливает для них значения 3 и 4,
соответственно:

ptype = perlfunc
шаблон = sub {мой (% хэш); \
если ($ _ [0]! ~ / три | четыре /) {возврат 0; } \
$ hash {"три"} = 3; $ hash {"четыре"} = 4; вернуть \% хэш; }

Сохраненная копия шаблон - это имя, которое ищется в кэше сопоставления с шаблоном (записи сохраняются
в кеш с varmap * поля). Если запись с данным именем найдена
в кеше происходит совпадение с шаблоном, а также извлекаются соответствующие переменные и значения.
из кеша. Например, если строка ввода соответствует следующему шаблону

ptype = perlfunc
pattern = sub {if (defined ($ _ [1]) && $ _ [0] = ~ / abc | def /) \
{возврат $ _ [1]; } return 0; }
varmap = abc_or_def_found; файл = 1

затем в кэше сопоставления с образцом создается запись «abc_or_def_found».
Следовательно, шаблон

ptype = cached
pattern = abc_or_def_found

также будет соответствовать этой строке ввода и установить $ 0, $ 1, $ + {file} и
$ + {_ inputsrc} к значениям из предыдущего совпадения.

NSubStr [N]
" У аборигенов SubStr [N], за исключением того, что результат совпадения аннулируется. Обратите внимание, что это
Тип шаблона не поддерживает переменные соответствия.

NRegExp [N]
" У аборигенов RegExp [N], за исключением того, что результат совпадения инвертируется и переменные карты
не поддерживаются. Обратите внимание, что единственные переменные соответствия, поддерживаемые этим шаблоном
type - это $ 0 и $ + {_ inputsrc}.

NPerlFunc [N]
" У аборигенов PerlFunc [N], за исключением того, что результат совпадения инвертируется и переменные карты
не поддерживаются. Обратите внимание, что единственные переменные соответствия, поддерживаемые этим шаблоном
type - это $ 0 и $ + {_ inputsrc}.

NCache
" У аборигенов Сохраненная копия, за исключением того, что результат совпадения аннулируется. Обратите внимание, что это
Тип шаблона не поддерживает переменные соответствия.

Tзначение pattern - это истинное значение, где TRUE и FALSE являются допустимыми значениями. ИСТИНА всегда
соответствует строке ввода, а FALSE никогда ничего не соответствует. Обратите внимание, что этот шаблон
type не поддерживает переменные соответствия.

При замене переменных соответствия каждая последовательность «$$» интерпретируется как литерал.
знак доллара ($), который позволяет маскировать переменные соответствия. Например, строка
После замены «Получено $$ 1» становится «Получено $ 1», а «Получено $$$ 1» становится
"Получено $ ". Чтобы устранить неоднозначность пронумерованных переменных соответствия из
В следующем тексте номер переменной должен быть заключен в фигурные скобки. Например, строка
"Получено $ {1} 0" становится "Получено" 1 "после замены, а
строка "Получено 10 долларов" станет "Получено ".

Если переменная соответствия не была задана шаблоном, она заменяется пустой строкой
(т.е. строка нулевой ширины). Таким образом появляется строка «Получено 10 долларов!» становится "Получено!" после
замена, если по выкройке не установлено 10 долларов. (Обратите внимание, что до SEC-2.6 неустановленные переменные
были * не * заменены.)

В текущей версии SEC имена переменных соответствия $ + {name} должны соответствовать
следующее соглашение об именах - первый символ может быть буквой или подчеркиванием, а
остальные символы могут быть буквами, цифрами, знаками подчеркивания и восклицательными знаками (!).
Однако при установке именованных переменных соответствия из шаблона рекомендуется начинать
имя переменной с буквы, так как имена специальных автоматически создаваемых переменных начинаются
с подчеркиванием (например, $ + {_ inputsrc}).

После того, как шаблон соответствует событию и установлены переменные соответствия, он также
можно ссылаться на ранее кэшированные переменные соответствия с синтаксисом
$: {entryname: varname}, Где имя записи - это имя записи кэша сопоставления с образцом, и
VarName это имя переменной, хранящейся под записью. Например, если переменная
$ + {ip} ранее был кэширован под записью "SSH", его можно обозначить как $: {SSH: ip}.
Из соображений эффективности синтаксис $: {entryname: varname} не поддерживается для быстрого
типы шаблонов, которые не устанавливают переменные соответствия (например, SubStr, NSubStr, NCached и
Tзначение).

Обратите внимание, что, поскольку правила Pair и PairWithWindow имеют два шаблона, сопоставьте переменные
первый шаблон затеняется для некоторых полей правил, когда второй шаблон совпадает и устанавливает
переменные. Чтобы ссылаться на теневые переменные, их имена должны начинаться с% вместо
of $ (например,% 1 относится к переменной соответствия $ 1, установленной первым шаблоном). Однако использование
% -префикс действителен только при следующих обстоятельствах - * оба * типа шаблона
поддерживать переменные сопоставления * и * в заданном поле правила сопоставить переменные из * обоих * шаблонов
может быть использован.

Переменные совпадения с префиксом% маскируются последовательностью "%%" (как обычное совпадение
переменные с "$$"). Точно так же фигурные скобки могут использоваться для устранения неоднозначности с префиксом%
переменные из следующего текста.

Наконец, обратите внимание, что второй шаблон правил Pair и PairWithWindow может содержать совпадение
переменные, если второй шаблон имеет тип SubStr, NSubStr, Regexp или NRegExp. В
переменные заменяются во время выполнения значениями, установленными первым шаблоном. Если
шаблон - это регулярное выражение, все специальные символы внутри заменяемых значений
замаскирован Perl цитата() и финальное выражение проверяется на наличие
правильность.

КОНТЕКСТЫ И КОНТЕКСТ ВЫРАЖЕНИЯ

Контекст SEC - это объект на основе памяти, который имеет одно или несколько имен, время жизни и
магазин событий. Кроме того, список действий может быть настроен для контекста, который выполняется
непосредственно перед истечением контекста.

Например, действие Создайте МОЙ КОНТЕКСТ 3600 (отчет МОЙ КОНТЕКСТ / bin / mail корень @ localhost)
создает контекст МОЙ КОНТЕКСТ который имеет время жизни 3600 секунд и пустое хранилище событий.
Также непосредственно перед МОЙ КОНТЕКСТ истекает и удаляется из памяти, действие докладе
МОЙ КОНТЕКСТ / bin / mail корень @ localhost выполняется, который отправляет по почте хранилище событий МОЙ КОНТЕКСТ в
корень @ localhost.

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

создать MYCONTEXT
добавить MYCONTEXT Это тест
псевдоним MYCONTEXT MYALIAS
добавить МЯЛИ Это еще один тест
сообщить MYCONTEXT / bin / mail root @ localhost
удалить МЯЛИИ

Первое действие создает контекст МОЙ КОНТЕКСТ с бесконечным временем жизни и пустым событием
хранить. Второе действие добавляет строку «Это тест» в хранилище событий
МОЙ КОНТЕКСТ. Третье действие устанавливает псевдоним Миалиас для контекста (имена
МОЙ КОНТЕКСТ и Миалиас относятся к той же структуре данных контекста). Четвертое действие добавляет
строка «Это еще один тест» в хранилище событий контекста. Пятое действие
пишет строки

Это тест
Это еще один тест

на стандартный ввод / bin / mail корень @ localhost команда. Шестое действие удаляет
структура данных контекста из памяти и отбрасывает ее имена МОЙ КОНТЕКСТ и Миалиас.

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

Выражения контекста - это логические выражения, которые определены с помощью контекст * править
поля. Выражения контекста могут использоваться для ограничения совпадений, производимых шаблонами,
поскольку, если выражение оценивается как ЛОЖЬ, правило не будет соответствовать входному событию.

Выражение контекста принимает имена контекста, мини-программы Perl, функции Perl и
поиск в кэше соответствия шаблонов в качестве операндов. Эти операнды можно комбинировать со следующими
операторы:
! - логическое НЕ,
&& - короткое замыкание логического И,
|| - логическое ИЛИ короткого замыкания.
Кроме того, скобки можно использовать для группировки.

Если операнд не содержит специальных операторов (таких как -> или:>, см. Ниже), он
рассматривается как имя контекста. Операнды имени контекста могут содержать переменные соответствия, но не могут
содержать пробелы. Если имя контекста относится к существующему контексту, операнд
оценивается ИСТИНА, в противном случае - ЛОЖЬ.

Например, рассмотрим следующую последовательность правил:

type = Single
ptype = RegExp
шаблон = Тест: (\ d +)
desc = test
действие = создать CONT_ $ 1

type = Single
ptype = RegExp
шаблон = Test2: (\ d +) (\ d +)
context = CONT_ $ 1 && CONT_ $ 2
desc = test
action = write - и $ 1, и $ 2 были замечены в прошлом

Если следующие строки ввода появляются в этом порядке

Тест: 19
Тест: 261
Тест2: 19 787
Тест: 787
Тест2: 787 261

первая строка ввода соответствует первому правилу, которое создает контекст CONT_19и
аналогично вторая строка ввода запускает создание контекста CONT_261, Третий
строка ввода "Test2: 19 787" соответствует регулярному выражению

Тест2: (\ d +) (\ d +)

но не соответствует второму правилу, поскольку логическое выражение

CONT_19 && CONT_787

оценивает ЛОЖЬ (контекст CONT_19 существует, но контекст CONT_787 нет). Четвертый вход
строка соответствует первому правилу, которое создает контекст CONT_787. Пятая строка ввода
«Test2: 787 261» соответствует второму правилу, поскольку логическое выражение

CONT_787 && CONT_261

оценивает ИСТИНА (оба контекста CONT_787 и контекст CONT_261 существуют), и поэтому
Строка «И 787, и 261 были замечены в прошлом» выводится на стандартный вывод.

Если операнд контекстного выражения содержит оператор стрелки (->), текст, следующий за
стрелка должна быть допустимым определением функции Perl, которое скомпилировано при запуске SEC с
Perl Eval() функция. В Eval() должен возвращать ссылку на код (см. также ИНТЕГРАЦИЯ PERL
раздел для получения дополнительной информации). Если перед стрелкой стоит какой-либо текст, он рассматривается как список
параметры для функции. Параметры должны быть разделены пробелами и могут содержать
сопоставить переменные. Чтобы оценить операнд выражения контекста, функция Perl
вызывается в скалярном контексте Perl. Если возвращаемое значение функции истинно в
Логический контекст Perl, операнд оценивает ИСТИНА, иначе он оценивает ЛОЖЬ.

Например, следующее правило соответствует событию сбоя входа в систему SSH, если попытка входа в систему
поступает с привилегированного порта клиентского хоста:

type = Single
ptype = RegExp
pattern = sshd \ [\ d + \]: Ошибка. + для (\ S +) из [\ d.] + порт (\ d +) ssh2
context = $ 2 -> (sub {$ _ [0] <1024})
desc = Ошибка входа в систему по SSH для приватного порта $ 1 $ 2
action = write - ошибка входа в SSH для пользователя $ 1 с привилегированного порта $ 2

Когда появляется следующее сообщение от демона SSH

16 декабря, 16:24:59 myserver sshd [13685]: сбой пароля для risto от порта 10.12.2.5 41063
ssh2

регулярное выражение правила соответствует этому сообщению, а значение $ 2 соответствует
переменная (41063) передается в функцию Perl

sub {$ _ [0] <1024}

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

16 декабря, 16:25:17 myserver sshd [13689]: сбой пароля для risto от порта 10.12.2.5 1023
ssh2

соответствует правилу, а строка "Ошибка входа в SSH для пользователя risto с привилегированного порта
1023 "выводится на стандартный вывод.

В качестве другого примера, следующее выражение контекста оценивает ИСТИНА, если
Файл / var / log / messages не существует или последний раз был изменен более часа назад (обратите внимание, что
функция Perl не принимает параметров):

context = -> (sub {my (@stat) = stat ("/ var / log / messages"); \
return (! scalar (@stat) || time () - $ stat [9]> 3600); })

Если операнд контекстного выражения содержит оператор:>, следующий текст:> должен
быть допустимым определением функции Perl, которое компилируется при запуске SEC с Perl Eval()
функция. Eval() должен возвращать ссылку на код (см. также раздел ИНТЕГРАЦИЯ PERL для
больше информации). Если какой-либо текст предшествует оператору:>, он рассматривается как список
параметры для функции. Параметры должны быть разделены пробелами и могут содержать
сопоставить переменные. Предполагается, что каждый параметр - это имя записи в шаблоне.
кеш совпадений. Если запись с данным именем не существует, неопределенное значение Perl будет
передается в функцию. Если запись с данным именем существует, ссылка на запись
передается функции Perl. Внутри реализована каждая запись кэша сопоставления с образцом.
как хеш Perl, который содержит все переменные соответствия для данной записи. В хеше каждый
пара ключ-значение представляет имя и значение некоторой переменной, например, если кэшированная переменная соответствия
$ + {ip} содержит 10.1.1.1, хеш содержит значение 10.1.1.1 с ключом ip. В
чтобы оценить операнд выражения контекста, функция Perl вызывается в Perl
скалярный контекст. Если возвращаемое значение функции истинно в логическом контексте Perl,
операнд оценивается как ИСТИНА, иначе он оценивается как ЛОЖЬ.

Например, рассмотрим следующую последовательность правил:

type = Single
ptype = RegExp
шаблон = sshd \ [\ d + \]: (? Принято | Не удалось). + \
для (? недействительный пользователь )?(? \ S +) из (? [\ d.] +) \
порт (? \ d +) ssh2
varmap = SSH
continue = TakeNext
desc = анализирует события входа в систему SSH и передает их следующим правилам
действие = нет

type = Single
ptype = Кэшировано
шаблон = SSH
context = SSH:> (sub {$ _ [0] -> {"status"} eq "Failed" && \
$ _ [0] -> {"порт"} <1024 && \
определено ($ _ [0] -> {"invuser"})})
desc = Зонд недействительного пользователя $ + {user} из привилегированного порта $ + {ip}
action = pipe '% t:% s' / bin / mail -s 'SSH alert' root @ localhost

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

sub {$ _ [0] -> {"status"} eq "Failed" && \
$ _ [0] -> {"порт"} <1024 && \
определено ($ _ [0] -> {"invuser"})}

Функция проверяет значения переменных соответствия $ + {status}, $ + {port} и $ + {invuser}.
под SSH запись и возвращает истину, если $ + {status} равно строке "Failed" (т. е.
попытка входа в систему не удалась), значение $ + {port} меньше 1024, а $ + {invuser} содержит
определенное значение (т. е. учетная запись пользователя не существует). Если функция (и, следовательно, контекст
выражение) оценивается как ИСТИНА, правило отправляет электронное письмо с предупреждением root @ localhost о том, что не-
существующая учетная запись пользователя была исследована с привилегированного порта клиентского хоста.

Если операнд контекстного выражения начинается с варсет ключевое слово, следующая строка будет
рассматривается как имя записи в кэше сопоставления с образцом. Операнд принимает значение ИСТИНА, если
данная запись существует, иначе - ЛОЖЬ.

Например, следующее определение выражения контекста оценивает ИСТИНА, если шаблон
запись в кэше соответствия SSH существует и под этой записью значение переменной соответствия
$ + {user} равно строке "risto":

context = varset SSH && SSH:> (sub {$ _ [0] -> {"user"} eq "risto"})

Если операнд контекстного выражения начинается со знака равенства (=), следующий текст должен
быть минипрограммой Perl, которая является допустимым параметром для Perl Eval() функция. В
минипрограмма может содержать переменные соответствия. Чтобы оценить минипрограмму Perl
операнд, он будет скомпилирован и выполнен путем вызова Perl Eval() в Perl
скалярный контекст (см. также раздел «ИНТЕГРАЦИЯ PERL»). Если возвращаемое значение из Eval() является
истина в логическом контексте Perl, операнд оценивает ИСТИНА, в противном случае он оценивает
ЛОЖНЫЙ. Обратите внимание, что в отличие от Perl-функций операторов -> и:>, которые скомпилированы
один раз при запуске SEC минипрограммы Perl компилируются перед каждым выполнением, и их
оценка, таким образом, значительно дороже.

Например, следующее выражение контекста оценивает ИСТИНА, если ни один из контекста C1
ни контекст C2 существует и значение переменной $ 1 равно строке
"myhost.mydomain":

context =! (C1 || C2) && = ("$ 1" eq "myhost.mydomain")

Поскольку && является короткозамкнутым оператором, код Perl

"$ 1" eq "myhost.mydomain"

* не * оценивается, если C1 or C2 существует.

Обратите внимание: поскольку функции и минипрограммы Perl могут содержать строки, которые конфликтуют с
операторы выражения контекста (например, '!'), рекомендуется заключать их в
круглые скобки, например,

context = $ 1 $ 2 -> (sub {$ _ [0]! = $ _ [1]})

context = = ({my ($ temp) = 0;! $ temp;})

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

context = ($ 1! $ 2) -> (sub {$ _ [0] eq $ _ [1]})

Если все выражение контекста заключено в квадратные скобки [], например, [МОЙКОНТЕКСТ1 &&
!МОЙКОНТЕКСТ2], SEC вычисляет выражение * до * сопоставления с образцом (обычно
шаблон сначала сопоставляется со строкой (ями) ввода, чтобы переменные сопоставления были инициализированы
и подставляется перед вычислением выражения). Однако, если выражение не
содержат переменные соответствия, и известно, что многие входные события соответствуют шаблону, но не
выражение, [] -оператор может сэкономить значительное количество процессорного времени.

ДЕЙСТВИЯ, ДЕЙСТВИЯ СПИСКИ И ДЕЙСТВИЯ СПИСОК ПЕРЕМЕННЫЕ

Списки действий определяются с помощью действие* поля правил. Список действий состоит из действий
определения, разделенные точкой с запятой. Каждое определение действия начинается с
ключевое слово, определяющее тип действия. В зависимости от типа действия могут следовать следующие параметры:
а непостоянные параметры могут содержать переменные соответствия. Например, если 1 и 2 доллара
Переменные соответствия имеют значения «test1» и «the second test», соответственно, действие
Создайте MYCONT_ $ 1 60 создает контекст MYCONT_test1 со сроком службы 60 секунд,
пока действие записывать - Команда имена of Тесты: $ 1, $2 записывает строку «Названия тестов:
test1, второй тест »на стандартный вывод. Чтобы использовать точки с запятой внутри не-
постоянный параметр, параметр должен быть заключен в круглые скобки (самый внешний набор
скобки будут удалены SEC во время синтаксического анализа файла конфигурации).

Например, следующий список действий состоит из удалять и shellcmd действия:

действие = удалить MYCONTEXT; shellcmd (RM /tmp/sec1.tmp; RM /tmp/sec2.tmp)

Команда удалять действие удаляет контекст МОЙ КОНТЕКСТ, В то время shellcmd действие выполняет
командной строки rm /tmp/sec1.tmp; rm /tmp/sec2.tmp. Поскольку командная строка содержит
точка с запятой, она была заключена в круглые скобки, так как в противном случае точка с запятой была бы
ошибочно считается разделителем между двумя действиями.

Помимо переменных соответствия, SEC поддерживает действие список переменные в списках действий, которые
облегчить обмен данными между действиями и интеграцию Perl. Каждая переменная списка действий
имеет имя, которое должно начинаться с буквы и состоять из букв, цифр и знаков подчеркивания.
Чтобы ссылаться на переменную списка действий, ее имя должно начинаться со знака процента.
(%). В отличие от переменных соответствия, переменные списка действий могут использоваться только в списках действий и
они заменяются их значениями непосредственно перед выполнением списка действий. Также,
Переменные списка действий продолжают существовать после выполнения текущего списка действий
и может использоваться в списках действий других правил.

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

% s - строка описания операции (значение по убыванию поле после переменных сопоставления имеет
были заменены их значениями). Обратите внимание, что для action2 поле пары и
PairWithWindow, переменная% s устанавливается путем вычисления описание2 поле правила.

% t - текущее время в удобочитаемом формате (возвращаемое функцией даты(1) полезность).

% u - текущее время в секундах с начала Эпохи (возвращенное функцией время(2) системный вызов).

Например, следующий список действий назначает текущее время в удобочитаемом формате.
и содержимое переменной соответствия $ 0 переменной списка действий% text и отправляет сообщение
значение% text для root @ localhost:

действие = назначить% text% t: $ 0; канал '% text' / bin / mail root @ localhost

Если список действий выполняется 19 ноября 10:58:51 2015 г. и переменная соответствия $ 0 имеет
значение "Это тестовое мероприятие", назначать action устанавливает для переменной списка действий% text значение
строка «Чт, 19 ноября, 10:58:51 2015: Это тестовое мероприятие», а труба действие отправляет это по почте
строка для root @ localhost. Обратите внимание, что в отличие от переменных соответствия, переменные списка действий имеют
глобальная область видимости и доступ к значению текстовой переменной% в списках действий других правил
таким образом даст строку «Thu Nov 19 10:58:51 2015: This is a test event» (до следующего
значение присваивается% text).

Чтобы исключить неоднозначность переменной из следующего текста, имя переменной должно быть
в фигурных скобках (например,% {s}). Кроме того, когда переменные списка действий заменяются на
их значения, каждая последовательность "%%" интерпретируется как буквальный знак процента (%), что позволяет
для маскировки переменных. Например, строка «s %% t» становится «s% t» после
замена, а не "s% ".

Однако обратите внимание, что если переменные соответствия с префиксом% поддерживаются для action2 поле
правила Pair или PairWithWindow, последовательность "%%%" должна использоваться в action2 для маскировки
переменной, поскольку строка проходит * два * раунда подстановки переменных (сначала для
Переменные соответствия с префиксом%, а затем для переменных списка действий, например, строка "s %%% t"
сначала становится «s %% t» и, наконец, «s% t»).

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

Если переменная списка действий не была установлена, она заменяется пустой строкой
(т.е. строка нулевой ширины). Таким образом, строка «Значение A:% a» становится «Значение A:
"после замены, если переменная% a не установлена. (Обратите внимание, что до SEC-2.6 не было установлено
переменные были * не * заменены.)

Наконец, значения заменяются строками, поэтому значения других типов (например,
ссылки) теряют свое первоначальное значение, если явно не указано иное (например, если
Ссылка на функцию Perl сохраняется в переменной списка действий, функция может быть позже
вызывается через эту переменную с призывают действие).

Поддерживаются следующие действия (необязательные параметры заключены в квадратные скобки):

нет Бездействие.

вход в систему [ ]
Сообщение регистрируется в местах назначения, указанных с --бревно и --syslog
параметры. Уровень сообщения журнала установлен на 4 (см. --отлаживать вариант для большего
информация об уровнях сообщений журнала). Значение по умолчанию для % s.

записывать [ ]
Нить с завершающей новой строкой записывается в файл
( не может содержать пробелов). Файл может быть обычным файлом, именованным каналом или
стандартный вывод (обозначается -). Если это обычный файл, является
добавляется в конец файла. Если файл не существует, он создается как
обычный файл перед записью. Обратите внимание, что файл не будет закрыт после
действие завершается, и следующие записывать действия будут обращаться к уже открытому файлу.
Однако несколько сигналов вызывают закрытие и повторное открытие файла (см. СИГНАЛЫ
раздел для получения дополнительной информации). Значение по умолчанию для % s.

Writen [ ]
Как и в случае записывать действие, за исключением того, что строка написано без
завершение новой строки. Обратите внимание, что записывать и Writen действия имеют один и тот же дескриптор файла
для доступа к файлу.

Closef
Закройте файл который ранее был открыт записывать or Writen
действие ( не может содержать пробелов).

owritecl [ ]
Как и в случае записывать действие, за исключением того, что файл открывается и закрывается
при каждой записи. Также строка пишется без символа новой строки в конце.
Если файл уже был открыт предыдущим записывать действие, owritecl не
использовать существующий дескриптор файла, но открывает и закрывает файл отдельно.

удграм [ ]
Нить записывается в сокет дейтаграммы UNIX ( мая
не содержать пробелов). Обратите внимание, что сокет не будет закрыт после действия
завершается, и следующие удграм действия будут обращаться к уже открытому сокету.
Однако несколько сигналов вызывают закрытие и повторное открытие сокета (см. СИГНАЛЫ
раздел для получения дополнительной информации). Значение по умолчанию для % s.

близкий
Закройте сокет дейтаграммы UNIX который ранее был открыт
удграм действие ( не может содержать пробелов).

Ustream [ ]
Нить записывается в сокет потока UNIX ( может нет
содержат пробелы). Обратите внимание, что сокет не будет закрыт после действия
завершается, и следующие Ustream действия будут обращаться к уже открытому сокету.
Однако несколько сигналов вызывают закрытие и повторное открытие сокета (см. СИГНАЛЫ
раздел для получения дополнительной информации). Значение по умолчанию для % s.

Closeustr
Закройте сокет потока UNIX который ранее был открыт
Ustream действие ( не может содержать пробелов).

удпсок : [ ]
Нить отправляется на порт UDP хозяина . Обратите внимание, что
UDP-сокет, который используется для связи, не будет закрыт после действия
завершается, и следующие удпсок действия для того же удаленного узла будут использовать
уже существующая розетка. Однако несколько сигналов вызывают закрытие сокета.
и воссоздан (см. раздел СИГНАЛЫ для получения дополнительной информации). Значение по умолчанию для
% s.

Closeudp :
Закройте UDP-сокет для однорангового узла : который ранее был открыт
удпсок действия.

tcpsock : [ ]
Нить отправляется в порт TCP хозяина . Тайм-аут
значение, указанное с --сокет-тайм-аут опция определяет, сколько секунд SEC
попытается установить соединение с удаленным узлом. Если подключение
учреждение не удается сразу, tcpsock буферы действий в
память для последующей отправки удаленному узлу. Обратите внимание, что соответствующий сокет TCP
не закроется после был передан, и следующие tcpsock
действия для того же однорангового узла будут использовать уже существующий сокет. Однако несколько
сигналы заставляют сокет быть закрытым и воссозданным (см. раздел СИГНАЛЫ для получения дополнительной информации
Информация). Значение по умолчанию для % s.

шкаф :
Закройте TCP-сокет для однорангового узла : который ранее был открыт
tcpsock действия.

shellcmd
Форк процесс для выполнения командной строки . Если - цитирование вариант был
указано и содержит% s переменных, значение% s заключено в кавычки
одинарные кавычки перед заменой на ; если значение% s содержит
одинарные кавычки, они маскируются обратной косой чертой (например, abc преобразуется в 'abc'
и aa'bb преобразуется в 'aa' \ '' bb '). Для получения дополнительной информации см.
Раздел ОБЩЕНИЕ В ПРОЦЕССЕ.

порождать
Как и в случае shellcmd действие, за исключением того, что каждая строка из стандартного вывода
становится синтетическим событием и будет рассматриваться как строка из входного файла
(См мероприятие действие для получения дополнительной информации). Если --intcontexts командной строки
задана опция, внутренний контекст _INTERNAL_EVENT устанавливается перед каждым синтетическим
событие обрабатывается (подробнее см. в разделе ВНУТРЕННИЕ СОБЫТИЯ И КОНТЕКСТЫ).

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

труба '[ ] ' [ ]
Форк процесс для выполнения командной строки . Струна с
завершение новой строки записывается на стандартный ввод (одинарные кавычки
используются для устранения неоднозначности из ). Если содержит
точка с запятой, должны быть заключены в круглые скобки (например, труба '(1 доллар; 2 доллара)'
/ bin / cat). Значение по умолчанию для % s. Если опущено, является
записывается на стандартный вывод. Для получения дополнительной информации см. ИНТЕРПРОЦЕСС.
СВЯЗЬ.

Создайте [ [ [ список>] ] ]
Создайте контекст с именем , время жизни секунды и пустое событие
хранить. В Параметр не может содержать пробелов и по умолчанию равен% s. В
Параметр должен оцениваться как целое число без знака во время выполнения. Указав 0 для
или пропуск значения означает бесконечное время жизни. Если дано,
он будет выполнен, когда истечет контекст. Если содержит несколько
действия, список должен быть заключен в круглые скобки. В , внутренний
имя контекста _ЭТО может использоваться для ссылки на текущий контекст (см. ВНУТРЕННИЙ
СОБЫТИЯ И КОНТЕКСТЫ для детального обсуждения). Если уже существующий
контекст воссоздается с помощью Создайте, его оставшийся срок службы установлен на секунды,
его список действий повторно инициализируется, а его хранилище событий очищается.

удалять [ ]
Удалить контекст . В параметр не может содержать пробелов и
по умолчанию% s.

устаревший [ ]
Как и в случае удалять действие, за исключением того, что список действий контекста (если
присутствует) выполняется перед удалением.

набор [ список>]
Изменить настройки контекста . Время создания контекста установлено на
текущее время, а время жизни контекста установлено на секунд. Если
задан параметр, список контекстных действий установлен на .
В Параметр не может содержать пробелов и по умолчанию равен% s. В
Параметр должен оцениваться как целое число без знака или дефис (-) во время выполнения.
Указав 0 для означает бесконечное время жизни. Если равно -,
время создания и время жизни контекста не меняются. Если
содержит несколько действий, список должен быть заключен в круглые скобки. В
list>, имя внутреннего контекста _THIS может использоваться для ссылки на текущий
контекст (подробное обсуждение см. в разделе ВНУТРЕННИЕ СОБЫТИЯ И КОНТЕКСТЫ).

псевдоним [ ]
Создайте псевдоним для контекста . После создания оба
а также будет указывать на ту же структуру данных контекста и, таким образом, может использоваться
взаимозаменяемо для ссылки на контекст. В а также параметры
не может содержать пробелов и по умолчанию% s. Если контекст делает
не существует, псевдоним не создается. Если удалять действие призвано для одного
контекстных имен, структура данных контекста уничтожается, и весь контекст
имена (которые теперь являются указателями на нераспределенную память) перестают существовать. Также обратите внимание, что
когда контекст истекает, его список действий выполняется только один раз, независимо от того, сколько
имена, которые имеет контекст.

Unalias [ ]
Удалить существующее имя контекста , так что его больше нельзя использовать для
ссылаясь на данный контекст. В параметр не может содержать пробелов
и по умолчанию% s. Если имя последняя ссылка на контекст,
Unalias действие идентично удалять.

[ ]
Нить добавляется в конец хранилища событий контекста .
В параметр не может содержать пробелов, а параметр
по умолчанию% s. Если контекст не существует, контекст создается с помощью
бесконечное время жизни, пустой список действий и пустое хранилище событий (как с Создайте
) перед добавлением строки в хранилище событий. Если это многострочный
строка (т. е. содержит символы новой строки), она разбивается на строки, и каждая строка
добавляется в хранилище событий отдельно.

перед именем [ ]
Как и в случае действие, за исключением того, что строка добавляется к
начало хранилища событий контекста .

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

докладе [ ]
Форк процесс для выполнения командной строки , и напишите строки из
хранилище событий контекста на стандартный ввод . Струны
записываются в том порядке, в котором они появляются в хранилище событий, с символом новой строки в конце
добавляется к каждой строке. Если контекст не существует или его хранилище событий
пустой, не выполняется. В параметр не может содержать
пробел, а если опускается, строки выводятся на стандартный вывод.
Для получения дополнительной информации см. Раздел «СВЯЗЬ С ПОМОЩЬЮ ПРОЦЕССА».

копия %
Строки s1, ..., sn из хранилища событий контекста объединены в
многострочная строка "s1 ... sn ", и эта строка присваивается
Переменная списка действий% . Если контекст не существует, значение
% не меняется.

пустой [% ]
Как и в случае копия действие, за исключением того, что хранилище событий контекста буду
опорожняться после задания. Если% не указан, содержание события
магазин сброшен без назначения.

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

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

существует %
Если контекст существует, установите для переменной списка действий% значение 1, иначе
установите% на 0.

Getize %
Найдите количество строк в хранилище событий контекста , и назначьте это
номер в переменную списка действий% . Если контекст не существует,
% установлен на неопределенное значение Perl.

Getaliases %
Найдите все псевдонимы для контекста , объедините имена в многострочную строку
"псевдоним1 ... aliasn "и назначьте эту строку списку действий
переменная% . Если контекст не существует, значение% не существует
не изменить.

Getltime %
Найдите время жизни контекста , и присвойте этот номер списку действий
переменная% . Если контекст не существует, значение% не существует
не изменить.

получить время %
Найдите время создания контекста , и присвойте этот номер списку действий
переменная% . Если контекст не существует, значение% не существует
не изменить.

время установки
Установите время создания контекста к . В параметр должен
оценивается в секундах с начала эпохи (как сообщает время(2) системный вызов) и должен
отражают момент времени между временем предыдущего создания и текущим временем (оба
конечные точки включены).

мероприятие [ ] [ ]
После секунд, создайте синтетическое событие . Если это мульти-
строка строки (т.е. она содержит символы новой строки), она разбивается на строки, и из каждого
line создается отдельное синтетическое событие. SEC будет рассматривать каждое синтетическое событие
как строка из входного файла - событие будет сопоставлено с правилами, и оно
может вызвать дальнейшие действия. Если --intcontexts указан параметр командной строки,
внутренний контекст _INTERNAL_EVENT настроен для синтетических событий (см. ВНУТРЕННИЙ
Раздел СОБЫТИЯ И КОНТЕКСТЫ). В параметр - это
целочисленная константа. Указав 0 для или пропуск значения означает «сейчас».
Значение по умолчанию для % s.

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

Cevent [ ]
Как и в случае Tevent действие, за исключением того, что если --intcontexts опция командной строки
дан, внутренний контекст настроен для синтетических событий.

сброс [ ] [ ]
Завершить операцию (операции) корреляции событий с помощью строки описания операции
. Обратите внимание, что сброс действие работает только для операций, запущенных с
тот же файл конфигурации. В параметр используется для обозначения определенного
правило в файле конфигурации. Если дано, операция, начатая
данное правило прекращено (если оно существует). Если беззнаковое целое число N, оно
относится к N-му правилу в файле конфигурации. Если равно 0, это относится к
текущее правило. Если начинается со знака плюс (+) или минус (-), это
задает смещение от текущего правила (например, -1 обозначает предыдущее, а +1 -
следующее правило). Если не указан, SEC проверяет каждое правило из текущего
файл конфигурации, если операция с был запущен по этому правилу, и
операция прекращается, если она существует. Значение по умолчанию для % s. Для
дополнительную информацию см. в разделе ОПЕРАЦИИ КОРРЕЛЯЦИИ СОБЫТИЙ.

getwpos % [ ]
Найдите начало окна корреляции событий для корреляции событий
операции и установите для переменной списка действий% эту отметку времени. Значение
присвоенный% измеряется в секундах с начала эпохи (как сообщает время(2)
системный вызов). Как и в случае с сброс действие, операция корреляции событий
идентифицируется строкой описания операции и смещение правила
. Если операция не существует, значение% не меняется.
Значение по умолчанию для % s. Для получения дополнительной информации см. СОБЫТИЕ.
Раздел КОРРЕЛЯЦИОННЫЕ ОПЕРАЦИИ.

установка [ ]
Установите начало окна корреляции событий на для мероприятия
операция корреляции (если она существует). В параметр должен оцениваться в секундах
с Эпохи (как сообщает время(2) системный вызов) и должен отражать время
момент между предыдущей позицией окна и текущим временем (обе конечные точки
включены). Как и в случае с сброс действие, операция корреляции событий идентифицируется
по строке описания операции и смещение правила . Дефолт
ценность для % s. Для получения дополнительной информации см. КОРРЕЛЯЦИЯ СОБЫТИЙ.
Раздел ОПЕРАЦИИ.

назначать % [ ]
Назначить строку в переменную списка действий% . Значение по умолчанию для
% s.

присваивает q % [ ]
Как и в случае назначать действие, кроме этого заключен в одинарные кавычки
прежде чем присвоить его% . Если содержит одинарные кавычки, они замаскированы
с обратной косой чертой (например, если переменная соответствия $ 1 содержит значение abc'123'xyz,
действие присваивает q % myvar $1 присваивает значение 'abc' \ '' 123 '\' 'xyz' списку действий
переменная% myvar). Это действие полезно для отключения интерпретации оболочки для
значения переменных списка действий, которые появляются в командных строках, выполняемых SEC.
Значение по умолчанию для % s.

бесплатно %
Отмените установку переменной списка действий% .

Eval %
Параметр is a Perl miniprogram that is compiled and executed by calling
Perl Eval() в контексте списка Perl. Если минипрограмма возвращает
единственное значение, оно присваивается переменной списка действий% . Если минипрограмма
возвращает несколько значений s1, ..., sn, они объединены в многострочную строку
"s1 ... sn ", и эта строка присваивается% . Если значение не
возвращается,% устанавливается на неопределенное значение Perl. Если Eval() терпит неудачу, значение
% не меняется. Поскольку большинство программ Perl содержат точки с запятой, которые также являются
используемых SEC в качестве разделителей действия, рекомендуется заключить
в скобках, чтобы замаскировать точки с запятой в . For . For
дополнительную информацию см. в разделе «ИНТЕГРАЦИЯ PERL».

призывают % % [ ]
Вызов предварительно скомпилированной функции Perl, на которую ссылается переменная списка действий% ,
и присвойте результат переменной списка действий% . % параметр
должна быть ссылка на код, который был ранее создан с Eval действие. В
параметр (если задан) - строка, определяющая параметры для
функция. Параметры должны быть разделены пробелом в нить.
Если функция возвращает единственное значение, ему присваивается% . Если функция
возвращает несколько значений s1, ..., sn, они объединены в многострочную строку
"s1 ... sn ", и эта строка присваивается% . Если значение не
возвращается,% устанавливается на неопределенное значение Perl. Если функция встречает
фатальная ошибка времени выполнения или% не является ссылкой на код, значение% не
изменение. Для получения дополнительной информации см. Раздел «ИНТЕГРАЦИЯ PERL».

звонить % [ ] ->
Вызовите предварительно скомпилированную функцию Perl and assign the result to the action list
переменная% . parameter must be a valid Perl function definition
который компилируется при запуске SEC с Perl Eval() функция и Eval() должен
вернуть ссылку на код. В параметр (если задан) - это строка, которая
определяет параметры функции. Параметры должны быть разделены символом
пробел в нить. Если функция возвращает одно значение, она
присваивается% . Если функция возвращает несколько значений s1, ..., sn, они
объединены в многострочную строку "s1 ... sn ", и эта строка
присвоено% . Если значение не возвращается, для% устанавливается неопределенное значение Perl.
Если функция обнаруживает фатальную ошибку времени выполнения, значение% не изменяется.
изменение. Поскольку большинство функций Perl содержат точки с запятой, которые также используются
SEC как разделители действий, рекомендуется заключить parameter in
круглые скобки, чтобы замаскировать точки с запятой в . For additional . For additional
информацию см. в разделе «ИНТЕГРАЦИЯ PERL».

переписывать [ ]
Заменить последний строки во входном буфере со строкой . Если
--nojointbuf была указана опция, и действие запускается соответствующим событием,
действие изменяет буфер, содержащий это событие. Если --nojointbuf вариант
был указан, и действие запускается системными часами (например, действие
выполняется из правила календаря), действие изменяет буфер, содержащий
последнее уже обработанное событие. С --jointbuf вариант, содержание стыка
входной буфер перезаписывается. В параметр должен оцениваться как беззнаковый
целое число во время выполнения. Если оценивается как 0, сбрасывается на количество
линии в . Если значение больше, чем размер буфера N,
сбрасывается на N. Если содержит меньше чем линии буду
быть дополненными ведущими пустыми строками. Если содержит более чем линии
только ведущий строки из записываются в буфер. Значение по умолчанию
для % s. Для получения дополнительной информации см. ОБРАБОТКА ВВОДА И ВРЕМЯ.
.

if % ( <действие список> ) [ еще ( <действие список2> ) ]
Если переменная списка действий% имеет значение true в логическом контексте Perl
(т.е. он содержит определенное значение, которое не является ни 0, ни пустой строкой), выполните команду
Список действия . Если второй список действий дается с
необязательный оператор else, он выполняется, если% либо не существует, либо
оценивает false (т.е.% содержит 0, пустую строку или неопределенное значение Perl).

в то время как % ( <действие список> )
Выполнить список действий неоднократно, пока список действий
переменная% оценивается как истина в логическом контексте Perl (т. е. она содержит
определенное значение, которое не является ни 0, ни пустой строкой).

перерыв Если используется внутри цикла while, завершает его выполнение; в противном случае прекращает
выполнение всего списка действий.

продолжать
Если используется внутри цикла while, запускает следующую итерацию цикла; иначе
прекращает выполнение всего списка действий.

Примеры:

Следуйте за файлом /var/log/trapd.log и передайте в SEC input все строки, добавленные к
файл:

действие = spawn / bin / tail -f /var/log/trapd.log

Отправьте метку времени и значение переменной $ 0 в локальный корень:

action = pipe '% t: $ 0' / bin / mail -s "предупреждающее сообщение" root @ localhost

Добавьте значение переменной $ 0 в хранилище событий контекста ftp_ ценностное of $ 1>,
и установите контекст, который истекает через 30 минут. Когда контекст истекает, его хранилище событий
будет отправлено в локальный корень:

действие = добавить ftp_ $ 1 $ 0; \
установить ftp_ $ 1 1800 (сообщить ftp_ $ 1 / bin / mail root @ localhost)

Создайте подпрограмму для удаления строк комментариев из списка ввода и используйте это
подпрограмма для удаления строк комментариев из хранилища событий контекста C1:

действие = eval% funcptr (sub {my (@buf) = split (/ \ n /, $ _ [0]); \
мой (@ret) = grep (! / ^ # /, @buf); return @ret; }); \
скопируйте C1% в; вызовите% out% funcptr% in; заполнить C1%

Следующий список действий достигает той же цели, что и предыдущий список действий с в то время как
и if действия:

действие = получает размер% размер C1; в то время как% size (событие сдвига C1%; \
lcall% nocomment% событие -> (sub {$ _ [0]! ~ / ^ # /}); \
если% nocomment (добавить событие C1%); \
lcall% size% size -> (sub {$ _ [0] -1;}))

РАЗБОР ВОПРОСЫ

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

действие = eval% o (печать ")";)

считается недопустимым списком действий (однако учтите, что
действие = eval% o (print "()";)
будет передано SEC, поскольку теперь круглые скобки уравновешены). Во избежание таких
при синтаксическом анализе каждая скобка без дубликата должна быть замаскирована обратной косой чертой
(обратная косая черта будет удалена SEC во время синтаксического анализа файла конфигурации). Например,
указанное выше действие можно записать как

действие = eval% o (печать "\)";)

ПРАВИЛО ВИДЫ

В этом разделе подробно обсуждаются типы правил SEC.

SINGLE ПРАВИЛО
Команда Один rule немедленно выполняет список действий, когда событие соответствует правилу.
Событие соответствует правилу, если шаблон соответствует событию и контекстному выражению (если
дано) оценивает ИСТИНА.

Единое правило поддерживает следующие поля:

напишите фиксировано на Single (значение не чувствительно к регистру, поэтому можно использовать single или sIngLe
вместо).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный).

тип тип шаблона (значение без учета регистра).

описания
шаблону.

вармап (опционально)
переменная карта.

контекст (опционально)
контекстное выражение.

по убыванию Строка описания операции.

действие Список действия.

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

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

Примеры:

type = single
продолжить = takenext
ptype = регулярное выражение
pattern = ftpd \ [(\ d +) \]: \ S + \ (ristov2. * FTP-сессия открыта
desc = ftp-сессия открыта для ristov2 pid $ 1
действие = создать ftp_ $ 1

type = single
продолжить = takenext
ptype = регулярное выражение
шаблон = ftpd \ [(\ d +) \]:
context = ftp_ $ 1
desc = событие сеанса ftp для ristov2 pid $ 1
действие = добавить ftp_ $ 1 $ 0; установить ftp_ $ 1 1800 \
(сообщить ftp_ $ 1 / bin / mail root @ localhost)

type = single
ptype = регулярное выражение
pattern = ftpd \ [(\ d +) \]: \ S + \ (ristov2. * FTP-сессия закрыта
desc = ftp-сессия закрыта для ristov2 pid $ 1
действие = отчет ftp_ $ 1 / bin / mail root @ localhost; \
удалить ftp_ $ 1

Этот набор правил создан для мониторинга файла журнала ftpd. Первое правило создает
контекст ftp_ когда кто-то подключается с хоста ристов2 через FTP и устанавливает новый
ftp-сессия (сессия идентифицируется PID процесса, который был создан
для обработки этого сеанса). Второе правило добавляет все дальнейшие строки файла журнала для
сессия в хранилище событий контекста ftp_ (перед добавлением строки правило
проверяет, существует ли контекст). После добавления строки правило продлевает время жизни контекста
на 30 минут и задает список действий, которые будут выполнены по истечении контекста.
Третье правило отправляет собранные строки файла журнала на root @ localhost, когда сеанс является
закрыто. Собранные строки также будут отправлены по почте, когда сеанс был неактивен в течение
30 минут (ни одной строки файла журнала для этого сеанса не наблюдалось).

Обратите внимание, что строка файла журнала, соответствующая первому правилу, также сопоставляется с
второе правило (так как первое правило имеет продолжать поле установлено в TakeNext). Поскольку
второе правило всегда соответствует этой строке, оно станет первой строкой в ​​хранилище событий
ftp_. Второе правило также имеет продолжать в поле TakeNext, иначе
никакие строки файла журнала не дойдут до третьего правила.

ОДИН СЦЕНАРИЙ ПРАВИЛО
Команда Сингл со скриптом Правило разветвляет процесс для выполнения внешней программы, когда событие
соответствует правилу. Имена всех существующих в настоящее время контекстов записываются в
стандартный ввод программы. После того, как программа была разветвлена, соответствие правил
продолжается немедленно, и статус программы будет периодически проверяться до тех пор, пока
программа выходит. Если программа возвращает 0 статус выхода, список действий, определяемый
действие поле выполнено; в противном случае список действий, определяемый action2 поле
выполнено (если дано).

Правило SingleWithScript поддерживает следующие поля:

напишите зафиксирован на SingleWithScript (значение не чувствительно к регистру).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный).

тип тип шаблона (значение без учета регистра).

описания
шаблону.

вармап (опционально)
переменная карта.

контекст (опционально)
контекстное выражение.

скрипт внешняя программа.

по убыванию Строка описания операции.

действие Список действия.

action2 (опционально)
Список действия.

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

Обратите внимание, что переменные соответствия могут использоваться в контекст, скрипт, по убыванию, действиеи action2
поля. Также обратите внимание, что это правило не запускает операцию корреляции событий, и
по убыванию Поле используется только для установки переменной списка действий% s.

Примеры:

type = SingleWithScript
ptype = RegExp
шаблон = интерфейс ([\ d.] +) вниз
скрипт =/ bin / ping -c 3 -q 1 доллар
desc = Проверить, отвечает ли $ 1 на пинг
action = logonly Интерфейс $ 1 не работает, но его можно проверить
action2 = pipe '% t: интерфейс $ 1 не работает' / bin / mail root @ localhost

Когда "интерфейс на входе появляется строка "вниз", правило проверяет,
отвечает на пинг. Если pingable, сообщение "Интерфейс сообщил
не работает, но доступен для проверки связи "; в противном случае по электронной почте будет отправлено предупреждение, содержащее удобочитаемый
метка времени отправляется на root @ localhost.

ОДИН СУПРЕСС ПРАВИЛО
Команда Синглвиссупресс правило запускает операции корреляции событий для фильтрации повторяющихся
экземпляров одного и того же события в течение T секунд. Значение T определяется окно
поле.

Когда событие соответствует правилу, SEC оценивает заданную строку описания операции.
с по убыванию поле. Если операция для данной строки и правила не существует, SEC
создаст его со временем жизни T секунд, и операция немедленно выполнит
Список действия. Если операция существует, она потребляет соответствующее событие без каких-либо действий.

Правило SingleWithSuppress поддерживает следующие поля:

напишите зафиксировано на SingleWithSuppress (значение не чувствительно к регистру).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный).

тип тип шаблона (значение без учета регистра).

описания
шаблону.

вармап (опционально)
переменная карта.

контекст (опционально)
контекстное выражение.

по убыванию Строка описания операции.

действие Список действия.

окно размер окна корреляции событий (значение - целочисленная константа).

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

Обратите внимание, что переменные соответствия могут использоваться в контекст, по убываниюи действие полей.

Примеры:

type = SingleWithSuppress
ptype = RegExp
pattern = (\ S +): [fF] файловая система заполнена
desc = Файловая система $ 1 заполнена
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 900

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

16 декабря, 14:26:09 test ufs: [ID 845546 kern.notice] ВНИМАНИЕ: alloc: / вар: файловая система заполнена

Когда наблюдается первое сообщение для файловой системы, создается операция, которая отправляет
предупреждение об этой файловой системе по электронной почте на адрес root @ localhost. Затем операция будет запущена
в течение 900 секунд и молча потреблять дальнейшие сообщения для * той же * файловой системы.
Однако, если будет обнаружено сообщение для другой файловой системы, будет выполнена другая операция.
start, который снова отправляет предупреждение root @ localhost (поскольку по убыванию поле содержит
$ 1 соответствует переменной, которая соответствует имени файловой системы).

PAIR ПРАВИЛО
Команда пара правило запускает операции корреляции событий для обработки пар событий в течение T
секунд. Значение T определяется окно поле. Значение по умолчанию - 0, что означает
бесконечность.

Когда событие соответствует условиям, определенным описания и контекст поле, SEC
оценивает строку описания операции, заданную с помощью по убыванию поле. Если операция
для данной строки и правила существует соответствующее событие без каких-либо действий.
Если операция не существует, SEC создаст ее со временем жизни T секунд, и
операция немедленно выполняет список действий, определенный действие поле. SEC будет
также скопируйте условия соответствия, указанные с pattern2 и контекст2 поле в
операции и замените переменные сопоставления их значениями в скопированных условиях.

Если событие не соответствует условиям, определенным описания и контекст поле, SEC будет
проверить условия совпадения всех операций, запущенных данным правилом. Каждое совпадение
операция выполняет список действий, указанный с action2 поле и отделка.

Если переменные соответствия установлены, когда операция соответствует событию, они становятся доступными как
переменные соответствия с префиксом $ в контекст2, описание2и action2 поля определения правила.
Например, если pattern2 является регулярным выражением, тогда $ 1 в описание2 поле установлено
by pattern2. Чтобы получить доступ к переменным соответствия, установленным описания, совпадение с префиксом%
переменные должны использоваться в контекст2, описание2и action2 поля. Например, если описания
и pattern2 являются регулярными выражениями, тогда% 1 в описание2 поле относится к набору значений
первой группой захвата в описания (т. е. он имеет то же значение, что и $ 1 в по убыванию
поле).

Правило пары поддерживает следующие поля:

напишите зафиксировано на Pair (значение не чувствительно к регистру).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный). Определяет точку продолжения после матча по описания и контекст.

тип тип шаблона для описания (значение не чувствительно к регистру).

описания
шаблону.

вармап (опционально)
карта переменных для описания.

контекст (опционально)
выражение контекста, вычисляемое вместе с описания.

по убыванию Строка описания операции.

действие Список действия.

продолжить2 (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный). Определяет точку продолжения после матча по pattern2 и
контекст2.

ptype2 тип шаблона для pattern2 (значение не чувствительно к регистру).

pattern2
шаблону.

вармап2 (опционально)
карта переменных для pattern2.

контекст2 (опционально)
выражение контекста, вычисляемое вместе с pattern2.

описание2 строка формата, которая устанавливает переменную% s для action2.

action2
Список действия.

окно (опционально)
размер окна корреляции событий (значение - целочисленная константа).

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

Обратите внимание, что переменные соответствия могут использоваться в контекст, по убыванию, действие, pattern2, контекст2, описание2,
и action2 полей.

Примеры:

type = Пара
ptype = RegExp
pattern = kernel: nfs: server (\ S +) не отвечает, все еще пытается
desc = Сервер $ 1 не отвечает
действие = канал '% t:% s' / bin / mail root @ localhost
ptype2 = SubStr
pattern2 = ядро: nfs: server $ 1 ОК
desc2 = Сервер $ 1 снова отвечает
действие2 = вход в систему
окно = 3600

Это правило запускает операции корреляции событий для обработки NFS «сервер не отвечает» и
сообщения системного журнала "server OK", например,

18 декабря 22:39:48 тестовое ядро: nfs: сервер box1 не отвечает, все еще пытается
18 декабря 22:42:27 тестовое ядро: nfs: server box1 ОК

Когда появляется сообщение «сервер не отвечает» для сервера NFS, выполняется операция
создан для этого сервера, который отправляет по электронной почте предупреждение о сервере на root @ localhost.
Затем операция будет выполняться в течение 3600 секунд и беззвучно потребляет "сервер, а не
отвечающие "сообщения для того же сервера. Если эта операция обнаруживает сообщение" сервер ОК "
для * того же * сервера будет записано сообщение «Сервер снова отвечает "
и закончить.

Например, если SEC наблюдает следующее событие в 22:39:48

18 декабря 22:39:48 тестовое ядро: nfs: сервер box1 не отвечает, все еще пытается

для сервера box1 создается операция корреляции событий, которая выдает предупреждение по электронной почте
об этом сервере немедленно. После этого операция продлится 3600 секунд (до
23:39:48), ожидая события, которое будет содержать подстроку "kernel: nfs: server
box1 OK "(потому что pattern2 поле содержит переменную соответствия $ 1, которая оценивается как
название сервера).

Если какие-либо другие сообщения об ошибках появляются для server box1 в течение 3600 секунд жизни
операция, например,

18 декабря 22:40:28 тестовое ядро: nfs: сервер box1 не отвечает, все еще пытается
18 декабря 22:41:09 тестовое ядро: nfs: сервер box1 не отвечает, все еще пытается

эти сообщения будут незаметно обработаны операцией. Если до истечения срока
операция наблюдает за событием, содержащим подстроку "kernel: nfs: server box1 OK",
например,

18 декабря 22:42:27 тестовое ядро: nfs: server box1 ОК

операция зарегистрирует сообщение «Сервер box1 снова отвечает» и завершится
немедленно. Если такое сообщение не появляется в течение 3600 секунд работы операции,
операция истечет без каких-либо действий. Обратите внимание, что если окно поле
будет либо удален из определения правила, либо установлен на 0, операция никогда не будет
молча истекает, но завершится только после наблюдения за событием, содержащим
подстрока «ядро: nfs: server box1 OK».

Если указанное выше правило изменено следующим образом

type = Пара
ptype = RegExp
шаблон = ^ ([[: alnum:]:] +) \ S + ядро: nfs: сервер (\ S +) не отвечает, все еще пытается
desc = Сервер $ 2 не отвечает
действие = вход в систему
ptype2 = RegExp
шаблон2 = ^ ([[: alnum:]:] +) \ S + ядро: nfs: сервер $ 2 ОК
desc2 = Сервер% 2 был недоступен с% 1 до $ 1
action2 = pipe '% s' / bin / mail root @ localhost
окно = 86400

это правило будет запускать операции корреляции событий, которые сообщают о простоях сервера NFS в
root @ localhost по электронной почте при условии, что время простоя не превышает 24 часов (86400
секунд).

Например, если SEC наблюдает следующее событие

18 декабря 23:01:17 тестовое ядро: nfs: server box.test не отвечает, все еще пытается

тогда правило соответствует этому событию, устанавливает переменную соответствия $ 1 равной "18 декабря 23:01:17" и $ 2 равной
"box.test" и создает операцию корреляции событий для сервера box.test. Этот
операция начнет свою работу с регистрации сообщения «Сервер box.test не отвечает»,
и затем будет работать в течение 86400 секунд, ожидая события, которое будет соответствовать обычному
выражение

^ ([[: alnum:]:] +) \ S + kernel: nfs: server box \ .test OK

Обратите внимание, что это выражение было создано из шаблона регулярного выражения в pattern2
поле, заменив переменную совпадения $ 2 ее значением. Однако, поскольку строка
"box.test" содержит символ точки (.), который является метасимволом регулярного выражения,
точка в регулярном выражении маскируется обратной косой чертой.

Предположим, что SEC будет наблюдать за событием.

18 декабря 23:09:54 тестовое ядро: nfs: server box.test OK

Это событие соответствует указанному выше регулярному выражению, которое используется операцией, выполняемой для
сервер box.test. Кроме того, совпадение регулярного выражения устанавливает для переменной $ 1 значение «18 декабря.
23:09:54 "и сбрасывает переменную $ 2. Чтобы вернуться к исходным значениям, когда
была создана операция, переменные соответствия% 1 и% 2 должны использоваться в описание2 поле (% 1
равно «18 декабря 23:01:17» и% 2 равно «box.test»). Следовательно, операция будет
отправить электронное сообщение "Сервер box.test был недоступен с 18 декабря 23:01:17 по 18 декабря.
23:09:54 "в root @ localhost и немедленно прекратит работу.

ПАРА С ОКНОМ ПРАВИЛО
Команда Пара с окном правило запускает операции корреляции событий для обработки пар событий
в течение T секунд. Значение T определяется окно поле.

Когда событие соответствует условиям, определенным описания и контекст поле, SEC
оценивает строку описания операции, заданную с помощью по убыванию поле. Если операция
для данной строки и правила существует соответствующее событие без каких-либо действий.
Если операция не существует, SEC создаст ее со временем жизни T секунд. SEC
также скопирует условия совпадения, указанные с pattern2 и контекст2 поле в
операции и замените переменные сопоставления их значениями в скопированных условиях.

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

Если переменные соответствия установлены, когда операция соответствует событию, они становятся доступными как
переменные соответствия с префиксом $ в контекст2, описание2и action2 поля определения правила.
Например, если pattern2 является регулярным выражением, тогда $ 1 в описание2 поле установлено
by pattern2. Чтобы получить доступ к переменным соответствия, установленным описания, совпадение с префиксом%
переменные должны использоваться в контекст2, описание2и action2 поля. Например, если описания
и pattern2 являются регулярными выражениями, тогда% 1 в описание2 поле относится к набору значений
первой группой захвата в описания (т. е. он имеет то же значение, что и $ 1 в по убыванию
поле).

Правило PairWithWindow поддерживает следующие поля:

напишите зафиксировано на PairWithWindow (значение не чувствительно к регистру).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный). Определяет точку продолжения после матча по описания и контекст.

тип тип шаблона для описания (значение не чувствительно к регистру).

описания
шаблону.

вармап (опционально)
карта переменных для описания.

контекст (опционально)
выражение контекста, вычисляемое вместе с описания.

по убыванию Строка описания операции.

действие Список действия.

продолжить2 (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный). Определяет точку продолжения после матча по pattern2 и
контекст2.

ptype2 тип шаблона для pattern2 (значение не чувствительно к регистру).

pattern2
шаблону.

вармап2 (опционально)
карта переменных для pattern2.

контекст2 (опционально)
выражение контекста, вычисляемое вместе с pattern2.

описание2 строка формата, которая устанавливает переменную% s для action2.

action2
Список действия.

окно размер окна корреляции событий (значение - целочисленная константа).

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

Обратите внимание, что переменные соответствия могут использоваться в контекст, по убыванию, действие, pattern2, контекст2, описание2,
и action2 полей.

Примеры:

type = PairWithWindow
ptype = RegExp
pattern = sshd \ [\ d + \]: Ошибка. + для (\ S +) из ([\ d.] +) порта \ d + ssh2
desc = Пользователь $ 1 не смог войти в систему с $ 2 по SSH в течение 1 минуты
действие = канал '% t:% s' / bin / mail root @ localhost
ptype2 = RegExp
pattern2 = sshd \ [\ d + \]: принято. + для $ 1 с порта $ 2 \ d + ssh2
desc2 = SSH-вход в систему для% 1 с% 2 успешно после первоначального сбоя
действие2 = вход в систему
окно = 60

Это правило запускает операции корреляции событий для обработки событий входа в систему SSH, например,

27 декабря 19:00:24 test sshd [10526]: сбой пароля для risto от порта 10.1.2.7 52622 ssh2
27 декабря 19:00:27 test sshd [10526]: принят пароль для risto от порта 10.1.2.7 52622
ssh2

Когда для имени пользователя и исходного IP-адреса наблюдается сбой входа в систему SSH,
для этой комбинации имени пользователя и IP-адреса создается операция, которая будет ожидать
успешный вход для * того же * имени пользователя и * того же * IP-адреса в течение 60 секунд. Если
пользователь не войдет в систему с того же IP-адреса в течение 60 секунд, операция отправит
предупреждение по электронной почте для root @ localhost перед завершением, в противном случае сообщение будет записано в журнал
"Вход по SSH выполнен успешно для из после первоначального отказа »и закончить.

Предположим, что следующие события генерируются демоном SSH, и каждая временная метка события
отражает время, в течение которого SEC наблюдает за событием:

30 декабря 13:02:01 test sshd [30517]: сбой пароля для risto от порта 10.1.2.7 42172 ssh2
30 декабря 13:02:30 test sshd [30810]: сбой пароля для root от 192.168.1.104 порта 46125
ssh2
30 декабря 13:02:37 test sshd [30517]: сбой пароля для risto от порта 10.1.2.7 42172 ssh2
30 декабря 13:02:59 test sshd [30810]: сбой пароля для root от 192.168.1.104 порта 46125
ssh2
30 декабря 13:03:04 test sshd [30810]: принят пароль для root от 192.168.1.104 порта 46125.
ssh2

Когда первое событие наблюдается в 13:02:01, запускается операция для пользователя risto и
IP-адрес 10.1.2.7, который будет ожидать успешного входа в систему для risto с 10.1.2.7. В
операция будет выполняться в течение 60 секунд, ожидая события, которое будет соответствовать обычному
выражение

sshd \ [\ d + \]: принято. + для ристо из порта 10 \ .1 \ .2 \ .7 \ d + ssh2

Обратите внимание, что это выражение было создано из шаблона регулярного выражения в pattern2
заменив соответствующие переменные $ 1 и $ 2 их значениями. Однако поскольку
значение $ 2 содержит символы точки (.), которые являются метасимволами регулярного выражения,
каждая точка маскируется обратной косой чертой в регулярном выражении.

Когда второе событие наблюдается в 13:02:30, для пользователя root запускается другая операция.
и IP-адрес 192.168.1.104, который будет ожидать, что root успешно войдет в систему из
192.168.1.104. Эта операция будет выполняться в течение 60 секунд, ожидая события, соответствующего
регулярное выражение

sshd \ [\ d + \]: принято. + для root из порта 192 \ .168 \ .1 \ .104 \ d + ssh2

Третье событие в 13:02:37 представляет собой второй сбой входа в систему для пользователя risto и IP.
адрес 10.1.2.7 и незаметно потребляется первой операцией. Точно так же четвертый
событие в 13:02:59 молча потребляется второй операцией. Первая операция будет
работать до 13:03:01, а затем истечь, не увидев успешного входа в систему для ристо из
10.1.2.7. Перед завершением операция отправит предупреждение по электронной почте root @ localhost.
этот пользователь risto не смог войти в систему из 10.1.2.7 в течение одной минуты. В 13:03:04,
вторая операция будет наблюдать событие, соответствующее его регулярному выражению

sshd \ [\ d + \]: принято. + для root из порта 192 \ .168 \ .1 \ .104 \ d + ssh2

Увидев это событие, операция занесет в журнал сообщение «SSH-вход для пользователя root успешно.
с 192.168.1.104 после первоначального сбоя »и немедленно прекратить работу. Обратите внимание, что
совпадение по регулярному выражению

sshd \ [\ d + \]: принято. + для root из порта 192 \ .168 \ .1 \ .104 \ d + ssh2

устанавливает переменную соответствия $ 1 равной 1 и сбрасывает $ 2. Следовательно, переменные% 1 и% 2 совпадают.
должны использоваться в описание2 поле, чтобы ссылаться на исходные значения $ 1 (корень)
и 2 доллара (192.168.1.104) при создании операции.

ОДИНОЧНЫЙ ПРАВИЛО
Команда Синглвитсрешолд правило запускает операции корреляции событий для подсчета повторных
экземпляров одного и того же события в течение T секунд, и выполнение действия, если N событий
наблюдаемый. Значения T и N определяются окно и молотить поле соответственно.

Когда событие соответствует правилу, SEC оценивает заданную строку описания операции.
с по убыванию поле. Если операция для данной строки и правила не существует, SEC
создаст его со временем жизни T секунд. Операция запомнит возникновение
время события (текущее время, возвращенное время(2) системный вызов) и сравните
количество запомненных раз вхождения с порогом N. Если операция соблюдена N
события, он выполняет список действий, определенный действие поле, и потребляет все дальше
совпадающие события без каких-либо действий. Если в правиле есть необязательный список действий, определенный с помощью
action2 поле, операция выполнит его до завершения, при условии, что
список действий с действие был ранее выполнен операцией. Обратите внимание, что
скользящее окно используется для подсчета событий - если операция наблюдалась менее N
события к концу его жизни, он отбрасывает время возникновения, которое старше T
секунд и продлевает срок его службы на T секунд с самого раннего оставшегося вхождения
время. Если не осталось оставшегося времени повторения, операция завершится без выполнения.
список действий.

Правило SingleWithThreshold поддерживает следующие поля:

напишите зафиксировано на SingleWithThreshold (значение не чувствительно к регистру).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный).

тип тип шаблона (значение без учета регистра).

описания
шаблону.

вармап (опционально)
переменная карта.

контекст (опционально)
контекстное выражение.

по убыванию Строка описания операции.

действие Список действия.

action2 (опционально)
Список действия.

окно размер окна корреляции событий (значение - целочисленная константа).

молотить порог подсчета (значение - целочисленная константа).

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

Обратите внимание, что переменные соответствия могут использоваться в контекст, по убыванию, действиеи action2 полей.

Примеры:

type = SingleWithThreshold
ptype = RegExp
шаблон = sshd \ [\ d + \]: Ошибка. + для (\ S +) из [\ d.] + порт \ d + ssh2
desc = Три сбоя входа по SSH в течение 1 м для пользователя $ 1
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 60
thresh = 3

Это правило запускает операции корреляции событий для подсчета количества неудачных попыток входа по SSH.
События. Каждая операция подсчитывает события для одного имени пользователя, и если операция наблюдалась
три неудачных попытки входа в систему в течение 60 секунд, он отправляет предупреждение по электронной почте root @ localhost.

Предположим, что следующие события генерируются демоном SSH, и каждая временная метка события
отражает время, в течение которого SEC наблюдает за событием:

28 декабря 01:42:21 test sshd [28132]: сбой пароля для risto от порта 10.1.2.7 42172 ssh2
28 декабря 01:43:10 test sshd [28132]: сбой пароля для risto от порта 10.1.2.7 42172 ssh2
28 декабря 01:43:29 test sshd [28132]: сбой пароля для risto от порта 10.1.2.7 42172 ssh2
28 декабря 01:44:00 test sshd [28149]: сбой пароля для risto2 от порта 10.1.2.7 42176 ssh2
28 декабря 01:44:03 test sshd [28211]: сбой пароля для risto от порта 10.1.2.7 42192 ssh2
28 декабря 01:44:07 test sshd [28211]: сбой пароля для risto от порта 10.1.2.7 42192 ssh2

Когда первое событие наблюдается в 01:42:21, для пользователя запускается операция подсчета.
risto с окном корреляции событий, заканчивающимся в 01:43:21. Поскольку к 01:43:21 два SSH
произошли сбои при входе в систему для пользователя risto, пороговое условие остается невыполненным
для операции. Поэтому начало его окна корреляции событий будет перемещено.
до 01:43:10 (время появления второго события), оставляя первое событие за пределами
окно. В 01:44:00 для пользователя risto2 запускается еще одна операция подсчета. В
пороговое условие для первой операции будет выполнено в 01:44:03 (поскольку
операция обнаружила три события сбоя входа в систему для пользователя risto в течение 60 секунд), и, таким образом,
будет отправлено предупреждение по электронной почте. Наконец, событие, происходящее в 01:44:07, будет
незаметно потребляется первой операцией (операция будет выполняться до 01:44:10). С
больше не будет событий сбоя входа в систему для пользователя risto2, вторая операция будет
существовать до 01:45:00 без каких-либо действий.

ОДИН С 2 ПОРОГАМИ ПРАВИЛО
Команда Одиночный с2порогами правило запускает операции корреляции событий, которые срабатывают, если N1
события наблюдались в окне T1 секунд, и тогда будет происходить не более N2 событий.
наблюдается в окне Т2 секунд. Значения T1, N1, T2 и N2 определяются
окно, молотить, window2и молотить2 поле соответственно.

Когда событие соответствует правилу, SEC оценивает заданную строку описания операции.
с по убыванию поле. Если операция для данной строки и правила не существует, SEC
создаст его со временем жизни T1 секунд. Операция запомнит возникновение
время события (текущее время, возвращенное время(2) системный вызов) и сравните
количество запомненных времен появления с порогом N1. Если в ходе операции наблюдалось
N1, он выполняет список действий, определенный действие поле и начинает другое
отсчет раунда в течение T2 секунд. Если к концу месяца наблюдалось не более N2 событий.
окно, операция выполняет список действий, определенный action2 поле и
отделка. Обратите внимание, что оба окна скользят - первое окно скользит, как окно
операция SingleWithThreshold, а начало второго окна перемещается в
время наступления второго наиболее раннего запомненного события при нарушении порога N2.

Правило SingleWith2Thresholds поддерживает следующие поля:

напишите исправлено на SingleWith2Thresholds (значение не чувствительно к регистру).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный).

тип тип шаблона (значение без учета регистра).

описания
шаблону.

вармап (опционально)
переменная карта.

контекст (опционально)
контекстное выражение.

по убыванию Строка описания операции.

действие Список действия.

окно размер окна корреляции событий (значение - целочисленная константа).

молотить порог счета.

описание2 строка формата, которая устанавливает переменную% s для action2.

action2
Список действия.

window2
размер окна корреляции событий (значение - целочисленная константа).

молотить2
порог счета.

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

Обратите внимание, что переменные соответствия могут использоваться в контекст, по убыванию, действие, описание2и action2 полей.

Примеры:

type = SingleWith2Thresholds
ptype = RegExp
шаблон = (\ S +):% SYS-3-CPUHOG
desc = Маршрутизатор $ 1 Перегрузка ЦП
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 300
thresh = 2
desc2 = Маршрутизатор $ 1 загрузка ЦП была нормальной в течение 1 часа
действие2 = вход в систему
окно2 = 3600
thresh2 = 0

Когда сообщение системного журнала SYS-3-CPUHOG получено от маршрутизатора, правило запускает подсчет
операция для этого маршрутизатора, который отправляет по электронной почте предупреждение root @ localhost, если другой такой
сообщение получено от того же маршрутизатора в течение 300 секунд. После отправки предупреждения
операция будет продолжаться до тех пор, пока не появятся сообщения системного журнала SYS-3-CPUHOG.
получил от роутера за 3600 секунд. Когда это условие выполняется,
операция будет записывать сообщение "Маршрутизатор Загрузка процессора была нормальной в течение 1 часа "и
закончить.

Предположим, что следующие события генерируются маршрутизатором, и каждая временная метка события отражает
время, когда SEC наблюдает за событием:

30 декабря 12:23:25 router1.mydomain Router1:% SYS-3-CPUHOG: процессор перегружен
30 декабря 12:25:38 router1.mydomain Router1:% SYS-3-CPUHOG: процессор перегружен
30 декабря 12:28:53 router1.mydomain Router1:% SYS-3-CPUHOG: процессор перегружен

Когда первое событие наблюдается в 12:23:25, для маршрутизатора запускается операция подсчета.
Маршрутизатор 1. Появление второго события в 12:25:38 выполняет пороговое условие.
данный с молотить и окно полей (два события наблюдались в пределах 300
секунд). Таким образом, операция отправит по электронной почте предупреждение о перегрузке ЦП.
Router1 для root @ localhost.

После этого операция начнет еще один раунд подсчета, ожидая, что не будет
События SYS-3-CPUHOG (начиная с thresh2 = 0) для Router1 в течение следующих 3600 секунд (
начало окна корреляции событий операции будет перенесено на 12:25:38 для
второй раунд счета). Поскольку появление третьего события в 12:28:53 нарушает
пороговое условие, заданное с помощью молотить2 и window2 поля, начало события
окно корреляции будет перенесено на 12:28:53. Так как SYS-3-CPUHOG больше не будет
сообщения для Router1, операция будет выполняться до 13:28:53, а затем истечет, регистрируя
сообщение «Маршрутизатор Маршрутизатор1 загрузка ЦП была нормальной в течение 1 часа» перед завершением.

ГРУППА СОБЫТИЙ ПРАВИЛО
Команда группа событий правило запускает операции корреляции событий для подсчета повторных экземпляров N
различные события e1, ..., eK в течение T секунд, и выполнение действия, если пороговые условия
c1, ..., cN для * всех * событий удовлетворяются (т. е. для каждого события eK существует не менее cK
экземпляры событий в окне). Значения N и T определяются напишите и окно
поля соответственно, а значения для c1, ..., cN задаются с молотить * поля. Ценности
для N и c1, ..., cN по умолчанию 1. Обратите внимание, что окно корреляции событий скользит, как
окно операции SingleWithThreshold.

Когда событие соответствует правилу, SEC оценивает заданную строку описания операции.
с по убыванию поле. Если операция для данной строки и правила не существует, SEC
создаст его со временем жизни T секунд. Операция запомнит возникновение
время события (текущее время, возвращенное время(2) системный вызов) и сравните
количество запомненных времен появления для каждого eK с пороговым значением cK. Если весь порог
конфигурации удовлетворены, операция выполняет список действий, определенный действие
поле, и потребляет все последующие совпадающие события без повторного выполнения списка действий, если
многоактный установлено значение Нет (по умолчанию). Однако если многоактный установлено Да,
операция будет оценивать пороговые условия для каждого последующего совпадающего события,
выполнение списка действий, заданного с действие поле, если все условия выполнены, и
сдвигая окно корреляции событий вперед, когда окно подходит к концу (если нет
события останутся в окне, операция завершится).

Если в определении правила есть необязательный список действий, определенный с помощью считать* поле для события
eK, операция выполняется каждый раз, когда наблюдается экземпляр eK (даже если многоактный is
установлен на Нет, и операция уже выполнила список действий, указанный с действие).

Если в определении правила есть необязательный список действий, определенный с помощью инициализации поле,
операция выполняет ее сразу после создания операции.

Если в определении правила есть необязательный список действий, определенный с помощью конец поле,
операция выполняет его непосредственно перед завершением операции. Обратите внимание, что это действие
список * не * выполняется, когда операция завершается с сброс действия.

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

Правило EventGroup поддерживает следующие поля:

напишите EventGroup [N] (значение не чувствительно к регистру, N по умолчанию равно 1).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный). Определяет точку продолжения после матча по описания и контекст.

тип тип шаблона для описания (значение не чувствительно к регистру).

описания
шаблону.

вармап (опционально)
карта переменных для описания.

контекст (опционально)
выражение контекста, вычисляемое вместе с описания.

считать (опционально)
список действий для выполнения после матча описания и контекст.

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

...

продолжитьN (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный). Определяет точку продолжения после матча по шаблонN и
контекстN.

ptypeN тип шаблона для шаблонN (значение не чувствительно к регистру).

шаблонN
шаблону.

вармапН (опционально)
карта переменных для шаблонN.

контекстN (опционально)
выражение контекста, вычисляемое вместе с шаблонN.

количествоN (опционально)
список действий для выполнения после матча шаблонN и контекстN.

молотитьN (опционально)
порог подсчета для событий, соответствующих шаблонN и контекстN (значение - целое число
константа, по умолчанию 1).

по убыванию Строка описания операции.

действие Список действия.

инициализации (опционально)
Список действия.

конец (опционально)
Список действия.

скользить (опционально)
Список действия.

многоактный (опционально)
Да или Нет (значения не чувствительны к регистру, по умолчанию - Нет).

окно размер окна корреляции событий (значение - целочисленная константа).

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

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

Примеры:

В следующем примере правила взаимно коррелируют события iptables, журнал доступа к веб-серверу Apache.
сообщения с кодами ответа 4xx и события сбоя входа в систему SSH:

type = EventGroup3
ptype = RegExp
pattern = sshd \ [\ d + \]: Ошибка. + для (?: недопустимый пользователь)? \ S + из ([\ d.] +) порт \ d + ssh2
thresh = 2
ptype2 = RegExp
pattern2 = ^ ([\ d.] +) \ S + \ S + \ [. +? \] ". +? HTTP \ / [\ d.] +" 4 \ d +
thresh2 = 3
ptype3 = RegExp
pattern3 = ядро: iptables:. * SRC = ([\ d.] +)
thresh3 = 5
desc = Повторное зондирование от хоста $ 1
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 120

Правило запускает операцию корреляции событий для IP-адреса в случае сбоя входа по SSH.
событие, событие iptables или событие Apache 4xx наблюдается для этого IP-адреса. Операция
отправляет по электронной почте предупреждение root @ localhost, если в течение 120 секунд три пороговых условия
удовлетворены для отслеживаемого IP-адреса - (1) не менее двух событий сбоя входа в систему через SSH
произошли для этого IP-адреса клиента, (2) по крайней мере три события Apache 4xx произошли для
этого IP-адреса клиента, (3) для этого IP-адреса источника наблюдалось как минимум пять событий iptables.

Предположим, что происходят следующие события, и каждая временная метка события отражает время SEC.
наблюдает за событием:

192.168.1.104 - - [05 / Янв / 2014: 01: 11: 22 +0200] "GET /test.html HTTP / 1.1" 404 286 "-"
"Mozilla / 5.0 (X11; Ubuntu; Linux i686; rv: 26.0) Gecko / 20100101 Firefox / 26.0"
5 января 01:12:52 localhost ядро: iptables: IN = eth0 OUT =
MAC=08:00:27:8e:a1:3a:00:1d:e0:7e:89:b1:08:00 SRC=192.168.1.104 DST=192.168.1.107 LEN=60
TOS = 0x10 PREC = 0x00 TTL = 64 ID = 48422 DF PROTO = TCP SPT = 46351 DPT = 21 WINDOW = 29200 RES = 0x00 SYN
URGP = 0
5 января 01:12:53 localhost ядро: iptables: IN = eth0 OUT =
MAC=08:00:27:8e:a1:3a:00:1d:e0:7e:89:b1:08:00 SRC=192.168.1.104 DST=192.168.1.107 LEN=60
TOS = 0x10 PREC = 0x00 TTL = 64 ID = 48423 DF PROTO = TCP SPT = 46351 DPT = 21 WINDOW = 29200 RES = 0x00 SYN
URGP = 0
5 января 01:13:01 localhost ядро: iptables: IN = eth0 OUT =
MAC=08:00:27:8e:a1:3a:00:1d:e0:7e:89:b1:08:00 SRC=192.168.1.104 DST=192.168.1.107 LEN=60
TOS = 0x10 PREC = 0x00 TTL = 64 ID = 20048 DF PROTO = TCP SPT = 44963 DPT = 23 WINDOW = 29200 RES = 0x00 SYN
URGP = 0
5 января 01:13:02 localhost ядро: iptables: IN = eth0 OUT =
MAC=08:00:27:8e:a1:3a:00:1d:e0:7e:89:b1:08:00 SRC=192.168.1.104 DST=192.168.1.107 LEN=60
TOS = 0x10 PREC = 0x00 TTL = 64 ID = 20049 DF PROTO = TCP SPT = 44963 DPT = 23 WINDOW = 29200 RES = 0x00 SYN
URGP = 0
5 января 01:13:08 localhost ядро: iptables: IN = eth0 OUT =
MAC=08:00:27:8e:a1:3a:00:1d:e0:7e:89:b1:08:00 SRC=192.168.1.104 DST=192.168.1.107 LEN=60
TOS = 0x10 PREC = 0x00 TTL = 64 ID = 36362 DF PROTO = TCP SPT = 56918 DPT = 25 WINDOW = 29200 RES = 0x00 SYN
URGP = 0
5 января 01:13:09 localhost ядро: iptables: IN = eth0 OUT =
MAC=08:00:27:8e:a1:3a:00:1d:e0:7e:89:b1:08:00 SRC=192.168.1.104 DST=192.168.1.107 LEN=60
TOS = 0x10 PREC = 0x00 TTL = 64 ID = 36363 DF PROTO = TCP SPT = 56918 DPT = 25 WINDOW = 29200 RES = 0x00 SYN
URGP = 0
192.168.1.104 - - [05 / Янв / 2014: 01: 13: 51 +0200] "GET /test.html HTTP / 1.1" 404 286 "-"
"Mozilla / 5.0 (X11; Ubuntu; Linux i686; rv: 26.0) Gecko / 20100101 Firefox / 26.0"
192.168.1.104 - - [05 / Янв / 2014: 01: 13: 54 +0200] "GET /test.html HTTP / 1.1" 404 286 "-"
"Mozilla / 5.0 (X11; Ubuntu; Linux i686; rv: 26.0) Gecko / 20100101 Firefox / 26.0"
192.168.1.104 - - [05 / Янв / 2014: 01: 14: 00 +0200] "GET /login.html HTTP / 1.1" 404 287 "-"
"Mozilla / 5.0 (X11; Ubuntu; Linux i686; rv: 26.0) Gecko / 20100101 Firefox / 26.0"
192.168.1.104 - - [05 / Янв / 2014: 01: 14: 03 +0200] "GET /login.html HTTP / 1.1" 404 287 "-"
"Mozilla / 5.0 (X11; Ubuntu; Linux i686; rv: 26.0) Gecko / 20100101 Firefox / 26.0"
192.168.1.104 - - [05 / Янв / 2014: 01: 14: 03 +0200] "GET /login.html HTTP / 1.1" 404 287 "-"
"Mozilla / 5.0 (X11; Ubuntu; Linux i686; rv: 26.0) Gecko / 20100101 Firefox / 26.0"
5 января 01:14:11 localhost sshd [1810]: неверный пароль для root от порта 192.168.1.104
46125 сш2
5 января 01:14:12 localhost sshd [1810]: неверный пароль для root от порта 192.168.1.104
46125 сш2
5 января 01:14:18 localhost sshd [1822]: неверный пароль для root от порта 192.168.1.104
46126 сш2
5 января 01:14:19 localhost sshd [1822]: неверный пароль для root от порта 192.168.1.104
46126 сш2
192.168.1.104 - - [05 / Янв / 2014: 01: 14: 34 +0200] "GET /test.html HTTP / 1.1" 404 286 "-"
"Mozilla / 5.0 (X11; Ubuntu; Linux i686; rv: 26.0) Gecko / 20100101 Firefox / 26.0"

Событие Apache 4xx в 01:11:22 запускает операцию корреляции событий для 192.168.1.104.
с окном корреляции событий 120 секунд, заканчивающимся в 01:13:22. Между
01:12:52 и 01:13:09, шесть событий iptables появляются для 192.168.1.104, и появление
пятое событие в 01:13:08 удовлетворяет третьему пороговому условию (в течение 120 секунд, при
не менее пяти событий iptables).

Поскольку к 01:13:22 (конец окна корреляции событий) никаких дополнительных событий не произошло.
произошло, первое и второе пороговые условия остаются невыполненными. Следовательно
начало окна корреляции событий будет перенесено на 01:12:52 (время появления
самого раннего события, которому не более 120 секунд). В итоге конец
окно переместится с 01:13:22 на 01:14:52. Единственное событие, которое осталось за рамками
window - это событие Apache 4xx в 01:11:22, и, следовательно, пороговое условие для iptables
событиями остается доволен.

Между 01:13:51 и 01:14:03 происходит пять событий Apache 4xx, и появляется
третье событие в 01:14:00 удовлетворяет второму пороговому условию (в течение 120 секунд, при
не менее трех событий Apache 4xx). За этими событиями следуют четыре SSH
события сбоя входа в систему, которые происходят между 01:14:11 и 01:14:19. Появление
второе событие в 01:14:12 удовлетворяет первому пороговому условию (в течение 120 секунд, при
не менее двух событий сбоя входа в систему SSH). Поскольку в данный момент
(01:14:12) два других условия также выполнены, операция отправляет электронное письмо
предупреждение о 192.168.1.104 для root @ localhost. После этого операция тихо
потребляет все последующие совпадающие события для 192.168.1.104 до 01:14:52, а затем
прекращается.

Обратите внимание, что если приведенное выше определение правила будет содержать multact = да заявление,
операция продолжит отправку электронных писем при каждом совпадающем событии после 01:14:12, при условии
что все пороговые условия выполнены. Следовательно, операция отправит три
дополнительные электронные письма в 01:14:18, 01:14:19 и 01:14:34. Кроме того, операция не
заканчиваться после того, как его окно заканчивается в 01:14:52, но лучше сдвинуть окно вперед и
ожидайте новых событий. При возникновении любых iptables, сбоя входа в систему SSH или Apache 4xx
событие для 192.168.1.104, операция выдаст предупреждение по электронной почте, если все пороговые значения
условия выполнены.

Следующий пример правила взаимно коррелирует события iptables и события входа в систему SSH:

type = EventGroup3
ptype = регулярное выражение
pattern = sshd \ [\ d + \]: Ошибка. + для (\ S +) из ([\ d.] +) порта \ d + ssh2
varmap = user = 1; ip = 2
count = alias OPER _ $ + {ip} LOGIN_FAILED _ $ + {user} _ $ + {ip}
ptype2 = регулярное выражение
pattern2 = sshd \ [\ d + \]: принято. + для (\ S +) из ([\ d.] +) порта \ d + ssh2
varmap2 = user = 1; ip = 2
context2 = LOGIN_FAILED _ $ + {user} _ $ + {ip}
ptype3 = регулярное выражение
pattern3 = ядро: iptables:. * SRC = ([\ d.] +)
varmap3 = ip = 1
desc = Клиент $ + {ip} получил доступ к защищенному брандмауэром порту и не смог войти в систему.
действие = канал '% t:% s' / bin / mail root @ localhost
init = создать ОПЕР _ $ + {ip}
слайд = удалить OPER _ $ + {ip}; сбросить 0
end = удалить OPER _ $ + {ip}
окно = 120

Правило запускает операцию корреляции событий для IP-адреса в случае сбоя входа в систему SSH или
Событие iptables было обнаружено для этого IP-адреса. Операция существует 120 секунд
(поскольку, когда окно корреляции событий сдвигается вперед, операция завершается сама собой
с сброс действие, указанное в скользить поле). Операция отправляет электронное письмо
предупреждение для root @ localhost, если в течение 120 секунд выполнены три пороговых условия
для отслеживаемого IP-адреса - (1) для этого наблюдалось как минимум одно событие iptables
исходный IP-адрес, (2) для этого клиентского IP-адреса наблюдалась как минимум одна ошибка входа в систему SSH, (3) в
по крайней мере один успешный вход по SSH был зарегистрирован для этого IP-адреса клиента и для некоторых пользователей,
при условии, что операция ранее наблюдала сбой входа в систему SSH для того же пользователя
и тот же клиентский IP.

Предположим, что происходят следующие события, и каждая временная метка события отражает время SEC.
наблюдает за событием:

27 декабря 19:00:06 тестовое ядро: iptables: IN = eth0 OUT =
MAC=00:13:72:8a:83:d2:00:1b:25:07:e2:1b:08:00 SRC=10.1.2.7 DST=10.2.5.5 LEN=60 TOS=0x00
PREC = 0x00 TTL = 62 ID = 1881 DF PROTO = TCP SPT = 34342 DPT = 23 WINDOW = 5840 RES = 0x00 SYN URGP = 0
27 декабря 19:00:14 test sshd [10520]: принят пароль для root от порта 10.1.2.7 52609 ssh2
27 декабря 19:00:24 test sshd [10526]: сбой пароля для risto от порта 10.1.2.7 52622 ssh2
27 декабря 19:00:27 test sshd [10526]: принят пароль для risto от порта 10.1.2.7 52622
ssh2

Событие iptables в 19:00:06 запускает операцию корреляции событий для 10.1.2.7, которая
имеет окно корреляции событий 120 секунд. Сразу после операции
запущен, он создает контекст OPER_10.1.2.7. Второе событие в 19:00:14 - нет.
соответствуют правилу, поскольку контекст LOGIN_FAILED_root_10.1.2.7 не существует. Третий
событие в 19:00:24 соответствует правилу, и операция, которая выполняется для 10.1.2.7, устанавливает
установите псевдоним LOGIN_FAILED_risto_10.1.2.7 для контекста OPER_10.1.2.7. Наконец,
четвертое событие в 19:00:27 соответствует правилу, поскольку контекст LOGIN_FAILED_risto_10.1.2.7
существует, поэтому событие обрабатывается операцией (наличие контекста
указывает, что при операции ранее наблюдалась ошибка входа в систему для пользователя risto из
10.1.2.7). В данный момент (19:00:27) все три пороговых условия для
операции выполняются, и поэтому он отправляет по электронной почте предупреждение о 10.1.2.7 на
корень @ localhost. После этого операция молча потребляет все последующие совпадающие события.
для 10.1.2.7 до 19:02:06, а затем завершается. Непосредственно перед расторжением
операция удаляет контекст OPER_10.1.2.7, который также удаляет его псевдоним
LOGIN_FAILED_risto_10.1.2.7.

ПОДДЕРЖАТЬ ПРАВИЛО
Команда Подавить Правило не выполняет никаких действий, когда событие соответствует правилу, и продолжает соответствовать
события от обработки более поздними правилами в файле конфигурации.

Правило подавления поддерживает следующие поля:

напишите зафиксировано на «Подавить» (значение без учета регистра).

тип тип шаблона (значение без учета регистра).

описания
шаблону.

вармап (опционально)
переменная карта.

контекст (опционально)
контекстное выражение.

по убыванию (опционально)
строка для описания правила.

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

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

Примеры:

type = Подавить
ptype = RegExp
pattern = sshd \ [\ d + \]: Ошибка. + для \ S + из ([\ d.] +) порта \ d + ssh2
context = SUPPRESS_IP_ $ 1

type = SingleWithThreshold
ptype = RegExp
pattern = sshd \ [\ d + \]: Ошибка. + для (\ S +) из ([\ d.] +) порта \ d + ssh2
desc = Три сбоя входа по SSH в течение 1 миллиона для пользователя $ 1 от $ 2
действие = канал '% t:% s' / bin / mail root @ localhost; \
создать SUPPRESS_IP_ $ 2 3600
окно = 60
thresh = 3

Первое правило отфильтровывает события сбоя входа в систему SSH для уже сообщенного исходного IP-адреса.
адрес, так что они не будут сопоставлены со вторым правилом в течение 3600 секунд
после отправки предупреждения по электронной почте.

КАЛЕНДАРЬ ПРАВИЛО
Команда Календарь Правило было разработано для выполнения действий в определенное время. В отличие от всех остальных
rules, это правило реагирует только на системные часы, игнорируя другие входные данные. Правило календаря
выполняет список действий, указанный с действие поле, если текущее время совпадает со всеми
условия спецификации времени, указанные с время поле. Список действий
выполняется только один раз за любую подходящую минуту.

Правило использует временную спецификацию, которая очень похожа на кронтаб(1) стиль, но
есть некоторые тонкие различия. Спецификация времени состоит из пяти или шести
условия, разделенные пробелом. Первое условие соответствует минутам (допустимые значения
0-59), второе условие соответствует часам (допустимые значения: 0-23), третье
условные дни (допустимые значения от 0 до 31, где 0 означает последний день месяца),
четвертые месяцы условий (допустимые значения от 1 до 12) и пятые рабочие дни условий.
(допустимые значения 0-7, где 0 и 7 обозначают воскресенье). Шестое условие необязательно
и соответствует годам (допустимые значения от 0 до 99, которые обозначают две последние цифры года).

Звездочки (*), диапазоны чисел (например, 8-11) и списки (например, 2,5,7-9) разрешены как
условия. Звездочки и диапазоны могут быть дополнены значениями шага (например, 47-55 / 2 означает
47,49,51,53,55).

Обратите внимание, что в отличие от кронтаб(1) указание времени, день и будний день * не *
соединяется логическим ИЛИ, а скорее логическим И. Следовательно, 0 1 25-31 10 7 означает 1 час ночи.
в последнее воскресенье октября. С другой стороны, с кронтаб(1) та же спецификация
означает 1 час ночи каждые последние семь дней или каждое воскресенье октября. Также, в отличие от некоторых версий
of крон(8), SEC не ограничивается, чтобы принимать меры только в течение первой секунды
текущая минута (например, если SEC запускается на 22-й секунде минуты,
условие подстановочного знака производит совпадение для этой минуты).

Правило календаря поддерживает следующие поля:

напишите зафиксирован на Calendar (значение без учета регистра).

время указание времени.

контекст (опционально)
контекстное выражение.

по убыванию Строка описания операции.

действие Список действия.

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

Обратите внимание, что это правило не запускает операцию корреляции событий, и по убыванию поле
просто используется для установки переменной списка действий% s.

Примеры:

type = Календарь
время = 0 2 25-31 3,12 6
desc = Проверить, сделано ли резервное копирование в последнюю субботу 1-го и 4-го кварталов
действие = событие WAITING_FOR_BACKUP

type = Календарь
время = 0 2 24-30 6,9 6
desc = Проверить, сделано ли резервное копирование в последнюю субботу 2-го и 3-го кварталов
действие = событие WAITING_FOR_BACKUP

type = PairWithWindow
ptype = SubStr
шаблон = WAITING_FOR_BACKUP
desc = Ежеквартальное резервное копирование не выполнено вовремя!
действие = канал '% t:% s' / bin / mail root @ localhost
ptype2 = SubStr
pattern2 = РЕЗЕРВНОЕ КОПИРОВАНИЕ ГОТОВО
desc2 = Ежеквартальное резервное копирование успешно завершено
действие2 = нет
окно = 1800

Первые два правила создают синтетическое событие WAITING_FOR_BACKUP в 2 часа ночи в последнюю субботу
Март, июнь, сентябрь и декабрь. Третье правило соответствует этому событию и запускает
операция корреляции событий, которая ожидает события BACKUP READY в течение 1800 секунд. Если
это событие не наступило до 2:30, операция отправляет предупреждение по электронной почте на адрес
корень @ localhost.

БЫСТРЫЙ ПЕРЕХОД ПРАВИЛО
Команда Jump Правило отправляет совпадающие события в определенные наборы правил для дальнейшей обработки. Если
событие соответствует правилу, SEC продолжает поиск соответствующих правил в конфигурации
набор (ы) файлов, указанный с cfset поле. Правила из каждого файла проверяются в порядке
их появление в файле. Наборы файлов конфигурации могут быть созданы из правил опций
с присоединиться поле, где каждый набор содержит хотя бы один файл конфигурации. Если
более одного названия набора дается с cfset, наборы обрабатываются слева направо; а
Правило сопоставления в одном наборе не мешает SEC обрабатывать следующие наборы. Если
константа установлено значение Да, имена наборов считаются константами и не будут
искал переменные соответствия во время выполнения.

Правило перехода поддерживает следующие поля:

напишите зафиксировано на Jump (значение без учета регистра).

продолжать (опционально)
TakeNext, DontCont, EndMatch или GoTo (кроме значений регистр
нечувствительный).

тип тип шаблона (значение без учета регистра).

описания
шаблону.

вармап (опционально)
переменная карта.

контекст (опционально)
контекстное выражение.

cfset (опционально)
Имена наборов файлов конфигурации разделены пробелами.

константа (опционально)
Да или Нет (значения не чувствительны к регистру, по умолчанию - Да).

по убыванию (опционально)
строка для описания правила.

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

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

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

Примеры:

type = Перейти
ptype = RegExp
шаблон = sshd \ [\ d + \]:
cfset = sshd-rules auth-rules

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

ДОПОЛНИТЕЛЬНЫЕ ОПЦИИ ПРАВИЛО
Команда Возможности rule устанавливает параметры обработки для набора правил в текущей конфигурации
файл. Если в файле конфигурации присутствует более одного правила параметров, последнее
instance отменяет все предыдущие. Обратите внимание, что правило параметров обрабатывается только тогда, когда
SEC (повторно) запускается и читает файл конфигурации. Поскольку это правило не применяется в
время выполнения, он никогда не может сопоставлять события, реагировать на системные часы или запускать корреляцию событий
операций.

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

Правило параметров поддерживает следующие поля:

напишите исправлено на Options (значение не чувствительно к регистру).

присоединиться (опционально)
Имена наборов файлов конфигурации разделены пробелами.

прокаллин (опционально)
Да или Нет (значения не чувствительны к регистру, по умолчанию - Да).

рем (необязательно, может встречаться более одного раза)
замечания и комментарии.

Примеры:

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

type = Параметры
joincfset = sshd-rules
прокаллин = нет

Следующее правило добавляет текущий файл конфигурации в наборы Linux и Солярис которые являются
используется для сопоставления всего ввода:

type = Параметры
joincfset = Linux Solaris

СОБЫТИЕ КОРРЕЛЯЦИЯ ОПЕРАЦИИ

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

Чтобы идентифицировать операции корреляции событий, SEC присваивает идентификатор каждой операции.
который состоит из имени файла конфигурации, номера правила и операции
строка описания (определяется по убыванию поле правила). Если есть N правил в
файла конфигурации, номера правил принадлежат диапазону 0..N-1, а количество k-
-ое правило - k-1. Обратите внимание: поскольку имя файла конфигурации и номер правила являются частью
идентификатор операции, разные правила могут иметь одинаковые по убыванию поля без опасности
столкновение между операциями.

Например, если файл конфигурации /etc/sec/my.conf содержит только одно правило

type = SingleWithThreshold
ptype = RegExp
шаблон = пользователь (\ S +) ошибка входа в систему на (\ S +)
desc = Повторные неудачные попытки входа в систему для пользователя $ 1 на $ 2
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 60
thresh = 3

тогда номер этого правила равен 0. Когда это правило соответствует событию ввода "пользователь admin
ошибка входа в систему на tty1 ", по убыванию поле выдает строку описания операции Неоднократный
Войти сбои для пользователь Администратор on телетайп1, и мероприятие будет направлено на дальнейшее
обработка в операцию со следующим идентификатором:

/etc/sec/my.conf | 0 | Повторяющиеся сбои при входе в систему для администратора пользователя на tty1

Если операция для этого идентификатора не существует, правило создаст ее. Вновь созданный
операция инициализирует счетчик событий равным 1, и она ожидает получить два дополнительных
«Ошибка входа в систему администратора пользователя на tty1» из правила в течение следующих 60 секунд.
Если операция получает такое событие, ее счетчик событий увеличивается, а если
счетчик достигает значения 3, предупреждение отправляется по электронной почте root @ localhost.

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

Ошибка входа в систему администратора пользователя на tty1
Ошибка входа в систему администратора пользователя на tty5
Ошибка входа в систему администратора пользователя на tty2

Вышеупомянутое правило запускает три операции корреляции событий. Однако если по убыванию поле
правило изменено на Неоднократный Войти сбои для пользователь $1, эти события обрабатываются
* та же * операция корреляции событий (операция отправляет предупреждение по электронной почте на адрес
root @ localhost при получении третьего события).

Поскольку правила из одного файла конфигурации сопоставляются с вводом в том порядке, в котором они
даны, порядок правил влияет на создание и подпитку корреляции событий
операции. Предположим, что конфигурационный файл /etc/sec/my.conf содержит следующие правила:

type = Подавить
ptype = TValue
шаблон = ИСТИНА
context = MYCONTEXT

type = SingleWithThreshold
ptype = RegExp
шаблон = пользователь (\ S +) ошибка входа в систему на (\ S +)
desc = Повторные неудачные попытки входа в систему для пользователя $ 1 на $ 2
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 60
thresh = 3

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

Обратите внимание, что правила Pair и PairWithWindow могут передавать одно и то же событие нескольким операциям.
Предположим, файл конфигурации /etc/sec/my2.conf содержит следующие правила:

type = Подавить
ptype = SubStr
шаблон = тест

type = Пара
ptype = RegExp
шаблон = база данных (\ S +) вниз
desc = База данных $ 1 не работает
действие = канал '% t:% s' / bin / mail root @ localhost
ptype2 = RegExp
pattern2 = база данных на 1 доллар больше | все базы данных вверх
desc2 = База данных% 1 запущена
action2 = pipe '% t:% s' / bin / mail root @ localhost
окно = 86400

Поскольку следующие входные события не содержат подстроки "test"

база данных mydb1 не работает
база данных mydb2 не работает
база данных mydb3 не работает

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

/etc/sec/my2.conf | 1 | База данных mydb1 не работает
/etc/sec/my2.conf | 1 | База данных mydb2 не работает
/etc/sec/my2.conf | 1 | База данных mydb3 не работает

Каждая вновь созданная операция отправляет уведомление по электронной почте root @ localhost о
состояние "база данных не работает", а затем будет ждать 86400 секунд (24 часа) для любого из
следующие сообщения:
(а) сообщение "база данных вверх" для данной базы данных,
(b) сообщение «все базы данных запущены».

Операция с ID

/etc/sec/my2.conf | 1 | База данных mydb1 не работает

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

база данных mydb1 вверх | все базы данных включены

Операция с ID

/etc/sec/my2.conf | 1 | База данных mydb2 не работает

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

база данных mydb2 вверх | все базы данных включены

Наконец, операция с ID

/etc/sec/my2.conf | 1 | База данных mydb3 не работает

использует следующее регулярное выражение:

база данных mydb3 вверх | все базы данных включены

Если следующие события ввода появляются через 10 минут

проверка базы данных
админ вошел в систему
база данных mydb3 вверх
все базы данных вверх

первое событие «проверка базы данных» соответствует первому правилу (подавить), которое не проходит
событие дальше по второму правилу (Пара). Однако все последующие события доходят до пары.
правило. Поскольку сообщения не соответствуют описания поле правила, правило их кормит
ко всем существующим в настоящее время операциям, которые он создал, так что операции могут соответствовать
эти события с их регулярными выражениями. Поскольку регулярные выражения всех трех
операции не соответствуют событию «администратор вошел в систему», операции будут продолжены.
В случае события «database mydb3 up» регулярное выражение операции

/etc/sec/my2.conf | 1 | База данных mydb3 не работает

производит совпадение. Таким образом, операция отправит уведомление по электронной почте «База данных
mydb3 находится "до root @ localhost и завершается. Однако следующее событие" все базы данных
up "соответствует регулярным выражениям двух оставшихся операций. В результате
будут отправлены уведомления по электронной почте «База данных mydb1 работает» и «База данных mydb2 работает.
up "до root @ localhost и завершить работу.

У каждой операции есть окно корреляции событий, которое определяет ее масштаб во времени. Размер
окна определяется окно* поле, а начало окна может быть
полученный с getwpos действие. SingleWithThreshold, SingleWith2Thresholds и
Операции EventGroup могут сдвигать свое окно вперед во время обработки событий, в то время как для всех
операции окно также можно переместить явно с помощью установка действие. Кроме того, с
сброс действия по корреляции событий могут быть прекращены. Обратите внимание, что getwpos, установка,
и сброс действия работают только для операций, запущенных по правилам из того же
Файл конфигурации.

Например, рассмотрим конфигурационный файл /etc/sec/sshd.rules, содержащий
следующие правила:

type = SingleWithThreshold
ptype = RegExp
шаблон = sshd \ [\ d + \]: Ошибка. + для (\ S +) из [\ d.] + порт \ d + ssh2
desc = Три сбоя входа по SSH в течение 1 м для пользователя $ 1
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 60
thresh = 3

type = Single
ptype = RegExp
шаблон = sshd \ [\ d + \]: принято. + для (\ S +) из [\ d.] + порт \ d + ssh2
desc = Успешный вход по SSH для пользователя $ 1
action = reset -1 Три сбоя входа по SSH в течение 1 м для пользователя $ 1

Предположим, что следующие события генерируются демоном SSH, и каждая временная метка события
отражает время, в течение которого SEC наблюдает за событием:

29 декабря 15:00:03 test sshd [14129]: сбой пароля для risto от порта 10.1.2.7 31312 ssh2
29 декабря 15:00:08 test sshd [14129]: сбой пароля для risto от порта 10.1.2.7 31312 ssh2
29 декабря 15:00:17 test sshd [14129]: принят пароль для risto от порта 10.1.2.7 31312
ssh2
29 декабря 15:00:52 test sshd [14142]: сбой пароля для risto от порта 10.1.1.2 17721 ssh2

Первое событие в 15:00:03 запускает операцию корреляции событий с идентификатором.

/etc/sec/sshd.rules | 0 | Три сбоя входа по SSH в течение 1 м для пользователя risto

Однако, когда третье событие происходит в 15:00:17, второе правило соответствует ему и
завершает операцию действием

reset -1 Три сбоя входа по SSH в течение 1 м для пользователя risto

Параметр -1 для сброс ограничивает действие операциями, запущенными предыдущим правилом
(т. е. первое правило с номером 0), а Три SSH Войти сбои одной 1m
для пользователь Ристо Параметр относится к строке описания операции. Вместе с
имя текущего конфигурационного файла (/etc/sec/sshd.rules), параметры выдают операцию
ID

/etc/sec/sshd.rules | 0 | Три сбоя входа по SSH в течение 1 м для пользователя risto

(Если операция с данным идентификатором не существует, сброс не будет выполнять никаких операций.)

Как следствие, четвертое событие в 15:00:52 запускает другую операцию с тем же идентификатором.
как закончилась операция. Без второго правила операция, которая была запущена
в 15:00:03 не будет завершено, а появление четвертого события вызовет
электронное письмо с предупреждением об этой операции.

ВХОД ОБРАБОТКА И СРОКИ

SEC обрабатывает входные данные итеративно, читая одну строку на каждой итерации, записывая это
строку в соответствующий входной буфер и сопоставление содержимого обновленного буфера с
правила из файлов конфигурации. Если в процессе сопоставления выполняется список действий
который создает новые входные события (например, через мероприятие действие), они * не * записываются в
буфер (ы) немедленно, но потребляется при следующих итерациях.

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

Для --jointbuf опция, SEC использует объединенный входной буфер для всех входных источников, которые
содержит N последних входных строк (значение N может быть установлено с помощью --bufsize вариант). Обновление
входной буфер означает, что новая строка становится первым элементом буфера, а
последний элемент (самая старая строка) удаляется с конца буфера. С
--nojointbuf опция, SEC поддерживает буфер из N строк для каждого входного файла, и если
строка ввода поступает из файла F, буфер F обновляется, как описано ранее. Там
также отдельный буфер для синтетических и внутренних событий.

Предположим, что SEC запущен со следующей командной строкой

/ usr / bin / sec --conf = / etc / sec / test-multiline.conf --jointbuf \
--input = / var / log / prog1.log --input = / var / log / prog2.log

а файл конфигурации /etc/sec/test-multiline.conf имеет следующее содержимое:

type = Single
rem = это правило соответствует двум последовательным строкам, где первая \
строка содержит "test1", а вторая строка "test2" и \
записывает совпадающие строки в стандартный вывод
ptype = RegExp2
шаблон = test1. * \ n. * test2
desc = две последовательные тестовые строки
действие = запись - $ 0

Когда следующие строки появляются во входных файлах /var/log/prog1.log и /var/log/prog2.log

31 декабря 12:33:12 test prog1: test1 (файл /var/log/prog1.log)
31 декабря 12:34:09 test prog2: test1 (файл /var/log/prog2.log)
31 декабря 12:39:35 test prog1: test2 (файл /var/log/prog1.log)
31 декабря 12:41:53 test prog2: test2 (файл /var/log/prog2.log)

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

31 декабря 12:34:09 test prog2: test1 (файл /var/log/prog2.log)
31 декабря 12:39:35 test prog1: test2 (файл /var/log/prog1.log)

Однако, если SEC запускается с --nojointbuf опция, настраиваются отдельные входные буферы
для /var/log/prog1.log и /var/log/prog2.log. Следовательно, правило срабатывает после третьего
событие произошло, и в стандартный вывод выводятся следующие строки:

31 декабря 12:33:12 test prog1: test1 (файл /var/log/prog1.log)
31 декабря 12:39:35 test prog1: test2 (файл /var/log/prog1.log)

Правило также срабатывает после того, как произошло четвертое событие, давая следующий результат:

31 декабря 12:34:09 test prog2: test1 (файл /var/log/prog2.log)
31 декабря 12:41:53 test prog2: test2 (файл /var/log/prog2.log)

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

/ usr / bin / sec --conf = / etc / sec / test-rewrite.conf \
--input = - --nojointbuf

а файл конфигурации /etc/sec/test-rewrite.conf имеет следующее содержимое:

type = Single
rem = это правило соответствует двум последовательным строкам, где первая \
строка содержит "test1", а вторая строка "test2" и \
объединяет эти строки во входном буфере
ptype = RegExp2
шаблон = ^ (. * test1. *) \ n (. * test2. *) $
continue = TakeNext
desc = соединить две тестовые строки
action = rewrite 2 присоединились к $ 1 и $ 2

type = Single
rem = это правило соответствует строке, которая начинается с "Joined", \
и записывает эту строку в стандартный вывод
ptype = RegExp
шаблон = ^ Присоединился
desc = выходные соединенные линии
действие = запись - $ 0

Когда следующие две строки появляются в стандартном вводе

Это тест1
Это тест2

им соответствует первое правило, которое использует переписывать действие по замене этих двух
строки во входном буфере с новым содержимым. Последняя строка во входном буфере ("Это
a test2 ") заменяется на" Joined This is a test1 and This is a test2 ", а
предыдущая строка во входном буфере («Это test1») заменяется пустой строкой.
Поскольку правило содержит continue = TakeNext заявление, процесс сопоставления будет продолжен
из следующего правила. Это правило соответствует последней строке во входном буфере, если она начинается
с "Joined" и записывает строку в стандартный вывод, производя

Присоединился Это тест1 и это тест2

После каждой итерации обработки событий кэш сопоставления с образцом очищается. В других
слова, если совпадение кешируется с правилом varmap * поле, оно доступно во время текущего
только итерация. Обратите внимание, что результаты успешного сопоставления с образцом также кэшируются, когда
последующая оценка выражения контекста дает ЛОЖЬ. Это позволяет повторно использовать
результаты частичного совпадения правил. Например, следующее правило создает кеш
запись «ssh_failed_login» для любого события неудачного входа по SSH, даже если контекст ALERTING_ON
не существует:

type = Single
ptype = RegExp
pattern = sshd \ [\ d + \]: Ошибка. + для (\ S +) из ([\ d.] +) порта \ d + ssh2
varmap = ssh_failed_login; пользователь = 1; ip = 2
context = ALERTING_ON
desc = Ошибка входа в SSH для пользователя $ 1 из $ 2
action = pipe '% s' / bin / mail -s 'SSH login alert' root @ localhost

Однако при условии, что выражение контекста не содержит переменных соответствия, заключая
выражение в квадратных скобках (например, [ALERTING_ON]) принудительно вычисляет его перед
сопоставление с образцом и, таким образом, предотвратит сопоставление и создание записи в кеше
если оценка дает ЛОЖЬ.

Правила из того же файла конфигурации сопоставляются с содержимым буфера в порядке
они даны в этом файле. Если указано несколько файлов конфигурации, правило
последовательности из всех файлов сопоставляются с содержимым буфера (если не указано иное
в противном случае с правилами опций). Порядок сопоставления определяется порядком
файлы конфигурации в командной строке SEC. Например, если Perl земной шар() функция возвращает
имена файлов в порядке возрастания ASCII и файлы конфигурации /home/risto/A.conf,
/home/risto/B.conf2 и /home/risto/C.conf указываются с --conf = / home / risto / *. conf
--conf = / home / risto / *. conf2 в командной строке SEC, тогда SEC сначала сопоставляет ввод с
последовательность правил из A.conf, затем из C.conf и, наконец, из B.conf2. Также обратите внимание
что даже если A.conf содержит правило подавления для определенного события, событие все равно
обрабатывается наборами правил в C.conf и B.conf2. Однако обратите внимание, что земной шар() может вернуть файл
имена в другом порядке при изменении настроек локали. Если вы хотите обеспечить соблюдение фиксированного порядка
для переносимого приложения конфигурационного файла рекомендуется создать уникальный
установить для каждого файла с помощью правила параметров и использовать правило перехода для определения
порядок обработки наборов, например:

# Это правило появляется в A.conf
type = Параметры
joincfset = FileA
прокаллин = нет

# Это правило появляется в B.conf2
type = Параметры
joincfset = FileB
прокаллин = нет

# Это правило появляется в C.conf
type = Параметры
joincfset = FileC
прокаллин = нет

# Это правило появляется в main.conf
type = Перейти
ptype = TValue
шаблон = ИСТИНА
cfset = ФайлA ФайлC ФайлB

После того, как соответствующий входной буфер был обновлен и его содержимое было сопоставлено
rules, SEC обрабатывает пойманные сигналы и проверяет состояние дочерних процессов. Когда
тайм-аут, указанный с помощью - чистое время срок действия опциона истек, SEC также проверяет статус
контексты и операции корреляции событий. Следовательно, относительно небольшие значения должны быть
указано с - чистое время вариант, чтобы сохранить точность события
корреляционный процесс. Если - чистое время опция установлена ​​в 0, SEC проверяет корреляцию событий
операции и контексты после обработки каждой строки ввода, но это потребляет больше ресурсов ЦП
время. Если --poll-тайм-аут значение опциона превышает значение, указанное с помощью - чистое время,
--poll-тайм-аут значение параметра имеет приоритет (т. е. засыпание после неудачных опросов будет
не сокращаться).

Наконец, обратите внимание, что помимо снов после неудачных опросов, SEC измеряет все время
интервалы и время появления в секундах, и всегда использует время(2) системный вызов для
получение текущего времени. Кроме того, для времени возникновения входного события SEC всегда использует время
он наблюдал за событием, а не за меткой времени, извлеченной из события.

ИНТЕРЬЕР СОБЫТИЯ И КОНТЕКСТЫ

В списке действий контекста контекст также может упоминаться с помощью внутреннего
имя контекста _THIS. Имя _THIS динамически создается и удаляется SEC и указывает
в контекст только во время выполнения его списка действий. Эта функция полезна, когда
за время своего существования контекст имел несколько имен (созданных с помощью псевдоним действие), и это
трудно определить, какие имена существуют, когда истекает контекст. Например, если
контекст создается с помощью Создайте A 60 (отчет A / bin / mail корень) что немедленно
последующей псевдоним A B и Unalias A, докладе действие не удастся, так как имя A нет
длиннее относится к контексту. Однако, заменив первое действие на Создайте A 60
(отчет _ЭТО / bin / mail корень) даст правильный результат.

Если же линия индикатора --события задана опция командной строки, SEC будет генерировать внутренние события, когда
запускается, когда он получает определенные сигналы, и когда он завершается нормально. Внутри
SEC, внутреннее событие обрабатывается так, как если бы это была строка, прочитанная из входного файла SEC.
Могут быть написаны особые правила для соответствия внутренним событиям, чтобы предпринять какие-то действия.
(например, запустите модуль корреляции внешних событий с порождать при запуске ТРЦ). В
поддерживаются следующие внутренние события:

SEC_STARTUP - генерируется при запуске SEC (это событие всегда будет первым событием
что видит SEC)

SEC_PRE_RESTART - генерируется перед обработкой ПОДПИСАТЬСЯ сигнал (это событие будет
последнее событие, которое видит SEC перед очисткой всех внутренних структур данных и перезагрузкой их
конфигурация)

SEC_RESTART - генерируется после обработки файла ПОДПИСАТЬСЯ сигнал (это событие будет
первое событие, которое видит SEC после очистки всех внутренних структур данных и перезагрузки их
конфигурация)

SEC_PRE_SOFTRESTART - генерируется перед обработкой СИГАБРТ сигнал (это событие будет
быть последним событием, которое SEC видит перед перезагрузкой своей конфигурации)

SEC_SOFTRESTART - генерируется после обработки СИГАБРТ сигнал (это событие будет
первое событие, которое видит SEC после перезагрузки своей конфигурации)

SEC_PRE_LOGROTATE - генерируется перед обработкой СИГУСР2 сигнал (это событие будет
последнее событие, которое видит SEC перед повторным открытием файла журнала и закрытием выходных данных)

SEC_LOGROTATE - генерируется после обработки СИГУСР2 сигнал (это событие будет
первое событие, которое SEC видит после повторного открытия файла журнала и закрытия выходных данных)

SEC_SHUTDOWN - генерируется, когда SEC получает СИГТЕРМ сигнал, или когда SEC достигает всех
EOF входных файлов после запуска с - notail вариант. С - ребенок
опция, SEC засыпает на 3 секунды после генерации события SEC_SHUTDOWN, а затем отправляет
SIGTERM своим дочерним процессам (если дочерний процесс был запущен SEC_SHUTDOWN, это
delay оставляет процессу достаточно времени для установки обработчика сигнала для SIGTERM).

Перед генерацией внутреннего события SEC устанавливает контекст с именем SEC_INTERNAL_EVENT в
чтобы устранить неоднозначность внутренних событий из обычного ввода. Контекст SEC_INTERNAL_EVENT
удаляется сразу после сопоставления внутреннего события со всеми правилами.

Если же линия индикатора --intcontexts указан параметр командной строки, или есть --Вход вариант с
указанный контекст, SEC создает внутренний контекст каждый раз, когда он читает строку из ввода
файл или синтетическое событие. Внутренний контекст удаляется сразу после того, как строка
соответствует всем правилам. Для всех входных файлов, у которых явно указано имя контекста
установить с --input = знак равно, имя внутреннего контекста .
Если строка была прочитана из входного файла для которого нет имени контекста
установлен, имя внутреннего контекста - _FILE_EVENT_ . Для синтетических событий
имя внутреннего контекста по умолчанию _INTERNAL_EVENT, но cspawn и Cevent
действия могут использоваться для генерации синтетических событий с настраиваемыми именами внутреннего контекста.
Это позволяет писать правила, которые соответствуют данным только из одного конкретного источника ввода. За
например, правило

type = Подавить
ptype = TValue
шаблон = ИСТИНА
context = [! _ FILE_EVENT_ / dev / logpipe]

передает только строки, которые были прочитаны из / dev / logpipe, а также синтетические события, которые
были сгенерированы с внутренним контекстом _FILE_EVENT_ / dev / logpipe (например, с действием
Cevent _FILE_EVENT_ / dev / logpipe 0 Эти is a тестXNUMX мероприятие). В качестве другого примера, если SEC имеет
был запущен из командной строки

/ usr / bin / sec --intevents --intcontexts --conf = / etc / sec / my.conf \
--input = / var / log / messages = СООБЩЕНИЯ \
--input = / var / log / secure = БЕЗОПАСНЫЙ \
--input = / var / log / cron = CRON

а файл правил /etc/sec/my.conf содержит следующие правила

type = Single
ptype = RegExp
шаблон = ^ (?: SEC_STARTUP | SEC_RESTART) $
context = [SEC_INTERNAL_EVENT]
desc = прослушивать 10514 / tcp на предмет входящих событий
действие = cspawn СООБЩЕНИЯ / usr / bin / nc -l -k 10514

type = Single
ptype = RegExp
шаблон =.
context = [СООБЩЕНИЯ]
desc = эхо всего из 10514 / tcp и / var / log / messages
действие = запись - $ 0

тогда SEC получит входные строки из файлов журнала / var / log / messages, / var / log / secure,
и / var / log / cron, а также будет запускать / usr / bin / nc для получения входных строк из порта
10514 / tcp. Все входные строки из / var / log / messages и 10514 / tcp совпадают со вторым
правило и записывается на стандартный вывод.

ВЗАИМОДЕЙСТВИЕ СВЯЗЬ

Правило SingleWithScript и shellcmd, порождать, cspawn, трубаи докладе действия вилка
дочерний процесс для выполнения внешней программы. Если командная строка программы содержит
метасимволы оболочки, командная строка сначала анализируется оболочкой, которая затем запускает
программа. SEC взаимодействует со своими дочерними процессами через каналы (созданные с помощью
труба(2) системный вызов). Когда дочерний процесс находится в конце канала для чтения, данные должны
записываться в конвейер в режиме блокировки, обеспечивающем надежную передачу данных. В
чтобы избежать блокировки, SEC создает еще один дочерний процесс для записи данных в канал
надежно.

После разветвления внешней программы SEC немедленно продолжает работу и проверяет программу.
статус периодически до выхода из программы. Время работы дочернего процесса не
ограничено любым способом. С - ребенок вариант, SEC отправляет СИГТЕРМ сигнал всему ребенку
процессы, когда он завершается. Если какие-то особые процедуры выхода должны быть выполнены в
дочерний процесс (или ребенок хочет игнорировать СИГТЕРМ), то ребенок должен установить
обработчик для СИГТЕРМ сигнал. Обратите внимание, что если командная строка программы содержит оболочку
метасимволы, синтаксическая оболочка будет работать как дочерний процесс SEC, а родительский
процесс программы. Следовательно СИГТЕРМ сигнал будет отправлен в оболочку, * не *
программа. Чтобы этого избежать, встроенная оболочка Exec можно использовать команду (см. sh(1)
для получения дополнительной информации), который заменяет оболочку программой без разветвления нового
процесс, например,

действие = создать exec /usr/local/bin/myscript.pl 2> /var/log/myscript.log

Обратите внимание, что если список действий включает два действия, которые разветвляют внешние программы,
порядок выполнения этих программ не определяется порядком действий в списке,
поскольку обе программы работают асинхронно. Чтобы решить эту проблему,
порядок выполнения должен быть указан явно (например, вместо написания действие = shellcmd
cmd1; shellcmd cmd2, используйте оператор оболочки && и напишите действие = shellcmd cmd1 && cmd2).

Иногда желательно запустить внешнюю программу и предоставить ей данные из
несколько правил. Чтобы создать такую ​​настройку, можно использовать именованные каналы. Например,
если / var / log / pipe - именованный канал, тогда

действие = shellcmd / usr / bin / logger -f / var / log / pipe -p user.notice

начинает / usr / bin / logger утилита, которая отправляет все строки, прочитанные из / var / log / pipe, в
локальный демон системного журнала с возможностью «пользователя» и уровнем «уведомления». Чтобы кормить события
в / usr / bin / logger, записывать можно использовать действие (например, записывать / вар / журнал / труба Эти is my
мероприятие). Хотя SEC держит именованный канал открытым в разных записывать действия, труба
будет закрыт при приеме сигналов SIGHUP, SIGABRT и SIGUSR2. Поскольку многие UNIX
инструменты прекращают работу при получении EOF из стандартного ввода, они нуждаются в перезапуске после такого
сигналы поступили. Для этого --события опции и внутренние события SEC могут
использоваться. Например, следующее правило запускает / usr / bin / logger утилита в SEC
запускается, а также перезапускает его после получения соответствующих сигналов:

type = Single
ptype = RegExp
шаблон = ^ (?: SEC_STARTUP | SEC_RESTART | SEC_SOFTRESTART | SEC_LOGROTATE) $
context = SEC_INTERNAL_EVENT
desc = запустить средство ведения журнала
действие = бесплатно% emptystring; owritecl / var / log / pipe% emptystring; \
shellcmd / usr / bin / logger -f / var / log / pipe -p user.notice

Обратите внимание, что если / var / log / pipe никогда не открывается для записи записывать действие, / usr / bin / logger
никогда не увидит EOF и, следовательно, не завершит работу. В owritecl действие открывается и закрывается
/ var / log / pipe без записи байтов, чтобы гарантировать наличие EOF в таком
случаи. Это позволяет любому предыдущему / usr / bin / logger процесс прекратить до нового
процесс запущен.

PERL ИНТЕГРАЦИЯ

SEC поддерживает шаблоны, контекстные выражения и действия, которые включают вызовы Perl.
Eval() или выполнение предварительно скомпилированного кода Perl. Использование кода Perl в SEC
шаблоны и контекстные выражения позволяют создавать правильные условия соответствия для сценариев
что не может быть обработано простым совпадением регулярного выражения. Например, рассмотрим
следующие события системного журнала iptables:

27 мая 10:00:15 box1 ядро: iptables: IN = eth0 OUT =
MAC=08:00:27:be:9e:2f:00:10:db:ff:20:03:08:00 SRC=10.6.4.14 DST=10.1.8.2 LEN=84 TOS=0x00
PREC = 0x00 TTL = 251 ID = 61426 PROTO = ICMP TYPE = 8 CODE = 0 ID = 11670 SEQ = 2
27 мая 10:02:22 box1 ядро: iptables: IN = eth0 OUT =
MAC=08:00:27:be:9e:2f:00:10:db:ff:20:03:08:00 SRC=10.6.4.14 DST=10.1.8.2 LEN=52 TOS=0x00
PREC = 0x00 TTL = 60 ID = 61441 DF PROTO = TCP SPT = 53125 DPT = 23 WINDOW = 49640 RES = 0x00 SYN URGP = 0

В зависимости от протокола и характера трафика события могут иметь самые разные
полей, и анализ всех данных событий с помощью одного регулярного выражения невозможен. За
для решения этой проблемы можно использовать шаблон PerlFunc, который создает переменные соответствия из
все поля совпадающего события, сохраняет их в одном хэше Perl и возвращает ссылку на
этот хеш. Вне шаблона PerlFunc переменные соответствия инициализируются ключом -
пары значений в возвращаемом хэше. Предположим следующее правило перехода с шаблоном PerlFunc
определено в файле правил main.rules:

type = Перейти
ptype = PerlFunc
шаблон = sub {мой (% var); моя ($ линия) = $ _ [0]; \
если ($ строка! ~ / ядро: iptables: / g) {возврат 0; } \
while ($ line = ~ / \ G \ s * ([AZ] +) (?: = (\ S *))? / g) {\
$ var {$ 1} = определено ($ 2)? $ 2: 1; \
} return \% var; }
varmap = IPTABLES
desc = разобрать событие iptables
cfset = iptables

Например, если событие iptables содержит поля SRC = 10.6.4.14, DST = 10.1.8.2 и
SYN, указанный выше шаблон PerlFunc устанавливает переменную соответствия $ + {SRC}, которая содержит 10.6.4.14,
переменная соответствия $ + {DST}, содержащая 10.1.8.2, и переменная соответствия $ + {SYN}, содержащая 1.
Правило перехода кэширует все созданные переменные соответствия под именем IPTABLES и отправляет
сопоставление события с Iptables набор правил для дальнейшей обработки. Предположим, что Iptables набор правил
определено в файле правил iptables.rules:

type = Параметры
прокаллин = нет
joincfset = iptables

type = SingleWithThreshold
ptype = Кэшировано
pattern = IPTABLES
context = IPTABLES:> (sub {return $ _ [0] -> {"PROTO"} eq "ICMP";})
desc = тип ICMP-флуда $ + {TYPE} код $ + {CODE} с хоста $ + {SRC}
действие = вход в систему
окно = 10
thresh = 100

type = SingleWithThreshold
ptype = Кэшировано
pattern = IPTABLES
context = IPTABLES:> (sub {return exists ($ _ [0] -> {"SYN"}) && \
существует ($ _ [0] -> {"FIN"}); })
desc = SYN + FIN флуд с хоста $ + {SRC}
действие = вход в систему
окно = 10
thresh = 100

Два правила SingleWithThreshold используют кэшированные шаблоны для сопоставления событий iptables по
поиск записи IPTABLES в кэше сопоставления с образцом (созданном вышеупомянутым правилом перехода
для каждого события iptables). Чтобы сузить совпадение до определенных событий iptables,
правила используют предварительно скомпилированные функции Perl в контекстных выражениях. Оператор:>
используется для ускорения сопоставления, предоставляя функции единственный параметр, который
относится к хешу пар имя-значение переменной для записи кэша IPTABLES.

Первое правило SingleWithThreshold регистрирует предупреждающее сообщение, если в течение 10 секунд 100
События iptables наблюдались для пакетов ICMP с одним и тем же типом, кодом и источником.
Айпи адрес. Второе правило SingleWithThreshold регистрирует предупреждающее сообщение, если в пределах 10
секунд 100 событий iptables наблюдались для TCP-пакетов, приходящих с одного и того же хоста,
и наличие флагов SYN и FIN, установленных в каждом пакете.

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

действие = eval% a ($ b = 1)

переменная $ b и ее значение становятся видимыми в следующем контекстном выражении

контекст = = (++ $ b> 10)

(с этим выражением можно неявно реализовать подсчет событий). Чтобы избежать
возможные конфликты с переменными внутри самого кода SEC, определяемый пользователем код Perl
выполняется в пространстве имен main :: SEC (т.е. внутри специального пакета main :: SEC). От
используя префикс main ::, можно получить доступ к структурам данных SEC и изменить их. Например,
следующие правила восстанавливают и сохраняют контексты при запуске и завершении работы SEC (SEC сохраняет все
контексты в хэше% main :: context_list):

type = Single
ptype = SubStr
шаблон = SEC_STARTUP
context = SEC_INTERNAL_EVENT
continue = TakeNext
desc = Загрузите модуль Storable и завершите работу, если он не найден
действие = eval% ret (требуется Storable); \
если% ret (логин Storabe загружен) else (eval% o выход(1))

type = Single
ptype = SubStr
шаблон = SEC_STARTUP
context = SEC_INTERNAL_EVENT
desc = Восстановить все контексты SEC из / var / lib / sec / SEC_CONTEXTS при запуске
действие = lcall% ret -> (sub {\
мой $ ptr = $ main :: context_list {"SEC_INTERNAL_EVENT"}; \
% main :: context_list = \
% {Storable :: retrieve ("/ var / lib / sec / SEC_CONTEXTS")}; \
$ main :: context_list {"SEC_INTERNAL_EVENT"} = $ ptr; })

type = Single
ptype = SubStr
pattern = SEC_SHUTDOWN
context = SEC_INTERNAL_EVENT
desc = Сохранить все контексты SEC в / var / lib / sec / SEC_CONTEXTS при завершении работы
действие = lcall% ret -> (sub {\
Storable :: store (\% main :: context_list, \
"/ var / lib / sec / SEC_CONTEXTS"); })

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

Наконец, иногда приходится использовать более крупные фрагменты кода Perl для обработки событий и
корреляция. Однако написание большого количества строк кода непосредственно в правило обременительно и
может снизить его удобочитаемость. В таких случаях рекомендуется разделить код на
настраиваемый модуль Perl, который загружается при запуске SEC, и использовать код через модуль
интерфейс (см. перлмод(1) для получения дополнительной информации):

type = Single
ptype = SubStr
шаблон = SEC_STARTUP
context = SEC_INTERNAL_EVENT
desc = Загрузить модуль SecStuff
действие = eval% ret (требуется '/usr/local/sec/SecStuff.pm'); \
если% ret (нет) else (eval% o выход(1))

type = Single
ptype = PerlFunc
шаблон = sub {return SecStuff :: my_match ($ _ [0]); }
desc = событие '$ 0' было сопоставлено my_match ()
действие = запись -% s

ПРИМЕРЫ

Пример 1 - a набор правил для Cisco События
В этом разделе представлен пример базы правил для управления устройствами Cisco. Предполагается, что
на управляемых устройствах включено ведение журнала системного журнала, и все сообщения системного журнала отправляются на
центральный хост и записывается в файлы журнала, которые контролируются SEC.

# Настроить контексты НОЧЬ и ВЫХОДНЫЕ для ночей
# и в выходные. Контекст НОЧИ имеет всю жизнь
# 8 часов и контекст WEEKEND 2 дня

type = Календарь
время = 0 23 * * *
desc = НОЧЬ
действие = создать% s 28800

type = Календарь
время = 0 0 * * 6
desc = ВЫХОДНЫЕ
действие = создать% s 172800

# Если роутер не подходит в течение 5 минут
# после перезагрузки генерировать событие
# " ОТКАЗ ПЕРЕЗАГРУЗКИ ". Соответствует следующее правило.
# это событие проверяет маршрутизатор с помощью ping и отправляет
# уведомление, если нет ответа.

type = PairWithWindow
ptype = RegExp
шаблон = \ s ([\ w .-] +) \ d +:% SYS-5-RELOAD
desc = $ 1 ОТКАЗ ПЕРЕЗАГРУЗКИ
действие = событие% s
ptype2 = RegExp
pattern2 = \ s $ 1 \ d +:% SYS-5-RESTART
desc2 =% 1 успешная перезагрузка
действие2 = вход в систему
окно = 300

type = SingleWithScript
ptype = RegExp
шаблон = ^ ([\ w .-] +) ОТКАЗ ПЕРЕЗАГРУЗКИ
скрипт =/ bin / ping -c 3 -q 1 доллар
desc = $ 1 не поднялся после перезагрузки
action = logonly $ 1 доступен для проверки связи после перезагрузки
action2 = pipe '% t:% s' / bin / mail root @ localhost

# Отправлять уведомление, если загрузка ЦП маршрутизатора слишком велика
# высокий (два сообщения CPUHOG получены в течение 5
# минут); отправить еще одно уведомление, если нагрузка
# снова нормально (нет сообщений CPUHOG за последние 15
# минут). Правило не действует ночью и в выходные.

type = SingleWith2Thresholds
ptype = RegExp
шаблон = \ s ([\ w .-] +) \ d +:% SYS-3-CPUHOG
context =! (НОЧЬ || ВЫХОДНЫЕ)
desc = $ 1 перегрузка ЦП
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 300
thresh = 2
desc2 = нормальная загрузка процессора $ 1
action2 = pipe '% t:% s' / bin / mail root @ localhost
окно2 = 900
thresh2 = 0

# Если интерфейс маршрутизатора в нерабочем состоянии за меньшую плату
# более 15 секунд, генерировать событие
# " ИНТЕРФЕЙС КОРОТКИЙ ОТКЛЮЧЕНИЕ ";
# в противном случае сгенерировать событие
# " ИНТЕРФЕЙС ВНИЗ".

type = PairWithWindow
ptype = RegExp
pattern = \ s ([\ w .-] +) \ d +:% LINK-3-UPDOWN: Интерфейс ([\ w .-] +), состояние изменено на выключенное
desc = $ 1 ИНТЕРФЕЙС $ 2 ВНИЗ
действие = событие% s
ptype2 = RegExp
pattern2 = \ s $ 1 \ d +:% LINK-3-UPDOWN: Интерфейс $ 2, состояние изменено на up
desc2 =% 1 ИНТЕРФЕЙС% 2 КОРОТКОЕ НЕИСПРАВНОСТЬ
действие2 = событие% s
окно = 15

# Если " ИНТЕРФЕЙС DOWN "событие
# получено, отправьте уведомление и дождитесь
# событие "interface up" от того же интерфейса маршрутизатора
# на следующие 24 часа

type = Пара
ptype = RegExp
шаблон = ^ ([\ w .-] +) ИНТЕРФЕЙС ([\ w .-] +) ВНИЗ
desc = $ 1 интерфейс $ 2 не работает
действие = канал '% t:% s' / bin / mail root @ localhost
ptype2 = RegExp
pattern2 = \ s $ 1 \ d +:% LINK-3-UPDOWN: Интерфейс $ 2, состояние изменено на up
desc2 =% 1 интерфейс% 2 включен
action2 = pipe '% t:% s' / bin / mail root @ localhost
окно = 86400

# Если было зафиксировано десять случаев "коротких отключений"
# в окне 6 часов отправить уведомление

type = SingleWithThreshold
ptype = RegExp
шаблон = ^ ([\ w .-] +) ИНТЕРФЕЙС ([\ w .-] +) КОРОТКОЕ ВЫКЛЮЧЕНИЕ
desc = Интерфейс $ 2 на узле $ 1 нестабилен
действие = канал '% t:% s' / bin / mail root @ localhost
окно = 21600
thresh = 10

Пример 2 - иерархически организованный наборы правил для Iptables и SSHD События
В этом разделе представлен пример иерархически организованных правил для обработки Linux.
События iptables из / var / log / messages и события входа в SSH из / var / log / secure. это
предполагается, что все файлы правил находятся в каталоге / etc / sec и что иерархия правил
имеет два уровня. Файл /etc/sec/main.rules содержит правила перехода первого уровня для сопоставления
и парсинг событий из входных файлов и отправка их в соответствующие наборы правил для дальнейшего
обработка. Все остальные файлы правил в каталоге / etc / sec содержат правила второго уровня.
которые получают свои данные из правил прыжков первого уровня. Кроме того, в примере предполагается, что SEC
запускается следующей командной строкой:

/ usr / bin / sec --conf = / etc / sec / *. rules --intcontexts \
--input = / var / log / messages --input = / var / log / secure

#
# содержимое /etc/sec/main.rules
#

type = Перейти
context = [_FILE_EVENT_ / var / log / messages]
ptype = PerlFunc
шаблон = sub {мой (% var); моя ($ линия) = $ _ [0]; \
если ($ строка! ~ / ядро: iptables: / g) {возврат 0; } \
while ($ line = ~ / \ G \ s * ([AZ] +) (?: = (\ S *))? / g) {\
$ var {$ 1} = определено ($ 2)? $ 2: 1; \
} return \% var; }
varmap = IPTABLES
desc = анализирует события iptables и направляет их к соответствующему набору правил
cfset = iptables

type = Перейти
context = [_FILE_EVENT_ / var / log / secure]
ptype = RegExp
шаблон = sshd \ [(? \ d +) \]: (? Принято | Не удалось) \
(? [\ w -] +) для (? недействительный пользователь )?\
(? [\ w -] +) из (? [\ d.] +) порт (? \ d +) ssh2 $
varmap = SSH_LOGIN
desc = анализировать события входа в систему SSH и направлять к соответствующему набору правил
cfset = ssh-логин

type = Перейти
context = [SSH_EVENT]
ptype = TValue
pattern = True
desc = направлять синтетические события SSH в соответствующий набор правил
cfset = ssh-события

#
# содержимое /etc/sec/iptables.rules
#

type = Параметры
прокаллин = нет
joincfset = iptables

type = SingleWithThreshold
ptype = Кэшировано
pattern = IPTABLES
context = IPTABLES:> (sub {return exists ($ _ [0] -> {"SYN"}) && \
существует ($ _ [0] -> {"FIN"}); }) \
&&! SUPPRESS_IP _ $ + {SRC}
desc = SYN + FIN флуд с хоста $ + {SRC}
действие = канал '% t:% s' / bin / mail -s 'iptables alert' root @ localhost; \
создать SUPPRESS_IP _ $ + {SRC} 3600
окно = 10
thresh = 100

type = SingleWithThreshold
ptype = Кэшировано
pattern = IPTABLES
context = IPTABLES:> (sub {return exists ($ _ [0] -> {"SYN"}) && \
! существует ($ _ [0] -> {"ACK"}); }) \
&&! SUPPRESS_IP _ $ + {SRC}
desc = SYN флуд с хоста $ + {SRC}
действие = канал '% t:% s' / bin / mail -s 'iptables alert' root @ localhost; \
создать SUPPRESS_IP _ $ + {SRC} 3600
окно = 10
thresh = 100

#
# содержимое /etc/sec/ssh-login.rules
#

type = Параметры
прокаллин = нет
joincfset = ssh-логин

type = Single
ptype = Кэшировано
pattern = SSH_LOGIN
context = SSH_LOGIN:> (sub {return $ _ [0] -> {"status"} eq "Failed" && \
$ _ [0] -> {"srcport"} <1024 && \
определено ($ _ [0] -> {"invuser"}); })
continue = TakeNext
desc = Зонд недействительного пользователя $ + {user} из привилегированного порта $ + {srcip}
action = pipe '% t:% s' / bin / mail -s 'SSH alert' root @ localhost

type = SingleWithThreshold
ptype = Кэшировано
pattern = SSH_LOGIN
context = SSH_LOGIN:> (sub {return $ _ [0] -> {"status"} eq "Failed" && \
определено ($ _ [0] -> {"invuser"}); })
desc = Десять проверок входа для недействительных пользователей от $ + {srcip} в течение 60 секунд
action = pipe '% t:% s' / bin / mail -s 'SSH alert' root @ localhost
thresh = 10
окно = 60

type = PairWithWindow
ptype = Кэшировано
pattern = SSH_LOGIN
context = SSH_LOGIN:> (sub {return $ _ [0] -> {"status"} eq "Failed";})
desc = Пользователь $ + {user} не смог войти в систему с $ + {srcip} в течение 60 секунд
действие = cevent SSH_EVENT 0% s
ptype2 = Кэшировано
pattern2 = SSH_LOGIN
context2 = SSH_LOGIN:> \
(sub {return $ _ [0] -> {"status"} eq "Принято";}) && \
$ + {пользователь}% + {пользователь} $ + {srcip}% + {srcip} -> \
(sub {return $ _ [0] eq $ _ [1] && $ _ [2] eq $ _ [3];})
desc2 = Пользователь $ + {пользователь} успешно вошел в систему с $ + {srcip} в течение 60 секунд
действие2 = вход в систему
окно = 60

#
# содержимое /etc/sec/ssh-events.rules
#

type = Параметры
прокаллин = нет
joincfset = ssh-события

type = SingleWithThreshold
ptype = RegExp
pattern = Пользователь ([\ w -] +) не смог войти в систему с [\ d.] + в течение 60 секунд
desc = Десять неудачных попыток входа для пользователя $ 1 в течение 1 часа
action = pipe '% t:% s' / bin / mail -s 'SSH alert' root @ localhost
thresh = 10
окно = 3600

ОКРУЖАЮЩАЯ СРЕДА

Если же линия индикатора СЕКРК переменная окружения установлена, SEC ожидает, что она будет содержать имя своего
файл ресурсов. Строки файла ресурсов, пустые или начинающиеся со знака числа (#)
игнорируются (пробел может предшествовать #). Каждая оставшаяся строка добавляется к ARGV массив
ТРЦ как * одиночный * элемент. Также строки добавляются к ARGV в том порядке, в котором они
появляются в файле ресурсов. Следовательно, если параметр командной строки SEC имеет значение,
имя параметра и значение должны быть разделены знаком равенства (=) или новой строкой.
Вот простой пример файла ресурсов:

# читать события из стандартного ввода
--input = -

# правила хранятся в /etc/sec/test.conf
--conf
/etc/sec/test.conf

Обратите внимание, что хотя SEC перечитывает свой файл ресурсов при получении ПОДПИСАТЬСЯ or СИГАБРТ
сигнал, добавив параметр, определяющий определенную процедуру запуска (например, --пид or
--отсоединить) не даст желаемого эффекта во время выполнения. Также обратите внимание, что файл ресурсов
содержимое * не * анализируется оболочкой, поэтому метасимволы оболочки передаются в SEC как есть.

СИГНАЛЫ

ПОДПИСАТЬСЯ полный перезапуск - SEC заново интерпретирует параметры командной строки и файла ресурсов,
повторно откройте его файлы журнала и ввода, закройте файлы вывода и сокеты (это будут
повторно открывается по запросу), перезагрузите его конфигурацию и удалите * все * корреляцию событий
состояние (все операции корреляции событий будут прекращены, все контексты будут
удаляется, все переменные списка действий будут удалены и т. д.). С - ребенок
вариант, SEC также отправит СИГТЕРМ сигнал своим дочерним процессам.

СИГАБРТ
мягкий перезапуск - SEC заново интерпретирует параметры командной строки и файла ресурсов,
повторно откройте его файл журнала и закройте его выходные файлы и сокеты (они будут повторно открыты
по требованию). Если --держать открытым опция указана, ранее открытые входные файлы
останется открытым при мягком перезапуске, в противном случае все входные файлы будут повторно открыты.
SEC загрузит (повторно) конфигурацию из файлов правил, которые были изменены (файл
время модификации, возвращенное состояние(2) изменено) или создано после предыдущего
загрузка конфигурации. SEC также прекратит начатую операцию корреляции событий.
из файлов правил, которые были изменены или удалены после предыдущей конфигурации
нагрузка. Другие операции и ранее загруженная конфигурация из неизмененного правила
файлы останутся нетронутыми. Обратите внимание, что в некоторых системах СИГИОТ используется вместо
СИГАБРТ.

СИГУСР1
подробная информация о текущем состоянии SEC (производительность и соответствие правил
статистика, выполняемые операции корреляции событий, созданные контексты и т. д.) будут
записывается в файл дампа SEC.

СИГУСР2
SEC повторно откроет свой файл журнала (полезно для ротации файлов журнала), а также закроет свой
выходные файлы и сокеты, которые будут открываться повторно по запросу.

SIGINT SEC увеличит уровень ведения журнала на единицу; если текущий уровень равен 6, уровень
будет установлено обратно на 1. Обратите внимание, что эта функция доступна, только если работает SEC.
не интерактивно (например, в режиме демона).

СИГТЕРМ
SEC завершится корректно. С - ребенок опция, все дочерние процессы SEC
получит СИГТЕРМ.

Используйте sec в Интернете с помощью сервисов onworks.net