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>

config/config.go

@@ -40,6 +40,7 @@ func (cfg *AppConfig) Setup() {
 		fmt.Println(err)
 		os.Exit(2)
 	}
+	cfg.VerificarSecretos()
 	cfg.Server.LoadPath()
 	cfg.View.Load(cfg.Server.Path)
 	cfg.Mail.View = &cfg.View
@@ -94,6 +95,8 @@ func (cfg *AppConfig) LoadComponents() {
 
 func (cfg *AppConfig) LoadStatic() {
 	cfg.Server.Static("/websocket", "./resources/views/websocket.html")
+	// El guard se registra antes que el estático para que corra primero.
+	cfg.Server.Use("/uploads", uploadsProtegidos)
 	cfg.Server.Static("/uploads", "./uploads", fiber.Static{
 		ByteRange: true,
 	})

config/secrets_check.go

@@ -0,0 +1,64 @@
+package config
+
+import (
+	"log"
+	"os"
+	"strings"
+)
+
+// Valores que estuvieron publicados en el repositorio y deben considerarse
+// comprometidos. Si siguen en uso, cualquiera que haya visto el repo puede
+// fabricarse una sesión de administrador o descifrar las contraseñas guardadas.
+const (
+	jwtAppComprometido = "SECRET_APP"
+	jwtApiComprometido = "SECRET_API"
+	appKeyComprometida = "1894cde6c936a294a478cff0a9227fd276d86df6573b51af5dc59c9064edf426"
+)
+
+// VerificarSecretos se ejecuta al arrancar. Los secretos JWT comprometidos
+// abortan el arranque (permiten suplantar a cualquier usuario y el único costo
+// de rotarlos es volver a iniciar sesión). La clave de cifrado solo advierte,
+// porque cambiarla invalida las contraseñas de integraciones ya guardadas y eso
+// requiere volver a capturarlas a mano desde el panel.
+func (cfg *AppConfig) VerificarSecretos() {
+	var criticos []string
+
+	if esSecretoDebil(cfg.Token.AppJwtSecret, jwtAppComprometido) {
+		criticos = append(criticos, "APP_JWT_SECRET")
+	}
+	if esSecretoDebil(cfg.Token.ApiJwtSecret, jwtApiComprometido) {
+		criticos = append(criticos, "API_JWT_SECRET")
+	}
+
+	if len(criticos) > 0 {
+		log.Printf("[SEGURIDAD] Los siguientes secretos siguen con el valor publicado en el repositorio: %s", strings.Join(criticos, ", "))
+		log.Printf("[SEGURIDAD] Con ese valor cualquiera puede firmarse una cookie de sesión y entrar como administrador.")
+		log.Printf("[SEGURIDAD] Define variables de entorno con valores nuevos y aleatorios antes de arrancar, por ejemplo:")
+		for _, nombre := range criticos {
+			log.Printf("[SEGURIDAD]   %s=$(openssl rand -hex 32)", nombre)
+		}
+		log.Fatalf("[SEGURIDAD] Arranque abortado para no exponer el sistema. Al rotarlos, las sesiones abiertas se cierran y hay que volver a iniciar sesión.")
+	}
+
+	if cfg.Server.Key == "" || cfg.Server.Key == appKeyComprometida {
+		log.Printf("[SEGURIDAD] APP_KEY tiene el valor por defecto publicado en el repositorio.")
+		log.Printf("[SEGURIDAD] Con esa clave, cualquiera con acceso a la base de datos puede descifrar las contraseñas SMTP y de integraciones.")
+		log.Printf("[SEGURIDAD] Define APP_KEY=$(openssl rand -hex 32) y vuelve a guardar las contraseñas de SMTP e integraciones desde el panel")
+		log.Printf("[SEGURIDAD] (al cambiar la clave, las contraseñas cifradas con la anterior dejan de poder descifrarse).")
+	}
+}
+
+// esSecretoDebil indica si el secreto está vacío o es el valor comprometido.
+func esSecretoDebil(valor, comprometido string) bool {
+	v := strings.TrimSpace(valor)
+	return v == "" || v == comprometido
+}
+
+// SecretoDesdeEntorno lee un secreto del entorno con un valor por defecto.
+// Se usa para credenciales que no deben vivir en config.yml.
+func SecretoDesdeEntorno(nombre, porDefecto string) string {
+	if v := strings.TrimSpace(os.Getenv(nombre)); v != "" {
+		return v
+	}
+	return porDefecto
+}

config/token.go

@@ -9,13 +9,16 @@ import (
 )
 
 type Token struct {
-	Hash         string `json:"token"`
-	Expire       int64  `mapstructure:"JWT_EXPIRE" json:"expires_in" yaml:"expires_in"`
-	AppJwtSecret string `mapstructure:"APP_JWT_SECRET" yaml:"app_jwt_secret"`
-	ApiJwtSecret string `mapstructure:"API_JWT_SECRET" yaml:"api_jwt_secret"`
+	Hash   string `json:"token"`
+	Expire int64  `mapstructure:"JWT_EXPIRE" json:"expires_in" yaml:"expires_in"`
+	// Los secretos JWT firman las cookies de sesión: si se filtran, cualquiera
+	// puede fabricarse una sesión de administrador válida. El tag env: permite
+	// definirlos por variable de entorno sin dejarlos escritos en config.yml.
+	AppJwtSecret string `mapstructure:"APP_JWT_SECRET" yaml:"app_jwt_secret" env:"APP_JWT_SECRET"`
+	ApiJwtSecret string `mapstructure:"API_JWT_SECRET" yaml:"api_jwt_secret" env:"API_JWT_SECRET"`
 }
 
-//CreateToken authenticates the user
+// CreateToken authenticates the user
 func (t *Token) CreateToken(c *fiber.Ctx, userID uint, secret string, expire ...int64) (*Token, error) {
 	token := jwt.New(jwt.SigningMethodHS256)
 
@@ -47,7 +50,7 @@ func (t *Token) CreateToken(c *fiber.Ctx, userID uint, secret string, expire ...
 	return t, nil
 }
 
-//ParseToken returns the users id or error
+// ParseToken returns the users id or error
 func (t *Token) ParseToken(c *fiber.Ctx, secret string) (uint, error) {
 	tokenString := c.Cookies("Verify-Rest-Token")
 
@@ -74,12 +77,12 @@ func (t *Token) ParseToken(c *fiber.Ctx, secret string) (uint, error) {
 	return uint(claims["id"].(float64)), nil
 }
 
-//DeleteToken deletes the jwt token
+// DeleteToken deletes the jwt token
 func (t *Token) DeleteToken(c *fiber.Ctx) {
 	c.ClearCookie("Verify-Rest-Token")
 }
 
-//RefreshToken refreshes the token
+// RefreshToken refreshes the token
 func (t *Token) RefreshToken(c *fiber.Ctx, secret string) (*Token, error) {
 	u, err := t.ParseToken(c, secret)
 

config/uploads_guard.go

@@ -0,0 +1,25 @@
+package config
+
+import "github.com/gofiber/fiber/v2"
+
+// UploadsGuard decide si una petición puede leer archivos de /uploads.
+// Se inyecta desde main.go porque el paquete config no puede importar pkg/auth
+// (sería una dependencia circular vía app). Se consulta en cada petición, no al
+// registrar la ruta, así que puede definirse después de cargar la configuración.
+//
+// Mientras esté en nil, /uploads queda cerrado: es preferible que un archivo no
+// cargue a que quede expuesto sin autenticación.
+var UploadsGuard func(*fiber.Ctx) bool
+
+// uploadsProtegidos bloquea el acceso anónimo a los archivos subidos.
+// Antes /uploads se servía como estático público: sabiendo (o adivinando) la
+// ruta se podía descargar el RUT de un cliente, una factura o un entregable sin
+// iniciar sesión. Los clientes del portal siguen usando los endpoints de
+// descarga dedicados, que además validan que el archivo les pertenezca.
+func uploadsProtegidos(c *fiber.Ctx) error {
+	if UploadsGuard != nil && UploadsGuard(c) {
+		return c.Next()
+	}
+	// 404 en vez de 401 para no confirmar si el archivo existe.
+	return c.Status(fiber.StatusNotFound).SendString("Not found")
+}