Documentação SafeNode

Guia completo da API e arquitetura do sistema

O SafeNode é uma plataforma de segurança completa que oferece proteção em tempo real contra ameaças, análise comportamental e monitoramento avançado. Esta documentação cobre todos os aspectos da API, estrutura do código e como integrar o sistema.

Segurança

Proteção em tempo real contra ameaças

Monitoramento

Análise e logs detalhados

API REST

Integração fácil e completa

Endpoints da API

GET /api/dashboard-stats.php

Retorna estatísticas em tempo real do dashboard

                                
// Exemplo de requisição
fetch('api/dashboard-stats.php')
  .then(res => res.json())
  .then(data => {
    // data.today.total_requests
    // data.today.blocked
    // data.top_blocked_ips
  });
                                
                            

Resposta:

{
  "success": true,
  "data": {
    "today": {
      "total_requests": 1250,
      "blocked": 45,
      "unique_ips": 320
    },
    "top_blocked_ips": [...],
    "recent_incidents": [...]
  }
}

GET /api/notifications.php

Retorna notificações e alertas do sistema

                                
// Buscar notificações não lidas
fetch('api/notifications.php?unread=1')
  .then(res => res.json())
  .then(data => {
    // data.count - número de notificações não lidas
  });

// Listar notificações
fetch('api/notifications.php?limit=20')
  .then(res => res.json())
  .then(data => {
    // data.notifications - array de notificações
  });
                                
                            

POST /api/dangerous-action.php

Executa ações perigosas (requer autenticação adicional)

                                
// Encerrar todas as sessões
const formData = new FormData();
formData.append('action', 'terminate_all_sessions');
formData.append('password', 'senha_do_usuario');
formData.append('otp_code', '123456');

fetch('api/dangerous-action.php', {
  method: 'POST',
  body: formData
});
                                
                            

SDK Endpoints

POST /api/sdk/validate.php

Valida requisições através do SDK SafeNode

GET /api/sdk/init.php

Inicializa o SDK e retorna configurações

Arquitetura do Sistema

Estrutura de Diretórios

                                    
safenode/
├── api/                    # Endpoints da API
│   ├── dashboard-stats.php
│   ├── notifications.php
│   └── sdk/
├── includes/               # Classes e helpers
│   ├── SecurityLogger.php
│   ├── ThreatDetector.php
│   ├── BehaviorAnalyzer.php
│   └── SecurityHelpers.php
├── assets/                 # Recursos estáticos
└── sdk/                    # SDK JavaScript
                                    
                                

Classes Principais

SecurityLogger

Registra eventos de segurança no banco de dados

includes/SecurityLogger.php

ThreatDetector

Detecta e classifica ameaças em requisições

includes/ThreatDetector.php

BehaviorAnalyzer

Analisa padrões comportamentais suspeitos

includes/BehaviorAnalyzer.php

SecurityAnalytics

Gera insights e análises avançadas

includes/SecurityAnalytics.php

Guia de Integração

SDKs Disponíveis

JavaScript (Browser)

Para sites web

sdk/safenode-hv.js

PHP

Para aplicações PHP

sdk/php/SafeNodeHV.php

Python

Para aplicações Python

sdk/python/safenode_hv.py

Node.js

Para aplicações Node.js

sdk/nodejs/safenode-hv.js

1. JavaScript (Browser) - Exemplo Completo

                                    
<!-- HTML -->
<script src="https://safenode.cloud/sdk/safenode-hv.js"></script>

<form id="meuFormulario">
    <input type="text" name="nome" required>
    <button type="submit">Enviar</button>
</form>

<script>
// Inicializar SDK quando a página carregar
const safenode = new SafeNodeHV('https://safenode.cloud/api/sdk', 'sua-api-key-aqui');

safenode.init().then(() => {
    console.log('SafeNode inicializado');
}).catch(err => {
    console.error('Erro ao inicializar:', err);
});

// Validar antes de enviar formulário
document.getElementById('meuFormulario').addEventListener('submit', async (e) => {
    e.preventDefault();
    
    try {
        const result = await safenode.validate();
        if (result.valid) {
            // Enviar formulário
            e.target.submit();
        }
    } catch (error) {
        alert('Erro na validação: ' + error.message);
    }
});
</script>
                                    
                                

2. PHP - Exemplo Completo

                                    
<?php
require_once 'sdk/php/SafeNodeHV.php';

$safenode = new SafeNodeHV('https://safenode.cloud/api/sdk', 'sua-api-key-aqui');

// Inicializar na página (GET)
if ($_SERVER['REQUEST_METHOD'] === 'GET') {
    try {
        $safenode->init();
        $token = $safenode->getToken();
        // Token armazenado na sessão do SDK
    } catch (Exception $e) {
        die('Erro ao inicializar: ' . $e->getMessage());
    }
}

// Validar ao processar formulário (POST)
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    try {
        $result = $safenode->validate();
        if ($result['valid']) {
            // Processar dados do formulário
            $nome = $_POST['nome'] ?? '';
            echo "Formulário processado: " . htmlspecialchars($nome);
        } else {
            die('Validação falhou');
        }
    } catch (Exception $e) {
        die('Erro: ' . $e->getMessage());
    }
}
?>
                                    
                                

3. Python - Exemplo com Flask

                                    
from flask import Flask, request, jsonify
from safenode_hv import SafeNodeHV

app = Flask(__name__)
safenode = SafeNodeHV('https://safenode.cloud/api/sdk', 'sua-api-key-aqui')

@app.route('/', methods=['GET'])
def index():
    safenode.init()
    return 'Página carregada'

@app.route('/submit', methods=['POST'])
def submit():
    try:
        result = safenode.validate()
        if result['valid']:
            # Processar dados
            nome = request.form.get('nome')
            return jsonify({'success': True, 'message': 'Processado'})
        else:
            return jsonify({'error': 'Validação falhou'}), 400
    except Exception as e:
        return jsonify({'error': str(e)}), 400

if __name__ == '__main__':
    app.run(debug=True)
                                    
                                

4. Node.js - Exemplo com Express

                                    
const express = require('express');
const SafeNodeHV = require('./sdk/nodejs/safenode-hv.js');

const app = express();
const safenode = new SafeNodeHV('https://safenode.cloud/api/sdk', 'sua-api-key-aqui');

app.use(express.json());

// Inicializar na página
app.get('/', async (req, res) => {
    await safenode.init();
    res.send('Página carregada');
});

// Validar e processar formulário
app.post('/submit', async (req, res) => {
    try {
        const result = await safenode.validate();
        if (result.valid) {
            // Processar dados
            res.json({'success': true, 'message': 'Processado'});
        } else {
            res.status(400).json({'error': 'Validação falhou'});
        }
    } catch (error) {
        res.status(400).json({'error': error.message});
    }
});

app.listen(3000, () => {
    console.log('Servidor rodando na porta 3000');
});
                                    
                                

Padrões de Código

PSR-12 Coding Standard

O SafeNode segue o padrão PSR-12 para garantir consistência e legibilidade do código.

Principais Regras:

Indentação: 4 espaços (não tabs)
Linhas: máximo 120 caracteres
Nomes de classes: PascalCase
Nomes de métodos: camelCase
Constantes: UPPER_SNAKE_CASE

Estrutura de Classes

                                    
<?php
/**
 * SafeNode - Nome da Classe
 * Descrição breve da funcionalidade
 */

class ClassName {
    // Propriedades privadas
    private $property;
    
    // Construtor
    public function __construct($param) {
        $this->property = $param;
    }
    
    // Métodos públicos
    public function publicMethod() {
        // Implementação
    }
}
                                    
                                

Estrutura do Banco de Dados

safenode_security_logs

Armazena todos os eventos de segurança

Campos principais: ip_address, threat_type, threat_score, action_taken, created_at

safenode_sites

Sites protegidos pelo sistema

Campos principais: domain, display_name, security_level, is_active

safenode_users

Usuários do sistema

Campos principais: email, username, password_hash, role