Neste tutorial, vamos construir um sistema simplificado de análise de logs de SIEM com sabor de IA usando Python. Nosso foco será na análise de logs e detecção de anomalias.

Vamos passar pelo processo de ingestão de logs, detectar anomalias com um modelo leve de machine learning e até abordar como o sistema poderia responder automaticamente.

Esta prova de conceito prática ilustrará como a IA pode aprimorar a monitorização de segurança de maneira prática e acessível.

Índice

O que são Sistemas SIEM?

Sistemas de Gerenciamento de Informações e Eventos de Segurança (SIEM) são o sistema nervoso central das operações de segurança modernas. Um SIEM agrega e correlaciona logs e eventos de segurança de todo o ambiente de TI para fornecer insights em tempo real sobre incidentes potenciais. Isso ajuda as organizações a detectar ameaças mais rapidamente e a responder mais cedo.

Esses sistemas reúnem grandes volumes de dados de log – desde alertas de firewall até logs de aplicativos – e os analisam em busca de sinais de problemas. A detecção de anomalias nesse contexto é crucial, e padrões incomuns nos logs podem revelar incidentes que poderiam passar despercebidos por regras estáticas. Por exemplo, um pico repentino em solicitações de rede pode indicar um ataque de DDoS, enquanto várias tentativas de login malsucedidas podem apontar para tentativas de acesso não autorizado.

A IA leva as capacidades de SIEM a um novo patamar. Ao aproveitar modelos de IA avançados (como modelos de linguagem grandes), um SIEM alimentado por IA pode inteligentemente analisar e interpretar logs, aprender como é o comportamento “normal” e sinalizar as coisas “estranhas” que merecem atenção.

Em essência, a IA pode atuar como um co-piloto inteligente para analistas, identificando anomalias sutis e até mesmo resumindo descobertas em linguagem simples. Avanços recentes em modelos de linguagem grandes permitem que os SIEMs raciocinem sobre incontáveis pontos de dados, assim como um analista humano faria — mas com muito mais rapidez e escala. O resultado é um assistente de segurança digital poderoso que ajuda a filtrar o ruído e focar em ameaças reais.

Pré-requisitos

Antes de começarmos, certifique-se de que você possui o seguinte:

  • Python 3.x instalado em seu sistema. Os exemplos de código devem funcionar em qualquer versão recente do Python.

  • Familiaridade básica com programação em Python (loops, funções, uso de bibliotecas) e uma compreensão de logs (por exemplo, como é uma entrada de log) será útil.

  • Bibliotecas Python: Usaremos algumas bibliotecas comuns que são leves e não exigem hardware especial:

    • pandas para manipulação básica de dados (se seus logs estiverem em formato CSV ou similar).

    • numpy para operações numéricas.

    • scikit-learn para o modelo de detecção de anomalias (especificamente, usaremos o algoritmo IsolationForest).

  • Um conjunto de dados de log para analisar. Você pode usar qualquer arquivo de log (logs do sistema, logs de aplicativos, etc.) em formato de texto simples ou CSV. Para fins de demonstração, vamos simular um pequeno conjunto de dados de log para que você possa acompanhar mesmo sem um arquivo de log pronto.

Nota: Se você não possui as bibliotecas acima, instale-as via pip:

pip install pandas numpy scikit-learn

Configurando o Projeto

Vamos configurar uma estrutura de projeto simples. Crie um novo diretório para este projeto de detecção de anomalias SIEM e navegue até ele. Dentro, você pode ter um script Python (por exemplo, siem_anomaly_demo.py) ou um Jupyter Notebook para executar o código passo a passo.

Verifique se seu diretório de trabalho contém ou pode acessar seus dados de log. Se estiver usando um arquivo de log, pode ser uma boa ideia colocar uma cópia nesta pasta do projeto. Para nossa prova de conceito, como iremos gerar dados de log sintéticos, não precisaremos de um arquivo externo — mas em um cenário real você precisaria.

Etapas de configuração do projeto:

  1. Inicialize o ambiente – Se preferir, crie um ambiente virtual para este projeto (opcional, mas uma boa prática):

    python -m venv venv
 source venv/bin/activate  # No Windows, use "venv\Scripts\activate"

    Em seguida, instale os pacotes necessários neste ambiente virtual.

  2. Prepare uma fonte de dados – Identifique a fonte de logs que deseja analisar. Isso pode ser um caminho para um arquivo de log ou banco de dados. Certifique-se de conhecer o formato dos logs (por exemplo, eles são separados por vírgulas, linhas JSON ou texto simples?). Para ilustração, fabricaremos algumas entradas de log.

  3. Configure seu script ou notebook – Abra seu arquivo Python ou notebook. Vamos começar importando as bibliotecas necessárias e configurando quaisquer configurações (como sementes aleatórias para reprodutibilidade).

Ao final desta configuração, você deverá ter um ambiente Python pronto para executar nosso código de análise de logs SIEM, e ter um conjunto de dados de log real ou a intenção de simular dados junto comigo.

Implementando Análise de Logs

Em um sistema SIEM completo, a análise de logs envolve a coleta de logs de várias fontes e a análise deles em um formato uniforme para processamento adicional. Os logs frequentemente contêm campos como timestamp, nível de severidade, origem, mensagem de evento, ID do usuário, endereço IP, e assim por diante. A primeira tarefa é ingerir e pré-processar esses logs.

1. Ingestão de Logs

Se seus logs estiverem em um arquivo de texto, você pode lê-los em Python. Por exemplo, se cada entrada de log for uma linha no arquivo, você poderia fazer:

with open("my_logs.txt") as f:
    raw_logs = f.readlines()

Se os logs forem estruturados (por exemplo, formato CSV com colunas), o Pandas pode simplificar muito a leitura:

import pandas as pd
df = pd.read_csv("my_logs.csv")
print(df.head())

Isso lhe dará um DataFrame df com suas entradas de log organizadas em colunas. Mas muitos logs são semi-estruturados (por exemplo, componentes separados por espaços ou caracteres especiais). Nestes casos, você pode precisar dividir cada linha por um delimitador ou usar regex para extrair campos. Por exemplo, imagine uma linha de log:

2025-03-06 08:00:00, INFO, User login success, user: admin

Esta linha possui um timestamp, um nível de log, uma mensagem e um usuário. Podemos analisar essas linhas com os métodos de string do Python:

logs = [
    "2025-03-06 08:00:00, INFO, User login success, user: admin",
    "2025-03-06 08:01:23, INFO, User login success, user: alice",
    "2025-03-06 08:02:45, ERROR, Failed login attempt, user: alice",
    # ... (mais linhas de log)
]
parsed_logs = []
for line in logs:
    parts = [p.strip() for p in line.split(",")]
    timestamp = parts[0]
    level = parts[1]
    message = parts[2]
    user = parts[3].split(":")[1].strip() if "user:" in parts[3] else None
    parsed_logs.append({"timestamp": timestamp, "level": level, "message": message, "user": user})

# Converter para DataFrame para análise mais fácil
df_logs = pd.DataFrame(parsed_logs)
print(df_logs.head())

Executando o acima na nossa lista de exemplo resultaria em algo assim:

            timestamp  level                 message   user
0  2025-03-06 08:00:00   INFO    User login success   admin
1  2025-03-06 08:01:23   INFO    User login success   alice
2  2025-03-06 08:02:45  ERROR  Failed login attempt   alice
...

Agora que estruturamos os logs em uma tabela. Em um cenário real, você continuaria analisando todos os campos relevantes dos seus logs (por exemplo, endereços IP, códigos de erro, e assim por diante) dependendo do que deseja analisar.

2. Pré-processamento e Extração de Características

Com os logs em um formato estruturado, o próximo passo é derivar características para detecção de anomalias. Mensagens de log brutas (strings) por si só são difíceis para um algoritmo aprender diretamente. Frequentemente extraímos características numéricas ou categorias que podem ser quantificadas. Alguns exemplos de características poderiam ser:

  • Contagem de eventos: número de eventos por minuto/hora, número de falhas de login para cada usuário, e assim por diante.

  • Duração ou tamanho: se os logs incluem durações ou tamanhos de dados (por exemplo, tamanho da transferência de arquivo, tempo de execução da consulta), esses valores numéricos podem ser usados diretamente.

  • Codificação categórica: níveis de log (INFO, ERROR, DEBUG) podem ser mapeados para números, ou tipos de eventos específicos podem ser codificados one-hot.

Para esta prova de conceito, vamos nos concentrar em uma característica numérica simples: a contagem de tentativas de login por minuto para um determinado usuário. Vamos simular isso como nossos dados de características.

Em um sistema real, você calcularia isso agrupando as entradas de log analisadas por janela de tempo e usuário. O objetivo é obter um array de números onde cada número representa “quantas tentativas de login ocorreram em um determinado minuto.” A maior parte do tempo esse número será baixo (comportamento normal), mas se um minuto específico apresentar um número anormalmente alto de tentativas, isso é uma anomalia (possivelmente um ataque de força bruta).

Para simular, vamos gerar uma lista de 50 valores representando comportamento normal, e então adicionar alguns valores que são anormalmente altos:

import numpy as np

# Simular 50 minutos de contagens normais de tentativas de login (cerca de 5 por minuto em média)
np.random.seed(42)  # para exemplo reproduzível
normal_counts = np.random.poisson(lam=5, size=50)

# Simular anomalia: um pico nas tentativas de login (por exemplo, um atacante tenta 30+ vezes em um minuto)
anomalous_counts = np.array([30, 40, 50])

# Combinar os dados
login_attempts = np.concatenate([normal_counts, anomalous_counts])
print("Login attempts per minute:", login_attempts)

Quando você executar o acima, login_attempts pode parecer:

Login attempts per minute: [ 5  4  4  5  5  3  5  ...  4 30 40 50]

A maioria dos valores está em um dígito, mas no final temos três minutos com 30, 40 e 50 tentativas – claros outliers. Estes são nossos dados preparados para detecção de anomalias. Em uma análise de log real, esse tipo de dado pode vir da contagem de eventos em seus logs ao longo do tempo ou da extração de alguma métrica do conteúdo do log.

Agora que nossos dados estão prontos, podemos passar para a construção do modelo de detecção de anomalias.

Como Construir o Modelo de Detecção de Anomalias

Para detectar anomalias em nossos dados derivados de logs, vamos utilizar uma abordagem de aprendizado de máquina. Especificamente, vamos usar uma Floresta de Isolamento – um algoritmo popular para detecção de anomalias não supervisionada.

A Floresta de Isolamento funciona particionando os dados aleatoriamente e isolando pontos. Anomalias são aqueles pontos que são rapidamente isolados (separados dos outros), ou seja, em menos divisões aleatórias. Isso torna ótimo para identificar outliers em um conjunto de dados sem a necessidade de rótulos (não precisamos saber antecipadamente quais entradas de log são “ruins”).

Por que Floresta de Isolamento?

  • É eficiente e funciona bem mesmo se tivermos muitos dados.

  • Não assume nenhuma distribuição específica dos dados (ao contrário de alguns métodos estatísticos).

  • Nos fornece uma maneira direta de pontuar anomalias.

Vamos treinar uma Floresta de Isolamento em nossos dados de tentativas_de_login:

from sklearn.ensemble import IsolationForest

# Prepare os dados no formato que o modelo espera (amostras, características)
X = login_attempts.reshape(-1, 1)  # cada amostra é unidimensional [contagem]

# Inicialize o modelo Isolation Forest
model = IsolationForest(contamination=0.05, random_state=42)
# contamination=0.05 significa que esperamos cerca de 5% dos dados serem anomalias

# Treine o modelo com os dados
model.fit(X)

Algumas observações sobre o código:

  • Nós remodelamos tentativas_de_login para uma matriz 2D X com uma coluna de característica porque o scikit-learn requer uma matriz 2D para treinamento (fit).

  • Nós definimos contamination=0.05 para dar ao modelo uma dica de que aproximadamente 5% dos dados podem ser anomalias. Em nossos dados sintéticos, adicionamos 3 anomalias em 53 pontos, que é aproximadamente 5,7%, então 5% é uma suposição razoável. (Se você não especificar a contaminação, o algoritmo escolherá um valor padrão com base em uma suposição ou usará 0.1 em algumas versões.)

  • random_state=42 garante apenas a reprodutibilidade.

Neste ponto, o modelo Isolation Forest foi treinado com nossos dados. Internamente, ele construiu um conjunto de árvores aleatórias que particionam os dados. Pontos que são difíceis de isolar (ou seja, no denso agrupamento de pontos normais) acabam profundamente nessas árvores, enquanto pontos que são fáceis de isolar (os outliers) acabam com caminhos mais curtos.

Em seguida, usaremos esse modelo para identificar quais pontos de dados são considerados anômalos.

Testando e Visualizando Resultados

Agora vem a parte empolgante: usar nosso modelo treinado para detectar anomalias nos dados de log. Vamos fazer o modelo prever rótulos para cada ponto de dados e depois filtrar aqueles marcados como outliers.

# Use o modelo para prever anomalias
labels = model.predict(X)
# O modelo gera +1 para pontos normais e -1 para anomalias

# Extraia os índices e valores das anomalias
anomaly_indices = np.where(labels == -1)[0]
anomaly_values = login_attempts[anomaly_indices]

print("Anomaly indices:", anomaly_indices)
print("Anomaly values (login attempts):", anomaly_values)

No nosso caso, esperamos que as anomalias sejam os grandes números que inserimos (30, 40, 50). A saída pode parecer:

Anomaly indices: [50 51 52]
Anomaly values (login attempts): [30 40 50]

Mesmo sem saber nada sobre “tentativas de login” especificamente, o Isolation Forest reconheceu esses valores como fora da linha em relação ao restante dos dados.

Este é o poder da detecção de anomalias em um contexto de segurança: não sabemos sempre como será um novo ataque, mas se ele causar algo a desviar muito dos padrões normais (como um usuário de repente fazendo 10 vezes mais tentativas de login do que o habitual), o detector de anomalias ilumina isso.

Visualizando os resultados

Em uma análise real, muitas vezes é útil visualizar os dados e as anomalias. Por exemplo, poderíamos plotar os valores de login_attempts ao longo do tempo (minuto a minuto) e destacar as anomalias em uma cor diferente.

Neste caso simples, um gráfico de linha mostraria uma linha quase plana em torno de 3-8 logins/min com três enormes picos no final. Esses picos são nossas anomalias. Você poderia conseguir isso com Matplotlib se estiver executando isso em um notebook:

import matplotlib.pyplot as plt

plt.plot(login_attempts, label="Login attempts per minute")
plt.scatter(anomaly_indices, anomaly_values, color='red', label="Anomalies")
plt.xlabel("Time (minute index)")
plt.ylabel("Login attempts")
plt.legend()
plt.show()

Para a saída baseada em texto como temos aqui, os resultados impressos já confirmam que os valores altos foram capturados. Em casos mais complexos, os modelos de detecção de anomalias também fornecem uma pontuação de anomalia para cada ponto (por exemplo, quão longe está da faixa normal). O IsolationForest do Scikit-learn, por exemplo, tem um método decision_function que gera uma pontuação (onde pontuações mais baixas significam mais anormais).

Para simplicidade, não vamos nos aprofundar nas pontuações aqui, mas é bom saber que você pode recuperá-las para classificar anomalias por severidade.

Com a detecção de anomalias funcionando, o que podemos fazer quando encontramos uma anomalia? Isso nos leva a pensar sobre respostas automatizadas.

Possibilidades de Resposta Automatizada

Detectar uma anomalia é apenas metade da batalha — o próximo passo é responder a ela. Em sistemas SIEM corporativos, a resposta automatizada (frequentemente associada ao SOAR – Orquestração de Segurança, Automação e Resposta) pode reduzir drasticamente o tempo de reação a incidentes.

O que um SIEM alimentado por IA poderia fazer ao sinalizar algo incomum? Aqui estão algumas possibilidades:

  • Alertando: A ação mais simples é enviar um alerta para a equipe de segurança. Isso pode ser um e-mail, uma mensagem no Slack ou a criação de um ticket em um sistema de gerenciamento de incidentes. O alerta conteria detalhes da anomalia (por exemplo, “Usuário alice teve 50 tentativas de login falhadas em 1 minuto, o que é anômalo”). GenAI pode ajudar aqui gerando um resumo claro em linguagem natural do incidente para o analista.

  • Mitigação automatizada: Sistemas mais avançados podem tomar ações diretas. Por exemplo, se um endereço IP estiver demonstrando comportamento malicioso nos registros, o sistema poderia bloquear automaticamente esse IP no firewall. No nosso exemplo de pico de login, o sistema poderia temporariamente bloquear a conta do usuário ou solicitar autenticação adicional, sob a suposição de que possa ser um ataque de bot. Os SIEMs baseados em IA hoje podem de fato acionar ações de resposta predefinidas ou até mesmo orquestrar fluxos de trabalho complexos quando certas ameaças são detectadas (consulte SIEM de IA: Como o SIEM com IA/ML está Revolucionando o SOC | Exabeam para mais informações).

  • Suporte à investigação: A IA generativa também poderia ser usada para reunir automaticamente contexto. Por exemplo, ao detectar a anomalia, o sistema poderia buscar logs relacionados (eventos circundantes, outras ações pelo mesmo usuário ou do mesmo IP) e fornecer um relatório agregado. Isso poupa o analista de consultar manualmente várias fontes de dados.

É importante implementar respostas automatizadas com cuidado — você não quer que o sistema reaja de forma exagerada a falsos positivos. Uma estratégia comum é uma resposta em camadas: anomalias de baixa confiança podem apenas registrar um aviso ou enviar um alerta de baixa prioridade, enquanto anomalias de alta confiança (ou combinações de anomalias) acionam medidas de defesa ativas.

No prática, um SIEM alimentado por IA se integraria à sua infraestrutura (via APIs, scripts e assim por diante) para executar essas ações. Para nosso PoC em Python, você poderia simular uma resposta automatizada, por exemplo, imprimindo uma mensagem ou chamando uma função fictícia quando uma anomalia for detectada. Por exemplo:

if len(anomaly_indices) > 0:
    print(f"Alert! Detected {len(anomaly_indices)} anomalous events. Initiating response procedures...")
    # Aqui, você poderia adicionar código para desabilitar um usuário ou notificar um administrador, etc.

Embora nossa demonstração seja simples, é fácil imaginar uma escalabilidade. O SIEM poderia, por exemplo, alimentar anomalias em um modelo generativo maior que avalia a situação e decide o melhor curso de ação (como um assistente de operações de chatbot que conhece seus runbooks). As possibilidades de automação estão se expandindo à medida que a IA se torna mais sofisticada.

Conclusão

Neste tutorial, construímos um componente básico de SIEM alimentado por IA que ingere dados de log, os analisa em busca de anomalias usando um modelo de aprendizado de máquina e identifica eventos incomuns que podem representar ameaças à segurança.

Começamos analisando e preparando os dados de log, e depois usamos um modelo de Isolation Forest para detectar outliers em um fluxo de contagens de tentativas de login. O modelo conseguiu identificar comportamentos fora do normal sem qualquer conhecimento prévio de como seria um “ataque” — ele se baseou puramente em desvios de padrões normais aprendidos.

Também discutimos como um sistema desse tipo poderia responder a anomalias detectadas, desde alertar humanos até tomar ações automaticamente.

Os modernos sistemas SIEM, ampliados com IA/ML, estão se movendo nessa direção: não apenas detectam problemas, mas também ajudam a triá-los e a responder a eles. A IA generativa aprimora ainda mais isso ao aprender com analistas e fornecer resumos e decisões inteligentes, tornando-se efetivamente um assistente incansável no Centro de Operações de Segurança.

Para os próximos passos e melhorias:

  • Você pode tentar essa abordagem em dados reais de log. Por exemplo, pegue um arquivo de log do sistema e extraia uma característica como “número de logs de erro por hora” ou “bytes transferidos por sessão” e execute a detecção de anomalias nisso.

  • Experimente outros algoritmos como One-Class SVM ou Local Outlier Factor para detecção de anomalias e veja como eles se comparam.

  • Incorpore um modelo de linguagem simples para analisar linhas de log ou para explicar anomalias. Por exemplo, um LLM poderia ler uma entrada de log anômala e sugerir o que pode estar errado (“Esse erro geralmente significa que o banco de dados está inacessível”).

  • Amplie os recursos: em um SIEM real, você usaria muitos sinais ao mesmo tempo (contagens de login falhados, geolocalização de IP incomum, nomes de processos raros em logs, e assim por diante). Mais recursos e dados podem melhorar o contexto para a detecção.