342 lines
14 KiB
Bash
342 lines
14 KiB
Bash
#!/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"
|
|
|
|
# Distinguish an unhealthy private proxy/Host route from a broken forwarder.
|
|
# The probing container shares ONLY the disposable proxy network namespace;
|
|
# no host-published port, credentials, response body or user HTTP query.
|
|
docker run --rm --network "container:$proxy_id" python:3.12-alpine \
|
|
python -c '
|
|
import http.client, sys
|
|
try:
|
|
conn = http.client.HTTPConnection("127.0.0.1", 80, timeout=9)
|
|
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)
|
|
sys.exit(1)
|
|
except (OSError, http.client.HTTPException):
|
|
print("OIDC_CI_PRIVATE_PROXY_SOCKET_OR_HTTP_BLOCKED", file=sys.stderr)
|
|
sys.exit(1)
|
|
print("ZITPLANE_OIDC_PRIVATE_PROXY_HOST_ROUTE_PASS")
|
|
'
|
|
|
|
# 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
|