📊 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
- Sumário Executivo
- Visão Geral do Projeto
- Análise de Segurança
- Análise de Qualidade de Código
- Análise de Arquitetura
- Análise do Frontend
- Análise de Infraestrutura
- Vulnerabilidades Detalhadas
- Débito Técnico
- Plano de Remediação
- Métricas e Estatísticas
- Conclusões e Recomendações
1. Sumário Executivo
1.1 Classificação Geral
| Categoria | Pontuação | Nível | Tendência |
|---|---|---|---|
| Segurança | 7.5/10 | 🟡 Bom | ⬆️ Melhorando |
| Qualidade de Código | 6.0/10 | 🟠 Adequado | ➡️ Estável |
| Arquitetura | 5.5/10 | 🟠 Funcional | ⬇️ Necessita atenção |
| Manutenibilidade | 5.5/10 | 🟠 Moderada | ➡️ Estável |
| Performance | 7.0/10 | 🟡 Bom | ➡️ Estável |
| Cobertura de Testes | 1.0/10 | 🔴 Crítico | ➡️ Inexistente |
1.2 Resumo de Findings
| Severidade | Quantidade | Exemplos |
|---|---|---|
| 🔴 Crítica | 3 | CORS wildcard, SSL verify off, ausência de testes |
| 🟠 Alta | 5 | Falta autoloading, funções globais, código legado |
| 🟡 Média | 8 | Política de senha, CSP report-only, duplicação |
| 🟢 Baixa | 6 | TODOs 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:
| Recurso | Status | Implementaçã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:
| Requisito | Atual | Recomendado |
|---|---|---|
| Tamanho mínimo | 8 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-Tokene 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(ebind_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 {
'&': '&',
'<': '<',
'>': '>',
'"': '"',
"'": '''
}[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:
| Header | Status | Valor |
|---|---|---|
| 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ção | Status | Detalhes |
|---|---|---|
| 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 backendrequire: ~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:
backend/api/estabelecimentos/terminais.phpbackend/api/estabelecimentos/atualizar-local.phpbackend/src/services/estabelecimentos/processar_cadastro_service.phpbackend/src/services/planos/remote/plan_remote_list_service.phpbackend/src/services/white-label/actions/cep_lookup_service.php- ... 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: <script>alert(1)</script>
// 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:
- Monitorar reports em
/csp-reportendpoint - Ajustar política baseado em reports
- 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ênciasFIXME: 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)
| # | Tarefa | Esforço | Risco se não feito |
|---|---|---|---|
| 1 | Corrigir CORS wildcard em 21 arquivos | 4h | 🔴 Alto |
| 2 | Habilitar SSL verification | 2h | 🔴 Alto |
| 3 | Implementar HSTS header | 1h | 🟡 Médio |
| 4 | Ativar CSP em modo blocking | 8h | 🟡 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)
| # | Tarefa | Esforço | Benefício |
|---|---|---|---|
| 1 | Implementar PSR-4 autoloading | 16h | Manutenibilidade |
| 2 | Adicionar PHPStan level 5 | 8h | Detecção de bugs |
| 3 | Criar middleware centralizado | 8h | Reduz duplicação |
| 4 | Extrair CORS para middleware | 4h | DRY 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)
| # | Tarefa | Esforço | Cobertura alvo |
|---|---|---|---|
| 1 | Setup PHPUnit | 4h | - |
| 2 | Testes unitários auth | 16h | 80% |
| 3 | Testes unitários permissions | 16h | 80% |
| 4 | Testes de integração APIs | 24h | 60% |
| 5 | Testes E2E (Playwright) | 40h | Fluxos 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)
| # | Tarefa | Esforço | Impacto |
|---|---|---|---|
| 1 | Repository pattern para Users | 24h | Base para outros |
| 2 | Repository para Establishments | 24h | Módulo crítico |
| 3 | Injeção de dependências | 40h | Testabilidade |
| 4 | Service containers | 24h | Gerenciamento |
| 5 | API versioning (/api/v1/) | 16h | Evolução segura |
10.5 Fase 5: Funcionalidades de Segurança (4-8 semanas)
| # | Tarefa | Esforço | Prioridade |
|---|---|---|---|
| 1 | Implementar 2FA (TOTP) | 40h | Alta |
| 2 | Audit log completo | 24h | Média |
| 3 | Política de senha forte | 4h | Média |
| 4 | Session concurrent limit | 8h | Baixa |
| 5 | IP whitelist para admin | 8h | Baixa |
11. Métricas e Estatísticas
11.1 Métricas de Código
| Métrica | Valor |
|---|---|
| Total de arquivos PHP | ~400 (excl. vendor) |
| Endpoints de API | 211 |
| Arquivos de serviços | 96 |
| Classes definidas | 13 |
| Funções globais | ~400+ |
| Linhas de código (estimado) | ~60.000 |
| Arquivos JavaScript | ~80 |
| Migrações de banco | 16 |
| Tabelas no banco | ~40 |
11.2 Métricas de Segurança
| Métrica | Valor |
|---|---|
| Queries com prepared statement | 100% |
| Endpoints com autenticação | ~95% |
| Endpoints com CSRF | ~80% |
| Uploads com validação | 100% |
| Senhas com bcrypt | 100% |
11.3 Métricas de Qualidade
| Métrica | Valor |
|---|---|
| Cobertura de testes | 0% |
| Try-catch blocks | ~900 |
| TODOs/FIXMEs | 7 |
| Duplicação CORS | 21 arquivos |
| Uso de $GLOBALS | 5 locais |
12. Conclusões e Recomendações
12.1 Pontos Fortes
- Segurança de SQL: 100% prepared statements - excelente
- Autenticação: Sistema robusto com rate limiting e session management
- Logging: Estruturado, com sanitização e persistência dupla
- Permissões: Granular e multi-tenant
- Containerização: Docker pronto para produção
- Upload de arquivos: Validação completa com storage externo
12.2 Pontos de Atenção Imediata
- 🔴 CORS wildcard - Corrigir nos 21 arquivos afetados
- 🔴 SSL verification - Habilitar em todas chamadas cURL
- 🔴 Testes - Implementar suite básica de testes
- 🟠 Autoloading - Migrar para PSR-4
12.3 Investimentos Recomendados
| Investimento | ROI | Prazo |
|---|---|---|
| Correções de segurança críticas | Alto | Imediato |
| Implementação de testes | Alto | 1-2 meses |
| Modernização arquitetural | Médio | 3-6 meses |
| 2FA para usuários admin | Alto | 1 mês |
12.4 Próximos Passos Sugeridos
- Semana 1-2: Corrigir vulnerabilidades críticas (CORS, SSL)
- Semana 3-4: Setup de PHPStan + CI/CD básico
- Mês 2: Implementar PSR-4 autoloading
- Mês 2-3: Criar suite de testes para módulos críticos
- Mês 3-4: Implementar 2FA
- Contínuo: Refatoração gradual para padrões modernos
Apêndice A: Checklist OWASP Top 10 (2021)
| Vulnerabilidade | Status | Notas |
|---|---|---|
| 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
| Requisito | Status | Açã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.