📊 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
- Visão Geral do Projeto
- Análise de Segurança
- Qualidade de Código
- Análise de Arquitetura
- Melhorias Recomendadas
- Matriz de Risco
- Plano de Ação Priorizado
1. Visão Geral do Projeto
1.1 Tecnologias Utilizadas
| Camada | Tecnologia |
|---|---|
| Backend | PHP 8.x (procedural/funcional) |
| Banco de Dados | MySQL/MariaDB (mysqli) |
| Frontend | PHP Templates + JavaScript vanilla |
| CSS Framework | Tailwind CSS 3.4 + DaisyUI 4.12 |
| Dependências PHP | Composer (PHPWord, DomPDF, Google API Client, Guzzle, Monolog) |
| Armazenamento | Google Drive API (documentos/arquivos) |
| Assinatura Digital | Autentique 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_labelrepresenta um tenant independente super-admintem 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-streamda 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
| Categoria | Status | Nota |
|---|---|---|
| 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étrica | Valor | Ideal |
|---|---|---|
| Arquivos PHP | ~1.600 | - |
| Complexidade Ciclomática Média | Alta | < 10 |
| Cobertura de Testes | 0% | > 70% |
| Duplicação Estimada | ~15-20% | < 5% |
| Documentação PHPDoc | Parcial | 100% |
| 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 ✅
- Separação de Responsabilidades: API, serviços e apresentação separados
- Multi-tenancy Bem Implementado: Isolamento por
white_label_id - Sistema de Permissões Robusto: RBAC com granularidade
- API Versionada:
/api/v1/permite evolução controlada - 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)
| # | Melhoria | Esforço | Impacto |
|---|---|---|---|
| S1 | Corrigir CORS para whitelist de origens | Baixo | Alto |
| S2 | Migrar todas queries para prepared statements | Médio | Alto |
| S3 | Implementar CSP headers | Baixo | Médio |
| S4 | Remover credenciais de $GLOBALS | Baixo | Médio |
| S5 | Validação mais rigorosa de uploads | Médio | Alto |
| S6 | Adicionar caractere especial na política de senha | Baixo | Baixo |
| S7 | Implementar 2FA (Two-Factor Auth) | Alto | Alto |
5.2 Qualidade de Código (Prioridade Média)
| # | Melhoria | Esforço | Impacto |
|---|---|---|---|
| Q1 | Implementar suite de testes (PHPUnit) | Alto | Crítico |
| Q2 | Dividir arquivos grandes em módulos | Médio | Alto |
| Q3 | Padronizar nomenclatura | Médio | Médio |
| Q4 | Adicionar type hints em todas funções | Médio | Médio |
| Q5 | Implementar PHPStan/Psalm level 6+ | Médio | Alto |
| Q6 | Documentar todas as funções públicas | Médio | Médio |
| Q7 | Configurar CI/CD com GitHub Actions | Médio | Alto |
5.3 Arquitetura (Prioridade Médio-Longa)
| # | Melhoria | Esforço | Impacto |
|---|---|---|---|
| A1 | Implementar camada Repository | Alto | Alto |
| A2 | Adicionar Redis para cache | Médio | Alto |
| A3 | Implementar sistema de filas | Alto | Alto |
| A4 | Unificar APIs (interna + v1) | Alto | Médio |
| A5 | Migrar para framework (Laravel) | Muito Alto | Alto |
| A6 | Containerização (Docker) | Médio | Alto |
| A7 | Implementar health checks | Baixo | Médio |
5.4 Frontend (Prioridade Baixa-Média)
| # | Melhoria | Esforço | Impacto |
|---|---|---|---|
| F1 | Migrar JS para módulos ES6 | Alto | Médio |
| F2 | Implementar bundler (Vite) | Médio | Médio |
| F3 | Padronizar componentes UI | Alto | Alto |
| F4 | Implementar testes E2E (Playwright) | Alto | Alto |
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ível | Descrição | Ação |
|---|---|---|
| 🔴 Crítico | CORS, SQLi, Testes | Imediata |
| 🟠 Alto | Cache, Filas, Repository | Sprint atual |
| 🟡 Médio | CSP, Type hints | Próximos sprints |
| 🟢 Baixo | Nomenclatura, Docs | Backlog |
7. Plano de Ação Priorizado
Fase 1: Correções Críticas de Segurança (Imediato)
-
S1 - Corrigir CORS
- Criar whitelist de origens permitidas
- Implementar em
backend/src/services/api/v1/kernel.php
-
S2 - Auditoria de SQL
- Revisar os 14 arquivos identificados com
real_escape_string - Migrar para prepared statements
- Revisar os 14 arquivos identificados com
-
S5 - Upload de Arquivos
- Remover
application/octet-streamda whitelist - Adicionar verificação de magic bytes
- Remover
Fase 2: Qualidade e Observabilidade (1-2 meses)
-
Q1 - Suite de Testes
- Configurar PHPUnit
- Criar testes para services críticos (Auth, Users, Establishments)
- Meta: 50% de cobertura inicial
-
Q7 - CI/CD
- GitHub Actions para testes
- Lint (PHPStan) automático
- Deploy automatizado
-
A7 - Health Checks
- Endpoint
/healthpara monitoramento - Verificação de conexões (DB, Redis, APIs)
- Endpoint
Fase 3: Arquitetura e Performance (2-4 meses)
-
A2 - Cache com Redis
- Cache de sessões
- Cache de queries frequentes
- Rate limiting distribuído
-
A1 - Camada Repository
- Criar interfaces de repository
- Migrar queries gradualmente
- Facilitar testes unitários
-
A3 - Sistema de Filas
- Emails assíncronos
- Integrações em background
- Polling de credenciamento
Fase 4: Evolução Contínua (4+ meses)
-
A5 - Avaliação de Framework
- POC com Laravel/Symfony
- Migração gradual de módulos
- Manter compatibilidade
-
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