Ferramenta de Varredura Automatizada

Varredura Automatizada em Python

Script desenvolvido em Python para automatizar a identificação de vulnerabilidades comuns em aplicações web, economizando tempo em testes de segurança.

recursos

$ Detecção de SQL Injection

$ Identificação de XSS

$ Verificação de Headers

$ Análise de CSRF

vantagens

$ Automatização de testes

$ Relatórios detalhados

$ Fácil integração

$ Código aberto

Principais Funcionalidades

SQL Injection

Detecta vulnerabilidades de injeção SQL através de testes automatizados em formulários e URLs.

SQLi Boolean-Based Time-Based

XSS Detection

Identifica vulnerabilidades Cross-Site Scripting (XSS) em campos de entrada e parâmetros.

Reflected Stored DOM

Security Headers

Verifica a presença e configuração de headers de segurança como CSP, HSTS e X-Frame-Options.

CSP HSTS CORS

CSRF Check

Analisa a presença de tokens CSRF em formulários e a configuração de cookies SameSite.

Tokens SameSite Referer

Info Disclosure

Identifica vazamento de informações através de mensagens de erro e headers do servidor.

Banner Errors Debug

Report Generation

Gera relatórios detalhados em HTML com vulnerabilidades encontradas e recomendações.

HTML PDF JSON

Implementação em Python

Estrutura Principal do Scanner

import requests
from bs4 import BeautifulSoup
import argparse
import re

class WebVulnerabilityScanner:
    def __init__(self, target_url):
        self.target_url = target_url
        self.session = requests.Session()
        self.vulnerabilities = []
        
    def scan_sql_injection(self):
        # Testar parâmetros GET para SQLi
        test_payloads = ["' OR '1'='1", "1' ORDER BY 1--"]
        for payload in test_payloads:
            test_url = f"{self.target_url}?id={payload}"
            response = self.session.get(test_url)
            if "error in your SQL syntax" in response.text:
                self.vulnerabilities.append({
                    'type': 'SQL Injection',
                    'url': test_url,
                    'payload': payload
                })
    
    def scan_xss(self):
        # Testar campos de formulário para XSS
        response = self.session.get(self.target_url)
        soup = BeautifulSoup(response.text, 'html.parser')
        forms = soup.find_all('form')
        
        for form in forms:
            xss_payload = "<script>alert('XSS')</script>"
            form_data = {}
            for input_tag in form.find_all('input'):
                if input_tag.get('type') in ['text', 'search', 'email']:
                    form_data[input_tag.get('name')] = xss_payload
            
            response = self.session.post(form.get('action'), data=form_data)
            if xss_payload in response.text:
                self.vulnerabilities.append({
                    'type': 'XSS',
                    'form': form.get('action'),
                    'payload': xss_payload
                })
    
    def check_security_headers(self):
        # Verificar headers de segurança
        response = self.session.get(self.target_url)
        headers = response.headers
        
        required_headers = ['Content-Security-Policy', 'X-Frame-Options', 
                          'X-Content-Type-Options', 'Strict-Transport-Security']
        
        for header in required_headers:
            if header not in headers:
                self.vulnerabilities.append({
                    'type': 'Missing Security Header',
                    'header': header
                })
    
    def generate_report(self, output_file):
        # Gerar relatório HTML com os resultados
        with open(output_file, 'w') as f:
            f.write("<h1>Relatório de Vulnerabilidades</h1>")
            for vuln in self.vulnerabilities:
                f.write(f"<div><h3>{vuln['type']}</h3><p>{vuln}</p></div>")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Web Vulnerability Scanner')
    parser.add_argument('--target', required=True, help='Target URL to scan')
    args = parser.parse_args()
    
    scanner = WebVulnerabilityScanner(args.target)
    scanner.scan_sql_injection()
    scanner.scan_xss()
    scanner.check_security_headers()
    scanner.generate_report('report.html')

Python 3 Requests BeautifulSoup

Como Utilizar

Instalação

Instale as dependências necessárias utilizando pip

pip install requests beautifulsoup4

Execução

Execute o scanner informando a URL alvo

python scanner.py --target https://example.com

Opções Avançadas

Personalize a varredura com parâmetros adicionais

python scanner.py --target https://example.com --output report.pdf --depth 2

Análise de Resultados

Revise o relatório gerado com as vulnerabilidades encontradas

cat report.html
# Ou abra no navegador

Funcionalidades Avançadas

Automação Completa

O script automatiza todo o processo de identificação de vulnerabilidades, desde a descoberta de formulários até a injeção de payloads de teste.

automation.py

# Descobrir todos os formulários na página
forms = discover_forms(target_url)

# Testar cada campo com payloads específicos
for form in forms:
test_form_for_vulnerabilities(form)

Relatórios Personalizáveis

Gera relatórios em múltiplos formatos (HTML, PDF, JSON) com diferentes níveis de detalhamento para atender a diversos públicos.

report.py

# Gerar relatório executivo (resumido)
generate_report(vulns, 'executive', 'pdf')

# Gerar relatório técnico (detalhado)
generate_report(vulns, 'technical', 'html')

Integração com APIs

Possibilidade de integração com ferramentas de segurança como OWASP ZAP e Burp Suite através de APIs.

integration.py

# Enviar resultados para o JIRA
jira.create_issue(vulnerability)

# Integrar com Slack para alertas
slack.send_alert(critical_vulns)

Configuração Flexível

Permite configuração detalhada através de arquivos YAML/JSON para adaptar a varredura a diferentes ambientes.

config.yaml

scan_options:
depth: 2
timeout: 10
exclude_urls: [/admin, /config]
payloads:
sql: [payloads/sqli.txt]
xss: [payloads/xss.txt]

Comparação com Ferramentas Existentes

Recurso	Nosso Scanner	OWASP ZAP	Burp Suite	Nikto
Automação Completa
Customização de Payloads
Integração com APIs
Fácil Personalização
Baixo Consumo de Recursos
Código Aberto