Neste tutorial, vamos construir um sistema simplificado de análise de logs SIEM com um toque 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, detecção de anomalias com um modelo leve de aprendizado de máquina e até mesmo 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 forma 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 de segurança e eventos 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 rapidamente.

Esses sistemas reúnem grandes volumes de dados de log — de alertas de firewall a 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 pelas regras estáticas. Por exemplo, um pico repentino de solicitações de rede pode indicar um ataque DDoS, enquanto múltiplas tentativas de login falhadas podem apontar para tentativas de acesso não autorizadas.

A IA leva as capacidades de SIEM um passo adiante. Ao aproveitar modelos avançados de IA (como grandes modelos de linguagem), um SIEM alimentado por IA pode interpretar e analisar logs de forma inteligente, 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é resumindo descobertas em linguagem simples. Avanços recentes em grandes modelos de linguagem permitem que os SIEMs raciocinem sobre incontáveis pontos de dados, muito como um analista humano faria — mas com muito mais velocidade 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 mergulharmos, 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 (laços, 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 requerem hardware especial:

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

    • 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, simularemos um pequeno conjunto de dados de log para que você possa acompanhar mesmo sem um arquivo de log pronto.

Observação: Se você não tiver 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 acesse-o. 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.

Certifique-se de que seu diretório de trabalho contenha ou possa 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 geraremos dados de log sintéticos, não precisaremos de um arquivo externo — mas em um cenário real, você precisaria.

Passos de configuração do projeto:

  1. Inicialize o ambiente – Se preferir, crie um ambiente virtual para este projeto (opcional, mas 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 log 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, são separados por vírgula, linhas JSON ou texto simples?). Para ilustração, vamos fabricar algumas entradas de log.

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

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

Implementando a Análise de Logs

Em um sistema SIEM completo, a análise de logs envolve coletar logs de várias fontes e analisá-los em um formato uniforme para processamento posterior. Os logs costumam conter campos como timestamp, nível de severidade, fonte, 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). Nesses 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

Isso tem um timestamp, um nível de log, uma mensagem e um usuário. Podemos analisar tais 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 uma análise mais fácil
df_logs = pd.DataFrame(parsed_logs)
print(df_logs.head())

Executando o acima em nossa lista de amostras, teríamos algo como: 

            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 de 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 brutos (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:

  • Contagens 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 de transferência de arquivo, tempo de execução de consulta), esses valores numéricos podem ser usados diretamente.

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

Para este prova de conceito, vamos focar 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 uma matriz de números onde cada número representa “quantas tentativas de login ocorreram em um determinado minuto”. Na maioria das vezes, esse número será baixo (comportamento normal), mas se um minuto específico teve um número excepcionalmente alto de tentativas, isso é uma anomalia (possivelmente um ataque de força bruta).

Para simular, vamos gerar uma lista de 50 valores representando o comportamento normal, e depois 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 reprodutível
normal_counts = np.random.poisson(lam=5, size=50)

# Simular anomalia: um pico nas tentativas de login (por exemplo, um invasor 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)

Ao executar o acima, login_attempts pode parecer com:

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

A maioria dos valores está na casa das unidades, mas no final temos três minutos com 30, 40 e 50 tentativas – claros valores discrepantes. Estes são nossos dados preparados para detecção de anomalias. Em uma análise de log real, este tipo de dados 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 avançar 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, usaremos uma abordagem de aprendizado de máquina. Especificamente, utilizaremos uma Floresta de Isolamento – um algoritmo popular para detecção de anomalias não supervisionada.

A Floresta de Isolamento funciona particionando aleatoriamente os dados e isolando pontos. As anomalias são aqueles pontos que são isolados (separados dos outros) rapidamente, ou seja, em menos divisões aleatórias. Isso a torna excelente para identificar outliers em um conjunto de dados sem precisar de rótulos (não precisamos saber de antemão 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 dá uma maneira simples de pontuar anomalias.

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

from sklearn.ensemble import IsolationForest

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

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

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

Algumas observações sobre o código:

  • Redimensionamos login_attempts para um array 2D X com uma coluna de características porque o scikit-learn exige um array 2D para treinamento (fit).

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

  • random_state=42 apenas garante 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 difíceis de isolar (ou seja, no aglomerado denso de pontos normais) acabam em partes profundas dessas árvores, enquanto pontos fáceis de isolar (os valores atípicos) acabam com caminhos mais curtos.

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

Testando e Visualizando Resultados

Agora vem a parte emocionante: 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 sinalizados como valores atípicos.

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

# Extrair os índices e valores de anomalia
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 assim:

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 destoantes do 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 fizer algo desviar muito dos padrões normais (como um usuário de repente fazer 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 linhas mostraria uma linha geralmente plana em torno de 3-8 logins/min com três grandes 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 saídas baseadas 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 as anomalias por gravidade.

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, Automação e Resposta de Segurança) pode reduzir drasticamente o tempo de reação a incidentes.

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

  • Alerta: A ação mais simples é enviar um alerta para o pessoal de segurança. Isso poderia ser um e-mail, uma mensagem no Slack ou a criação de um tíquete em um sistema de gerenciamento de incidentes. O alerta conteria detalhes da anomalia (por exemplo, “O usuário alice teve 50 tentativas de login falhadas em 1 minuto, o que é anormal”). A 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 apresentando comportamento malicioso nos logs, 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 poderia ser um ataque de bot. Os SIEMs baseados em IA de 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 AI SIEM: Como o SIEM com IA/ML está Revolucionando o SOC | Exabeam para mais informações).

  • Suporte à investigação: A IA generativa também pode 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 exageradamente 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.

Na 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 é 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 escalá-la. O SIEM poderia, por exemplo, alimentar anomalias em um modelo generativo maior que avalia a situação e decide a melhor ação a ser tomada (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, analisa-os 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 dados de log, em seguida, utilizamos um modelo de Isolation Forest para detectar outliers em uma sequência de contagens de tentativas de login. O modelo identificou com sucesso comportamentos fora do padrão sem qualquer conhecimento prévio sobre como é um “ataque” – ele se baseou puramente em desvios dos padrões normais aprendidos.

Também discutimos como esse sistema poderia responder a anomalias detectadas, desde alertar humanos até agir automaticamente.

Sistemas SIEM modernos, aprimorados com IA/ML, estão seguindo nessa direção: não apenas detectam problemas, mas também ajudam a triar e 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 esta abordagem em dados de log reais. 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 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 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 as funcionalidades: em um SIEM real, você usaria muitos sinais ao mesmo tempo (contagens de login falhadas, geolocalização de IP incomum, nomes de processos raros em logs, e assim por diante). Mais recursos e dados podem melhorar o contexto para detecção.