Transição da SPL para a YARA-L 2.0
Este guia destina-se a utilizadores que já estão familiarizados com a linguagem de processamento de pesquisa (SPL) do Splunk. Apresenta uma introdução rápida ao YARA-L 2.0: a linguagem principal para criar pesquisas, painéis de controlo e regras de deteção no Google Security Operations.
Compreenda a estrutura do YARA-L 2.0
O YARA-L 2.0 é a linguagem de consulta unificada usada no Google SecOps para uma pesquisa de ameaças avançada, a criação de painéis de controlo em tempo real e a criação de regras de deteção de alta fidelidade em todos os seus dados de registo empresariais à medida que são carregados.
A linguagem funciona em conjunto com o motor de deteção do Google SecOps e permite-lhe pesquisar ameaças e outros eventos em grandes volumes de dados.
Diferenças básicas de estrutura entre o SPL e o YARA-L
O SPL usa uma série de comandos encadeados com carateres de barra vertical (|), enquanto o YARA-L é baseado em secções. Define uma consulta através de secções distintas, como events, outcome e condition, para descrever um padrão que quer pesquisar, detetar ou visualizar.
A tabela seguinte compara a estrutura básica entre o SPL e o YARA-L:
| Função | SPL (procedural) | YARA-L (declarativo) |
|---|---|---|
| Conceito principal | Transforme uma stream de dados passo a passo através de um pipeline de comandos. | Analisa e aplica uma estrutura multipartida de condições e transformações a um fluxo de dados operacionais e de segurança, identificando ameaças e extraindo estatísticas valiosas. |
| Fluxo de dados | Procedimental. Os resultados de um comando são transferidos como entrada para o seguinte. | Estrutura declarativa para processar e correlacionar padrões de forma ideal em grande escala. Eliminar a necessidade de pensar na eficiência. |
| Correlação de eventos | Baseia-se em comandos explícitos, como join, transaction e stats. |
Integrado através da definição de vários eventos e da respetiva correlação com base num campo comum na lógica da consulta. |
| Visualização baseada no tempo | Processado como uma janela de pesquisa estática (por exemplo, last
60m). Cada nova pesquisa é um novo pedido. |
É processado como um intervalo de tempo contínuo e dinâmico definido na consulta (por exemplo, over 5m). |
| Sintaxe | Baseado em comandos (por exemplo, index=web). |
Conciso e orientado pela lógica (por exemplo, metadata.event_type=
"USER_LOGIN"). |
Estrutura específica das consultas
O YARA-L aplica uma estrutura específica para as consultas, que é diferente dos comandos sequenciais com pipes do SPL. Embora a SPL crie resultados encadeando comandos, a YARA-L define diferentes aspetos da consulta em secções distintas.
| Command | Ação | Obrigatório | Opcional |
|---|---|---|
meta
|
Define metadados descritivos para a regra, como o autor, a descrição e a gravidade. | Obrigatório apenas para regras. |
events
|
Define e filtra eventos. | Obrigatório (lógica essencial da consulta). |
match
|
Agrupa por eventos e permite especificar o período (por exemplo, by 5m). |
Opcional. Obrigatório apenas para consultas de correlação de vários eventos. |
outcome |
Calcular métricas principais e obter estatísticas. | Opcional. |
condition
|
Avalia os critérios da variável de consulta para determinar se um resultado se aplica (por exemplo, #event >5). |
Obrigatório apenas para regras. Opcional na pesquisa e nos painéis de controlo. |
dedup |
Remove eventos duplicados agrupando-os com base em variáveis principais (por exemplo, target.user.userid, target.ip> e principal.hostname). |
Opcional. |
order
|
Ordena os resultados dos eventos recolhidos definidos por campos específicos (por exemplo, asc). |
Opcional. |
limit |
Restringe o número máximo de eventos devolvidos pela consulta. | Opcional. |
Comandos comuns em SPL e YARA-L
A estrutura da secção YARA-L permite-lhe usar os mesmos comandos comuns encontrados no SP. Esta secção descreve as semelhanças e as diferenças.
comando SPL search = secção YARA-L events
O comando search no SPL é equivalente à secção events no YARA-L. A secção events define os eventos e como são filtrados inicialmente. Embora outras secções (como match ou outcome) sejam opcionais, a secção events é fundamental para todas as regras.
Por exemplo:
metadata.event_type = "USER_LOGIN"
ou:
principal.hostname != "" AND metadata.event_type = "NETWORK_CONNECTION"
Na secção events das regras (e consultas avançadas), usa variáveis de eventos para simplificar a sua lógica.
Uma variável de evento funciona como um agrupamento lógico de filtros, representando um evento específico ou um grupo de eventos que correspondem a determinados critérios.
Por exemplo, para definir uma variável de evento, como $e, use-a como prefixo de todos os eventos e filtros relacionados na secção events da sua consulta. Em seguida, pode usar essa variável noutras secções da consulta (como match ou outcome) para fazer referência a esse grupo específico de eventos e aos respetivos campos de dados.
A aplicação mais comum para variáveis de eventos é nas regras de deteção. O exemplo seguinte demonstra como usar a variável de evento ($e) numa regra para agrupar eventos e encontrar o número de inícios de sessão falhados de um utilizador num dia. Em seguida, a regra é acionada se exceder um limite definido.
No exemplo de regra, cada evento é definido com a variável de evento ($e). A variável $e também é referenciada em metadata.id para associar os metadados da regra aos eventos definidos.
rule DailyFailedLoginAttempts {
meta:
author = "Alex"
description = "Detects a high number of failed login attempts for a single user within a day."
events:
// Alias for each event
$e.metadata.event_type = "USER_LOGIN"
$e.security_result.action = "FAIL"
$e.principal.user.userid != ""
$userid = $e.principal.user.userid
match:
// Group events by principal.user.userid within a 24-hour window
$userid over 1d
outcome:
// Count the number of unique event IDs for each user per day
$daily_failed_login_count = count($e.metadata.id)
condition:
// Trigger a detection if the daily failed login count exceeds a threshold
// You should adjust this threshold based on your environment's baseline.
#e > 0
}
Para se certificar de que a regra é acionada, tem de verificar frequentemente a contagem dos eventos agrupados. Pode especificar uma contagem mínima na secção condition através da variável de evento. Por exemplo, a condição (#e > 0) verifica se existe, pelo menos, um evento que corresponda aos critérios.
comando SPL eval = secção YARA-L outcome
O comando eval é uma função SPL fundamental usada para manipular e definir valores de campos nos resultados da pesquisa.
- Finalidade: calcula e define novos valores de campos.
- Funcionalidade: avalia expressões matemáticas, de string ou booleanas.
- Resultado: o resultado da avaliação cria um novo campo ou substitui o valor de um campo existente.
- Encadeamento: é possível encadear várias expressões usando uma vírgula (por exemplo,
| eval A=1, B=A+1). - Processamento sequencial: as expressões numa cadeia são processadas sequencialmente, o que permite que os cálculos posteriores façam referência e se baseiem em campos criados ou modificados por expressões anteriores.
Os exemplos na tabela seguinte (e depois) explicam esta estrutura de comando:
| Função | Descrição | Exemplo de YARA-L |
|---|---|---|
| Operadores booleanos | Usado no events e no condition. Consulte a secção Use ou na secção de condições. |
|
| Campos calculados | Usado na secção outcome. |
|
| Criação de nomes de campos dinâmicos | Usado na secção outcome. |
Veja exemplos em Compare o SPL com o YARA-L. |
Exemplo: crie um novo campo que contenha o resultado de um cálculo
Usando o YARA-L, crie um novo campo, bytes, em cada evento. Calcule os bytes adicionando os valores no campo bytes enviado com o campo bytes recebido.
metadata.event_type = "SCAN_NETWORK"
principal.hostname != ""
$host = principal.hostname
match:
$host
outcome:
$bytes = cast.as_int(sum(network.sent_bytes))
Exemplo: concatenar valores de dois campos
Use o caráter de ponto (.) para concatenar os valores no campo first_name
com os valores no campo last_name. Use aspas ("") para inserir um caráter de espaço entre os dois campos. Quando concatenados, os valores são lidos como strings, independentemente do valor real.
No SPL, a consulta teria um aspeto semelhante ao seguinte:
| eval full_name = first_name+" "+last_name
Em YARA-L, a consulta de pesquisa seria semelhante à seguinte:
principal.user.first_name = $first_name
principal.user.last_name = $last_name
outcome:
$full_name = strings.concat(principal.user.first_name = $first_name
principal.user.last_name = $last_name
outcome:
$full_name = strings.concat($first_name, " ", $last_name))
Usando o exemplo de consulta de início de sessão falhado, o exemplo seguinte permite-lhe encontrar utilizadores que tiveram cinco ou mais inícios de sessão falhados num período de 10 minutos (10m) entre si (usando variáveis de eventos e de marcadores de posição):
metadata.event_type = "USER_LOGIN"
security_result.action = "FAIL"
target.user.userid = $userid
match:
$userid by 10m
outcome:
$login_count= count(metadata.id)
condition:
$login_count > 5
comando SPL where = secção YARA-L condition
O comando SPL where é equivalente a uma combinação da secção events, outcome ou condition em YARA-L. Na secção events, pode declarar eventos e especificar atributos específicos para os mesmos (por exemplo, priniciapal.hostname = "xyz"). Depois de declarar os eventos, pode usar operadores booleanos, operadores de comparação e resultados de funções de agregação (da secção outcome) para definir os parâmetros que os eventos têm de cumprir para que a consulta devolva um resultado.
O exemplo seguinte demonstra como definir uma condição de limite numa contagem agregada. A consulta está estruturada para contabilizar o número total de eventos de início de sessão falhados por ID do utilizador e, em seguida, usa a secção condition para gerar resultados apenas para utilizadores que tenham registado cinco ou mais inícios de sessão falhados.
metadata.event_type = "USER_LOGIN"
security_result.action = "FAIL"
match:
target.user.userid
outcome:
// metadata.id counts all unique events associated with failed logins.
$count = count(metadata.id)
//metadata.id counts all unique events associated with blocked logins.
condition:
$count > 5
comando SPL dedup = secção YARA-L dedup
O comando SPL dedup é equivalente à secção dedup em YARA-L. Use a secção dedup para remover resultados duplicados especificados por um evento na secção events.
Por exemplo:
principal.hostname = "foo"
dedup:
target.ip
Comando SPL stats = secção match ou outcome do YARA-L (ou ambas)
No SPL, a agregação é normalmente processada pela
stats família de comandos,
que especifica o tipo de agregação (como count, distinct count, max,
min) e o campo "group by".
No YARA-L, as secções match e outcome oferecem em conjunto esta capacidade:
Lógica de agregação: a secção
matchcria agregações definindo o grupo de eventos a considerar (match: $grouping_field by time). Em seguida, a secçãooutcomedefine as funções de agregação específicas a calcular nesse grupo (por exemplo,count(),min(),max()).Intervalo de tempo: a secção
matchsuporta a especificação de um intervalo de tempo para agrupar eventos. Use a palavra-chaveover(para regras) ouby(para pesquisa e painéis de controlo) (por exemplo,match: $userid by 1h). Esta funcionalidade é semelhante ao SPL, como"timechart","streamstats"e"eventstats". Para mais informações, consulte o artigo Janelas de tempo.
Exemplo: calcular a soma dos bytes agrupados por nome de anfitrião principal e IP de destino
O exemplo seguinte usa a secção match para definir um grupo de agregação com base no nome de anfitrião principal e no endereço IP de destino durante um período de um dia. A soma resultante dos bytes enviados é calculada na secção outcome.
metadata.event_type = "NETWORK_CONNECTION"
network.sent_bytes > 0
principal.hostname != ""
target.ip != ""
// Define placeholder variables for grouping
$principal_hostname = principal.hostname
$target_ip = target.ip
// Group events by principal hostname, target IP, and day
match:
$principal_hostname, $target_ip by day
// Calculate the sum of sent bytes for each group
outcome:
$daily_bytes_sent = sum(network.sent_bytes)
Mapeie SPL para YARA-L
O SPL processa os dados passo a passo através de comandos canalizados, enquanto o YARA-L usa uma estrutura declarativa baseada em secções para definir padrões e ações. Apesar destas diferenças fundamentais na abordagem, o poder expressivo do YARA-L permite-lhe realizar muitas das mesmas tarefas que está habituado a fazer no SPL, desde a filtragem básica a agregações e correlações complexas.
Esta secção explica as diferenças ao mapear as funcionalidades SPL conhecidas para os respetivos equivalentes na framework YARA-L.
Compare o SPL com o YARA-L
Esta tabela compara funções e conceitos comuns na linguagem SPL comum com os respetivos equivalentes no YARA-L 2.0 ou como o conceito é processado numa estrutura de consulta YARA-L.
| Comando ou conceito SPL | Finalidade | Equivalente ao YARA-L | Descrição e mapeamento YARA-L | Exemplo de implementação do YARA-L |
|---|---|---|---|---|
search |
Filtragem de dados inicial | Secção events |
Defina campos e condições de eventos. Não é necessário o prefixo events: para a pesquisa nem para os painéis de controlo. Veja um exemplo. |
|
where |
Filtragem adicional nos resultados | Secções events e condition |
Aplicar lógica booleana, frequentemente em resultados agregados. Veja um exemplo. |
|
eval |
Calcula novos valores a partir de campos existentes, agregações e pesquisas de dados | secção outcome ou events |
Veja um exemplo de SPL eval.
|
|
stats |
Agregações (count, sum, média) |
match ou outcome |
Agrupar por campos em match. Calcule agregados em outcome. Veja exemplos em Agregações e consultas estatísticas e no comando SPL stats. |
|
dedup |
Remove eventos duplicados com base num ou mais campos | Secção dedup |
Especifique os campos nos quais quer remover duplicados. |
|
table |
Define a saída da coluna da tabela | select ou unselect
|
Usado em painéis de controlo. Na pesquisa, apresenta outcome variáveis. |
|
sort |
Apresenta os resultados por ordem ascendente ou descendente | Secção order |
Veja o exemplo na célula seguinte da tabela. |
|
limit |
Restringe o número de resultados devolvidos | Secção limit |
Veja o exemplo na célula seguinte. |
|
| Funções de valor múltiplo | Processado com funções de mv* (mvexpand, mvfilter) |
Apoio técnico integrado | O YARA-L anula automaticamente a aninhagem de matrizes na secção de eventos. As funções de matriz estão disponíveis em outcome, se necessário. |
Veja exemplos de funções com vários valores. |
| Visualização baseada no tempo | earliest=-5m, latest=now |
Secção match, over, by |
Para deteções contínuas, use match: $field over 5m or by 5m. Para painéis de controlo na IU de pesquisa, use match: $field by 5m. |
Veja exemplos em Janelas de tempo. |
Consultas estatísticas e de agregação
No YARA-L, as funções estatísticas e de agregação são normalmente colocadas na secção outcome, e a agregação baseia-se na secção match.
O comando stats é o mecanismo principal para implementar a agregação de dados nas consultas YARA-L. Transforma dados de eventos não processados em métricas de segurança resumidas. Embora o comando eval processe transformações ao nível do campo, linha a linha (semelhante a uma expressão SELECT), o comando stats realiza uma agregação ao nível do conjunto (semelhante a GROUP BY em SQL).
A tabela seguinte fornece a sintaxe e a utilização principais, demonstrando como usar eficazmente as estatísticas para implementar uma lógica de segurança sofisticada com base em padrões de dados e valores atípicos estatísticos.
| Função SPL | Descrição | Equivalente ao YARA-L | Exemplo de implementação do YARA-L |
|---|---|---|---|
count |
Conta o número de eventos. | count() |
|
dc (count_distinct) |
Conta o número de valores únicos para um campo. | count_distinct() |
|
sum |
Calcula a soma dos valores de um campo. | sum() |
|
avg |
Calcula o valor médio de um campo. | avg() |
|
min/max |
Encontra o valor mínimo ou máximo de um campo. | min() ou max() |
|
median() |
Encontra o valor mediano. | window.median |
|
first() and last() |
Devolve valores com base na ordem dos eventos nos resultados da pesquisa. | window.first/window.last |
|
STDDEV() |
Calcula o desvio padrão, que mede a dispersão de um conjunto de dados. | window.stddv |
|
Para ver detalhes, consulte funções adicionais.
Por exemplo, uma consulta de várias fases pode acompanhar vários inícios de sessão falhados em agregações em camadas. Para ver detalhes, consulte o exemplo de agregação em várias fases e o artigo Crie consultas em várias fases no YARA-L.
Agregação em várias fases (média horária para semanal)
Este exemplo de várias fases agrega inicialmente os dados para encontrar os bytes transferidos por anfitrião a cada hora. Em seguida, usa essa agregação para calcular a média geral nesses intervalos de uma hora nos últimos sete dias.
stage bytes_per_host {
metadata.event_type = "SCAN_NETWORK"
principal.hostname != ""
$host = principal.hostname
match:
$host by hour
outcome:
$bytes = cast.as_int(sum(network.sent_bytes))
}
$host = $bytes_per_host.host
match:
$host
outcome:
$hour_buckets = array_distinct(timestamp.get_timestamp($bytes_per_host.window_start))
$num_hour_buckets = count_distinct($bytes_per_host.window_start)
$avg_hourly_bytes = avg($bytes_per_host.bytes)
Funções com vários valores (leem uma matriz)
A sintaxe do YARA-L foi criada para compreender que um campo pode ter vários valores. Quando escreve uma consulta que inclui um evento com um campo de vários valores na secção events, a linguagem verifica automaticamente todos os valores na matriz. Não precisa de usar uma função especial para filtrar a matriz. Basta indicar a condição que quer corresponder. Por exemplo, se o campo principal.ip do evento de registo contiver o seguinte, o motor YARA-L verifica automaticamente todos os valores na matriz principal.ip. Se algum dos valores for "10.1.1.5", a condição é cumprida.
["10.1.1.5", "10.2.2.6", "10.3.3.7"]
A tabela seguinte mostra uma comparação entre o YARA-L e o SPL sobre como gerir campos com vários valores nos dados de registo. Os campos com vários valores, como uma matriz de endereços IP ou uma lista de grupos de utilizadores, são uma caraterística comum nos registos estruturados.
| Função SPL | Purpose | Equivalente ao YARA-L | Exemplo de implementação do YARA-L |
|---|---|---|---|
mvfilter() |
Filtra um campo com vários valores para manter apenas os valores correspondentes. | Quando usado na secção events de uma consulta YARA-L, liste o campo a corresponder. O YARA-L verifica automaticamente se algum valor na matriz de grupos corresponde a "`admin`". |
|
mvcount() |
Conta o número de valores num campo com vários valores. | count() aplicado a um campo na secção de consulta outcome. Não é necessário anular o aninhamento de nenhum valor primeiro. |
Veja o exemplo Contar a quantidade de utilizadores que pertencem ao grupo de funcionários de TI. |
mvexpand |
Cria um novo evento para cada valor num campo de vários valores. | Processa campos com vários valores de forma nativa e implícita; a anulação da aninhagem ocorre automaticamente. | Veja o exemplo Contar a quantidade de utilizadores que pertencem ao grupo de funcionários de TI. |
mvjoin |
Junta todos os valores de um campo com vários valores numa única string para fins de formatação de dados. | Os valores são armazenados automaticamente como uma matriz nos resultados. O resultado do YARA-L é estruturado e não uma string simples. Apresenta o campo como uma matriz se for necessária uma manipulação adicional da matriz. Para ver detalhes, use funções de matriz. |
Exemplo: conte o número de inícios de sessão do admin
No exemplo seguinte, a condição $metadata.event_type = "USER_LOGIN" filtra eventos em que o event_type é "USER_LOGIN":
events:
metadata.event_type = "USER_LOGIN" // Changed to a more appropriate event type for login
principal.user.group_identifiers = "admin"
outcome:
// This counts each unique event ID where the principal user is in the `"admin"` group.
$admin_login_count = count(metadata.id)
O campo $principal.user.group_identifiers= "admin" é um campo repetido (uma matriz).
- Anulação da aninhagem implícita: o YARA-L anula a aninhagem deste campo internamente durante a avaliação da consulta.
- Verificação da condição: um evento satisfaz a condição se qualquer um dos valores na matriz
$principal.user.group_identifiersfor igual a"admin". - Não é necessário nenhum comando explícito: ao contrário da SPL, não precisa de um comando de anulação da aninhagem específico, como
mvexpand.
A secção de impacto na agregação (outcome) significa que a anulação da aninhagem implícita é crucial na secção outcome (por exemplo, outcome: $admin_login_count = count(metadata.id))). Tenha em atenção o seguinte impacto:
- Um único evento de UDM que contenha vários valores correspondentes num campo repetido pode gerar várias linhas internas para fins de avaliação de consultas.
- Uma vez que a secção
eventsjá desaninhou eficazmente os eventos com base em cada valor correspondente em$principal.user.group_identifiers, a agregaçãocount(metadata.id)contabiliza cada uma destas instâncias desaninhadas.
Exemplo: conte a quantidade de utilizadores que pertencem ao grupo de funcionários de TI
SPL:
index=<your_index_name> user_id="jsmith"
| where match(memberOf, "Domain Admins|IT Staff|HR")
| mvexpand memberOf
| stats count by memberOf
| mvexpand actions
| table memberOf, count, actions
YARA-L (pesquisa):
principal.user.userid = "jsmith"
additional.fields["memberOf"] = $group
$group = /Domain Admins|IT Staff|HR/ nocase
match:
$group by 1h
outcome:
$group_count = count_distinct(metadata.id)
$memberOf = array_distinct($group)
$risk_score = max(50)
Exemplo: crie uma regra para receber um alerta quando um hash de ficheiro específico estiver presente
SPL:
| eval file_hashes="hash12345,hash67890,hashABCDE"
| makemv delim="," file_hashes
| mvexpand file_hashes
| search file_hashes="hash67890"
| table _time, file_hashes
YARA-L (regra):
rule specific_file_hash_detected {
meta:
rule_name = "Specific File Hash Detected"
description = "Detects events where a specific file hash is present."
severity = "Medium"
events:
$e.target.file.sha256 == "hash67890"
outcome:
$time = array_distinct($e.metadata.event_timestamp)
$file_hashes = array_distinct($e.target.file.sha256)
condition:
$e
}
Visualização baseada no tempo
Na YARA-L, a janela temporal é um método para correlacionar eventos durante um período específico e contínuo. Quando usada em regras, esta janela move-se continuamente com os dados recebidos, o que permite a deteção contínua em tempo real de padrões que se desenvolvem ao longo do tempo.
Este processo é uma parte fundamental da conceção para a deteção automática e é uma das vantagens da utilização do YARA-L. Ao especificar o período, as deteções e os painéis de controlo funcionam continuamente com dados em tempo real.
| Funcionalidade | SPL | YARA-L |
|---|---|---|
| Objetivo principal | Pesquisa estática, análise ad hoc | Deteção contínua, correlação automática |
| Funções principais |
earliest, latest, span, transaction
|
over, by |
| Exemplo de 5 minutos | earliest=-5m (pesquisa estática)ou
transaction maxspan=5m
|
match:[event] over 5m (deteção contínua nas regras)ou
[event] by 5m (pesquisa e painéis de controlo)
|
Os exemplos nesta secção ilustram a diferença entre uma janela de tempo de rolagem (com by) e uma janela de tempo deslizante (com over) em YARA-L.
Período de tempo de acumulação (by <time_unit>)
Conceito: usado na pesquisa YARA-L, as janelas deslizantes criam intervalos de tempo fixos de tamanho fixo que não se sobrepõem. O sistema processa cada evento atribuindo-o exatamente a um intervalo de tempo específico com base na respetiva data/hora. Estes intervalos fixos são absolutos e estão estritamente alinhados com os marcadores de tempo padrão, como dias, horas ou minutos.
Utilização: usado frequentemente em consultas de pesquisa e painéis de controlo do Google SecOps para agregar dados em segmentos de tempo discretos.
Exemplo: contagem diária de inícios de sessão bem-sucedidos por utilizador
Esta consulta de pesquisa agrupa os eventos de início de sessão bem-sucedidos por cada utilizador único em cada dia do calendário. O exemplo seguinte demonstra uma janela deslizante de pesquisa YARA-L (by day):
events:
//Filter for successful login events
metadata.event_type = "USER_LOGIN"
principal.user.userid != ""
match:
//Group by each unique user ID, aggregated over a calendar day.
principal.user.userid by day
outcome:
//Count how many successful logins occurred for this user on this specific day.
$daily_success_count = count(metadata.id)
//Get the timestamp of the FIRST event within this daily group.
$first_event_time = window.first(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds))
//Get the timestamp of the LAST event within this daily group.
$last_event_time = window.last(metadata.event_timestamp.seconds, timestamp.get_timestamp(metadata.event_timestamp.seconds))
Como funciona: se o utilizador jdoe tiver 10 inícios de sessão bem-sucedidos em Nov 17 e 15 em Nov 18, esta consulta produz duas linhas separadas para jdoe, uma para cada dia, com as respetivas contagens. O grupo Nov 17 inclui eventos de 2025-11-17 00:00:00 to 23:59:59 UTC.
Intervalo de tempo deslizante (over <duration>)
Conceito: usadas em regras YARA-L, as janelas deslizantes são janelas de tempo móveis e potencialmente sobrepostas de uma duração especificada. São ideais para correlacionar eventos que ocorrem a uma determinada proximidade uns dos outros.
Utilização: usado principalmente em regras YARA-L para detetar padrões ou sequências de eventos num período contínuo.
Exemplo: detetar vários inícios de sessão falhados no prazo de 5 minutos
Este exemplo de regra YARA-L gera uma deteção se um único utilizador tiver mais de 5 failed logins tentativas num período de 5-minute contínuo:
rule TooManyFailedLogins_SlidingWindow {
meta:
author = "Alex"
description = "Detects when a user has more than 5 failed logins within a 5-minute sliding window."
severity = "Medium"
events:
// Define an event variable $e for failed login attempts
$e.metadata.event_type = "USER_LOGIN"
$e.security_result.action = "FAIL"
$e.principal.user.userid != ""
$userid = $e.principal.user.userid
match:
// Group events by userid over a continuous 5-minute sliding window.
// Any events for the same $userid within 5 minutes of each other are grouped.
$userid over 5m
outcome:
// Count the number of failed login events within each 5-minute window for the grouped userid.
$failed_count = count($e.metadata.id)
condition:
// Trigger a detection if the count of failed logins in ANY 5-minute window is greater than 5.
#e > 5
}
Como funciona: o sistema monitoriza continuamente as tentativas de início de sessão falhadas. Em qualquer momento, considera os últimos 5 minutos de eventos para cada utilizador. Por exemplo, se, entre 10:02:30 e 10:07:30, o utilizador jdoe acumular seis tentativas de início de sessão falhadas, é acionada uma deteção. Esta janela desliza constantemente para a frente, permitindo a deteção de padrões em tempo real, independentemente dos limites do calendário.
O que se segue?
- Explore mais sobre a vista geral do YARA-L 2.0
- Explore a sintaxe da linguagem YARA-L 2.0 completa
- Saiba como escrever regras do motor de deteção
- Novidades nos blogs do Google SecOps
Precisa de mais ajuda? Receba respostas de membros da comunidade e profissionais da Google SecOps.