fix: seguridad de pagos y accesos, integración PayPal y Coolify ampliado

Seguridad (crítico):
- Los webhooks de Bold y dLocal solo validaban la firma si el atacante la
  enviaba: sin cabecera se aceptaba cualquier payload. Ahora es obligatoria.
- GET /pago-exitoso marcaba contratos como pagados leyendo un query param del
  navegador. Ahora solo muestra estado; la confirmación la hace la verificación
  contra la API de la pasarela o el webhook firmado.
- /uploads se servía como estático público: se descargaban RUTs, facturas y
  entregables sabiendo la ruta. Ahora exige sesión.
- Los secretos JWT no se podían sobreescribir por entorno (faltaba el tag env:)
  y su valor estaba en el repo, permitiendo firmarse una sesión de admin. Ahora
  son configurables y el arranque se detiene si siguen con el valor publicado.
- .env y session.db salen del control de versiones.
- Query Runner, gestión de usuarios/roles/módulos y seeds quedan restringidos a
  administradores; antes bastaba con tener sesión.

Pasarelas de pago:
- dLocal generaba enlaces que nunca se reconciliaban: mandaba el ID numérico en
  vez de "contrato-N", la URL de retorno apuntaba a la API de dLocal y nunca se
  enviaba notification_url, así que su webhook jamás se disparaba.
- PayPal solo tenía pantalla de configuración. Se implementa el servicio
  completo (OAuth, orden, captura, verificación de webhook) y queda
  seleccionable como pasarela.
- La moneda estaba fija en COP: un contrato en USD generaba un cobro por esa
  cifra en pesos.

Contratos:
- pago_confirmado nunca volvía a false, así que el segundo ciclo de renovación
  no se cobraba aunque el cliente pagara. Se reinicia al generar enlace nuevo.
- Los contratos vencidos nunca cambiaban de estado y recibían correo a diario
  de forma indefinida; ahora se cierran tras 30 días de gracia.

Otros:
- Coolify: coolifyCall ignoraba el status HTTP y reportaba errores como éxito.
  El agente pasa de 10 a cobertura completa (servicios, bases de datos,
  variables de entorno, proyectos, equipos y recursos de servidor).
- SeedBalanceData ya no corre en cada arranque (recreaba transacciones
  borradas); ahora se invoca con SEED_BALANCE=1.
- Los seeds dejan de devolver permisos revocados en cada despliegue.
- Timeouts en las llamadas HTTP a Telegram y dLocal que podían colgarse.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

rest/controllers/api/bold_controller.go

@@ -29,12 +29,16 @@ func BoldWebhook(c *fiber.Ctx) error {
 	}
 
 	// ─── 2. Verificar firma HMAC ─────────────────────────────────────────────
+	// La firma es obligatoria: sin ella cualquiera podría enviar un
+	// "SALE_APPROVED" falso y marcar un contrato como pagado sin haber pagado.
 	signature := c.Get("x-bold-signature")
-	if signature != "" {
-		if !services.VerifyBoldSignature(rawBody, signature, cfg) {
-			log.Println("[BOLD] Webhook: firma inválida — descartado")
-			return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
-		}
+	if signature == "" {
+		log.Printf("[BOLD] Webhook rechazado: sin firma (IP %s)", c.IP())
+		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"ok": false, "error": "firma requerida"})
+	}
+	if !services.VerifyBoldSignature(rawBody, signature, cfg) {
+		log.Printf("[BOLD] Webhook rechazado: firma inválida (IP %s)", c.IP())
+		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"ok": false, "error": "firma inválida"})
 	}
 
 	// ─── 3. Parsear evento ───────────────────────────────────────────────────

rest/controllers/api/dlocal_controller.go

@@ -236,13 +236,17 @@ func DlocalWebhook(c *fiber.Ctx) error {
 		return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
 	}
 
-	// ─── 2. Verificar firma HMAC-SHA256 (opcional según config) ──────────────
+	// ─── 2. Verificar firma HMAC-SHA256 (obligatoria) ────────────────────────
+	// Sin firma cualquiera podría notificar un pago falso y marcar el contrato
+	// como pagado, así que se rechaza la petición en vez de aceptarla.
 	signature := c.Get("X-dLocal-Signature")
-	if signature != "" {
-		if !services.VerifyDlocalSignature(rawBody, signature, *cfg) {
-			log.Println("[DLOCAL] Webhook: firma inválida — descartado")
-			return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
-		}
+	if signature == "" {
+		log.Printf("[DLOCAL] Webhook rechazado: sin firma (IP %s)", c.IP())
+		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"ok": false, "error": "firma requerida"})
+	}
+	if !services.VerifyDlocalSignature(rawBody, signature, *cfg) {
+		log.Printf("[DLOCAL] Webhook rechazado: firma inválida (IP %s)", c.IP())
+		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"ok": false, "error": "firma inválida"})
 	}
 
 	// ─── 3. Parsear notificación ─────────────────────────────────────────────

rest/controllers/api/pago_controller.go

@@ -61,7 +61,11 @@ func PagoExitosoPage(c *fiber.Ctx) error {
 		}, "layouts/landing")
 	}
 
-	// Bold confirmó el pago directamente en la URL de retorno
+	// Bold dice en la URL de retorno que el pago fue aprobado.
+	// OJO: esto viene del navegador del usuario y es manipulable, así que NO se
+	// usa para marcar el contrato como pagado. Solo se registra el retorno; la
+	// confirmación real la hace verificarPago() contra la API de Bold / el
+	// webhook firmado, que son las únicas fuentes de verdad.
 	if boldTxStatus == "approved" {
 		// IP real (detrás de nginx)
 		ip := c.Get("X-Real-IP")
@@ -71,38 +75,42 @@ func PagoExitosoPage(c *fiber.Ctx) error {
 		if ip == "" {
 			ip = c.IP()
 		}
+
+		estado, fechaPago := verificarPago(ref)
+
+		estadoLog := "pendiente"
+		if estado {
+			estadoLog = "pagado"
+		}
 		_ = models.SaveBoldCallbackLog(models.BoldCallbackLog{
 			Referencia: ref, PaymentLink: paymentLink, Params: paramsJSON,
-			Estado: "pagado", IP: ip, UserAgent: string(c.Request().Header.UserAgent()),
+			Estado: estadoLog, IP: ip, UserAgent: string(c.Request().Header.UserAgent()),
 		})
-		// Marcar contrato si aún no está confirmado
-		var contratoID uint
-		if _, err := fmt.Sscanf(ref, "contrato-%d", &contratoID); err == nil && contratoID > 0 {
-			if ok, _ := models.MarcarContratoPagado(contratoID); ok {
-				go services.EnviarCorreoConfirmacionPago(contratoID, "bold")
-			}
-			// Enriquecer callback log: primero webhook log, luego Bold API directa
-			go func(linkID string) {
-				// 1. Si el webhook ya llegó, usar esos datos
-				if wLogs, err := models.GetBoldWebhookLogsByRef(ref); err == nil {
-					for _, wl := range wLogs {
-						if wl.PayerEmail != "" || wl.Monto > 0 {
-							models.EnrichBoldCallbackLog(ref, wl.PayerEmail, wl.Monto)
-							return
-						}
-					}
-				}
-				// 2. Fallback: consultar Bold API directamente para obtener el monto
-				if linkID != "" {
-					if boldCfg, err := models.GetBoldConfig(); err == nil {
-						if _, _, monto, err := services.CheckBoldLinkStatus(boldCfg, linkID); err == nil && monto > 0 {
-							models.EnrichBoldCallbackLog(ref, "", monto)
-						}
-					}
-				}
-			}(paymentLink)
+		if !estado {
+			log.Printf("[PAGO] Retorno con bold-tx-status=approved para %s pero la verificación contra Bold no lo confirma todavía", ref)
 		}
-		estado, fechaPago := verificarPago(ref)
+
+		// Enriquecer callback log: primero webhook log, luego Bold API directa
+		go func(linkID string) {
+			// 1. Si el webhook ya llegó, usar esos datos
+			if wLogs, err := models.GetBoldWebhookLogsByRef(ref); err == nil {
+				for _, wl := range wLogs {
+					if wl.PayerEmail != "" || wl.Monto > 0 {
+						models.EnrichBoldCallbackLog(ref, wl.PayerEmail, wl.Monto)
+						return
+					}
+				}
+			}
+			// 2. Fallback: consultar Bold API directamente para obtener el monto
+			if linkID != "" {
+				if boldCfg, err := models.GetBoldConfig(); err == nil {
+					if _, _, monto, err := services.CheckBoldLinkStatus(boldCfg, linkID); err == nil && monto > 0 {
+						models.EnrichBoldCallbackLog(ref, "", monto)
+					}
+				}
+			}
+		}(paymentLink)
+
 		return c.Render("pago_exitoso", fiber.Map{
 			"Ref": ref, "Estado": estado, "FechaPago": fechaPago,
 		}, "layouts/landing")

rest/controllers/api/paypal_controller.go

@@ -0,0 +1,102 @@
+package controllers
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/services"
+)
+
+// PaypalWebhook recibe las notificaciones de PayPal y confirma el pago del
+// contrato asociado.
+// Ruta: POST /webhooks/paypal
+//
+// La firma se verifica siempre contra la API de PayPal: sin eso cualquiera
+// podría enviar un "pago completado" falso y renovar un contrato sin pagar.
+func PaypalWebhook(c *fiber.Ctx) error {
+	rawBody := c.Body()
+
+	cfg, err := models.GetPaypalConfig()
+	if err != nil {
+		log.Println("[PAYPAL] Webhook: sin configuración activa")
+		return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
+	}
+
+	headers := map[string]string{
+		"paypal-auth-algo":         c.Get("Paypal-Auth-Algo"),
+		"paypal-cert-url":          c.Get("Paypal-Cert-Url"),
+		"paypal-transmission-id":   c.Get("Paypal-Transmission-Id"),
+		"paypal-transmission-sig":  c.Get("Paypal-Transmission-Sig"),
+		"paypal-transmission-time": c.Get("Paypal-Transmission-Time"),
+	}
+	if headers["paypal-transmission-id"] == "" || headers["paypal-transmission-sig"] == "" {
+		log.Printf("[PAYPAL] Webhook rechazado: sin cabeceras de firma (IP %s)", c.IP())
+		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"ok": false, "error": "firma requerida"})
+	}
+
+	valido, err := services.PaypalVerificarWebhook(cfg, headers, rawBody)
+	if err != nil {
+		log.Printf("[PAYPAL] Webhook: no se pudo verificar la firma: %v", err)
+		return c.Status(fiber.StatusServiceUnavailable).JSON(fiber.Map{"ok": false})
+	}
+	if !valido {
+		log.Printf("[PAYPAL] Webhook rechazado: firma inválida (IP %s)", c.IP())
+		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"ok": false, "error": "firma inválida"})
+	}
+
+	evento, err := services.ParsePaypalWebhook(rawBody)
+	if err != nil {
+		log.Printf("[PAYPAL] Webhook: %v", err)
+		return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
+	}
+
+	log.Printf("[PAYPAL] Webhook %s — evento=%s ref=%s recurso=%s",
+		evento.ID, evento.EventType, evento.Referencia, evento.ResourceID)
+
+	switch evento.EventType {
+	case "CHECKOUT.ORDER.APPROVED":
+		// El cliente aprobó el pago pero todavía no se cobró: hay que capturarlo.
+		if evento.ResourceID != "" {
+			if ok, err := services.PaypalCapturarOrden(cfg, evento.ResourceID); err != nil {
+				log.Printf("[PAYPAL] Error capturando la orden %s: %v", evento.ResourceID, err)
+				return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
+			} else if !ok {
+				log.Printf("[PAYPAL] La orden %s no quedó capturada todavía", evento.ResourceID)
+				return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
+			}
+		}
+	case "PAYMENT.CAPTURE.COMPLETED":
+		// El cobro ya se hizo efectivo: no hay nada que capturar.
+	default:
+		// Otros eventos (reembolsos, disputas, etc.) solo se registran.
+		return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
+	}
+
+	marcarContratoPagadoPorReferencia(evento.Referencia, "paypal")
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{"ok": true})
+}
+
+// marcarContratoPagadoPorReferencia confirma el pago del contrato codificado en
+// una referencia con formato "contrato-{id}".
+func marcarContratoPagadoPorReferencia(referencia, pasarela string) {
+	if referencia == "" {
+		log.Printf("[%s] Pago confirmado pero sin referencia de contrato: requiere conciliación manual", pasarela)
+		return
+	}
+	var contratoID uint
+	if _, err := fmt.Sscanf(referencia, "contrato-%d", &contratoID); err != nil || contratoID == 0 {
+		log.Printf("[%s] Referencia '%s' no corresponde a un contrato", pasarela, referencia)
+		return
+	}
+	ok, err := models.MarcarContratoPagado(contratoID)
+	if err != nil {
+		log.Printf("[%s] Error marcando contrato %d como pagado: %v", pasarela, contratoID, err)
+		return
+	}
+	log.Printf("[%s] Contrato %d marcado como pagado (nuevo=%v)", pasarela, contratoID, ok)
+	if ok {
+		go services.EnviarCorreoConfirmacionPago(contratoID, pasarela)
+	}
+}