Introdução
Como administrador de sistemas ou analista de segurança, você frequentemente encontrará arquivos de log massivos gerados por servidores web como Apache ou Nginx. Ler manualmente milhares de linhas de logs para encontrar atividades maliciosas é insustentável e propenso a erros humanos.
Neste laboratório, você assumirá o papel de um profissional de resposta a incidentes. Você escreverá um script em Python projetado para processar logs de acesso de servidores web Apache. Ao utilizar a biblioteca de Expressões Regulares (re) do Python, você extrairá automaticamente endereços IP e detectará assinaturas conhecidas de ataques de injeção de SQL (SQLi). Por fim, você exportará essas descobertas para um relatório CSV estruturado para análise posterior.
Este módulo é onde o Python começa a se tornar um multiplicador de capacidade para o analista, em vez de apenas uma linguagem de programação. Os logs são um dos exemplos mais claros de um trabalho que é repetitivo demais para uma revisão manual cuidadosa, mas estruturado o suficiente para que a automação ofereça ajuda imediata.
Ler Arquivos de Log em Python
Nesta etapa, você aprenderá como usar o Python para abrir e ler um arquivo de log. O ambiente já foi preparado com um arquivo de log de exemplo do Apache chamado access.log em seu diretório de trabalho.
Ler arquivos linha por linha é um padrão fundamental de automação. Ele escala melhor do que copiar dados manualmente e prepara você para adicionar lógica de filtragem, análise, contagem e geração de relatórios sem alterar a abordagem básica de ingestão.
Primeiro, vamos visualizar o conteúdo do arquivo de log de exemplo para entender com o que estamos trabalhando. Use o comando cat no seu terminal para imprimir o conteúdo do arquivo.
cat access.log
Você verá várias linhas de logs de acesso padrão do Apache. Algumas dessas linhas contêm solicitações web normais, enquanto outras contêm tentativas suspeitas de injeção de SQL.
Agora, vamos criar um script Python para ler este arquivo programaticamente. Usaremos o editor de texto nano para criar um arquivo chamado log_analyzer.py.
nano log_analyzer.py
Em Python, a função open() é usada para abrir um arquivo, e a instrução with garante que o arquivo seja fechado corretamente após terminarmos a leitura. Copie e cole o seguinte código Python no seu editor nano:
def analyze_logs(file_path):
print(f"Opening log file: {file_path}")
## Open the file in read mode ('r')
with open(file_path, 'r') as file:
## Read the file line by line
for line in file:
## Print each line, stripping the extra newline character
print(line.strip())
if __name__ == "__main__":
log_file = "access.log"
analyze_logs(log_file)
Salve o arquivo no nano pressionando Ctrl+O, depois Enter para confirmar o nome do arquivo. Se você quiser continuar construindo o script antes de testá-lo, pode permanecer no nano e seguir para a próxima etapa. Use Ctrl+X apenas quando estiver pronto para retornar ao terminal.
Execute seu script Python recém-criado usando o comando python3:
python3 log_analyzer.py
Você verá o script exibindo exatamente as mesmas linhas de log que viu anteriormente com o comando cat. Isso confirma que seu script Python pode processar com sucesso os dados de log linha por linha.
Aplicar Regex para Extração de IP
Nesta etapa, você aprimorará seu script Python para extrair automaticamente o endereço IP de cada linha de log. Para fazer isso, usaremos Expressões Regulares (Regex). Regex é uma ferramenta poderosa para encontrar padrões em textos.
As expressões regulares são úteis porque os logs são semiestruturados: eles seguem padrões, mas geralmente não na forma de objetos Python limpos. O Regex oferece uma maneira de descrever o padrão de texto que você deseja e deixar que o interpretador faça o trabalho repetitivo de correspondência.
O Python fornece um módulo integrado chamado re para trabalhar com expressões regulares. Precisamos importar este módulo e definir um padrão que corresponda a um endereço IPv4. Um endereço IPv4 consiste em quatro números (variando de 0 a 255) separados por pontos.
Se o log_analyzer.py ainda estiver aberto no nano, continue editando-o lá. Caso contrário, reabra-o com:
nano log_analyzer.py
Atualize seu script para incluir o módulo re e a lógica para buscar endereços IP. Substitua todo o conteúdo do arquivo pelo seguinte código:
import re
def analyze_logs(file_path):
print(f"Analyzing log file: {file_path}\n")
## Define a Regex pattern for an IPv4 address
## \b ensures word boundaries, \d{1,3} matches 1 to 3 digits, \. matches a literal dot
ip_pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
with open(file_path, 'r') as file:
for line in file:
## re.findall returns a list of all matches in the string
ips_found = re.findall(ip_pattern, line)
if ips_found:
## We take the first IP found in the line
source_ip = ips_found[0]
print(f"Extracted IP: {source_ip}")
if __name__ == "__main__":
log_file = "access.log"
analyze_logs(log_file)
Salve o arquivo com Ctrl+O e Enter. Se quiser testar esta versão intermediária agora, saia com Ctrl+X e execute o script. Caso contrário, você pode continuar diretamente para a próxima etapa.
python3 log_analyzer.py
Você deverá ver uma saída semelhante a esta:
Analyzing log file: access.log
Extracted IP: 192.168.1.10
Extracted IP: 10.0.0.15
Extracted IP: 172.16.0.5
Extracted IP: 192.168.1.22
Extracted IP: 10.0.0.25
O script agora está ignorando com sucesso o restante do texto do log e isolando apenas os endereços IP de origem usando o poder do Regex.
Detectar Assinaturas de SQLi
Nesta etapa, você adicionará um recurso de detecção de segurança ao seu script. A Injeção de SQL (SQLi) é um ataque web comum onde instruções SQL maliciosas são inseridas em campos de entrada.
Isso transforma o script de um analisador em um detector. Em vez de apenas extrair campos, você agora está aplicando lógica de segurança para decidir quais linhas merecem atenção. Essa mudança da coleta para a interpretação é o que torna a automação operacionalmente valiosa.
Os atacantes frequentemente usam palavras-chave específicas como UNION SELECT para roubar dados, ou ' OR '1'='1 para contornar a autenticação. Podemos usar Regex para escanear as linhas de log em busca dessas assinaturas de ataque conhecidas.
Se você ainda estiver editando o mesmo arquivo no nano, continue trabalhando nele. Caso contrário, reabra-o:
nano log_analyzer.py
Definiremos um novo padrão Regex para capturar frases comuns de SQLi. Usaremos (?i) para tornar a busca insensível a maiúsculas/minúsculas, o que significa que ele capturará UNION, union ou uNiOn. Atualize seu script para corresponder ao seguinte código:
import re
def analyze_logs(file_path):
print(f"Scanning log file for SQLi attacks: {file_path}\n")
ip_pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
## Define a Regex pattern for SQL Injection signatures
## (?i) makes it case-insensitive
## It looks for 'union select' OR 'or 1=1' variations
sqli_pattern = r"(?i)(union.*select|or\s+1\s*=\s*1|'.*or.*')"
with open(file_path, 'r') as file:
for line in file:
ips_found = re.findall(ip_pattern, line)
source_ip = ips_found[0] if ips_found else "Unknown IP"
## re.search returns a match object if the pattern is found, otherwise None
if re.search(sqli_pattern, line):
print(f"[ALERT] SQL Injection detected from IP: {source_ip}")
print(f"Raw Log: {line.strip()}\n")
if __name__ == "__main__":
log_file = "access.log"
analyze_logs(log_file)
Salve o arquivo com Ctrl+O e Enter. Saia do nano com Ctrl+X apenas quando estiver pronto para executar o script a partir do terminal.
python3 log_analyzer.py
Sua saída agora deve sinalizar especificamente as solicitações maliciosas:
Scanning log file for SQLi attacks: access.log
[ALERT] SQL Injection detected from IP: 10.0.0.15
Raw Log: 10.0.0.15 - - [10/Oct/2026:13:55:45 -0700] "GET /login.php?user=admin' OR '1'='1 HTTP/1.1" 200 5120
[ALERT] SQL Injection detected from IP: 192.168.1.22
Raw Log: 192.168.1.22 - - [10/Oct/2026:13:56:12 -0700] "GET /products.php?id=1 UNION SELECT username, password FROM users HTTP/1.1" 200 4012
Seu script agora está atuando como um Sistema de Detecção de Intrusão (IDS) básico, identificando automaticamente as solicitações suspeitas no arquivo de log.
Exportar para Relatório CSV
Nesta etapa final, você formatará os resultados e os salvará em um arquivo CSV (Comma-Separated Values). Imprimir no terminal é ótimo para testes, mas as equipes de segurança precisam de relatórios estruturados que possam ser abertos em softwares de planilha ou ingeridos por outras ferramentas.
O Python possui um módulo csv integrado que torna a escrita de arquivos CSV muito fácil.
Se você manteve o arquivo aberto, continue editando-o. Caso contrário, reabra-o:
nano log_analyzer.py
Importaremos o módulo csv, abriremos um novo arquivo chamado report.csv no modo de escrita ('w') e escreveremos nossas descobertas nele. Substitua seu código por esta versão final:
import re
import csv
def analyze_logs(file_path, output_csv):
print(f"Analyzing logs and generating report: {output_csv}...")
ip_pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
sqli_pattern = r"(?i)(union.*select|or\s+1\s*=\s*1|'.*or.*')"
## Open the output CSV file in write mode
with open(output_csv, 'w', newline='') as csv_file:
writer = csv.writer(csv_file)
## Write the header row
writer.writerow(['Source IP', 'SQLi Detected', 'Raw Log'])
with open(file_path, 'r') as file:
for line in file:
clean_line = line.strip()
ips_found = re.findall(ip_pattern, clean_line)
source_ip = ips_found[0] if ips_found else "Unknown IP"
## Check if SQLi is detected
sqli_detected = "Yes" if re.search(sqli_pattern, clean_line) else "No"
## Write the data row to the CSV
writer.writerow([source_ip, sqli_detected, clean_line])
print("Report generation finished.")
if __name__ == "__main__":
log_file = "access.log"
report_file = "report.csv"
analyze_logs(log_file, report_file)
Salve o arquivo e execute o script:
python3 log_analyzer.py
Você verá uma mensagem indicando que a geração do relatório foi concluída. Agora, vamos verificar se o arquivo CSV foi criado e verificar seu conteúdo usando o comando cat:
cat report.csv
Você deverá ver uma saída CSV formatada corretamente:
Source IP,SQLi Detected,Raw Log
192.168.1.10,No,192.168.1.10 - - [10/Oct/2026:13:55:36 -0700] "GET /index.html HTTP/1.1" 200 2326
10.0.0.15,Yes,10.0.0.15 - - [10/Oct/2026:13:55:45 -0700] "GET /login.php?user=admin' OR '1'='1 HTTP/1.1" 200 5120
172.16.0.5,No,172.16.0.5 - - [10/Oct/2026:13:56:01 -0700] "POST /api/data HTTP/1.1" 404 134
192.168.1.22,Yes,192.168.1.22 - - [10/Oct/2026:13:56:12 -0700] "GET /products.php?id=1 UNION SELECT username, password FROM users HTTP/1.1" 200 4012
10.0.0.25,No,10.0.0.25 - - [10/Oct/2026:13:57:00 -0700] "GET /about.html HTTP/1.1" 200 1024
Resumo
Neste laboratório, você fez a transição bem-sucedida da leitura manual de logs para a análise automatizada de logs usando Python. Você aprendeu como ler e processar arquivos de texto linha por linha usando o tratamento de arquivos integrado do Python. Você também utilizou o módulo re para aplicar Expressões Regulares para extrair formatos de dados específicos, como endereços IP. Além disso, você implementou uma lógica de detecção de segurança comparando assinaturas conhecidas de ataques de injeção de SQL com dados de log brutos. Por fim, você praticou a exportação de dados estruturados para um relatório CSV usando o módulo csv, tornando os resultados fáceis de compartilhar e analisar posteriormente.
Essas habilidades formam a base da automação de segurança e da análise de dados, permitindo que você manipule grandes conjuntos de dados com eficiência.
