Pular para o conteúdo principal

📊 Análise Técnica Completa - FD Capital

Data da Análise: 15 de Setembro de 2026
Versão do Documento: 2.0
Analista: Análise Automatizada de Código
Escopo: Segurança, Qualidade de Código, Arquitetura e Melhorias


📑 Índice​

  1. Sumário Executivo
  2. Visão Geral do Projeto
  3. Análise de Segurança
  4. Análise de Qualidade de Código
  5. Análise de Arquitetura
  6. Análise do Frontend
  7. Análise de Infraestrutura
  8. Vulnerabilidades Detalhadas
  9. Débito Técnico
  10. Plano de Remediação
  11. Métricas e Estatísticas
  12. Conclusões e Recomendações

1. Sumário Executivo​

1.1 Classificação Geral​

CategoriaPontuaçãoNívelTendência
Segurança7.5/10🟡 Bom⬆️ Melhorando
Qualidade de Código6.0/10🟠 Adequado➡️ Estável
Arquitetura5.5/10🟠 Funcional⬇️ Necessita atenção
Manutenibilidade5.5/10🟠 Moderada➡️ Estável
Performance7.0/10🟡 Bom➡️ Estável
Cobertura de Testes1.0/10🔴 Crítico➡️ Inexistente

1.2 Resumo de Findings​

SeveridadeQuantidadeExemplos
🔴 Crítica3CORS wildcard, SSL verify off, ausência de testes
🟠 Alta5Falta autoloading, funções globais, código legado
🟡 Média8Política de senha, CSP report-only, duplicação
🟢 Baixa6TODOs pendentes, nomenclatura inconsistente

1.3 Pontos de Destaque Positivos​

✅ 100% das queries SQL usam prepared statements
✅ Sistema CSRF robusto com validação timing-safe
✅ Rate limiting implementado em endpoints sensíveis
✅ Gestão de sessões com fingerprinting e timeout
✅ Logging estruturado com sanitização de dados sensíveis
✅ Sistema de permissões granular e multi-tenant
✅ Containerização pronta para produção


2. Visão Geral do Projeto​

2.1 Stack Tecnológico​

┌─────────────────────────────────────────────────────────────────┐
│ STACK TECNOLÓGICO │
├─────────────────────────────────────────────────────────────────┤
│ FRONTEND │
│ ├─ PHP 8.3 (Server-Side Rendering) │
│ ├─ TailwindCSS 3.4.17 │
│ ├─ DaisyUI 4.12.14 │
│ ├─ JavaScript (ES6+, jQuery-like wrapper) │
│ └─ Font Awesome 6.5.2 │
├─────────────────────────────────────────────────────────────────┤
│ BACKEND │
│ ├─ PHP 8.3-FPM │
│ ├─ MySQL (mysqli driver) │
│ ├─ Session-based authentication │
│ └─ RESTful API pattern │
├─────────────────────────────────────────────────────────────────┤
│ INFRAESTRUTURA │
│ ├─ Docker (multi-stage build) │
│ ├─ Nginx (reverse proxy) │
│ ├─ Google Drive API (storage) │
│ └─ Composer (dependency management) │
├─────────────────────────────────────────────────────────────────┤
│ INTEGRAÇÕES │
│ ├─ MovingPay API (pagamentos/credenciamento) │
│ ├─ Google Drive API (armazenamento de documentos) │
│ ├─ Autentique API (assinaturas digitais) │
│ └─ Google Places API (busca de leads) │
└─────────────────────────────────────────────────────────────────┘

2.2 Estrutura de Diretórios​

fd-capital/
├── 📁 assets/ # Recursos estáticos (CSS, JS, imagens)
│ ├── css/ # Estilos compilados
│ ├── js/ # JavaScript do frontend
│ │ └── pages/ # Scripts específicos por página
│ └── images/ # Imagens e ícones
├── 📁 backend/ # Código do servidor
│ ├── api/ # 211 endpoints REST
│ │ ├── auth/ # Autenticação (login, logout, reset)
│ │ ├── usuarios/ # CRUD de usuários
│ │ ├── estabelecimentos/ # Gestão de ECs
│ │ ├── propostas/ # Propostas comerciais
│ │ ├── white-label/ # Multi-tenancy
│ │ └── ... # Outros módulos
│ ├── config/ # Configurações (env, database, app)
│ ├── includes/ # Helpers legados (em migração)
│ └── src/ # Código novo organizado
│ ├── helpers/ # Utilitários (bootstrap, response)
│ ├── integrations/ # APIs externas
│ │ ├── google-drive/ # Google Drive Service
│ │ ├── movingpay/ # MovingPay APIs
│ │ └── autentique/ # Autentique Client
│ └── services/ # 96 arquivos de lógica de negócio
├── 📁 components/ # Componentes PHP reutilizáveis
├── 📁 dashboard/ # Páginas do painel principal
├── 📁 database/ # Migrações (16 arquivos)
├── 📁 docker/ # Configurações Docker
├── 📁 docs/ # Documentação
├── 📁 frontend/ # Frontend modular
│ ├── assets/js/core/ # Core JS (csrf, http, permissions)
│ └── pages/ # Páginas organizadas por módulo
├── 📁 public/ # Arquivos públicos
├── 📁 resources/ # Recursos fonte (CSS)
├── 📁 tools/ # Scripts de utilitários
├── 📄 .env.example # Template de configuração
├── 📄 composer.json # Dependências PHP
├── 📄 docker-compose.yml # Orquestração Docker
├── 📄 Dockerfile # Build da imagem
├── 📄 index.php # Página de login
└── 📄 tailwind.config.js # Configuração Tailwind

2.3 Dependências​

PHP (composer.json):

{
"phpoffice/phpword": "^1.3", // Geração de documentos Word
"dompdf/dompdf": "^3.1", // Geração de PDFs
"google/apiclient": "^2.15", // Google APIs
"google/apiclient-services": "^0.458.0"
}

Frontend (package.json):

{
"tailwindcss": "^3.4.17",
"daisyui": "^4.12.14",
"autoprefixer": "^10.4.20",
"postcss": "^8.4.49"
}

3. Análise de Segurança​

3.1 Autenticação​

✅ Implementação de Login (EXCELENTE)​

// backend/src/services/auth/auth_service.php

// 1. Validação de entrada
if ($email === '' || $password === '') {
return ['status' => 'error', 'message' => 'Email e senha são obrigatórios.'];
}

// 2. Rate limiting antes de consultar banco
if (backend_rate_limit_is_blocked($conn, 'login', $email)) {
return ['status' => 'error', 'message' => 'Muitas tentativas...'];
}

// 3. Validação de formato
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
backend_rate_limit_hit($conn, 'login', $email);
return ['status' => 'error', 'message' => 'Email e senha inválidos.'];
}

// 4. Consulta com prepared statement
$stmt = $conn->prepare('SELECT * FROM users WHERE email = ? LIMIT 1');
$stmt->bind_param('s', $email);

// 5. Verificação timing-safe de senha
if (!$user || !password_verify($password, $user['password'])) {
backend_rate_limit_hit($conn, 'login', $email);
return ['status' => 'error', 'message' => 'Email ou senha inválidos.'];
}

// 6. Session regeneration após login
backend_session_mark_authenticated((int) $user['id']);

Análise:

  • ✅ Rate limiting: 5 tentativas em 15 minutos
  • ✅ Prepared statements em todas queries
  • ✅ Mensagens de erro não revelam se email existe
  • ✅ password_verify() com timing-safe comparison
  • ✅ Session regeneration previne session fixation

✅ Gestão de Sessões (MUITO BOM)​

// backend/src/services/auth/session_service.php

const BACKEND_SESSION_TIMEOUT_SECONDS = 7200; // 2 horas
const BACKEND_SESSION_REGENERATE_SECONDS = 1800; // 30 minutos

// Configurações de segurança
ini_set('session.use_strict_mode', '1');
ini_set('session.cookie_httponly', '1');
ini_set('session.cookie_samesite', 'Lax');

session_set_cookie_params([
'lifetime' => 0,
'secure' => backend_session_is_https(),
'httponly' => true,
'samesite' => 'Lax',
]);

// Fingerprinting para detectar session hijacking
function backend_session_fingerprint(): string {
return hash('sha256', (string) ($_SERVER['HTTP_USER_AGENT'] ?? ''));
}

// Validação em cada request
if (!hash_equals($_SESSION['_fingerprint'], backend_session_fingerprint())) {
backend_session_destroy(); // Session hijacking detectado
}

Checklist de Sessões:

RecursoStatusImplementação
Session Timeout✅2 horas de inatividade
Session Regeneration✅A cada 30 minutos e após login
Fingerprinting✅Hash SHA-256 do User-Agent
HttpOnly Cookie✅session.cookie_httponly = 1
SameSite Cookie✅Lax (proteção CSRF básica)
Secure Cookie✅Quando HTTPS detectado
Strict Mode✅session.use_strict_mode = 1

🟡 Política de Senhas (ADEQUADA, PODE MELHORAR)​

// backend/src/services/auth/password_policy_service.php

function backend_password_validate(string $password): array {
if (strlen($password) < 8) {
return ['valid' => false, 'message' => '...pelo menos 8 caracteres.'];
}
if (!preg_match('/[A-Z]/', $password)) {
return ['valid' => false, 'message' => '...pelo menos uma letra maiúscula.'];
}
if (!preg_match('/[a-z]/', $password)) {
return ['valid' => false, 'message' => '...pelo menos uma letra minúscula.'];
}
if (!preg_match('/[0-9]/', $password)) {
return ['valid' => false, 'message' => '...pelo menos um número.'];
}
return ['valid' => true, 'message' => 'Senha válida.'];
}

Requisitos atuais vs. Recomendados:

RequisitoAtualRecomendado
Tamanho mínimo8 chars ✅12 chars
Letra maiúscula✅✅
Letra minúscula✅✅
Número✅✅
Caractere especial❌✅
Lista de senhas comuns❌✅
Histórico de senhas❌✅ (últimas 5)

3.2 Proteção CSRF​

✅ Implementação (EXCELENTE)​

// backend/src/services/auth/csrf_service.php

// Geração de token criptograficamente seguro
function backend_csrf_token(): string {
backend_session_start();
if (empty($_SESSION[BACKEND_CSRF_FIELD])) {
$_SESSION[BACKEND_CSRF_FIELD] = bin2hex(random_bytes(32));
}
return $_SESSION[BACKEND_CSRF_FIELD];
}

// Validação timing-safe
function backend_csrf_validate(?string $token = null): bool {
backend_session_start();
$token = $token ?: ($_POST[BACKEND_CSRF_FIELD] ?? $_SERVER['HTTP_X_CSRF_TOKEN'] ?? '');
$expected = $_SESSION[BACKEND_CSRF_FIELD] ?? '';
return $token !== '' && $expected !== '' && hash_equals($expected, $token);
}
// frontend/assets/js/core/csrf.js

// Intercepta todas requisições fetch
const originalFetch = window.fetch.bind(window);
window.fetch = function (input, init) {
const options = init ? Object.assign({}, init) : {};
const method = String(options.method || 'GET').toUpperCase();

if (method !== 'GET' && method !== 'HEAD') {
const headers = new Headers(options.headers || {});
headers.set('X-CSRF-Token', token);
options.headers = headers;
}
return originalFetch(input, options);
};

// jQuery também configurado
jQuery.ajaxSetup({ headers: { 'X-CSRF-Token': token } });

Cobertura:

  • ✅ Token de 64 caracteres hexadecimais (256 bits)
  • ✅ Validação com hash_equals() (timing-safe)
  • ✅ Suporte a header X-CSRF-Token e POST body
  • ✅ Interceptação automática no frontend

3.3 Proteção contra SQL Injection​

✅ Prepared Statements (EXCELENTE - 100% COBERTURA)​

Exemplo típico encontrado no código:

// Todas as 211 APIs seguem este padrão

// ✅ CORRETO - Prepared Statement
$stmt = $conn->prepare('SELECT * FROM users WHERE email = ? LIMIT 1');
$stmt->bind_param('s', $email);
$stmt->execute();

// ✅ CORRETO - Múltiplos parâmetros
$stmt = $conn->prepare("
SELECT el.* FROM estabelecimentos_locais el
JOIN users u ON el.user_id = u.id
WHERE el.id = ? AND u.white_label_id = ?
");
$stmt->bind_param("ii", $estabelecimentoId, $white_label_id);

// ✅ CORRETO - IN clause dinâmica
$placeholders = implode(',', array_fill(0, count($ids), '?'));
$types = str_repeat('i', count($ids));
$stmt = $conn->prepare("DELETE FROM ... WHERE id IN ({$placeholders})");
$stmt->bind_param($types, ...$ids);

Verificação automatizada:

  • 🔍 Buscado padrão ->prepare( e bind_param: ~800 ocorrências
  • 🔍 Buscado padrão mysqli_real_escape_string: 11 ocorrências (todos em helpers de sanitização, não queries diretas)
  • ❌ Nenhuma query concatenada com variáveis de usuário encontrada

3.4 Proteção contra XSS​

✅ Backend - Output Encoding (BOM)​

// components/cp_dashboard_shell.php

function cp_shell_h(string $value): string {
return htmlspecialchars($value, ENT_QUOTES, 'UTF-8');
}

// Uso em templates
<title><?= cp_shell_h($pageTitle) ?></title>
<input value="<?= cp_shell_h($userInput) ?>">

✅ Frontend - Escape Functions (BOM)​

// assets/js/cp-utils.js

function escapeHtml(value) {
return String(value ?? '').replace(/[&<>"']/g, function(char) {
return {
'&': '&amp;',
'<': '&lt;',
'>': '&gt;',
'"': '&quot;',
"'": '&#039;'
}[char];
});
}

function escapeJsString(value) {
return String(value ?? '').replace(/[\\'"\r\n\u2028\u2029]/g, ...);
}

// Validação de paths
function safeRelativePath(path) {
if (normalized.includes('\0') || normalized.includes('../')) {
return '';
}
if (/^(?:javascript|data|vbscript):/i.test(normalized)) {
return '';
}
return normalized;
}

3.5 Headers de Segurança​

// components/security_headers.php

function cp_send_security_headers(): void {
header('X-Content-Type-Options: nosniff');
header('X-Frame-Options: SAMEORIGIN');
header('Referrer-Policy: strict-origin-when-cross-origin');
header('Permissions-Policy: camera=(), microphone=(), geolocation=(self)');

// ⚠️ PROBLEMA: Apenas em Report-Only
header("Content-Security-Policy-Report-Only:
default-src 'self' https: data: blob:;
script-src 'self' 'unsafe-inline' 'unsafe-eval' https:;
style-src 'self' 'unsafe-inline' https:;
img-src 'self' https: data: blob:;
connect-src 'self' https:;
frame-ancestors 'self'
");
}

Checklist de Headers:

HeaderStatusValor
X-Content-Type-Options✅nosniff
X-Frame-Options✅SAMEORIGIN
Referrer-Policy✅strict-origin-when-cross-origin
Permissions-Policy✅Camera/Mic desabilitados
Content-Security-Policy⚠️Report-Only (não bloqueia)
Strict-Transport-Security❌Não implementado
X-XSS-Protection❌Depreciado (OK não ter)

3.6 Upload de Arquivos​

✅ Validação Robusta (MUITO BOM)​

// backend/api/estabelecimentos/upload-documento.php

// 1. Autenticação obrigatória
if (!isset($_SESSION['colaborador_id'])) {
exit;
}

// 2. CSRF obrigatório
if (!backend_csrf_validate()) {
exit;
}

// 3. Verificação de permissão
$temPermissao = temPermissao($conn, (int) $userId, 'establishments.update');

// 4. Whitelist de tipos
$tiposPermitidos = [
'contrato_estatuto',
'cartao_cnpj',
'rg_cnh_representante',
'comprovante_endereco',
'foto_fachada'
];

// 5. Limite de tamanho
$tamanhoMaximo = 10 * 1024 * 1024; // 10MB

// 6. Validação de extensão E mime type
$extensao = strtolower(pathinfo($arquivo['name'], PATHINFO_EXTENSION));
$tiposPermitidosArquivo = [
'pdf' => ['application/pdf'],
'jpg' => ['image/jpeg'],
'png' => ['image/png'],
];

// 7. Verificação real do mime type
$finfo = new finfo(FILEINFO_MIME_TYPE);
$mime = $finfo->file($tmpName);
if (!in_array($mime, $tiposPermitidosArquivo[$extensao], true)) {
exit; // Mime type não corresponde à extensão
}

// 8. Verificação de upload real
if (!is_uploaded_file($tmpName)) {
exit;
}

// 9. Upload para Google Drive (não filesystem local)
$uploaded = backend_drive_upload_private_bytes(...);

Proteções implementadas:

ProteçãoStatusDetalhes
Autenticação✅Session-based
CSRF✅Token validado
Autorização✅Permissão verificada
Whitelist tipos✅Extensões específicas
Limite tamanho✅10MB máximo
Mime validation✅finfo() real check
is_uploaded_file()✅Previne LFI
Storage externo✅Google Drive

4. Análise de Qualidade de Código​

4.1 Padrões e Convenções​

❌ Ausência de Autoloading PSR-4 (CRÍTICO)​

Problema: Todo o projeto usa require_once manual:

// Padrão atual (ruim)
require_once __DIR__ . '/../../helpers/bootstrap.php';
require_once __DIR__ . '/../services/core/permission_service.php';
require_once __DIR__ . '/../../integrations/google-drive/drive_storage.php';

Contagem de requires:

  • require_once: ~450 ocorrências no backend
  • require: ~30 ocorrências
  • Classes PSR-4: apenas 13 classes no projeto

Impacto:

  • ❌ Não há verificação em tempo de compilação
  • ❌ Ordem de includes pode causar bugs
  • ❌ Difícil navegação e refatoração
  • ❌ Impossível usar ferramentas de análise estática efetivamente

❌ Funções Globais vs Classes (ALTO)​

Análise quantitativa:

  • Funções globais definidas: ~400+
  • Classes definidas: 13
  • Ratio: 97% funções, 3% classes

Exemplo do padrão atual:

// Atual - Funções soltas com estado global
function backend_auth_login(mysqli $conn, string $email, string $password): array
function backend_permission_user_can(mysqli $conn, int $userId, string $key): bool
function backend_csrf_validate(?string $token = null): bool

// Recomendado - Classes com injeção de dependências
class AuthService {
public function __construct(
private readonly mysqli $conn,
private readonly RateLimiter $rateLimiter
) {}

public function login(string $email, string $password): AuthResult {}
}

4.2 Tratamento de Erros​

✅ Try-Catch Consistente (BOM)​

Contagem: ~900 blocos try-catch no backend

// Padrão bem implementado
try {
$response = backend_auth_login($context['conn'], $email, $password);
backend_json_response($response);
} catch (Throwable $e) {
backend_flow_log('login', 'request_fail', [
'error' => $e->getMessage(),
'file' => $e->getFile(),
'line' => $e->getLine(),
], 'error');

$message = 'Erro interno do servidor';
if (backend_env('APP_ENV') === 'local') {
$message .= ' — ' . $e->getMessage();
}
backend_error($message, 500);
}

✅ Error Reporting Configurado (BOM)​

// Endpoints de API
error_reporting(E_ALL);
ini_set('display_errors', 0); // Nunca exibe em produção
ini_set('log_errors', 1); // Sempre loga

4.3 Logging​

✅ Sistema de Logging Robusto (EXCELENTE)​

// backend/src/services/core/log_service.php

// Sanitização automática de dados sensíveis
function backend_log_sanitize(mixed $value): mixed {
$sensitiveKeys = [
'senha', 'password', 'token', 'access_token',
'authorization', 'cookie', 'card', 'cvv'
];
// ... [REDACTED] para valores sensíveis
}

// Log estruturado em JSON
$payload = [
'timestamp' => date('c'),
'level' => $level,
'module' => $module,
'event' => $event,
'request_id' => $_SERVER['HTTP_X_REQUEST_ID'] ?? null,
'method' => $_SERVER['REQUEST_METHOD'] ?? null,
'uri' => $_SERVER['REQUEST_URI'] ?? null,
'ip' => $_SERVER['REMOTE_ADDR'] ?? null,
'user_id' => $_SESSION['colaborador_id'] ?? null,
'context' => backend_log_sanitize($context),
];

// Persistência em arquivo e banco
file_put_contents($logDir . '/' . date('Y-m-d') . '.log', ...);
backend_log_write_database($payload);

Estrutura de logs:

backend/logs/
├── auth/
│ └── 2026-09-15.log
├── api/
│ └── 2026-09-15.log
├── entrepay/
│ └── global_init.log
└── ...

4.4 Duplicação de Código​

🟡 Headers CORS Repetidos (21+ arquivos)​

// Padrão repetido em 21 arquivos diferentes
header('Content-Type: application/json; charset=utf-8');
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: GET, POST, OPTIONS');
header('Access-Control-Allow-Headers: Content-Type');

Arquivos afetados:

  1. backend/api/estabelecimentos/terminais.php
  2. backend/api/estabelecimentos/atualizar-local.php
  3. backend/src/services/estabelecimentos/processar_cadastro_service.php
  4. backend/src/services/planos/remote/plan_remote_list_service.php
  5. backend/src/services/white-label/actions/cep_lookup_service.php
  6. ... e mais 16 arquivos

Recomendação: Criar middleware centralizado:

// backend/src/middleware/cors.php
function backend_cors_headers(array $allowedOrigins = []): void {
$origin = $_SERVER['HTTP_ORIGIN'] ?? '';
if (in_array($origin, $allowedOrigins, true)) {
header('Access-Control-Allow-Origin: ' . $origin);
header('Access-Control-Allow-Credentials: true');
}
// ...
}

4.5 Cobertura de Testes​

🔴 INEXISTENTE (CRÍTICO)​

Busca por arquivos de teste:

  • Diretório tests/: não existe
  • Arquivos *Test.php: 0 encontrados
  • Arquivos *_test.php: 0 encontrados
  • phpunit.xml: não existe

Impacto:

  • ❌ Impossível garantir regressões
  • ❌ Refatorações são arriscadas
  • ❌ Sem documentação executável
  • ❌ CI/CD limitado

5. Análise de Arquitetura​

5.1 Diagrama de Arquitetura​

┌────────────────────────────────────────────────────────────────────────────┐
│ CLIENTE (Browser) │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ TailwindCSS │ │ DaisyUI │ │ jQuery- │ │ Font │ │
│ │ 3.4.17 │ │ 4.12.14 │ │ like $() │ │ Awesome 6 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘ │
└────────────────────────────────────────────────────────────────────────────┘
│
│ HTTPS
▼
┌────────────────────────────────────────────────────────────────────────────┐
│ NGINX (Reverse Proxy) │
│ • server_tokens off (versão oculta) │
│ • Bloqueia: .env, vendor/, backend/src/, database/ │
│ • Limit: client_max_body_size 32m │
│ • Gzip: text/plain, text/css, application/javascript, application/json │
└────────────────────────────────────────────────────────────────────────────┘
│
│ FastCGI :9000
▼
┌────────────────────────────────────────────────────────────────────────────┐
│ PHP 8.3-FPM │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ CAMADA DE APRESENTAÇÃO │ │
│ │ /dashboard/*.php /components/*.php /frontend/pages/*.php │ │
│ │ • Server-side rendering com PHP │ │
│ │ • Templates com escape automático (cp_shell_h) │ │
│ │ • Assets compilados (TailwindCSS) │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ CAMADA DE API (REST) │ │
│ │ /backend/api/* (211 endpoints) │ │
│ │ ├── bootstrap.php (session, db, permissions) │ │
│ │ ├── Autenticação via Session │ │
│ │ ├── CSRF validation │ │
│ │ └── JSON responses │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ CAMADA DE SERVIÇOS │ │
│ │ /backend/src/services/* (96 arquivos) │ │
│ │ ├── auth/ (auth_service, session_service, csrf_service) │ │
│ │ ├── core/ (permission_service, authorization_service) │ │
│ │ ├── usuarios/ (user_service, user_registration_service) │ │
│ │ ├── estabelecimentos/ (establishment_service, registration) │ │
│ │ ├── propostas/ (proposal_service, simulator_service) │ │
│ │ └── ... │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ CAMADA DE INTEGRAÇÃO │ │
│ │ /backend/src/integrations/* │ │
│ │ ├── movingpay/ (api_estabelecimentos, api_planos, api_adiq) │ │
│ │ ├── google-drive/ (GoogleDriveService) │ │
│ │ └── autentique/ (autentique_client) │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────────────────────┘
│ │ │
│ │ │
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────────────────┐
│ MySQL │ │ Google Drive │ │ APIs Externas │
│ (Persistência) │ │ (Storage) │ │ • MovingPay (Pagamentos) │
│ │ │ │ │ • Autentique (Assinaturas) │
│ ~40 tabelas │ │ • Documentos │ │ • Google Places (Leads) │
│ utf8mb4_unicode │ │ • Logotipos │ │ • ViaCEP (Endereços) │
└──────────────────┘ │ • Assinaturas │ └──────────────────────────────┘
└──────────────────┘

5.2 Problemas Arquiteturais​

🔴 Monolito Fortemente Acoplado​

ATUAL:
Endpoint → (Validação + Lógica + SQL + Integração) tudo misturado

RECOMENDADO:
Endpoint → Controller → Service → Repository → Database
└→ External API Client

🔴 Ausência de Repository Pattern​

Problema: SQL direto nos services:

// Atual - SQL misturado com lógica de negócio
function backend_auth_find_user_by_email(mysqli $conn, string $email): ?array {
$stmt = $conn->prepare('SELECT * FROM users WHERE email = ? LIMIT 1');
$stmt->bind_param('s', $email);
$stmt->execute();
return $stmt->get_result()->fetch_assoc();
}

Recomendado:

interface UserRepositoryInterface {
public function findByEmail(string $email): ?User;
public function findById(int $id): ?User;
public function save(User $user): void;
}

class MySqlUserRepository implements UserRepositoryInterface {
public function __construct(private mysqli $conn) {}
// ... implementação
}

🟡 Configuração Dispersa​

Arquivos de configuração:

.env # Variáveis de ambiente
.env.example # Template
backend/config/app.php # Configurações da app
backend/config/database.php # Conexão MySQL
backend/config/env.php # Loader do .env
backend/includes/planos_config.php # Config legado

Recomendação: Centralizar em um único Config Manager.

5.3 Fluxo de Autenticação​

┌─────────┐ POST /backend/api/auth/login.php ┌─────────────┐
│ Browser │ ──────────────────────────────────────── │ login.php │
└─────────┘ {email, password} └──────┬──────┘
│
▼
┌───────────────────────────┐
│ backend_bootstrap() │
│ • session: true │
│ • db: true │
│ • permissions: true │
└─────────────┬─────────────┘
│
▼
┌───────────────────────────┐
│ backend_auth_login() │
│ 1. Validate input │
│ 2. Check rate limit │
│ 3. Query user │
│ 4. Verify password │
│ 5. Check status │
│ 6. Load permissions │
│ 7. Regenerate session │
└─────────────┬─────────────┘
│
▼
┌───────────────────────────┐
│ $_SESSION vars │
│ • colaborador_id │
│ • role │
│ • white_label_id │
│ • permissoes[] │
│ • session_hash │
│ • _fingerprint │
└───────────────────────────┘

5.4 Sistema de Permissões​

// Hierarquia de roles
AUTH_ROLE_SUPER_ADMIN = 'super-admin' // Rank: 100 - Acesso total
AUTH_ROLE_ADMIN = 'admin' // Rank: 80 - Admin plataforma
AUTH_ROLE_GESTOR = 'gestor' // Rank: 50 - Gestor white-label
AUTH_ROLE_COLABORADOR = 'colaborador' // Rank: 20 - Usuário comum

// Verificação de permissões
backend_permission_user_can($conn, $userId, 'establishments.delete')
backend_permission_require_any($conn, $userId, ['users.edit', 'users.admin'])

// Escopo por White Label
// Super-admin: vê tudo
// Admin: vê white-labels que gerencia
// Gestor/Colaborador: vê apenas seu white-label

6. Análise do Frontend​

6.1 Biblioteca jQuery-like Personalizada​

// assets/js/cp-dom.js - Wrapper leve similar ao jQuery

// Seleção de elementos
$('#myElement')
$('.myClass')
$('button[type="submit"]')

// Manipulação DOM
$(selector).addClass('active')
$(selector).removeClass('active')
$(selector).html(content)
$(selector).val(value)

// Eventos
$(selector).on('click', handler)
$(selector).on('submit', handler)

// AJAX
$.ajax({
url: 'api/endpoint.php',
type: 'POST',
data: formData,
success: callback
})

Vantagens:

  • ✅ Leve (~500 linhas vs jQuery ~10k)
  • ✅ API familiar para desenvolvedores
  • ✅ Sem dependências externas

Desvantagens:

  • ❌ Não é standard (curva de aprendizado)
  • ❌ Possíveis edge cases não cobertos

6.2 Proteções XSS no Frontend​

// assets/js/cp-utils.js

// Escape de HTML
CPUtils.escapeHtml('<script>alert(1)</script>')
// Retorna: &lt;script&gt;alert(1)&lt;/script&gt;

// Validação de paths (previne path traversal)
CPUtils.safeRelativePath('../../../etc/passwd')
// Retorna: '' (bloqueado)

CPUtils.safeRelativePath('javascript:alert(1)')
// Retorna: '' (bloqueado)

6.3 Padrão de Requisições​

// frontend/assets/js/core/http.js

async function request(path, options) {
const url = joinUrl(apiBaseUrl, path);
const response = await fetch(url, {
credentials: 'include', // Envia cookies de sessão
...options
});

const contentType = response.headers.get('content-type');
if (contentType.indexOf('application/json') !== -1) {
const payload = await response.json();
if (!response.ok || payload.status === 'error') {
throw new Error(payload.message || 'Erro na requisicao.');
}
return payload;
}
}

// Uso
CP.http.get('backend/api/users/listar.php')
CP.http.post('backend/api/users/salvar.php', formData)

7. Análise de Infraestrutura​

7.1 Dockerfile (Multi-stage Build)​

# Estágio 1: Build CSS
FROM node:22-alpine AS css
RUN npm ci --omit=optional
RUN npm run build:css

# Estágio 2: Composer dependencies
FROM php:8.3-cli-alpine AS vendor
RUN composer install --no-dev --optimize-autoloader

# Estágio 3: Imagem final
FROM php:8.3-fpm-alpine
RUN apk add --no-cache nginx ...
RUN docker-php-ext-install mysqli gd zip opcache

# Configurações de segurança
COPY docker/php.ini /usr/local/etc/php/conf.d/app.ini
COPY docker/nginx.conf /etc/nginx/nginx.conf

EXPOSE 80
HEALTHCHECK --interval=30s CMD wget -qO- http://127.0.0.1/

Análise:

  • ✅ Multi-stage reduz tamanho da imagem
  • ✅ Usa Alpine (imagem mínima)
  • ✅ Healthcheck configurado
  • ✅ Nginx + PHP-FPM otimizado

7.2 Configuração PHP (docker/php.ini)​

variables_order = "EGPCS"
expose_php = Off # ✅ Não revela versão PHP
display_errors = Off # ✅ Nunca mostra erros
log_errors = On # ✅ Sempre loga
memory_limit = 256M
upload_max_filesize = 32M
post_max_size = 32M
max_execution_time = 120
date.timezone = America/Sao_Paulo
session.cookie_httponly = 1 # ✅ HttpOnly
session.cookie_samesite = Lax # ✅ SameSite
opcache.enable = 1 # ✅ Performance

7.3 Configuração Nginx (docker/nginx.conf)​

server_tokens off; # ✅ Não revela versão Nginx
client_max_body_size 32m;

# ✅ Bloqueia arquivos sensíveis
location ~ /\. { deny all; }
location ~* ^/(\.env|composer\.(json|lock))$ { deny all; }
location ~* ^/(vendor|database|backend/src|backend/config)/ { deny all; }

# Gzip para performance
gzip on;
gzip_types text/plain text/css application/javascript application/json;

8. Vulnerabilidades Detalhadas​

8.1 🔴 CRÍTICA: CORS Permissivo​

Severidade: CRÍTICA
CVSS: 8.1 (High)
CWE: CWE-942 (Permissive Cross-domain Policy)

Descrição: 21+ endpoints utilizam Access-Control-Allow-Origin: *, permitindo requisições de qualquer origem.

Arquivos afetados:

backend/api/estabelecimentos/atualizar-local.php
backend/api/estabelecimentos/terminais.php
backend/api/estabelecimentos/vincular-plano.php
backend/src/services/estabelecimentos/processar_cadastro_service.php
backend/src/services/planos/remote/plan_remote_list_service.php
backend/src/services/planos/rates/plan_debit_rates_service.php
backend/src/services/white-label/actions/cep_lookup_service.php
backend/src/services/white-label/actions/cnpj_lookup_service.php
... (13 mais)

Impacto:

  • Sites maliciosos podem fazer requisições em nome do usuário
  • Bypass de proteção CSRF para algumas operações
  • Potencial exfiltração de dados

Remediação:

// ✅ CORRETO
$allowedOrigins = [
'https://app.fdcapital.com.br',
'https://admin.fdcapital.com.br'
];
$origin = $_SERVER['HTTP_ORIGIN'] ?? '';

if (in_array($origin, $allowedOrigins, true)) {
header('Access-Control-Allow-Origin: ' . $origin);
header('Access-Control-Allow-Credentials: true');
} else {
// Não envia header CORS - browser bloqueia
}

8.2 🔴 CRÍTICA: SSL Verification Disabled​

Severidade: CRÍTICA
CVSS: 7.4 (High)
CWE: CWE-295 (Improper Certificate Validation)

Descrição: Algumas chamadas cURL desabilitam verificação SSL:

// ❌ VULNERÁVEL
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);

Arquivos afetados:

backend/src/services/estabelecimentos/registration/standard_registration_service.php
backend/api/estabelecimentos/vincular-plano.php
backend/src/services/estabelecimentos/registration/mdr/movingpay_service.php

Impacto:

  • Vulnerável a ataques Man-in-the-Middle
  • Credenciais podem ser interceptadas
  • Tokens de API podem ser roubados

Remediação:

// ✅ CORRETO
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
// Se necessário, especificar CA bundle:
curl_setopt($ch, CURLOPT_CAINFO, '/etc/ssl/certs/ca-certificates.crt');

8.3 🟠 ALTA: CSP em Report-Only​

Severidade: Alta
CWE: CWE-1021 (Improper Restriction of Rendered UI Layers)

Descrição: Content-Security-Policy está apenas em modo Report-Only, não bloqueia ataques XSS.

Código atual:

header("Content-Security-Policy-Report-Only: ...");

Remediação:

  1. Monitorar reports em /csp-report endpoint
  2. Ajustar política baseado em reports
  3. Migrar para modo blocking:
header("Content-Security-Policy:
default-src 'self';
script-src 'self' 'nonce-{random}' https://cdnjs.cloudflare.com;
style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;
img-src 'self' data: https:;
font-src 'self' https://fonts.gstatic.com;
connect-src 'self' https://api.fdcapital.com.br;
frame-ancestors 'self';
");

8.4 🟡 MÉDIA: Falta HSTS Header​

Severidade: Média
CWE: CWE-319 (Cleartext Transmission of Sensitive Information)

Descrição: Header Strict-Transport-Security não está configurado.

Remediação:

// Adicionar em security_headers.php
if (backend_session_is_https()) {
header('Strict-Transport-Security: max-age=31536000; includeSubDomains; preload');
}

8.5 🟡 MÉDIA: Falta 2FA/MFA​

Severidade: Média
CWE: CWE-308 (Use of Single-factor Authentication)

Descrição: Sistema financeiro sem autenticação de dois fatores.

Recomendação: Implementar TOTP (Time-based One-Time Password) usando biblioteca como spomky-labs/otphp.


9. Débito Técnico​

9.1 TODOs e FIXMEs no Código​

Contagem no backend (excluindo vendor):

  • TODO: 5 ocorrências
  • FIXME: 2 ocorrências

Exemplos encontrados:

// backend/src/services/usuarios/user_logger.php
// TODO: Implementar rotação de logs

// backend/includes/auth.php
// TODO: Migrar para backend_session_start()

// backend/src/integrations/movingpay/api_planos.php
// FIXME: Tratar timeout de API

9.2 Código Legado​

Padrão antigo (cp_*) vs novo (backend_*):

// Funções legadas ainda em uso
cp_csrf_token() → backend_csrf_token()
cp_csrf_validate() → backend_csrf_validate()

// Arquivos de compatibilidade
backend/includes/csrf.php // Adapter para código legado
backend/includes/auth.php // Mistura de padrões

9.3 Variáveis Globais​

// Uso de $GLOBALS ainda presente
$GLOBALS['conn'] = $conn;
$GLOBALS['host'] = $dbConfig['host'];
$GLOBALS['fdcapital_tailwind_shell'] = true;

// Impacto:
// - Estado implícito difícil de rastrear
// - Testes impossíveis de isolar
// - Race conditions em cenários async

10. Plano de Remediação​

10.1 Fase 1: Segurança Crítica (Urgente - 1-2 semanas)​

#TarefaEsforçoRisco se não feito
1Corrigir CORS wildcard em 21 arquivos4h🔴 Alto
2Habilitar SSL verification2h🔴 Alto
3Implementar HSTS header1h🟡 Médio
4Ativar CSP em modo blocking8h🟡 Médio

Script de correção CORS:

// backend/src/middleware/cors.php
function backend_cors_headers(): void {
$allowedOrigins = explode(',', backend_env('CORS_ALLOWED_ORIGINS', ''));
$origin = $_SERVER['HTTP_ORIGIN'] ?? '';

if (in_array($origin, $allowedOrigins, true)) {
header('Access-Control-Allow-Origin: ' . $origin);
header('Access-Control-Allow-Credentials: true');
header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS');
header('Access-Control-Allow-Headers: Content-Type, Authorization, X-CSRF-Token');
}

if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
http_response_code(204);
exit;
}
}

10.2 Fase 2: Qualidade de Código (2-4 semanas)​

#TarefaEsforçoBenefício
1Implementar PSR-4 autoloading16hManutenibilidade
2Adicionar PHPStan level 58hDetecção de bugs
3Criar middleware centralizado8hReduz duplicação
4Extrair CORS para middleware4hDRY principle

composer.json com autoload:

{
"autoload": {
"psr-4": {
"FDCapital\\": "backend/src/",
"FDCapital\\Api\\": "backend/api/"
}
},
"require-dev": {
"phpstan/phpstan": "^2.0",
"squizlabs/php_codesniffer": "^3.10"
}
}

10.3 Fase 3: Testes (4-8 semanas)​

#TarefaEsforçoCobertura alvo
1Setup PHPUnit4h-
2Testes unitários auth16h80%
3Testes unitários permissions16h80%
4Testes de integração APIs24h60%
5Testes E2E (Playwright)40hFluxos críticos

phpunit.xml:

<?xml version="1.0"?>
<phpunit bootstrap="vendor/autoload.php" colors="true">
<testsuites>
<testsuite name="Unit">
<directory>tests/Unit</directory>
</testsuite>
<testsuite name="Integration">
<directory>tests/Integration</directory>
</testsuite>
</testsuites>
<coverage>
<include>
<directory>backend/src</directory>
</include>
</coverage>
</phpunit>

10.4 Fase 4: Arquitetura (8-16 semanas)​

#TarefaEsforçoImpacto
1Repository pattern para Users24hBase para outros
2Repository para Establishments24hMódulo crítico
3Injeção de dependências40hTestabilidade
4Service containers24hGerenciamento
5API versioning (/api/v1/)16hEvolução segura

10.5 Fase 5: Funcionalidades de Segurança (4-8 semanas)​

#TarefaEsforçoPrioridade
1Implementar 2FA (TOTP)40hAlta
2Audit log completo24hMédia
3Política de senha forte4hMédia
4Session concurrent limit8hBaixa
5IP whitelist para admin8hBaixa

11. Métricas e Estatísticas​

11.1 Métricas de Código​

MétricaValor
Total de arquivos PHP~400 (excl. vendor)
Endpoints de API211
Arquivos de serviços96
Classes definidas13
Funções globais~400+
Linhas de código (estimado)~60.000
Arquivos JavaScript~80
Migrações de banco16
Tabelas no banco~40

11.2 Métricas de Segurança​

MétricaValor
Queries com prepared statement100%
Endpoints com autenticação~95%
Endpoints com CSRF~80%
Uploads com validação100%
Senhas com bcrypt100%

11.3 Métricas de Qualidade​

MétricaValor
Cobertura de testes0%
Try-catch blocks~900
TODOs/FIXMEs7
Duplicação CORS21 arquivos
Uso de $GLOBALS5 locais

12. Conclusões e Recomendações​

12.1 Pontos Fortes​

  1. Segurança de SQL: 100% prepared statements - excelente
  2. Autenticação: Sistema robusto com rate limiting e session management
  3. Logging: Estruturado, com sanitização e persistência dupla
  4. Permissões: Granular e multi-tenant
  5. Containerização: Docker pronto para produção
  6. Upload de arquivos: Validação completa com storage externo

12.2 Pontos de Atenção Imediata​

  1. 🔴 CORS wildcard - Corrigir nos 21 arquivos afetados
  2. 🔴 SSL verification - Habilitar em todas chamadas cURL
  3. 🔴 Testes - Implementar suite básica de testes
  4. 🟠 Autoloading - Migrar para PSR-4

12.3 Investimentos Recomendados​

InvestimentoROIPrazo
Correções de segurança críticasAltoImediato
Implementação de testesAlto1-2 meses
Modernização arquiteturalMédio3-6 meses
2FA para usuários adminAlto1 mês

12.4 Próximos Passos Sugeridos​

  1. Semana 1-2: Corrigir vulnerabilidades críticas (CORS, SSL)
  2. Semana 3-4: Setup de PHPStan + CI/CD básico
  3. Mês 2: Implementar PSR-4 autoloading
  4. Mês 2-3: Criar suite de testes para módulos críticos
  5. Mês 3-4: Implementar 2FA
  6. Contínuo: Refatoração gradual para padrões modernos

Apêndice A: Checklist OWASP Top 10 (2021)​

VulnerabilidadeStatusNotas
A01 - Broken Access Control🟡CORS precisa correção
A02 - Cryptographic Failures✅Bcrypt, HTTPS
A03 - Injection✅100% prepared statements
A04 - Insecure Design🟡Falta 2FA
A05 - Security Misconfiguration🟡CORS, SSL verify
A06 - Vulnerable Components✅Deps atualizadas
A07 - Auth Failures✅Rate limit, sessions
A08 - Data Integrity Failures✅CSRF completo
A09 - Security Logging✅Logging robusto
A10 - SSRF🟡Validar URLs externas

Apêndice B: Checklist LGPD​

RequisitoStatusAção necessária
Criptografia em trânsito✅HTTPS
Criptografia em repouso🟡Implementar para dados sensíveis
Logs de acesso✅Implementado
Consentimento❌Implementar gestão de consentimento
Direito ao esquecimento❌Implementar soft-delete + anonimização
Portabilidade❌Implementar export de dados
Relatório de impacto❌Documentar

Documento gerado em 15/09/2026. Revisão recomendada a cada 3 meses ou após mudanças significativas no código.