Inteligência de Ameaças Avançada

Solução completa para monitoramento, análise e detecção de ameaças cibernéticas em tempo real

Atualização Automática

Cache inteligente renovado automaticamente a cada 12 horas com dados oficiais do Tor Project e feeds de inteligência de ameaças

Performance Otimizada

Sistema de cache distribuído e otimizado para respostas em milissegundos, com rate limiting inteligente por IP

Fontes Confiáveis

Dados obtidos diretamente da API oficial do Tor Project e honeypots proprietários para máxima precisão

Honeypot Avançado

Sistema de honeypot proprietário que captura URLs maliciosas em tempo real para análise de ameaças

Analytics Detalhado

Estatísticas completas por país, tipo de nó, status de atividade e análise temporal de ameaças

API RESTful

Interface completa para desenvolvedores com endpoints documentados, autenticação e múltiplos formatos de saída

API Endpoints

Interface RESTful completa para integração com sistemas de segurança e análise de ameaças

Endpoints Principais

GET

/tornodes-ip.txt

Lista completa de IPs dos nós Tor em formato texto

GET

/honeypot-urls.txt

URLs maliciosas capturadas pelo honeypot

GET

/status

Status do serviço e informações de cache

Dados Detalhados

GET

/api/nodes

Todos os nós Tor com informações completas

GET

/api/nodes/running

Apenas nós ativos e funcionais

GET

/api/stats

Estatísticas detalhadas e métricas

Feeds e Formatos

GET

/api/feed/rss

Feed RSS para monitoramento automático

# Buscar lista de IPs dos nós Tor
curl -H "Accept: text/plain" \
     https://tor.protexion.cloud/tornodes-ip.txt

# Buscar nós ativos com informações detalhadas
curl -H "Accept: application/json" \
     https://tor.protexion.cloud/api/nodes/running

# Verificar status do serviço
curl https://tor.protexion.cloud/status

import requests
import json

# Configurar headers
headers = {
    'User-Agent': 'CTI-Client/1.0',
    'Accept': 'application/json'
}

# Buscar todos os nós Tor
response = requests.get(
    'https://tor.protexion.cloud/api/nodes',
    headers=headers
)

if response.status_code == 200:
    data = response.json()
    nodes = data['nodes']

    # Filtrar apenas nós exit ativos
    exit_nodes = [
        node for node in nodes
        if node.get('exit_node') and node.get('running')
    ]

    print(f"Nós exit ativos: {len(exit_nodes)}")

    # Buscar URLs maliciosas
    urls_response = requests.get(
        'https://tor.protexion.cloud/honeypot-urls.txt',
        headers={'Accept': 'text/plain'}
    )

    if urls_response.status_code == 200:
        malicious_urls = urls_response.text.strip().split('\n')
        print(f"URLs maliciosas detectadas: {len(malicious_urls)}")
else:
    print(f"Erro: {response.status_code}")

// Classe para interagir com a API CTI Protexion
class CTIProtexion {
    constructor(baseUrl = 'https://tor.protexion.cloud') {
        this.baseUrl = baseUrl;
        this.headers = {
            'Accept': 'application/json',
            'User-Agent': 'CTI-JS-Client/1.0'
        };
    }

    async getStats() {
        try {
            const response = await fetch(`${this.baseUrl}/api/stats`, {
                headers: this.headers
            });

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}`);
            }

            const data = await response.json();
            return data.statistics;
        } catch (error) {
            console.error('Erro ao buscar estatísticas:', error);
            return null;
        }
    }

    async getRunningNodes() {
        try {
            const response = await fetch(`${this.baseUrl}/api/nodes/running`, {
                headers: this.headers
            });

            const data = await response.json();
            return data.nodes;
        } catch (error) {
            console.error('Erro ao buscar nós ativos:', error);
            return [];
        }
    }

    async getMaliciousUrls() {
        try {
            const response = await fetch(`${this.baseUrl}/honeypot-urls.txt`, {
                headers: { 'Accept': 'text/plain' }
            });

            const text = await response.text();
            return text.split('\n').filter(url => url && !url.startsWith('#'));
        } catch (error) {
            console.error('Erro ao buscar URLs maliciosas:', error);
            return [];
        }
    }
}

// Exemplo de uso
const cti = new CTIProtexion();

cti.getStats().then(stats => {
    if (stats) {
        console.log('Estatísticas CTI:', stats);
    }
});

cti.getRunningNodes().then(nodes => {
    console.log(`Nós Tor ativos: ${nodes.length}`);
});

cti.getMaliciousUrls().then(urls => {
    console.log(`URLs maliciosas: ${urls.length}`);
});

<?php
class CTIProtexion {
    private $baseUrl;
    private $headers;

    public function __construct($baseUrl = 'https://tor.protexion.cloud') {
        $this->baseUrl = $baseUrl;
        $this->headers = [
            'Accept: application/json',
            'User-Agent: CTI-PHP-Client/1.0'
        ];
    }

    public function getTorNodes() {
        $url = $this->baseUrl . '/tornodes-ip.txt';

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => implode("\r\n", [
                    'Accept: text/plain',
                    'User-Agent: CTI-PHP-Client/1.0'
                ])
            ]
        ]);

        $response = @file_get_contents($url, false, $context);

        if ($response === false) {
            throw new Exception("Erro ao buscar nós Tor");
        }

        $lines = preg_split("/\r\n|\n|\r/", $response);
        $ips = [];

        foreach ($lines as $line) {
            $line = trim($line);

            // Pular comentários e linhas vazias
            if ($line === '' || strpos($line, '#') === 0) {
                continue;
            }

            // Validar IP
            if (filter_var($line, FILTER_VALIDATE_IP)) {
                $ips[] = $line;
            }
        }

        return $ips;
    }

    public function getApiData($endpoint) {
        $url = $this->baseUrl . $endpoint;

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => implode("\r\n", $this->headers)
            ]
        ]);

        $response = @file_get_contents($url, false, $context);

        if ($response === false) {
            throw new Exception("Erro ao buscar dados da API");
        }

        return json_decode($response, true);
    }

    public function getMaliciousUrls() {
        $url = $this->baseUrl . '/honeypot-urls.txt';

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => 'Accept: text/plain'
            ]
        ]);

        $response = @file_get_contents($url, false, $context);

        if ($response === false) {
            throw new Exception("Erro ao buscar URLs maliciosas");
        }

        $lines = preg_split("/\r\n|\n|\r/", $response);
        $urls = [];

        foreach ($lines as $line) {
            $line = trim($line);
            if ($line && !str_starts_with($line, '#')) {
                $urls[] = $line;
            }
        }

        return $urls;
    }
}

// Exemplo de uso
try {
    $cti = new CTIProtexion();

    // Buscar nós Tor
    $torNodes = $cti->getTorNodes();
    echo "Total de nós Tor: " . count($torNodes) . "\n";

    // Buscar estatísticas
    $stats = $cti->getApiData('/api/stats');
    if ($stats && $stats['status'] === 'success') {
        echo "Nós ativos: " . $stats['statistics']['running_nodes'] . "\n";
    }

    // Buscar URLs maliciosas
    $maliciousUrls = $cti->getMaliciousUrls();
    echo "URLs maliciosas detectadas: " . count($maliciousUrls) . "\n";

} catch (Exception $e) {
    echo "Erro: " . $e->getMessage() . "\n";
}
?>

URLs Maliciosas Detectadas

Lista dinâmica de URLs capturadas pelo nosso sistema de honeypot para análise de ameaças cibernéticas

Últimas Detecções

Carregando...

Carregando URLs maliciosas...

Baixar Lista Completa

Estatísticas em Tempo Real

Monitoramento 24/7 da rede Tor e análise contínua de ameaças cibernéticas

24/7

Monitoramento Contínuo

12h

Intervalo de Cache

99.9%

Disponibilidade

REST

API Completa

Especificações Técnicas

Linguagem Backend: Python 3.11+

Framework Web: Flask + Gunicorn

Fonte de Dados: Tor Project Official API

Rate Limiting: Por IP com Redis

Sistema de Cache: Redis + Memória

Formatos de Saída: JSON, TXT, RSS

Honeypot Engine: Proprietário

Infraestrutura: Cloud Native

Desenvolvedor & Suporte

Especialista em Segurança Cibernética e Inteligência de Ameaças

Dathan Nobrega

Especialista em segurança cibernética, análise de malware e infraestrutura de rede. Criador do CTI Protexion para auxiliar profissionais de segurança, pesquisadores e organizações na detecção e análise de ameaças.

GitHub LinkedIn Email

Precisa de Suporte?

Entre em contato para suporte técnico, integração personalizada, consultoria em segurança ou desenvolvimento de soluções CTI customizadas.

Entrar em Contato