// 1. CSP estricto en app-config.yaml
app:
  csp:
    default-src: ["'self'"]
    script-src: ["'self'", "'unsafe-eval'"]  # unsafe-eval solo si usas Monaco
    style-src: ["'self'", "'unsafe-inline'"] # Backstage lo necesita
    img-src: ["'self'", "data:", "https:"]
    connect-src: ["'self'"]
    frame-ancestors: ["'none'"]  # anti click-jacking

// 2. Habilitar SameSite=Strict y HttpOnly en cookies de sesión
backend:
  auth:
    providers:
      github:
        session:
          cookie:
            sameSite: 'strict'
            httpOnly: true
            secure: true

# app-config.yaml
permission:
  enabled: true
  policies:
    - name: 'scaffolder-template-admin'
      policy:
        permission:
          name: 'scaffolder-template-action'
          action: 'create'
        policy: 'only-admins'

# Script de auditoría
#!/usr/bin/env bash
set -e

TEMPLATE_DIR=$1
echo "Auditando templates en $TEMPLATE_DIR"

# Buscar ${{ secrets.* }} pasados a fetch:template
grep -rn 'fetch:template' "$TEMPLATE_DIR" | while read line; do
  if echo "$line" | grep -q 'secrets'; then
    echo "⚠️  PELIGRO: $line"
    echo "   fetch:template no debe recibir secrets"
  fi
done

# Buscar uso de fs:delete, debug:log, o ejecutables
for action in fs:delete debug:log run:command run:shell; do
  if grep -qr "$action" "$TEMPLATE_DIR"; then
    echo "⚠️  Acción peligrosa encontrada: $action"
  fi
done

echo "✓ Auditoría completa"

# GitOps para templates
# main → soft templates (auto-aprobadas)
# protected/ → solo con PR aprobada por un humano
catalog:
  locations:
    - type: url
      target: https://github.com/mi-empresa/templates/blob/main/approved/*.yaml
    - type: url
      target: https://github.com/mi-empresa/templates/blob/protected/dangerous/*.yaml
      rules:
        - allow: [User, Group]
          role: admin-only

// 1. Limitar el tamaño máximo de los catalog-info.yaml
// En tu processor de catalog, añadir:
processor.providers.push({
  supports: () => true,
  read: async (path) => {
    const stat = await fs.stat(path);
    if (stat.size > 1024 * 1024) { // 1MB
      throw new Error('catalog-info.yaml demasiado grande');
    }
    // ...
  },
});

# 2. Limitar quién puede registrar entidades
# Por defecto, todos los usuarios internos pueden
permission:
  enabled: true
  policies:
    - policy:
        permission: catalog-entity
        action: create
      policy: 'only-catalog-admins'

// 3. Limitar la frecuencia de refresh
catalog:
  providers:
    github:
      schedule:
        frequency: { minutes: 30 }  # No más frecuente
        timeout: { minutes: 5 }

# 1. Configurar el proxy de Backstage para bloquear redes internas
proxy:
  endpoints:
    '/gitlab/api':
      target: 'https://gitlab.internal.com'
      changeOrigin: true
      secure: true
      # El proxy SOLO se usa para esto
      # Cualquier otro path pasa al backend

// 2. Validar URLs de catalog providers
// No permitir file://, gopher://, etc.
const ALLOWED_PROTOCOLS = ['https:', 'http:'];

function validateProviderUrl(url: string) {
  const parsed = new URL(url);
  if (!ALLOWED_PROTOCOLS.includes(parsed.protocol)) {
    throw new Error(`Protocolo no permitido: ${parsed.protocol}`);
  }
  // Bloquear rangos privados si es un proxy
  if (parsed.hostname === 'localhost' || parsed.hostname.startsWith('127.')) {
    throw new Error('No se permite localhost en producción');
  }
}

# NetworkPolicy de Kubernetes para el pod de Backstage
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backstage-egress
  namespace: idp
spec:
  podSelector:
    matchLabels:
      app: backstage
  policyTypes:
    - Egress
  egress:
    # Permitir solo HTTPS saliente (catalog providers, Scaffolder actions)
    - to:
        - namespaceSelector: {}
      ports:
        - port: 443
          protocol: TCP
    # DNS obligatorio
    - to:
        - namespaceSelector: {}
      ports:
        - port: 53
          protocol: UDP

parameters:
  - title: API credentials
    properties:
      apiKey:
        type: string
        ui:field: Secret  # <-- Campo especial que oculta el valor
        ui:options:
          monospace: true

# app-config.yaml
scaffolder:
  defaultEnvironment:
    parameters:
      region: 'eu-west-1'
    secrets:
      AWS_ACCESS_KEY: ${AWS_ACCESS_KEY}  # se resuelve de process.env
      GITHUB_TOKEN: ${GITHUB_TOKEN}

steps:
  - id: deploy
    action: deploy:aws
    name: Deploy to AWS
    input:
      accessKey: ${{ secrets.AWS_ACCESS_KEY }}
      region: ${{ parameters.region }}

// Backend module que emite tokens de GitHub temporales
// @backstage/plugin-scaffolder-backend-module-github-token-exchange

import { createBackendModule } from '@backstage/backend-plugin-api';
import { githubAuthApiRef } from '@backstage/plugin-github-backend';

export const githubTokenModule = createBackendModule({
  pluginId: 'scaffolder',
  moduleId: 'github-token-exchange',
  register(env) {
    env.registerInit({
      deps: { github: githubAuthApiRef },
      async init({ github }) {
        scaffolder.addAction({
          name: 'github:token-exchange',
          handler: async (ctx) => {
            // El usuario está autenticado, intercambiamos su sesión
            // por un token de GitHub de 1 hora
            const { token } = await github.getAccessToken();
            return { output('githubToken', token) };
          },
        });
      },
    });
  },
});