Pular para o conteúdo principal

📊 Análise Completa do Projeto PayUp/GEV-TECH

Versão: 1.0
Data: 15 de Setembro de 2026
Autor: Análise Automatizada de Código


📑 Índice​

  1. Visão Geral do Projeto
  2. Análise de Segurança
  3. Qualidade de Código
  4. Análise de Arquitetura
  5. Melhorias Recomendadas
  6. Matriz de Risco
  7. Plano de Ação Priorizado

1. Visão Geral do Projeto​

1.1 Tecnologias Utilizadas​

CamadaTecnologia
BackendPHP 8.x (procedural/funcional)
Banco de DadosMySQL/MariaDB (mysqli)
FrontendPHP Templates + JavaScript vanilla
CSS FrameworkTailwind CSS 3.4 + DaisyUI 4.12
Dependências PHPComposer (PHPWord, DomPDF, Google API Client, Guzzle, Monolog)
ArmazenamentoGoogle Drive API (documentos/arquivos)
Assinatura DigitalAutentique API

1.2 Estrutura de Diretórios​

payup/
├── backend/
│ ├── api/ # Endpoints da API interna
│ ├── config/ # Configurações (env, database, mail)
│ ├── includes/ # Helpers/adaptadores legados
│ ├── src/
│ │ ├── helpers/ # Funções utilitárias
│ │ ├── integrations/ # Clientes de APIs externas
│ │ └── services/ # Lógica de negócio por módulo
│ └── storage/ # Sessões, uploads temporários
├── frontend/
│ └── pages/ # Páginas PHP do dashboard
├── components/ # Componentes reutilizáveis PHP
├── assets/
│ ├── css/ # Estilos compilados
│ └── js/ # JavaScript por página
├── dashboard/ # Páginas legadas (migração em andamento)
└── docs/ # Documentação

1.3 Modelo Multi-Tenant (White-Label)​

O sistema opera com arquitetura multi-tenant, onde:

  • Cada white_label representa um tenant independente
  • super-admin tem acesso global à plataforma
  • Usuários são isolados por white_label_id
  • Dados são filtrados automaticamente por escopo do tenant

2. Análise de Segurança​

2.1 Pontos Fortes ✅​

2.1.1 Proteção CSRF​

// backend/src/services/auth/csrf_service.php
$_SESSION[BACKEND_CSRF_FIELD] = bin2hex(random_bytes(32));
// Validação com hash_equals (timing-safe)
return hash_equals($expected, $token);

Status: ✅ Implementado corretamente com tokens de 32 bytes e comparação segura.

2.1.2 Gerenciamento de Sessão​

// backend/src/services/auth/session_service.php
- Session timeout: 7200 segundos (2 horas)
- Regeneração de ID: 1800 segundos (30 minutos)
- Fingerprint de User-Agent
- Cookies: httponly, samesite=Lax, secure (quando HTTPS)
- Strict mode habilitado

Status: ✅ Configuração robusta seguindo boas práticas OWASP.

2.1.3 Rate Limiting​

// backend/src/services/auth/rate_limit_service.php
- Login: 5 tentativas em 15 minutos
- Password Reset: 3 tentativas em 15 minutos
- Key: SHA256(action|identity|IP)

Status: ✅ Proteção contra brute-force implementada.

2.1.4 Política de Senhas​

// backend/src/services/auth/password_policy_service.php
- Mínimo 8 caracteres
- Pelo menos 1 letra maiúscula
- Pelo menos 1 letra minúscula
- Pelo menos 1 número
- Hash: PASSWORD_BCRYPT

Status: ✅ Política adequada, mas pode ser melhorada.

2.1.5 Prepared Statements​

A maioria das queries usa prepared statements corretamente:

$stmt = $conn->prepare('SELECT * FROM users WHERE email = ? LIMIT 1');
$stmt->bind_param('s', $email);

Status: ✅ Uso predominante de prepared statements.

2.2 Vulnerabilidades e Riscos ⚠️​

2.2.1 🔴 CRÍTICO: SQL Injection Potencial​

Localização: Uso de real_escape_string em alguns serviços (14 arquivos identificados)

// backend/src/services/comercial/leads_service.php (e outros)
$table = $conn->real_escape_string($table);
$column = $conn->real_escape_string($column);
$result = $conn->query("SHOW COLUMNS FROM `{$table}` LIKE '{$column}'");

Problema: Embora real_escape_string seja usado, concatenação de strings em queries é um anti-pattern que pode levar a SQL injection em casos de edge-case ou modificações futuras.

Recomendação:

  • Migrar todas as queries dinâmicas para prepared statements
  • Usar whitelist para nomes de tabelas/colunas quando necessário

2.2.2 🔴 CRÍTICO: CORS Permissivo​

// backend/src/services/api/v1/kernel.php
header('Access-Control-Allow-Origin: ' . ($origin !== '' ? $origin : '*'));

Problema: O CORS aceita qualquer origem quando o header Origin está presente, refletindo-o diretamente.

Recomendação:

$allowedOrigins = ['https://app.gevtech.com.br', 'https://admin.gevtech.com.br'];
if (in_array($origin, $allowedOrigins, true)) {
header('Access-Control-Allow-Origin: ' . $origin);
}

2.2.3 🟡 MÉDIO: Variáveis Sensíveis em Logs​

// backend/config/database.php
backend_flow_log('db_connect_start', [
'host' => $dbConfig['host'],
'port' => $dbConfig['port'],
'database' => $dbConfig['database'],
]);

Problema: Informações de conexão são logadas, o que pode expor dados sensíveis.

Recomendação: Não logar informações de conexão em produção.

2.2.4 🟡 MÉDIO: Upload de Arquivos​

// backend/api/estabelecimentos/upload-documento.php
$tiposPermitidosArquivo = [
'doc' => ['application/msword', 'application/octet-stream'],
// ...
];

Problema: application/octet-stream é genérico e pode aceitar arquivos maliciosos.

Recomendação:

  • Remover application/octet-stream da whitelist
  • Implementar verificação de magic bytes adicional
  • Considerar antivírus/sandbox para uploads

2.2.5 🟡 MÉDIO: Credenciais em Variáveis Globais​

// backend/config/database.php
$GLOBALS['username'] = $dbConfig['username'];
$GLOBALS['password'] = $dbConfig['password'];

Problema: Credenciais armazenadas em $GLOBALS podem ser acessadas de qualquer lugar.

Recomendação: Remover ou encapsular em classe singleton com acesso controlado.

2.2.6 🟢 BAIXO: Ausência de Content Security Policy​

Problema: Não há headers CSP configurados, o que deixa a aplicação vulnerável a XSS.

Recomendação:

header("Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'");

2.2.7 🟢 BAIXO: Falta de Caractere Especial na Política de Senha​

Recomendação: Adicionar exigência de caractere especial:

if (!preg_match('/[!@#$%^&*(),.?":{}|<>]/', $password)) {
return ['valid' => false, 'message' => 'A senha deve conter pelo menos um caractere especial.'];
}

2.3 Matriz de Segurança​

CategoriaStatusNota
Autenticação✅8/10
Autorização (RBAC)✅9/10
Proteção CSRF✅10/10
Proteção SQLi⚠️7/10
Proteção XSS⚠️6/10
Gerenciamento de Sessão✅9/10
Rate Limiting✅8/10
Upload Seguro⚠️7/10
Headers de Segurança⚠️5/10
Logs e Auditoria✅8/10

Nota Geral de Segurança: 7.7/10


3. Qualidade de Código​

3.1 Pontos Fortes ✅​

3.1.1 Organização em Serviços​

O código está bem organizado em serviços por domínio:

services/
├── auth/ # Autenticação, sessão, CSRF
├── core/ # Permissões, logs, mail
├── usuarios/ # Gestão de usuários
├── estabelecimentos/ # Estabelecimentos e credenciamento
├── financeiro/ # Comissões, taxas, aluguéis
├── comercial/ # Leads, CRM
└── ...

3.1.2 Padrão de Resposta Consistente​

backend_success(['data' => $result], 'Operação realizada.');
backend_error('Mensagem de erro', 400);

3.1.3 Logging Estruturado​

backend_api_log('module', 'action', ['context' => 'data'], 'level');

3.1.4 Validação de Entrada​

if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
return ['status' => 'error', 'message' => 'Email inválido.'];
}

3.2 Problemas Identificados ⚠️​

3.2.1 🔴 Ausência de Testes Automatizados​

Problema: Não há suite de testes unitários ou de integração. Os únicos testes encontrados são de bibliotecas vendor.

Impacto:

  • Alto risco de regressões
  • Dificuldade de refatoração
  • Baixa confiança em deploys

Recomendação: Implementar PHPUnit com cobertura mínima de 70%.

3.2.2 🔴 Funções Muito Extensas​

// backend/src/services/comercial/leads_service.php
// Arquivo com 158.296 caracteres (3.400+ linhas)

Problema: Arquivos/funções muito grandes violam o princípio de responsabilidade única.

Recomendação:

  • Dividir em múltiplos arquivos menores
  • Extrair lógica para classes especializadas
  • Máximo recomendado: 200-300 linhas por arquivo

3.2.3 🟡 Código Procedural vs OOP​

Problema: O código mistura paradigmas procedural e OO sem padrão claro:

// Procedural
function backend_auth_login(mysqli $conn, string $email, string $password): array

// OO (Database singleton)
class Database { private static $instance = null; }

Recomendação: Migrar gradualmente para arquitetura OOP com:

  • Controllers
  • Services
  • Repositories
  • DTOs

3.2.4 🟡 Duplicação de Código​

Exemplos encontrados:

  • Validações de CSRF repetidas em múltiplos endpoints
  • Lógica de paginação duplicada
  • Verificações de permissão similares

Recomendação: Extrair para middleware/interceptors.

3.2.5 🟡 Falta de Type Hints Consistentes​

// Inconsistente
function getWhiteLabelId(mysqli $conn): mixed // OK
function garantirWhiteLabelNaSessao(mysqli $conn): mixed // Poderia ser ?int

Recomendação: Adicionar type hints em todas as funções:

function getWhiteLabelId(mysqli $conn): ?int

3.2.6 🟢 Nomenclatura Inconsistente​

// Mistura de convenções
backend_auth_login() // snake_case com prefixo
getWhiteLabelId() // camelCase
garantirMarcaWhiteLabelNaSessao() // português

Recomendação: Padronizar nomenclatura (sugestão: snake_case em português ou inglês consistente).

3.3 Métricas de Código​

MétricaValorIdeal
Arquivos PHP~1.600-
Complexidade Ciclomática MédiaAlta< 10
Cobertura de Testes0%> 70%
Duplicação Estimada~15-20%< 5%
Documentação PHPDocParcial100%
Type Hints~60%100%

Nota Geral de Qualidade: 6.5/10


4. Análise de Arquitetura​

4.1 Arquitetura Atual​

┌─────────────────────────────────────────────────────────────┐
│ APRESENTAÇÃO │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ PHP Templates │ │ JavaScript │ │
│ │ (dashboard/) │ │ (assets/js/) │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
├───────────┴────────────────────┴────────────────────────────┤
│ API │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ backend/api/ (REST-like) │ │
│ │ - /auth/ - /usuarios/ - /estabelecimentos/ │ │
│ │ - /v1/ - /financeiro/ - /comercial/ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
├──────────────────────────────────────────────────────────────┤
│ SERVIÇOS │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Auth │ │ Users │ │ Finance │ │ Leads │ │
│ │ Service │ │ Service │ │ Service │ │ Service │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ │ │ │ │ │
├───────┴─────────────┴─────────────┴─────────────┴───────────┤
│ PERSISTÊNCIA │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ MySQL/MariaDB (mysqli) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Google Drive API (Storage) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
├──────────────────────────────────────────────────────────────┤
│ INTEGRAÇÕES │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ PayUp │ │ Autentiq │ │ DataCorp │ │MovingPay │ │
│ │ API │ │ ue │ │ (KYC) │ │ (Adiq) │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└──────────────────────────────────────────────────────────────┘

4.2 Pontos Fortes da Arquitetura ✅​

  1. Separação de Responsabilidades: API, serviços e apresentação separados
  2. Multi-tenancy Bem Implementado: Isolamento por white_label_id
  3. Sistema de Permissões Robusto: RBAC com granularidade
  4. API Versionada: /api/v1/ permite evolução controlada
  5. Integração Desacoplada: Clientes de API em módulos separados

4.3 Problemas Arquiteturais ⚠️​

4.3.1 🔴 Acoplamento com MySQL​

Problema: Uso direto de mysqli em toda a aplicação sem abstração.

$conn = require dirname(__DIR__) . '/config/database.php';
$stmt = $conn->prepare('...');

Impacto:

  • Dificulta troca de banco de dados
  • Código de infraestrutura misturado com lógica de negócio
  • Queries repetidas

Recomendação: Implementar camada de Repository:

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

4.3.2 🔴 Ausência de Framework​

Problema: Aplicação PHP vanilla sem framework, resultando em:

  • Reinvenção de funcionalidades comuns
  • Falta de padronização
  • Maior superfície de vulnerabilidades

Recomendação: Considerar migração gradual para Laravel ou Symfony.

4.3.3 🟡 API Mista (Internal + Public v1)​

Problema: Duas APIs com estruturas diferentes:

  • backend/api/ - API interna (session-based)
  • backend/api/v1/ - API pública (token-based)

Recomendação: Unificar em uma única API RESTful com autenticação dual.

4.3.4 🟡 Falta de Caching​

Problema: Sem estratégia de cache implementada.

Recomendação:

  • Redis para cache de sessão e dados
  • Cache de queries frequentes
  • HTTP caching headers

4.3.5 🟡 Ausência de Filas/Jobs​

Problema: Processamento síncrono de tarefas pesadas (emails, integrações).

Recomendação: Implementar sistema de filas (Redis + Beanstalkd ou similar).

4.4 Diagrama de Melhorias Proposto​

┌───────────────────────────────────────────────────────────────┐
│ LOAD BALANCER │
│ (Nginx) │
└──────────────────────────┬────────────────────────────────────┘
│
┌──────────────────────────▼────────────────────────────────────┐
│ API GATEWAY │
│ - Rate Limiting - CORS - Auth - Logging │
└──────────────────────────┬────────────────────────────────────┘
│
┌──────────────────────────▼────────────────────────────────────┐
│ CAMADA DE APLICAÇÃO │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ Controllers │ │ Middleware │ │ Request Validation │ │
│ └──────┬──────┘ └──────┬──────┘ └──────────┬──────────┘ │
│ │ │ │ │
│ └────────────────┴─────────────────────┘ │
│ │ │
│ ┌───────────────────────▼─────────────────────────────────┐ │
│ │ SERVICES │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────────────┐ │ │
│ │ │ Domain │ │Application │ │ Infrastructure │ │ │
│ │ │ Services │ │ Services │ │ Services │ │ │
│ │ └────────────┘ └────────────┘ └────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────▼─────────────────────────────────┐ │
│ │ REPOSITORIES │ │
│ │ Interface-based │ Eloquent/Doctrine (futuro) │ │
│ └─────────────────────────────────────────────────────────┘ │
└───────────────────────────────────────────────────────────────┘
│
┌────────────────┼────────────────┐
│ │ │
┌─────────▼──────┐ ┌──────▼──────┐ ┌──────▼──────┐
│ MySQL │ │ Redis │ │ Google │
│ (Read/Write) │ │ (Cache) │ │ Drive │
└────────────────┘ └─────────────┘ └─────────────┘

5. Melhorias Recomendadas​

5.1 Segurança (Prioridade Alta)​

#MelhoriaEsforçoImpacto
S1Corrigir CORS para whitelist de origensBaixoAlto
S2Migrar todas queries para prepared statementsMédioAlto
S3Implementar CSP headersBaixoMédio
S4Remover credenciais de $GLOBALSBaixoMédio
S5Validação mais rigorosa de uploadsMédioAlto
S6Adicionar caractere especial na política de senhaBaixoBaixo
S7Implementar 2FA (Two-Factor Auth)AltoAlto

5.2 Qualidade de Código (Prioridade Média)​

#MelhoriaEsforçoImpacto
Q1Implementar suite de testes (PHPUnit)AltoCrítico
Q2Dividir arquivos grandes em módulosMédioAlto
Q3Padronizar nomenclaturaMédioMédio
Q4Adicionar type hints em todas funçõesMédioMédio
Q5Implementar PHPStan/Psalm level 6+MédioAlto
Q6Documentar todas as funções públicasMédioMédio
Q7Configurar CI/CD com GitHub ActionsMédioAlto

5.3 Arquitetura (Prioridade Médio-Longa)​

#MelhoriaEsforçoImpacto
A1Implementar camada RepositoryAltoAlto
A2Adicionar Redis para cacheMédioAlto
A3Implementar sistema de filasAltoAlto
A4Unificar APIs (interna + v1)AltoMédio
A5Migrar para framework (Laravel)Muito AltoAlto
A6Containerização (Docker)MédioAlto
A7Implementar health checksBaixoMédio

5.4 Frontend (Prioridade Baixa-Média)​

#MelhoriaEsforçoImpacto
F1Migrar JS para módulos ES6AltoMédio
F2Implementar bundler (Vite)MédioMédio
F3Padronizar componentes UIAltoAlto
F4Implementar testes E2E (Playwright)AltoAlto

6. Matriz de Risco​

IMPACTO
Baixo Médio Alto
┌────────┬────────┬────────┐
Alto │ │ │ S1,S2 │
│ │ │ S5,Q1 │
├────────┼────────┼────────┤
P Médio │ │ S3,S4 │ A1,A2 │
R │ │ Q5,A7 │ A3,A6 │
O ├────────┼────────┼────────┤
B Baixo │ S6 │ Q3,Q4 │ Q7,F3 │
│ │ Q6 │ F4 │
└────────┴────────┴────────┘

Legenda de Risco​

NívelDescriçãoAção
🔴 CríticoCORS, SQLi, TestesImediata
🟠 AltoCache, Filas, RepositorySprint atual
🟡 MédioCSP, Type hintsPróximos sprints
🟢 BaixoNomenclatura, DocsBacklog

7. Plano de Ação Priorizado​

Fase 1: Correções Críticas de Segurança (Imediato)​

  1. S1 - Corrigir CORS

    • Criar whitelist de origens permitidas
    • Implementar em backend/src/services/api/v1/kernel.php
  2. S2 - Auditoria de SQL

    • Revisar os 14 arquivos identificados com real_escape_string
    • Migrar para prepared statements
  3. S5 - Upload de Arquivos

    • Remover application/octet-stream da whitelist
    • Adicionar verificação de magic bytes

Fase 2: Qualidade e Observabilidade (1-2 meses)​

  1. Q1 - Suite de Testes

    • Configurar PHPUnit
    • Criar testes para services críticos (Auth, Users, Establishments)
    • Meta: 50% de cobertura inicial
  2. Q7 - CI/CD

    • GitHub Actions para testes
    • Lint (PHPStan) automático
    • Deploy automatizado
  3. A7 - Health Checks

    • Endpoint /health para monitoramento
    • Verificação de conexões (DB, Redis, APIs)

Fase 3: Arquitetura e Performance (2-4 meses)​

  1. A2 - Cache com Redis

    • Cache de sessões
    • Cache de queries frequentes
    • Rate limiting distribuído
  2. A1 - Camada Repository

    • Criar interfaces de repository
    • Migrar queries gradualmente
    • Facilitar testes unitários
  3. A3 - Sistema de Filas

    • Emails assíncronos
    • Integrações em background
    • Polling de credenciamento

Fase 4: Evolução Contínua (4+ meses)​

  1. A5 - Avaliação de Framework

    • POC com Laravel/Symfony
    • Migração gradual de módulos
    • Manter compatibilidade
  2. F3/F4 - Frontend Moderno

    • Componentização
    • Testes E2E
    • Bundler moderno

📋 Checklist de Implementação​

Segurança Imediata​

  • Corrigir CORS para whitelist
  • Auditar e corrigir uso de real_escape_string
  • Implementar CSP headers
  • Remover credenciais de $GLOBALS
  • Melhorar validação de uploads

Qualidade de Código​

  • Configurar PHPUnit
  • Criar primeiros testes unitários
  • Configurar PHPStan level 5
  • Criar GitHub Actions workflow
  • Padronizar type hints

Infraestrutura​

  • Documentar setup com Docker
  • Implementar health check endpoint
  • Configurar logs centralizados
  • Implementar métricas (Prometheus)

📚 Referências​


Última atualização: 15/09/2026
Próxima revisão: 15/10/2026