#!/bin/sh # One-shot isolated Gitea runner ONLY. No public host port; no real user data. set -eu : "${GITHUB_RUN_ID:?Gitea run ID required}" case "$GITHUB_RUN_ID" in *[!0-9]*|'') echo 'OIDC_CI_INVALID_RUN_ID' >&2; exit 1;; esac project="zitplane-p05-$GITHUB_RUN_ID" network="zitplane-backend-dev-internal" secret_volume="zitplane-oidc-$GITHUB_RUN_ID-secrets" browser="zitplane-oidc-$GITHUB_RUN_ID-browser" forwarder="zitplane-oidc-$GITHUB_RUN_ID-loopback" marker=".p05-oidc-owned" dc() { docker compose --env-file .env -p "$project" \ -f deployment/docker/compose.backend.dev.yaml \ -f tests/ci/compose.portless.override.yaml \ -f tests/ci/oidc_e2e/compose.owner.override.yaml "$@" } docker --version docker compose version docker info --format '{{.Driver}}' >/dev/null echo ZITPLANE_OIDC_DOCKER_PREFLIGHT_PASS # Refuse to assume ownership of any preexisting name, fixed shared network, # credential or prior project; cleanup must not delete unowned resources. if [ -e .env ] || [ -e "$marker" ] || [ -e .p05-ci-owned ] || docker network inspect "$network" >/dev/null 2>&1 || docker volume inspect "$secret_volume" >/dev/null 2>&1 || docker container inspect "$browser" >/dev/null 2>&1 || docker container inspect "$forwarder" >/dev/null 2>&1 || [ -n "$(docker ps -a -q --filter "label=com.docker.compose.project=$project")" ] || [ -n "$(docker volume ls -q --filter "label=com.docker.compose.project=$project")" ]; then echo 'OIDC_CI_OWNERSHIP_PREFLIGHT_BLOCKED: existing state' >&2 exit 1 fi for v in "${project}_postgres-data" "${project}_zitadel-bootstrap"; do if docker volume inspect "$v" >/dev/null 2>&1; then echo OIDC_CI_PREEXISTING_VOLUME_BLOCKED >&2 exit 1 fi done # Mark only CI ownership after verifying a fresh checkout and NO Docker # resources. If env/config generation fails, cleanup deletes only our env. touch "$marker" python3 core/backend/zitadel/dev.py init python3 - <<'PY' from datetime import datetime, timedelta, timezone from pathlib import Path p = Path('.env') if not p.is_file(): raise SystemExit('Disposable env missing') expiration = (datetime.now(timezone.utc) + timedelta(hours=2)).strftime('%Y-%m-%dT%H:%M:%SZ') with p.open('a', encoding='utf-8') as out: out.write('OIDC_CI_PAT_EXPIRATION=' + expiration + '\n') p.chmod(0o600) PY dc config --quiet dc config --format json | python3 -c 'import json,sys; v=json.load(sys.stdin); assert set(v["services"])=={"postgres","zitadel-api","zitadel-login","proxy"}; assert not v["services"]["proxy"].get("ports"), "A public host port was configured"; assert v["services"]["zitadel-api"]["environment"]["ZITADEL_FIRSTINSTANCE_PATPATH"]=="/zitadel/bootstrap/oidc-ci-owner.pat"; print("ZITPLANE_OIDC_NO_PUBLISHED_PORT_AND_OWNER_CONFIG_PASS")' # Mark ownership only AFTER all preflight/config checks; always() cleanup knows it. touch .p05-ci-owned dc up -d --wait for name in postgres zitadel-api zitadel-login proxy; do cid="$(dc ps -q "$name")" [ -n "$cid" ] && [ "$(docker inspect -f '{{.State.Running}}' "$cid")" = true ] || { echo "OIDC_CI_SERVICE_NOT_RUNNING=$name" >&2; exit 1; } if [ "$name" != proxy ]; then [ "$(docker inspect -f '{{.State.Health.Status}}' "$cid")" = healthy ] || { echo "OIDC_CI_SERVICE_NOT_HEALTHY=$name" >&2; exit 1; } fi done echo ZITPLANE_OIDC_FOUR_SERVICES_READY_PASS proxy_id="$(dc ps -q proxy)" test -n "$proxy_id" bootstrap_volume="${project}_zitadel-bootstrap" # Classify the direct private proxy socket/HTTP route separately from the # forwarder BEFORE any ephemeral OIDC client/user or credential is created. # This probe shares ONLY the run-owned proxy network namespace. No published # host port, raw exception/log, URL, HTTP body, cookie or secret is printed. docker run --rm --network "container:$proxy_id" python:3.12-alpine \ python -c ' import errno import http.client import socket import sys import time transient = {"CONNECTION_REFUSED", "TIMEOUT", "CONNECTION_RESET"} for attempt in range(1, 4): conn = http.client.HTTPConnection("127.0.0.1", 80, timeout=9) try: conn.request("GET", "/debug/ready", headers={"Host": "localhost:8080"}) response = conn.getresponse() if response.status != 200: print("OIDC_CI_PRIVATE_PROXY_HOST_ROUTE_HTTP_STATUS=" + str(response.status), file=sys.stderr, flush=True) sys.exit(1) print("ZITPLANE_OIDC_PRIVATE_PROXY_HOST_ROUTE_PASS", flush=True) sys.exit(0) except (TimeoutError, socket.timeout): reason = "TIMEOUT" except ConnectionRefusedError: reason = "CONNECTION_REFUSED" except ConnectionResetError: reason = "CONNECTION_RESET" except http.client.HTTPException: reason = "HTTP_PROTOCOL_ERROR" except OSError as exc: reasons = { errno.ECONNREFUSED: "CONNECTION_REFUSED", errno.ETIMEDOUT: "TIMEOUT", errno.ECONNRESET: "CONNECTION_RESET", errno.ENETUNREACH: "NETWORK_UNREACHABLE", errno.EHOSTUNREACH: "NETWORK_UNREACHABLE", errno.EACCES: "PERMISSION_DENIED", errno.EPERM: "PERMISSION_DENIED", } reason = reasons.get(exc.errno, "SOCKET_OTHER") finally: try: conn.close() except OSError: pass print("OIDC_CI_PRIVATE_PROXY_PROBE_ATTEMPT=" + str(attempt) + " CLASS=" + reason, file=sys.stderr, flush=True) # Retry only known transient socket errors, never HTTP/protocol/policy. if reason not in transient or attempt == 3: break time.sleep(2) print("OIDC_CI_PRIVATE_PROXY_READINESS_BLOCKED_CLASS=" + reason, file=sys.stderr, flush=True) sys.exit(1) ' # P05-OIDC-04: inspect the run-owned proxy socket and PID namespace BEFORE # binding any forwarder. Print ONLY numeric inode/PID and sanitized comm, # never argv, env, credentials, raw logs, HTTP content or query strings. docker run --rm -i --network "container:$proxy_id" --pid "container:$proxy_id" \ python:3.12-alpine python - <<'PY' from pathlib import Path import os import re listeners = [] for family, filename in (("TCP4", "/proc/net/tcp"), ("TCP6", "/proc/net/tcp6")): try: rows = Path(filename).read_text(encoding="ascii").splitlines()[1:] except OSError: print("OIDC_CI_PROXY_PORT8080_SOCKET_TABLE_UNAVAILABLE=" + family, flush=True) continue for row in rows: parts = row.split() if len(parts) < 10: continue try: port = int(parts[1].rsplit(":", 1)[1], 16) except (ValueError, IndexError): continue if port == 8080 and parts[3] == "0A": listeners.append((family, parts[9])) if not listeners: print("OIDC_CI_PROXY_PORT8080_LISTENER=NONE", flush=True) for family, inode in listeners: owner = None for pid in (p for p in os.listdir("/proc") if p.isdecimal()): try: for fd in os.listdir("/proc/" + pid + "/fd"): try: if os.readlink("/proc/" + pid + "/fd/" + fd) == "socket:[" + inode + "]": owner = pid break except OSError: continue except OSError: continue if owner is not None: break comm = "UNKNOWN" if owner is not None: try: name = Path("/proc/" + owner + "/comm").read_text(encoding="ascii").strip() comm = re.sub(r"[^A-Za-z0-9_.-]", "_", name)[:32] or "UNKNOWN" except OSError: pass print("OIDC_CI_PROXY_PORT8080_LISTENER=" + family + " INODE=" + inode + " PID=" + (owner or "UNKNOWN") + " COMM=" + comm, flush=True) PY echo ZITPLANE_OIDC_PROXY_PREBIND_SOCKET_FORENSICS_PASS # Docker Hub alpine/socat has socat preinstalled, with an explicit versioned # published tag; no shell and no package installation during container start. # Resolve to a verified digest and run that IMMUTABLE digest, never latest. forwarder_tag="alpine/socat:1.8.1.3" docker pull "$forwarder_tag" >/dev/null entrypoint="$(docker image inspect --format '{{json .Config.Entrypoint}}' "$forwarder_tag")" if [ "$entrypoint" != '["socat"]' ]; then echo OIDC_CI_FORWARDER_PREBUILT_ENTRYPOINT_NOT_VERIFIED >&2 exit 1 fi forwarder_image="$(docker image inspect --format '{{index .RepoDigests 0}}' "$forwarder_tag")" case "$forwarder_image" in alpine/socat@sha256:*) echo ZITPLANE_OIDC_PINNED_FORWARDER_DIGEST_VERIFIED_PASS ;; *) echo OIDC_CI_FORWARDER_IMAGE_DIGEST_MISSING >&2; exit 1 ;; esac # The forwarder owns a separate private network namespace, not Traefik's. # The issuer remains localhost:8080; downstream private proxy DNS is proxy:80. # Provisioning and Chromium join the forwarder's namespace. The original # Compose, issuer, Host, browser and auth contract remain unchanged. docker create --name "$forwarder" \ --label "zitplane.oidc.run=$GITHUB_RUN_ID" \ --network "$network" "$forwarder_image" \ TCP-LISTEN:8080,bind=127.0.0.1,reuseaddr,fork TCP:proxy:80 >/dev/null docker start "$forwarder" >/dev/null forwarder_http_ready() { # No private HTTP contents or query parameters are printed. docker run --rm --network "container:$forwarder" python:3.12-alpine \ python -c ' import http.client conn = http.client.HTTPConnection("127.0.0.1", 8080, timeout=5) conn.request("GET", "/debug/ready", headers={"Host": "localhost:8080"}) assert conn.getresponse().status == 200 ' >/dev/null 2>&1 } # Bounded socat startup check. If it remains unreliable, switch once to the # official version/digest-pinned Python stdlib forwarder within THIS CI run. socat_ready=0 attempt=0 while [ "$attempt" -lt 3 ]; do attempt=$((attempt + 1)) state="$(docker inspect -f '{{.State.Status}}' "$forwarder")" if [ "$state" != running ]; then break fi if forwarder_http_ready; then socat_ready=1 break fi sleep 2 done if [ "$socat_ready" -ne 1 ]; then state="$(docker inspect -f '{{.State.Status}}' "$forwarder")" exitcode="$(docker inspect -f '{{.State.ExitCode}}' "$forwarder")" echo "OIDC_CI_SOCAT_DIAGNOSTIC_STATE=$state EXIT_CODE=$exitcode" # Only whitelisted error classifications, never raw docker logs. The # diagnostic container has NO test user/client/password/token access. docker logs "$forwarder" 2>&1 | python3 -c ' import sys data = sys.stdin.read(8192).lower() classes = ( ("ADDRESS_IN_USE", ("address already in use", "eaddrinuse")), ("PERMISSION_DENIED", ("permission denied", "eacces")), ("ADDRESS_OPTION_INVALID", ("unknown device/address", "unknown option", "wrong number of parameters")), ("SOCAT_ARGUMENT_COUNT", ("exactly 2 addresses required", "too many parameters")), ("SOCKET_BIND_ERROR", ("bind(", "cannot bind")), ("BINARY_RUNTIME_ERROR", ("exec format error", "not found")), ) reason = next((name for name, words in classes if any(s in data for s in words)), "UNCLASSIFIED") print("OIDC_CI_SOCAT_STARTUP_ERROR_CLASS=" + reason) ' || echo OIDC_CI_SOCAT_ERROR_CLASSIFIER_UNAVAILABLE label="$(docker inspect -f '{{ index .Config.Labels "zitplane.oidc.run" }}' "$forwarder")" if [ "$label" != "$GITHUB_RUN_ID" ]; then echo OIDC_CI_UNOWNED_FORWARDER_FALLBACK_REFUSED >&2 exit 1 fi docker rm -f "$forwarder" >/dev/null # Existing official python:3.12-alpine CI image is resolved to an immutable # registry SHA256 digest and runs ONLY the audited stdlib byte relay. python_forwarder_tag="python:3.12-alpine" docker pull "$python_forwarder_tag" >/dev/null python_forwarder_image="$(docker image inspect --format '{{index .RepoDigests 0}}' "$python_forwarder_tag")" case "$python_forwarder_image" in python@sha256:*|docker.io/library/python@sha256:*) echo ZITPLANE_OIDC_PYTHON_FORWARDER_IMAGE_DIGEST_VERIFIED_PASS ;; *) echo OIDC_CI_PYTHON_FORWARDER_DIGEST_MISSING >&2; exit 1 ;; esac docker create --name "$forwarder" \ --label "zitplane.oidc.run=$GITHUB_RUN_ID" \ --network "$network" "$python_forwarder_image" \ python -u /tmp/forwarder.py >/dev/null docker cp tests/ci/oidc_e2e/forwarder.py "$forwarder:/tmp/forwarder.py" docker start "$forwarder" >/dev/null echo ZITPLANE_OIDC_PYTHON_FORWARDER_FALLBACK_STARTED else echo ZITPLANE_OIDC_SOCAT_FORWARDER_READY_PASS fi # The SAME no-host-port status/Host contract applies to either forwarding # process. Never provision a client/user unless this proves HTTP 200. ready=0 attempt=0 while [ "$attempt" -lt 12 ]; do attempt=$((attempt + 1)) state="$(docker inspect -f '{{.State.Status}}' "$forwarder")" if [ "$state" != running ]; then exitcode="$(docker inspect -f '{{.State.ExitCode}}' "$forwarder")" echo "OIDC_CI_FORWARDER_NOT_RUNNING_STATE=$state EXIT_CODE=$exitcode" >&2 # Python diagnostic emits ONLY fixed error classes; never raw logs. docker logs "$forwarder" 2>&1 | python3 -c ' import sys s=sys.stdin.read(4096) for marker in ("OIDC_CI_PYTHON_FORWARDER_STARTUP_ADDRESS_IN_USE", "OIDC_CI_PYTHON_FORWARDER_STARTUP_PERMISSION_DENIED", "OIDC_CI_PYTHON_FORWARDER_STARTUP_ADDRESS_NOT_AVAILABLE", "OIDC_CI_PYTHON_FORWARDER_STARTUP_SOCKET_STARTUP_UNKNOWN"): if marker in s: print(marker) break else: print("OIDC_CI_FORWARDER_EXIT_REASON_UNCLASSIFIED") ' || true exit 1 fi if forwarder_http_ready; then ready=1 break fi sleep 2 done if [ "$ready" -ne 1 ]; then state="$(docker inspect -f '{{.State.Status}}' "$forwarder")" exitcode="$(docker inspect -f '{{.State.ExitCode}}' "$forwarder")" echo "OIDC_CI_FORWARDER_HTTP_NOT_READY_STATE=$state EXIT_CODE=$exitcode" >&2 docker run --rm --network "container:$forwarder" python:3.12-alpine \ python -c ' import http.client, sys try: conn = http.client.HTTPConnection("127.0.0.1", 8080, timeout=5) conn.request("GET", "/debug/ready", headers={"Host": "localhost:8080"}) print("OIDC_CI_FORWARDER_HTTP_STATUS=" + str(conn.getresponse().status), file=sys.stderr) except (OSError, http.client.HTTPException): print("OIDC_CI_FORWARDER_LISTENER_CONNECTION_BLOCKED", file=sys.stderr) ' || true exit 1 fi echo ZITPLANE_OIDC_PRIVATE_LOOPBACK_FORWARDER_READY_PASS docker volume create --name "$secret_volume" \ --label "zitplane.oidc.run=$GITHUB_RUN_ID" >/dev/null # Provisioning container only: holds ephemeral IAM_OWNER PAT READ-ONLY and # writes a CI-only client/user credential file to a separate short-lived volume. docker run --rm -i --network "container:$forwarder" \ -e "OIDC_CI_RUN_ID=$GITHUB_RUN_ID" \ --volume "$bootstrap_volume:/zitadel/bootstrap:ro" \ --volume "$secret_volume:/ci/secret" \ python:3.12-alpine python - < tests/ci/oidc_e2e/provision.py echo ZITPLANE_OIDC_DISPOSABLE_PROVISIONING_PASS # Copy only nonsecret repository app/source and test harness files into a # throwaway browser container. Docker cp does NOT depend on runner host paths. docker create --name "$browser" \ --label "zitplane.oidc.run=$GITHUB_RUN_ID" \ --network "container:$forwarder" \ --volume "$secret_volume:/ci/secret:ro" \ mcr.microsoft.com/playwright:v1.58.2-noble \ bash /tmp/oidc_e2e/browser.sh >/dev/null docker cp users/ui "$browser:/tmp/ui" docker cp tests/ci/oidc_e2e "$browser:/tmp/oidc_e2e" # Logs only safe named PASS/BLOCKED markers, never passwords/tokens/query URLs. docker start -a "$browser" exit_code="$(docker inspect -f '{{.State.ExitCode}}' "$browser")" if [ "$exit_code" != 0 ]; then echo 'ZITPLANE_OIDC_BROWSER_ACCEPTANCE_BLOCKED' >&2 exit 1 fi echo ZITPLANE_OIDC_REAL_BROWSER_ACCEPTANCE_PASS