Compare commits

...
Author SHA1 Message Date
shadowdaoandClaude Sonnet 5.5 f0a737832c test: scale the cert-scripts subprocess timeout for emulated (non-x86) builds
HAProxy Manager Build and Push / Build-and-Push (push) Successful in 23m53s
With python:3.12-slim now a real multi-arch index, the arm64 leg really runs
the image gate under QEMU (~30x slower). test-cert-scripts.py took 229 s there
and its 200-iteration bash loop exceeded a flat 120 s timeout (CI run 5756),
and the whole arm64 step then hit its 30-minute ceiling (run 5758). x86 keeps
120 s; other machines get 900 s.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 20:20:48 -08:00
shadowdaoandClaude Sonnet 5.5 4cb4ad39f8 docs: nbthread comment names the real plumbing (lib-edge-container.sh)
HAProxy Manager Build and Push / Build-and-Push (push) Failing after 33m19s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 19:45:04 -08:00
shadowdaoandClaude Sonnet 5.5 8ab6fdcef0 feat: HAPROXY_NBTHREAD per-host thread-count knob (global nbthread, only when set)
HAProxy Manager Build and Push / Build-and-Push (push) Successful in 22m41s
2026-11-19 sdbees: with nbthread 4 a thread spun on a server lock held by a
TLS health-check thread stalled in a page fault under memory pressure ->
watchdog abort of the whole edge. nbthread 1 removes the failure class.

HAPROXY_NBTHREAD (container env, integer 1-64) renders `nbthread N` in the
global section ONLY when set. Unset/invalid = not rendered: every other host's
config is byte-identical to before (verified against main's template, with and
without Coraza). Invalid values are ignored with a warning, never rendered.

Tests: scripts/test-nbthread-knob.py (parse, render, unset byte-identity vs the
template minus the block, no cpu-map/thread-groups), run in the image build; real
haproxy -c of nbthread 1 (+SPOE+QUIC) and of a bad value in
validate-rendered-config.py. VERSION 2026.11.8 (with the arm64 base guard).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 19:30:07 -08:00
shadowdaoandClaude Sonnet 5.5 56404f4777 ci: refuse arm64 images that contain non-arm64 binaries (base-arch guard + ELF verification)
The in-house python:3.12-slim mirror tag was still a flattened amd64-only
manifest, so the linux/arm64 build ran on an amd64 base and published x86-64
binaries labelled arm64 (haproxy-manager-base:latest, :2026.11.6-rc).

- Dockerfile: fail the build when dpkg arch != TARGETARCH (no-op when correct)
- scripts/verify-image-arch.py (+ test): ELF e_machine of haproxy, bash, python,
  psutil .so per platform digest
- build-push.yaml: verify amd64 (fatal) and arm64 before assembling; an arm64
  mismatch is excluded from the tags and fails the job

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 18:27:39 -08:00
jknapp 3ce1dc8662 Merge pull request 'fix(wp-admin gate): exempt the WordPress install screens (setup-config.php, install.php)' (#21) from fix/wpadmin-gate-install-exempt into main
HAProxy Manager Build and Push / Build-and-Push (push) Successful in 14m39s
2026-11-20 02:20:38 +00:00
shadowdaoandClaude Sonnet 5.5 3eee8e6023 wp-admin gate: state the real residual risks of exempting the install screens
HAProxy Manager Build and Push / Build-and-Push (push) Successful in 10m50s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 16:47:16 -08:00
shadowdaoandClaude Sonnet 5.5 c91187aa85 fix(wp-admin gate): exempt the WordPress install screens (setup-config.php, install.php)
HAProxy Manager Build and Push / Build-and-Push (push) Successful in 16m35s
A fresh WordPress with no wp-config.php redirects every request to
/wp-admin/setup-config.php. The edge wp-admin gate bounced that cookieless
request to wp-login.php?redirect_to=/wp-admin/setup-config.php, which then
tripped CRS 930120 ("config.php" in ARGS:redirect_to) and showed the WAF
block page: manual installers never saw WordPress's setup screen.

New ACL wp_admin_install (path_end, exact /wp-admin/setup-config.php and
/wp-admin/install.php on the normalised path, case-sensitive) added as a
negated exclusion on the redirect rule. upgrade.php stays gated (only
logged-in users are sent there). Variants (.php.php, .phpx, case, path info,
inserted directory, dotdot/encoded escapes) stay gated; encoded separators
still deny.

Tests: the structural suite now pins the new ACL; new
test-wpadmin-gate-behaviour.py runs the real gate rules in the real haproxy
and sends raw requests (run by the image build). VERSION 2026.11.7.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 16:34:52 -08:00
jknapp 193d39e109 Merge pull request 'HAProxy 3.2 LTS edge image (default for all new deployments)' (#20) from feat/haproxy-upgrade into main
HAProxy Manager Build and Push / Build-and-Push (push) Successful in 9m40s
2026-11-17 21:07:33 +00:00
shadowdaoandClaude Sonnet 5.5 aebb68fe9d ci: make tag verification independent of buildx version
buildx v0.28.0 ignores `imagetools inspect --format '{{.Manifest.Digest}}'`
and prints the whole inspect text, so the verify step rejected every ref as a
"bad digest" (CI run 5381). Move the gate into scripts/verify-published-tags.sh:
the index digest is the sha256 of `inspect --raw`, cross-checked against the
anchored `Digest:` line and a bare --format output when present; platforms are
read from the raw JSON. All other checks (every tag in every registry, platform
match, one digest across registries, any miss fails) are unchanged. Adds an
offline test with a stub emulating 0.28 and 0.38 output.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-16 22:30:21 -08:00
16 changed files with 895 additions and 37 deletions

No files matched your search

+43 -24
View File
@@ -133,6 +133,29 @@ jobs:
PKG_CACHE=${{ steps.pkgcache.outputs.url }} PKG_CACHE=${{ steps.pkgcache.outputs.url }}
outputs: type=image,"name=repo.anhonesthost.net/cloud-hosting-platform/haproxy-manager-base,ghcr.io/shadowdao/haproxy-manager-base",push-by-digest=true,name-canonical=true,push=true outputs: type=image,"name=repo.anhonesthost.net/cloud-hosting-platform/haproxy-manager-base,ghcr.io/shadowdao/haproxy-manager-base",push-by-digest=true,name-canonical=true,push=true
# Per-platform ELF check BEFORE anything is tagged (2026-11-19: an "arm64"
# entry held x86-64 binaries). amd64 mismatch fails the job and publishes
# nothing. An arm64 mismatch (or a failed check) keeps arm64 OUT of the
# tags (amd64-only publish, as for a failed arm64 build) and the job is
# failed afterwards so it is not mistaken for a good multi-arch publish.
- name: Verify amd64 image binaries are amd64
env:
DIGEST: ${{ steps.amd64.outputs.digest }}
run: |
set -euo pipefail
python3 -I scripts/verify-image-arch.py "repo.anhonesthost.net/cloud-hosting-platform/haproxy-manager-base@${DIGEST}" amd64
- name: Verify arm64 image binaries are arm64
id: arm64check
if: steps.arm64.outcome == 'success'
continue-on-error: true
timeout-minutes: 10
env:
DIGEST: ${{ steps.arm64.outputs.digest }}
run: |
set -euo pipefail
python3 -I scripts/verify-image-arch.py "repo.anhonesthost.net/cloud-hosting-platform/haproxy-manager-base@${DIGEST}" arm64
# imagetools needs a NEW buildx. Same pinned, sha256-verified binary as # imagetools needs a NEW buildx. Same pinned, sha256-verified binary as
# mirror-base-image.yaml (kept identical on purpose). The assemble step # mirror-base-image.yaml (kept identical on purpose). The assemble step
# previously ran on whatever buildx the (possibly ephemeral) runner had # previously ran on whatever buildx the (possibly ephemeral) runner had
@@ -163,7 +186,8 @@ jobs:
BUILDKIT_PROGRESS: plain BUILDKIT_PROGRESS: plain
AMD64_DIGEST: ${{ steps.amd64.outputs.digest }} AMD64_DIGEST: ${{ steps.amd64.outputs.digest }}
ARM64_DIGEST: ${{ steps.arm64.outputs.digest }} ARM64_DIGEST: ${{ steps.arm64.outputs.digest }}
ARM64_OUTCOME: ${{ steps.arm64.outcome }} # success only if the build AND the ELF check succeeded (a skipped check = not verified = not attached)
ARM64_OUTCOME: ${{ steps.arm64check.outcome == 'success' && steps.arm64.outcome || 'unverified' }}
VERSION: ${{ steps.ver.outputs.version }} VERSION: ${{ steps.ver.outputs.version }}
TAGS: ${{ steps.tags.outputs.tags }} TAGS: ${{ steps.tags.outputs.tags }}
run: | run: |
@@ -199,26 +223,21 @@ jobs:
PLATFORMS: ${{ steps.assemble.outputs.platforms }} PLATFORMS: ${{ steps.assemble.outputs.platforms }}
run: | run: |
set -euo pipefail set -euo pipefail
repos="repo.anhonesthost.net/cloud-hosting-platform/haproxy-manager-base ghcr.io/shadowdao/haproxy-manager-base" # Version-independent digest logic lives in the script (tested by
want=$(printf '%s' "$PLATFORMS" | tr ',' '\n' | sort | tr '\n' ' ') # scripts/test-verify-published-tags.py); buildx 0.28 ignores --format.
ref_digest=""; ref_name=""; fail=0 export IMAGETOOLS="${BUILDX} imagetools"
for r in $repos; do tag_args=()
for t in $TAGS; do for t in $TAGS; do tag_args+=(--tag "$t"); done
ref="${r}:${t}" scripts/verify-published-tags.sh \
if ! d=$(timeout 90 $BUILDX imagetools inspect "$ref" --format '{{.Manifest.Digest}}' 2>&1); then --platforms "$PLATFORMS" \
echo "::error::MISSING or unreadable: ${ref}: ${d}"; fail=1; continue --repo repo.anhonesthost.net/cloud-hosting-platform/haproxy-manager-base \
fi --repo ghcr.io/shadowdao/haproxy-manager-base \
[[ "$d" =~ ^sha256:[0-9a-f]{64}$ ]] || { echo "::error::bad digest for ${ref}: ${d}"; fail=1; continue; } "${tag_args[@]}"
got=$(timeout 90 $BUILDX imagetools inspect "$ref" --format '{{range .Manifest.Manifests}}{{if ne .Platform.OS "unknown"}}{{.Platform.OS}}/{{.Platform.Architecture}}{{"\n"}}{{end}}{{end}}' | sort | tr '\n' ' ')
if [ "$got" != "$want" ]; then # Tags are already published (amd64-only) if arm64 failed verification; fail
echo "::error::platform mismatch for ${ref}: have [${got}] want [${want}]"; fail=1 # the job so that is visible instead of reading as a green multi-arch publish.
fi - name: Fail if arm64 was built but its binaries are not arm64
echo "ok ${ref} ${d} [${got}]" if: always() && steps.arm64.outcome == 'success' && steps.arm64check.outcome != 'success'
if [ -z "$ref_digest" ]; then ref_digest="$d"; ref_name="$ref" run: |
elif [ "$d" != "$ref_digest" ]; then echo "::error::arm64 image was built but failed the ELF architecture check; tags were published amd64-only (or not at all)"
echo "::error::digest mismatch: ${ref}=${d} vs ${ref_name}=${ref_digest}"; fail=1 exit 1
fi
done
done
[ "$fail" = 0 ] || { echo "::error::tag verification FAILED"; exit 1; }
echo "verified: ${TAGS} in both registries, digest ${ref_digest}, platforms ${PLATFORMS}"
+2
View File
@@ -14,6 +14,8 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
- **WAF body inspection**: `python3 scripts/test-waf-body-inspection.py` - offline (runs in the image build); pins `option http-buffer-request`, the `X-WHP-WAF-Body` complete/partial stamp (strip -> stamp -> SPOE -> strip), `tune.bufsize` against the 100 ms SPOE fail-open budget and the 65535-byte SPOP frame cap, and Coraza's body limits in `coraza-spoa/config.yaml`. Run it after touching the Coraza block, `tune.bufsize`, or the SPOE engine. - **WAF body inspection**: `python3 scripts/test-waf-body-inspection.py` - offline (runs in the image build); pins `option http-buffer-request`, the `X-WHP-WAF-Body` complete/partial stamp (strip -> stamp -> SPOE -> strip), `tune.bufsize` against the 100 ms SPOE fail-open budget and the 65535-byte SPOP frame cap, and Coraza's body limits in `coraza-spoa/config.yaml`. Run it after touching the Coraza block, `tune.bufsize`, or the SPOE engine.
- **Superseded-cert retirement**: covered by the same file (`TestRetirementRules`, `TestSanOverlapRetirement`). A new bundle retires any OTHER pem/lineage sharing ANY name (CN or SAN) with it - the pem moved to `cert-retired/`, the lineage's live+archive+renewal moved TOGETHER to `/etc/letsencrypt/retired/<stamp>/` (leaving archive/ behind makes certbot refuse the name forever), never deleted; the bundle's own `--cert-name` lineage is `live/<primary>` exactly and is never retired - unless that cert is still the only valid one for a name this edge serves (`retirement_blockers()`). `GET /api/capabilities` advertises this to WHP, which must not use whole-site re-bundling without it. Expired pems already in the crt dir are moved to `cert-retired/` by `cert_retire_expired_pems` (never the last pem, never `default_self_signed_cert.pem`). Expired lineages are never published (`cert_is_expired` in `cert-publish-lib.sh`, `leaf_is_expired()` in Python). Fixtures: `scripts/test-fixtures/san-certs/`. - **Superseded-cert retirement**: covered by the same file (`TestRetirementRules`, `TestSanOverlapRetirement`). A new bundle retires any OTHER pem/lineage sharing ANY name (CN or SAN) with it - the pem moved to `cert-retired/`, the lineage's live+archive+renewal moved TOGETHER to `/etc/letsencrypt/retired/<stamp>/` (leaving archive/ behind makes certbot refuse the name forever), never deleted; the bundle's own `--cert-name` lineage is `live/<primary>` exactly and is never retired - unless that cert is still the only valid one for a name this edge serves (`retirement_blockers()`). `GET /api/capabilities` advertises this to WHP, which must not use whole-site re-bundling without it. Expired pems already in the crt dir are moved to `cert-retired/` by `cert_retire_expired_pems` (never the last pem, never `default_self_signed_cert.pem`). Expired lineages are never published (`cert_is_expired` in `cert-publish-lib.sh`, `leaf_is_expired()` in Python). Fixtures: `scripts/test-fixtures/san-certs/`.
- **Multi-arch index assembly (coraza-spoa)**: `python3 scripts/test-assemble-multiarch-index.py` - offline (NOT run in the image build; it also reads `.gitea/workflows/build-push-coraza.yaml`); `scripts/assemble-multiarch-index.sh` turns the by-digest amd64 + arm64 pushes into the tag(s): arm64 is attached only if THIS run's arm64 step outcome is `success` (failure => amd64-only tag, never a stale arm64), a bad amd64 digest publishes nothing. `scripts/e2e-coraza-multiarch.sh` rehearses the whole thing against throwaway local registries (see coraza-spoa/README.md "Multi-arch"). - **Multi-arch index assembly (coraza-spoa)**: `python3 scripts/test-assemble-multiarch-index.py` - offline (NOT run in the image build; it also reads `.gitea/workflows/build-push-coraza.yaml`); `scripts/assemble-multiarch-index.sh` turns the by-digest amd64 + arm64 pushes into the tag(s): arm64 is attached only if THIS run's arm64 step outcome is `success` (failure => amd64-only tag, never a stale arm64), a bad amd64 digest publishes nothing. `scripts/e2e-coraza-multiarch.sh` rehearses the whole thing against throwaway local registries (see coraza-spoa/README.md "Multi-arch").
- **Publish verify gate**: `python3 scripts/test-verify-published-tags.py` - offline (needs `jq`; NOT run in the image build); `scripts/verify-published-tags.sh` is the last build-push.yaml step: every tag in every registry must resolve, carry the assembled platforms, and share ONE index digest. The digest is the sha256 of `imagetools inspect --raw` cross-checked against the text `Digest:` line / bare `--format` output (buildx 0.28 ignores `--format` and prints full text; CI run 5381).
- **Per-host thread count knob**: `python3 scripts/test-nbthread-knob.py` - runs in the image build; `HAPROXY_NBTHREAD` (container env, 1-64; invalid/unset = ignored) renders `nbthread N` in `global` ONLY when set, so every other host's config is byte-identical. Real `haproxy -c` of `nbthread 1` is the `nbthread-1` scenario in `scripts/validate-rendered-config.py`. WHP side: `/etc/whp/edge-nbthread` -> `lib-edge-container.sh` -> `docker run -e` at recreate.
- **Default splash**: `python3 scripts/test-default-splash.py` - offline (runs in the image build); unrouted hosts (server hostname, bare IP, unknown names) are answered by `http-request return ... file /haproxy/errors/default-splash.html` BEFORE the Coraza SPOE call, never for a routed host (`routed_hosts.list`/`routed_wildcards.list`, written by `generate_config()` from the routing rows and in the rollback set), never for ACME/blocked/suspended. Run it after touching the splash block, the routing ACL templates, or the domain loops in `generate_config()`. See README "Default Splash". - **Default splash**: `python3 scripts/test-default-splash.py` - offline (runs in the image build); unrouted hosts (server hostname, bare IP, unknown names) are answered by `http-request return ... file /haproxy/errors/default-splash.html` BEFORE the Coraza SPOE call, never for a routed host (`routed_hosts.list`/`routed_wildcards.list`, written by `generate_config()` from the routing rows and in the rollback set), never for ACME/blocked/suspended. Run it after touching the splash block, the routing ACL templates, or the domain loops in `generate_config()`. See README "Default Splash".
- **gunicorn access logging**: `python3 scripts/test-gunicorn-access-logging.py` - real gunicorn; :8080 has no access log, :8000 access goes to `/var/log/haproxy/api-access.log` (rotated by `scripts/gunicorn-access-rotate.py`), nothing per-request on stdout (journald rate-limit/Graylog flood), gunicorn errors stay on stderr. See docs/logging.md. Run after touching start-up.sh's gunicorn lines. - **gunicorn access logging**: `python3 scripts/test-gunicorn-access-logging.py` - real gunicorn; :8080 has no access log, :8000 access goes to `/var/log/haproxy/api-access.log` (rotated by `scripts/gunicorn-access-rotate.py`), nothing per-request on stdout (journald rate-limit/Graylog flood), gunicorn errors stay on stderr. See docs/logging.md. Run after touching start-up.sh's gunicorn lines.
- **Access log receiver**: `python3 scripts/test-access-log-receiver.py` - offline (runs in the image build); one datagram = one line (PRI stripped, control chars neutralised), size cap + gzip generations, write errors drop without raising, real UNIX-socket path. Run it after touching `haproxy-log-receiver.py` or the `log` line in `hap_header.tpl`. - **Access log receiver**: `python3 scripts/test-access-log-receiver.py` - offline (runs in the image build); one datagram = one line (PRI stripped, control chars neutralised), size cap + gzip generations, write errors drop without raising, real UNIX-socket path. Run it after touching `haproxy-log-receiver.py` or the `log` line in `hap_header.tpl`.
+13
View File
@@ -10,6 +10,17 @@
# Future improvement: a scheduled Gitea Action that does the above automatically. # Future improvement: a scheduled Gitea Action that does the above automatically.
FROM repo.anhonesthost.net/cloud-hosting-platform/python:3.12-slim FROM repo.anhonesthost.net/cloud-hosting-platform/python:3.12-slim
# Base-architecture guard. If the mirrored base tag is a single-platform
# (flattened amd64) manifest instead of a multi-arch index, buildx silently uses
# that amd64 base for a linux/arm64 build, every RUN below executes natively as
# x86-64, and the result is x86-64 binaries labelled arm64 (2026-11-19:
# haproxy-manager-base:latest). TARGETARCH is set by buildx (empty on the legacy
# builder, where the check is skipped). On a correct build this is a no-op.
ARG TARGETARCH
RUN if [ -n "${TARGETARCH}" ] && [ "$(dpkg --print-architecture)" != "${TARGETARCH}" ]; then \
echo "FATAL: base image is $(dpkg --print-architecture) but this build targets ${TARGETARCH}; the in-house python:3.12-slim mirror is not a multi-arch index (re-run mirror-base-image.yaml)" >&2; exit 1; \
fi
# image.source is what ghcr.io uses to link the package to a GitHub repo # image.source is what ghcr.io uses to link the package to a GitHub repo
# sidebar; pointing at the public GitHub mirror enables that linking. The # sidebar; pointing at the public GitHub mirror enables that linking. The
# canonical source-of-truth git remote is still Gitea, but Gitea's registry # canonical source-of-truth git remote is still Gitea, but Gitea's registry
@@ -147,9 +158,11 @@ RUN pip install -r requirements.txt
# The unit suites run here too. They had never run anywhere automated either, # The unit suites run here too. They had never run anywhere automated either,
# and they cost a few seconds. # and they cost a few seconds.
RUN python3 /haproxy/scripts/test-wpadmin-gate.py \ RUN python3 /haproxy/scripts/test-wpadmin-gate.py \
&& python3 /haproxy/scripts/test-wpadmin-gate-behaviour.py \
&& python3 /haproxy/scripts/test-trusted-proxy-gate.py \ && python3 /haproxy/scripts/test-trusted-proxy-gate.py \
&& python3 /haproxy/scripts/test-xmlrpc-rate-limit.py \ && python3 /haproxy/scripts/test-xmlrpc-rate-limit.py \
&& python3 /haproxy/scripts/test-default-splash.py \ && python3 /haproxy/scripts/test-default-splash.py \
&& python3 /haproxy/scripts/test-nbthread-knob.py \
&& python3 /haproxy/scripts/test-access-log-receiver.py \ && python3 /haproxy/scripts/test-access-log-receiver.py \
&& python3 /haproxy/scripts/test-haproxy-stderr-relay.py \ && python3 /haproxy/scripts/test-haproxy-stderr-relay.py \
&& python3 /haproxy/scripts/test-haproxy-supervisor.py \ && python3 /haproxy/scripts/test-haproxy-supervisor.py \
+1 -1
View File
@@ -1 +1 @@
2026.11.6 2026.11.8
+20
View File
@@ -3153,6 +3153,21 @@ def get_or_create_cluster_secret():
logger.error("Failed to get/create cluster-secret: %s", e) logger.error("Failed to get/create cluster-secret: %s", e)
return '' return ''
def parse_nbthread(raw):
"""HAPROXY_NBTHREAD -> int 1..64, or None (= do not render `nbthread`).
Fail-safe: anything that is not a plain positive integer in range is
IGNORED with a warning, never rendered, so a typo in a host file cannot
produce an invalid haproxy.cfg (which would be a total edge outage)."""
raw = (raw or '').strip()
if not raw:
return None
if not (raw.isascii() and raw.isdigit()) or not 1 <= int(raw) <= 64:
logger.warning(f"Ignoring HAPROXY_NBTHREAD={raw!r}: expected an integer 1-64")
return None
return int(raw)
def generate_config(): def generate_config():
try: try:
conn = sqlite3.connect(DB_FILE) conn = sqlite3.connect(DB_FILE)
@@ -3246,10 +3261,15 @@ def generate_config():
splash_raw = os.environ.get('HAPROXY_DEFAULT_SPLASH', '').strip().lower() splash_raw = os.environ.get('HAPROXY_DEFAULT_SPLASH', '').strip().lower()
default_splash = splash_raw not in ('0', 'false', 'no', 'off') default_splash = splash_raw not in ('0', 'false', 'no', 'off')
# Optional per-host thread count (global `nbthread`). Unset/invalid =
# not rendered = HAProxy's automatic choice, byte-identical config.
nbthread = parse_nbthread(os.environ.get('HAPROXY_NBTHREAD'))
# Add Haproxy Default Headers # Add Haproxy Default Headers
default_headers = template_env.get_template('hap_header.tpl').render( default_headers = template_env.get_template('hap_header.tpl').render(
cluster_secret = get_or_create_cluster_secret(), cluster_secret = get_or_create_cluster_secret(),
syslog_target = syslog_target, syslog_target = syslog_target,
nbthread = nbthread,
coraza_spoe_backend = coraza_spoe_backend, coraza_spoe_backend = coraza_spoe_backend,
) )
config_parts.append(default_headers) config_parts.append(default_headers)
+9 -2
View File
@@ -54,6 +54,7 @@ destructive there; see _cleanup_tmp().
""" """
import os import os
import platform
import re import re
import shutil import shutil
import stat import stat
@@ -63,6 +64,12 @@ import textwrap
import time import time
import unittest import unittest
# Subprocess ceiling. The arm64 image gate runs under QEMU (~30x slower: this
# file took 8 s natively and 229 s emulated, and the 200-iteration bash loop in
# test_validation_of_a_live_pem_being_republished_is_not_spurious then exceeded
# a flat 120 s, failing the arm64 leg of every build). Native x86 keeps 120 s.
SUBPROCESS_TIMEOUT = 120 if platform.machine() in ('x86_64', 'AMD64') else 900
MODULE_DIR = os.path.abspath( MODULE_DIR = os.path.abspath(
os.environ.get('HAPROXY_MANAGER_DIR', os.environ.get('HAPROXY_MANAGER_DIR',
os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')) os.path.join(os.path.dirname(os.path.abspath(__file__)), '..'))
@@ -379,7 +386,7 @@ class CertScriptFixture(unittest.TestCase):
path = os.path.join(SCRIPTS_DIR, name) path = os.path.join(SCRIPTS_DIR, name)
self.assertTrue(os.path.exists(path), f'{path} does not exist') self.assertTrue(os.path.exists(path), f'{path} does not exist')
return subprocess.run(['bash', path], env=self.env(**env_overrides), return subprocess.run(['bash', path], env=self.env(**env_overrides),
capture_output=True, text=True, timeout=120) capture_output=True, text=True, timeout=SUBPROCESS_TIMEOUT)
def bundle_is_valid(self, path): def bundle_is_valid(self, path):
"""Ask the shipped library whether HAProxy could use this bundle.""" """Ask the shipped library whether HAProxy could use this bundle."""
@@ -964,7 +971,7 @@ class TestCertPublishLibrary(CertScriptFixture):
['bash', '-c', ['bash', '-c',
'. "$1"; for i in $(seq 1 200); do cert_bundle_valid "$2" || exit 1; done', '. "$1"; for i in $(seq 1 200); do cert_bundle_valid "$2" || exit 1; done',
'_', LIB, self.live_pem], '_', LIB, self.live_pem],
env=self.env(), capture_output=True, text=True, timeout=120) env=self.env(), capture_output=True, text=True, timeout=SUBPROCESS_TIMEOUT)
_stop() _stop()
output = result.stdout + result.stderr output = result.stdout + result.stderr
+80
View File
@@ -0,0 +1,80 @@
#!/usr/bin/env python3
"""HAPROXY_NBTHREAD knob: parsing, rendering, and the unset-path invariant.
The invariant that matters: a host that does not set HAPROXY_NBTHREAD gets a
`global` section BYTE-IDENTICAL to what the image rendered before the knob
existed (HAProxy keeps choosing its own thread count). The real `haproxy -c`
of the `nbthread 1` shape is in scripts/validate-rendered-config.py.
python3 scripts/test-nbthread-knob.py
"""
import os
import re
import sys
import unittest
MODULE_DIR = os.path.abspath(
os.environ.get('HAPROXY_MANAGER_DIR',
os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')))
sys.path.insert(0, MODULE_DIR)
import haproxy_manager as hm # noqa: E402
def render(**kw):
return hm.template_env.get_template('hap_header.tpl').render(
cluster_secret='s', syslog_target='/log.sock',
coraza_spoe_backend=kw.pop('coraza_spoe_backend', None), **kw)
class ParseNbthread(unittest.TestCase):
def test_unset_and_blank(self):
for raw in (None, '', ' '):
self.assertIsNone(hm.parse_nbthread(raw))
def test_valid(self):
self.assertEqual(hm.parse_nbthread('1'), 1)
self.assertEqual(hm.parse_nbthread(' 4\n'), 4)
self.assertEqual(hm.parse_nbthread('64'), 64)
def test_invalid_is_ignored_never_rendered(self):
for raw in ('0', '65', '-1', 'abc', '1.5', '1 2', '1;x', '١', '0x4', '+2'):
self.assertIsNone(hm.parse_nbthread(raw), raw)
class Render(unittest.TestCase):
def test_unset_has_no_nbthread_at_all(self):
for kw in ({}, {'nbthread': None}, {'nbthread': 0}, {'coraza_spoe_backend': 'x:1'}):
self.assertNotIn('nbthread', render(**kw).replace('{{', ''), kw)
def test_unset_is_byte_identical_to_template_without_the_block(self):
src_path = os.path.join(MODULE_DIR, 'templates', 'hap_header.tpl')
with open(src_path) as fh:
src = fh.read()
stripped, n = re.subn(r'\{%- if nbthread %\}.*?\{%- endif %\}\n', '', src, flags=re.S)
self.assertEqual(n, 1, 'expected exactly one nbthread block in hap_header.tpl')
legacy = hm.template_env.from_string(stripped)
for coraza in (None, 'x:1'):
want = legacy.render(cluster_secret='s', syslog_target='/log.sock',
coraza_spoe_backend=coraza)
self.assertEqual(render(coraza_spoe_backend=coraza), want)
self.assertEqual(render(coraza_spoe_backend=coraza, nbthread=None), want)
def test_set_renders_one_directive_in_global_only(self):
out = render(nbthread=1)
self.assertEqual(len(re.findall(r'^\s*nbthread 1$', out, re.M)), 1)
glob = out.split('\nresolvers ', 1)[0]
self.assertIn('\n nbthread 1\n', glob)
self.assertLess(out.index('nbthread 1'), out.index('tune.ssl.default-dh-param'))
# nothing else changed: removing the directive restores the unset render
self.assertEqual(out.replace('\n nbthread 1', '', 1).count('nbthread 1'), 0)
def test_no_cpu_map_or_thread_groups_rendered(self):
for kw in ({}, {'nbthread': 1}):
out = '\n'.join(l for l in render(**kw).splitlines()
if not l.lstrip().startswith('#'))
for bad in ('cpu-map', 'thread-groups', 'nbtgroups'):
self.assertNotIn(bad, out)
if __name__ == '__main__':
unittest.main(verbosity=2)
+43
View File
@@ -0,0 +1,43 @@
#!/usr/bin/env python3
"""Tests scripts/verify-image-arch.py against a stub `docker` (no daemon needed)."""
import os, stat, subprocess, sys, tempfile, textwrap
HERE = os.path.dirname(os.path.abspath(__file__))
SCRIPT = os.path.join(HERE, "verify-image-arch.py")
fails = 0
def elf(machine):
return b"\x7fELF\x02\x01\x01" + b"\0" * 11 + machine.to_bytes(2, "little") + b"\0" * 40
def run(cfg_arch, file_arch, expect_rc, label, psutil_so=True):
global fails
with tempfile.TemporaryDirectory() as td:
stub = os.path.join(td, "docker")
with open(stub, "w") as f:
f.write(textwrap.dedent(f"""\
#!/usr/bin/env python3
import sys, os
a = sys.argv[1:]
E = {elf(file_arch)!r}
if a[0] == "image": print("{cfg_arch}")
elif a[0] == "create": print("cid1")
elif a[0] == "cp":
src, dst = a[-2], a[-1]
if src.endswith("/psutil"):
os.makedirs(dst)
if {psutil_so!r}: open(os.path.join(dst, "_psutil_linux.cpython-312.so"), "wb").write(E)
else: open(dst, "wb").write(E)
"""))
os.chmod(stub, os.stat(stub).st_mode | stat.S_IXUSR)
r = subprocess.run([sys.executable, "-I", SCRIPT, "ref@sha256:x", "arm64"],
env={"DOCKER": stub, "PATH": os.environ["PATH"]}, capture_output=True, text=True)
ok = r.returncode == expect_rc
print(("ok " if ok else "FAIL"), label, "rc=", r.returncode)
if not ok:
fails += 1; print(r.stdout, r.stderr)
run("arm64", 183, 0, "genuine arm64 passes")
run("arm64", 62, 1, "arm64-labelled x86-64 binaries (the 2026-11-19 bug) fail")
run("amd64", 183, 1, "wrong config architecture fails")
run("arm64", 183, 1, "missing compiled extension fails closed", psutil_so=False)
sys.exit(1 if fails else 0)
+193
View File
@@ -0,0 +1,193 @@
#!/usr/bin/env python3
"""Offline tests for scripts/verify-published-tags.sh (final publish gate).
CI run 5381 failed because buildx v0.28.0 ignores `--format '{{.Manifest.Digest}}'`
and prints the whole inspect text, while buildx 0.38 prints a bare digest. A stub
`imagetools` emulates BOTH output styles (plus `--raw`), so no registry or Docker
is needed. Held invariants:
- the 0.28-style (full text) and 0.38-style (bare digest) outputs both verify
- a reported digest that disagrees with the sha256 of the raw manifest fails
- a missing tag, a platform mismatch, or different digests across registries /
tags fail the job
- build-push.yaml's verify step uses the script, and release/* + rc-* tags
resolve to ONLY <version>-rc and <sha> (never latest)
Running: python3 scripts/test-verify-published-tags.py (needs jq)
"""
import hashlib
import json
import os
import re
import stat
import subprocess
import tempfile
import unittest
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SCRIPT = os.path.join(HERE, 'verify-published-tags.sh')
WORKFLOW = os.path.join(ROOT, '.gitea', 'workflows', 'build-push.yaml')
STUB = r'''#!/usr/bin/env python3
import hashlib, json, os, sys
a = sys.argv[1:]
mode = os.environ['STUB_MODE'] # v028 | v038
table = json.load(open(os.environ['STUB_TABLE'])) # ref -> {"raw": str, "lie": optional digest}
assert a[0] == 'inspect'
ref = [x for x in a[1:] if not x.startswith('-') and not x.startswith('{{')][0]
ent = table.get(ref)
if ent is None:
sys.stderr.write('ERROR: %s: not found\n' % ref); sys.exit(1)
raw = ent['raw'].encode() + (b'\n' if ent.get('nl') else b'')
digest = ent.get('lie') or 'sha256:' + hashlib.sha256(ent['raw'].encode()).hexdigest()
if '--raw' in a:
sys.stdout.buffer.write(raw); sys.exit(0)
if '--format' in a:
if mode == 'v038':
print(digest)
else: # 0.28: --format ignored, whole text printed
print('Name: ' + ref); print('MediaType: application/vnd.oci.image.index.v1+json')
print('Digest: ' + digest)
sys.exit(0)
print('Name: ' + ref)
print('MediaType: application/vnd.oci.image.index.v1+json')
print('Digest: ' + digest)
print(' ')
print('Manifests: ')
for m in json.loads(ent['raw'])['manifests']:
print(' Name: %s@%s' % (ref, m['digest']))
print(' Digest: sha256:' + 'f' * 64) # indented: must never be mistaken for the index digest
print(' Platform: %s/%s' % (m['platform']['os'], m['platform']['architecture']))
'''
def index(archs, salt=''):
ms = [{'mediaType': 'application/vnd.oci.image.manifest.v1+json',
'digest': 'sha256:' + hashlib.sha256((x + salt).encode()).hexdigest(), 'size': 1,
'platform': {'architecture': x, 'os': 'linux'}} for x in archs]
ms.append({'mediaType': 'application/vnd.oci.image.manifest.v1+json',
'digest': 'sha256:' + '7' * 64, 'size': 1,
'platform': {'architecture': 'unknown', 'os': 'unknown'},
'annotations': {'vnd.docker.reference.type': 'attestation-manifest'}})
return json.dumps({'schemaVersion': 2, 'mediaType': 'application/vnd.oci.image.index.v1+json',
'manifests': ms}, separators=(',', ':'))
REPOS = ['reg.one/a/img', 'reg.two/b/img']
TAGS = ['1.2-rc', 'abc123']
class VerifyTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.stub = os.path.join(self.tmp.name, 'stub')
open(self.stub, 'w').write(STUB)
os.chmod(self.stub, os.stat(self.stub).st_mode | stat.S_IEXEC)
self.table = os.path.join(self.tmp.name, 'table.json')
def tearDown(self):
self.tmp.cleanup()
def table_for(self, raw, **over):
t = {'%s:%s' % (r, g): {'raw': raw} for r in REPOS for g in TAGS}
for k, v in over.items():
ref = k.replace('__', ':').replace('_', '/', 0)
t[ref] = v
return t
def run_script(self, table, mode, platforms='linux/amd64,linux/arm64', tags=TAGS):
json.dump(table, open(self.table, 'w'))
args = [SCRIPT, '--platforms', platforms]
for r in REPOS:
args += ['--repo', r]
for t in tags:
args += ['--tag', t]
env = dict(os.environ, IMAGETOOLS=self.stub, STUB_MODE=mode, STUB_TABLE=self.table)
return subprocess.run(args, env=env, capture_output=True, text=True, timeout=60)
def test_buildx_028_full_text_output_verifies(self):
r = self.run_script(self.table_for(index(['amd64', 'arm64'])), 'v028')
self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
self.assertIn('verified:', r.stdout)
self.assertNotIn('bad digest', r.stdout)
def test_buildx_038_bare_digest_output_verifies(self):
r = self.run_script(self.table_for(index(['amd64', 'arm64'])), 'v038')
self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
def test_trailing_newline_on_raw_output_tolerated(self):
raw = index(['amd64', 'arm64'])
t = {'%s:%s' % (r, g): {'raw': raw, 'nl': True} for r in REPOS for g in TAGS}
self.assertEqual(self.run_script(t, 'v028').returncode, 0)
def test_amd64_only_publish_matches_platforms(self):
raw = index(['amd64'])
self.assertEqual(self.run_script(self.table_for(raw), 'v028', 'linux/amd64').returncode, 0)
r = self.run_script(self.table_for(raw), 'v028', 'linux/amd64,linux/arm64')
self.assertEqual(r.returncode, 1)
self.assertIn('platform mismatch', r.stdout)
def test_missing_tag_fails(self):
t = self.table_for(index(['amd64', 'arm64']))
del t['reg.two/b/img:abc123']
r = self.run_script(t, 'v038')
self.assertEqual(r.returncode, 1)
self.assertIn('MISSING', r.stdout)
def test_different_digest_across_registries_fails(self):
t = self.table_for(index(['amd64', 'arm64']))
t['reg.two/b/img:1.2-rc'] = {'raw': index(['amd64', 'arm64'], salt='other')}
for mode in ('v028', 'v038'):
r = self.run_script(t, mode)
self.assertEqual(r.returncode, 1, mode)
self.assertIn('digest mismatch', r.stdout)
def test_reported_digest_disagreeing_with_raw_manifest_fails(self):
t = self.table_for(index(['amd64', 'arm64']))
t['reg.one/a/img:1.2-rc']['lie'] = 'sha256:' + '0' * 64
for mode in ('v028', 'v038'):
r = self.run_script(t, mode)
self.assertEqual(r.returncode, 1, mode)
self.assertIn('cross-check FAILED', r.stdout)
def test_garbage_manifest_fails(self):
t = self.table_for('not json')
self.assertEqual(self.run_script(t, 'v038').returncode, 1)
class WorkflowTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
import yaml
cls.src = open(WORKFLOW).read()
cls.doc = yaml.safe_load(cls.src)
cls.steps = cls.doc['jobs']['Build-and-Push']['steps']
def step(self, name):
return [s for s in self.steps if s.get('name') == name][0]
def test_verify_step_uses_script_not_format_digest(self):
run = self.step('Verify published tags in every registry')['run']
self.assertIn('scripts/verify-published-tags.sh', run)
self.assertNotIn('{{.Manifest.Digest}}', run)
def test_run_blocks_are_valid_bash(self):
for s in self.steps:
if 'run' in s:
p = subprocess.run(['bash', '-n'], input=s['run'], text=True, capture_output=True)
self.assertEqual(p.returncode, 0, '%s: %s' % (s.get('name'), p.stderr))
def test_release_and_rc_never_publish_latest(self):
run = self.step('Resolve tags')['run']
m = re.search(r'refs/heads/release/\*\|refs/tags/rc-\*\)\s*\n\s*tags="([^"]*)"', run)
self.assertIsNotNone(m)
self.assertEqual(m.group(1), '${VERSION}-rc ${SHA}')
main = re.search(r'refs/heads/main\)\s*\n\s*tags="([^"]*)"', run)
self.assertIsNotNone(main)
self.assertEqual(main.group(1), 'latest ${VERSION} ${SHA}')
# latest appears in no other tag assignment
self.assertEqual(len(re.findall(r'tags="[^"]*latest', run)), 1)
if __name__ == '__main__':
unittest.main()
+226
View File
@@ -0,0 +1,226 @@
#!/usr/bin/env python3
"""BEHAVIOURAL test of the wp-admin edge gate against the REAL haproxy binary.
test-wpadmin-gate.py asserts on the TEXT of the rendered config. This file runs
the actual gate rules (extracted from the rendered hap_listener.tpl, not
re-typed) in a real haproxy and sends real requests, so the install-screen
exemption and its path-normalisation edge cases are measured, not inferred.
Only the exclusion ACLs that depend on the client address (is_local,
is_trusted_ip, is_whitelisted) are stubbed to never match: the test client is
127.0.0.1, which the real is_local would exempt wholesale. Everything else
(normalize-uri chain, wp_admin_* ACLs, deny rules, set-var, redirect) is the
production text.
A request that PASSES the gate gets 200 "ok" from a stub `http-request return`;
a gated one gets the edge 302 (Location: .../wp-login.php?redirect_to=...) or
the 403 deny.
Skips (exit 0, loud message) when no `haproxy` binary is on PATH. The Dockerfile
build has one, so the image build always runs it.
python3 scripts/test-wpadmin-gate-behaviour.py
"""
import os
import re
import shutil
import socket
import subprocess
import sys
import tempfile
import time
import unittest
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
os.environ.setdefault('HAPROXY_MANAGER_DIR', os.path.abspath(os.path.join(HERE, '..')))
import importlib.util # noqa: E402
_spec = importlib.util.spec_from_file_location(
'wpadmin_gate_tests', os.path.join(HERE, 'test-wpadmin-gate.py'))
gate = importlib.util.module_from_spec(_spec)
_spec.loader.exec_module(gate)
HAPROXY = shutil.which('haproxy')
# Code lines (comment-stripped) that make up the gate, in template order.
_KEEP = re.compile(
r'^(?:'
r'http-request normalize-uri '
r'|acl (?:has_wp_logged_in|wp_gate_exempt|wp_admin_\w+|path_has_encoded_sep) '
r'|http-request deny deny_status 403 if wp_admin'
r'|http-request set-var\(txn\.wp_login_url\) '
r'|http-request redirect code 302 location %\[var\(txn\.wp_login_url\)\]'
r')')
# (description, raw request path, extra header, expected status, location-prefix)
PASS, REDIR, DENY = 200, 302, 403
LOGIN = '/wp-login.php?redirect_to='
CASES = [
# --- the install/setup screens: exempt ------------------------------
('setup-config.php', '/wp-admin/setup-config.php', None, PASS, None),
('setup-config.php language step', '/wp-admin/setup-config.php?step=-1', None, PASS, None),
('install.php', '/wp-admin/install.php', None, PASS, None),
('install.php step 2', '/wp-admin/install.php?step=2', None, PASS, None),
('subdirectory install', '/blog/wp-admin/install.php', None, PASS, None),
('subdirectory setup-config', '/blog/wp-admin/setup-config.php', None, PASS, None),
# spellings that NORMALISE to the exempt path are the same request to the backend
('dotdot normalises to the exempt page', '/wp-admin/css/../setup-config.php', None, PASS, None),
('encoded dot normalises to the exempt page', '/wp-admin/setup-config%2Ephp', None, PASS, None),
('double slash merges to the exempt page', '//wp-admin/install.php', None, PASS, None),
# --- everything near them stays gated -------------------------------
('dashboard', '/wp-admin/', None, REDIR, LOGIN + '%2Fwp-admin%2F'),
('index.php', '/wp-admin/index.php', None, REDIR, LOGIN),
('upgrade.php is NOT exempt', '/wp-admin/upgrade.php', None, REDIR, LOGIN),
('plugins.php', '/wp-admin/plugins.php', None, REDIR, LOGIN),
('setup-config.php.php', '/wp-admin/setup-config.php.php', None, REDIR, LOGIN),
('setup-config.phpx', '/wp-admin/setup-config.phpx', None, REDIR, LOGIN),
('install.php.bak', '/wp-admin/install.php.bak', None, REDIR, LOGIN),
('case variant Setup-Config.php', '/wp-admin/Setup-Config.php', None, REDIR, LOGIN),
('case variant Install.php', '/wp-admin/Install.php', None, REDIR, LOGIN),
('upper-case dir WP-ADMIN', '/WP-ADMIN/install.php', None, REDIR, LOGIN),
('path info after the script', '/wp-admin/install.php/x', None, REDIR, LOGIN),
('trailing slash', '/wp-admin/install.php/', None, REDIR, LOGIN),
('inserted directory', '/wp-admin/evil/install.php', None, REDIR, LOGIN),
('inserted directory (setup-config)', '/wp-admin/x/setup-config.php', None, REDIR, LOGIN),
('dotdot climbs off the exempt page', '/wp-admin/install.php/../plugins.php', None, REDIR, LOGIN),
('asset dir dotdot to plugins.php', '/wp-admin/css/../plugins.php', None, REDIR, LOGIN),
('encoded slash separator', '/wp-admin%2Fsetup-config.php', None, DENY, None),
('encoded slash before wp-admin', '/blog%2Fwp-admin/install.php', None, DENY, None),
('backslash prefix (open redirect guard)', '/%5Cevil.example/wp-admin/plugins.php', None, DENY, None),
# --- identity still passes ------------------------------------------
('logged-in cookie on plugins.php', '/wp-admin/plugins.php',
'Cookie: wordpress_logged_in_abc=1', PASS, None),
]
def _free_port():
s = socket.socket()
s.bind(('127.0.0.1', 0))
port = s.getsockname()[1]
s.close()
return port
def _raw_get(port, path, header=None):
req = 'GET %s HTTP/1.1\r\nHost: site.example.com\r\nConnection: close\r\n' % path
if header:
req += header + '\r\n'
req += '\r\n'
with socket.create_connection(('127.0.0.1', port), timeout=5) as s:
s.sendall(req.encode('latin-1'))
buf = b''
while True:
chunk = s.recv(4096)
if not chunk:
break
buf += chunk
head = buf.split(b'\r\n\r\n', 1)[0].decode('latin-1')
lines = head.split('\r\n')
status = int(lines[0].split()[1])
loc = None
for ln in lines[1:]:
if ln.lower().startswith('location:'):
loc = ln.split(':', 1)[1].strip()
return status, loc
@unittest.skipUnless(HAPROXY, 'SKIP: no haproxy binary on PATH (the image build has one)')
class WpAdminGateBehaviour(unittest.TestCase):
@classmethod
def setUpClass(cls):
cfg = gate.render_listener()
lines = []
for raw in cfg.split('\n'):
stripped = raw.strip()
if not stripped or stripped.startswith('#'):
continue
code = stripped.split(' #', 1)[0].rstrip()
if _KEEP.match(code):
lines.append(code)
joined = '\n'.join(lines)
# Guard against a silently empty extraction: every moving part must be there.
for needle in ('normalize-uri path-strip-dotdot full', 'acl wp_admin_install',
'acl wp_admin_allowed', 'acl wp_admin_asset', 'acl wp_gate_exempt',
'acl has_wp_logged_in', 'acl path_has_encoded_sep',
'set-var(txn.wp_login_url)', 'http-request redirect code 302'):
assert needle in joined, 'extraction lost %r' % needle
cls.tmp = tempfile.mkdtemp(prefix='wpgate-behaviour-')
exempt = os.path.join(cls.tmp, 'exempt.list')
open(exempt, 'w').close()
joined = joined.replace('/etc/haproxy/wpadmin_gate_exempt.list', exempt)
cls.port = _free_port()
conf = '\n'.join([
'global',
' expose-experimental-directives',
' maxconn 100',
'defaults',
' mode http',
' timeout connect 2s',
' timeout client 5s',
' timeout server 5s',
'frontend gate',
' bind 127.0.0.1:%d' % cls.port,
# client-address exclusions stubbed: the real is_local would match 127.0.0.1
' acl is_local src 203.0.113.1',
' acl is_trusted_ip src 203.0.113.2',
' acl is_whitelisted src 203.0.113.3',
' ' + joined.replace('\n', '\n '),
' http-request return status 200 content-type text/plain string ok',
'',
])
cls.conf_path = os.path.join(cls.tmp, 'gate.cfg')
with open(cls.conf_path, 'w') as f:
f.write(conf)
chk = subprocess.run([HAPROXY, '-c', '-f', cls.conf_path],
capture_output=True, text=True)
assert chk.returncode == 0, 'haproxy -c rejected the gate:\n' + chk.stdout + chk.stderr
cls.proc = subprocess.Popen([HAPROXY, '-db', '-f', cls.conf_path],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
for _ in range(50):
try:
socket.create_connection(('127.0.0.1', cls.port), timeout=0.2).close()
break
except OSError:
time.sleep(0.1)
else:
raise AssertionError('haproxy did not start listening')
@classmethod
def tearDownClass(cls):
proc = getattr(cls, 'proc', None)
if proc:
proc.terminate()
try:
proc.wait(timeout=5)
except subprocess.TimeoutExpired:
proc.kill()
shutil.rmtree(getattr(cls, 'tmp', ''), ignore_errors=True)
def test_cases(self):
for desc, path, header, want, loc_prefix in CASES:
with self.subTest(desc=desc, path=path):
status, loc = _raw_get(self.port, path, header)
self.assertEqual(status, want, '%s: %s -> %s %s' % (desc, path, status, loc))
if loc_prefix is not None:
self.assertIsNotNone(loc, 'no Location header for ' + path)
self.assertTrue(loc.endswith(loc_prefix) or loc_prefix in loc,
'%s: Location %r' % (path, loc))
# redirect must stay same-origin (open-redirect guard)
self.assertTrue(loc.startswith('/') and not loc.startswith('//'), loc)
def test_nul_byte_after_exempt_name_is_not_exempt(self):
"""%00 is not an unreserved escape, so it is not decoded and the path no
longer ends in the exempt name. Anything but a pass-through is fine
(gated 302, or haproxy refusing the request)."""
status, _ = _raw_get(self.port, '/wp-admin/setup-config.php%00')
self.assertNotEqual(status, PASS)
if __name__ == '__main__':
unittest.main(verbosity=2)
+16 -3
View File
@@ -59,7 +59,7 @@ import haproxy_manager # noqa: E402
ALLOWLIST = ('/admin-ajax.php', '/admin-post.php', ALLOWLIST = ('/admin-ajax.php', '/admin-post.php',
'/load-styles.php', '/load-scripts.php') '/load-styles.php', '/load-scripts.php')
EXCLUSIONS = ('!wp_admin_allowed', '!wp_admin_asset', '!has_wp_logged_in', EXCLUSIONS = ('!wp_admin_allowed', '!wp_admin_install', '!wp_admin_asset', '!has_wp_logged_in',
'!wp_gate_exempt', '!is_local', '!is_trusted_ip', '!is_whitelisted') '!wp_gate_exempt', '!is_local', '!is_trusted_ip', '!is_whitelisted')
# The normalizer set, in the order it MUST render. Decoding has to precede the # The normalizer set, in the order it MUST render. Decoding has to precede the
@@ -220,10 +220,23 @@ class WpAdminGate(unittest.TestCase):
line = require_rule(self.cfg, 'acl wp_admin_asset', 'wp_admin_asset ACL') line = require_rule(self.cfg, 'acl wp_admin_asset', 'wp_admin_asset ACL')
self.assertRegex(line, r'path_reg.*\(css\|js\|images\)') self.assertRegex(line, r'path_reg.*\(css\|js\|images\)')
def test_install_php_is_NOT_allowlisted(self): def test_install_php_is_not_in_the_ajax_allowlist(self):
"""install.php is deliberately gated -- a takeover vector on abandoned installs.""" """install.php / setup-config.php live in their OWN ACL (wp_admin_install),
not in wp_admin_allowed, so the admin-ajax/asset allowlist stays minimal."""
line = require_rule(self.cfg, 'acl wp_admin_allowed', 'wp_admin_allowed ACL') line = require_rule(self.cfg, 'acl wp_admin_allowed', 'wp_admin_allowed ACL')
self.assertNotIn('install.php', line) self.assertNotIn('install.php', line)
self.assertNotIn('setup-config.php', line)
def test_install_screens_exempt_exactly_two_anchored_paths(self):
"""A fresh WordPress redirects every request to /wp-admin/setup-config.php
and a manual installer has no cookie. Exactly these two pages are exempt,
each anchored to /wp-admin/<file> (path_end, no regex, no wildcard).
upgrade.php is deliberately NOT exempt (logged-in only)."""
line = require_rule(self.cfg, 'acl wp_admin_install', 'wp_admin_install ACL')
self.assertEqual(line.split(None, 3)[2], 'path_end')
entries = line.split()[3:]
self.assertEqual(sorted(entries),
['/wp-admin/install.php', '/wp-admin/setup-config.php'])
def test_redirect_rule_has_all_exclusions(self): def test_redirect_rule_has_all_exclusions(self):
rule = require_rule_by_predicate( rule = require_rule_by_predicate(
+14 -1
View File
@@ -146,6 +146,17 @@ SCENARIOS = (
'HAPROXY_CORAZA_SPOE_BACKEND': '127.0.0.1:9000', 'HAPROXY_CORAZA_SPOE_BACKEND': '127.0.0.1:9000',
'HAPROXY_DEFAULT_SPLASH': 'off', 'HAPROXY_DEFAULT_SPLASH': 'off',
}), }),
# Per-host thread count knob: `nbthread 1` must parse next to everything
# else rendered (limited-quic, QUIC bind, SPOE, stats-file). A bad value
# must be IGNORED (not rendered), never reach haproxy.
('nbthread-1', {
'HAPROXY_SUSPENSION_ENABLED': 'true',
'HAPROXY_CORAZA_SPOE_BACKEND': '127.0.0.1:9000',
'HAPROXY_NBTHREAD': '1',
}),
('nbthread-bad', {
'HAPROXY_NBTHREAD': 'abc',
}),
) )
@@ -308,7 +319,7 @@ def render(scenario_name, env_overrides, workdir):
saved_env = {} saved_env = {}
for key in ('HAPROXY_SUSPENSION_ENABLED', 'HAPROXY_CORAZA_SPOE_BACKEND', for key in ('HAPROXY_SUSPENSION_ENABLED', 'HAPROXY_CORAZA_SPOE_BACKEND',
'HAPROXY_DEFAULT_SPLASH'): 'HAPROXY_DEFAULT_SPLASH', 'HAPROXY_NBTHREAD'):
saved_env[key] = os.environ.pop(key, None) saved_env[key] = os.environ.pop(key, None)
os.environ.update(env_overrides) os.environ.update(env_overrides)
@@ -342,6 +353,8 @@ def assert_scenario_branches(scenario_name, config_path, env_overrides):
'HAPROXY_CORAZA_SPOE_BACKEND' in env_overrides), 'HAPROXY_CORAZA_SPOE_BACKEND' in env_overrides),
'splash': ('file /haproxy/errors/default-splash.html', 'splash': ('file /haproxy/errors/default-splash.html',
env_overrides.get('HAPROXY_DEFAULT_SPLASH') != 'off'), env_overrides.get('HAPROXY_DEFAULT_SPLASH') != 'off'),
'nbthread': ('\n nbthread 1\n',
env_overrides.get('HAPROXY_NBTHREAD') == '1'),
} }
for label, (needle, should_be_present) in expected.items(): for label, (needle, should_be_present) in expected.items():
present = needle in text present = needle in text
+93
View File
@@ -0,0 +1,93 @@
#!/usr/bin/env python3
"""Verify that a per-platform image really contains binaries for that platform.
CI only (not copied into images' runtime use). Usage:
verify-image-arch.py <image-ref> <amd64|arm64>
Pulls <image-ref> (normally <repo>@sha256:<digest> of ONE platform, pushed by
digest and not yet tagged) with --platform linux/<arch>, never runs it, and
checks:
* the image config's architecture equals <arch>;
* the ELF e_machine of haproxy, bash, the python interpreter and every
compiled extension of the python stack (psutil *.so) equals <arch>.
Why: 2026-11-19, haproxy-manager-base:latest carried an "arm64" entry whose
binaries were all x86-64 (the in-house python:3.12-slim base was a flattened
amd64-only manifest, so the arm64 build silently ran on an amd64 base).
Manifest/config metadata said arm64; only the ELF headers told the truth.
Exit 0 = every checked file matches; non-zero = mismatch or could not check
(fail closed). Env DOCKER overrides the docker command (tests use a stub).
"""
import os
import shlex
import struct
import subprocess
import sys
import tempfile
EM = {"amd64": 62, "arm64": 183} # EM_X86_64, EM_AARCH64
EM_NAME = {62: "x86-64", 183: "aarch64", 40: "arm", 3: "i386"}
FILES = ["/usr/sbin/haproxy", "/bin/bash", "/usr/local/bin/python3.12"]
EXT_DIR = "/usr/local/lib/python3.12/site-packages/psutil" # compiled (_psutil_linux*.so)
def elf_machine(path):
"""e_machine of an ELF file, or None if it is not a little-endian ELF."""
with open(path, "rb") as f:
h = f.read(20)
if len(h) < 20 or h[:4] != b"\x7fELF":
return None
endian = "<" if h[5] == 1 else ">"
return struct.unpack(endian + "H", h[18:20])[0]
def docker(*args, check=True):
cmd = shlex.split(os.environ.get("DOCKER", "docker")) + list(args)
return subprocess.run(cmd, check=check, capture_output=True, text=True)
def main(argv):
if len(argv) != 3 or argv[2] not in EM:
print("usage: verify-image-arch.py <image-ref> <amd64|arm64>", file=sys.stderr)
return 2
ref, arch = argv[1], argv[2]
want = EM[arch]
bad = []
docker("pull", "--quiet", "--platform", f"linux/{arch}", ref)
cfg = docker("image", "inspect", ref, "--format", "{{.Architecture}}").stdout.strip()
print(f"{ref}: image config architecture={cfg} (expected {arch})")
if cfg != arch:
bad.append(f"config architecture {cfg!r}")
cid = docker("create", "--platform", f"linux/{arch}", ref).stdout.strip()
try:
with tempfile.TemporaryDirectory() as td:
for f in FILES:
dst = os.path.join(td, os.path.basename(f))
docker("cp", "-L", f"{cid}:{f}", dst)
m = elf_machine(dst)
print(f" {f}: {EM_NAME.get(m, m)}")
if m != want:
bad.append(f"{f} is {EM_NAME.get(m, m)}")
extdir = os.path.join(td, "psutil")
docker("cp", f"{cid}:{EXT_DIR}", extdir)
sos = sorted(os.path.join(extdir, n) for n in os.listdir(extdir) if n.endswith(".so"))
if not sos:
bad.append(f"no compiled extension found in {EXT_DIR}")
for so in sos:
m = elf_machine(so)
print(f" psutil/{os.path.basename(so)}: {EM_NAME.get(m, m)}")
if m != want:
bad.append(f"psutil/{os.path.basename(so)} is {EM_NAME.get(m, m)}")
finally:
docker("rm", cid, check=False)
if bad:
print(f"::error::{ref} is labelled linux/{arch} but: " + "; ".join(bad), file=sys.stderr)
return 1
print(f"OK: {ref} is genuinely {arch}")
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv))
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env bash
# Final publish gate: every <repo>:<tag> must resolve, carry exactly the
# platforms the assemble step reported, and have ONE index digest across all
# tags and all registries. Any miss or mismatch exits 1.
#
# verify-published-tags.sh --platforms linux/amd64,linux/arm64 \
# --repo <registry/path> [--repo ...] --tag <tag> [--tag ...]
#
# The index digest is computed in a buildx-VERSION-INDEPENDENT way. CI run 5381
# showed buildx v0.28.0 ignores `--format '{{.Manifest.Digest}}'` and prints the
# whole inspect text, while 0.38 prints a bare digest. So the digest comes from:
# 1. sha256 of the raw manifest bytes (`inspect --raw`) - always, authoritative
# (a content digest IS the sha256 of the manifest bytes);
# 2. the strictly anchored `Digest:` line of the default text output, if present;
# 3. the `--format '{{.Manifest.Digest}}'` output, ONLY if it is a bare digest
# (0.28's full-text output is ignored here, not an error).
# Every source that is available must agree, else the ref fails.
# Platforms are read from the raw JSON (also version independent).
#
# Env: IMAGETOOLS overrides the command (default "docker buildx imagetools");
# the CI step sets it to "$BUILDX imagetools"; the test suite uses a stub.
set -uo pipefail
IMAGETOOLS=${IMAGETOOLS:-docker buildx imagetools}
platforms=""; repos=(); tags=()
while [ $# -gt 0 ]; do
case "$1" in
--platforms) platforms=${2-}; shift 2 ;;
--repo) repos+=("${2-}"); shift 2 ;;
--tag) tags+=("${2-}"); shift 2 ;;
*) echo "verify-published-tags: unknown argument: $1" >&2; exit 2 ;;
esac
done
[ -n "$platforms" ] && [ ${#repos[@]} -gt 0 ] && [ ${#tags[@]} -gt 0 ] \
|| { echo "::error::verify-published-tags: --platforms, --repo and --tag are required"; exit 2; }
command -v jq >/dev/null || { echo "::error::verify-published-tags: jq is required"; exit 2; }
want=$(printf '%s' "$platforms" | tr ',' '\n' | sort | tr '\n' ' ')
work=$(mktemp -d); trap 'rm -rf "$work"' EXIT
digest_re='^sha256:[0-9a-f]{64}$'
ref_digest=""; ref_name=""; fail=0
for r in "${repos[@]}"; do
for t in "${tags[@]}"; do
ref="${r}:${t}"
raw="$work/raw"
if ! timeout 90 $IMAGETOOLS inspect --raw "$ref" >"$raw" 2>"$work/err" || [ ! -s "$raw" ]; then
echo "::error::MISSING or unreadable: ${ref}: $(head -c 300 "$work/err")"; fail=1; continue
fi
# Raw bytes as served, and with trailing newlines stripped (some buildx
# versions append one when printing); the content digest is one of the two.
h1="sha256:$(sha256sum <"$raw" | cut -d' ' -f1)"
h2="sha256:$(printf '%s' "$(cat "$raw")" | sha256sum | cut -d' ' -f1)"
# Source 2: strictly anchored top-level "Digest:" line of the text output.
textd=""
if timeout 90 $IMAGETOOLS inspect "$ref" >"$work/text" 2>/dev/null; then
mapfile -t lines < <(grep -E '^Digest:[[:space:]]+sha256:[0-9a-f]{64}[[:space:]]*$' "$work/text" | sed -E 's/^Digest:[[:space:]]+//; s/[[:space:]]+$//')
[ ${#lines[@]} -eq 1 ] && textd=${lines[0]}
fi
# Source 3: bare --format output, only when it really is a bare digest.
fmtd=""
if out=$(timeout 90 $IMAGETOOLS inspect "$ref" --format '{{.Manifest.Digest}}' 2>/dev/null); then
out=$(printf '%s' "$out" | tr -d '[:space:]')
[[ "$out" =~ $digest_re ]] && fmtd=$out
fi
d=""
for cand in "$textd" "$fmtd"; do
[ -n "$cand" ] || continue
if [ "$cand" != "$h1" ] && [ "$cand" != "$h2" ]; then
echo "::error::digest cross-check FAILED for ${ref}: reported ${cand}, raw manifest hashes to ${h1}"; fail=1; d="!"; break
fi
d=$cand
done
[ "$d" = "!" ] && continue
[ -n "$d" ] || d=$h2
[[ "$d" =~ $digest_re ]] || { echo "::error::bad digest for ${ref}: ${d}"; fail=1; continue; }
if [ -z "$textd$fmtd" ]; then
echo "::warning::no reported digest for ${ref}; using sha256 of the raw manifest"
fi
if ! got=$(jq -r '.manifests[]? | select(.platform.os != "unknown") | "\(.platform.os)/\(.platform.architecture)"' "$raw" 2>/dev/null | sort | tr '\n' ' '); then
echo "::error::unparseable manifest for ${ref}"; fail=1; continue
fi
if [ "$got" != "$want" ]; then
echo "::error::platform mismatch for ${ref}: have [${got}] want [${want}]"; fail=1
fi
echo "ok ${ref} ${d} [${got}]"
if [ -z "$ref_digest" ]; then ref_digest="$d"; ref_name="$ref"
elif [ "$d" != "$ref_digest" ]; then
echo "::error::digest mismatch: ${ref}=${d} vs ${ref_name}=${ref_digest}"; fail=1
fi
done
done
[ "$fail" = 0 ] || { echo "::error::tag verification FAILED"; exit 1; }
echo "verified: ${tags[*]} in ${#repos[@]} registries, digest ${ref_digest}, platforms ${platforms}"
+13
View File
@@ -40,6 +40,19 @@ global
user haproxy user haproxy
group haproxy group haproxy
daemon daemon
{%- if nbthread %}
# PER-HOST THREAD COUNT. Only emitted when HAPROXY_NBTHREAD is set on the
# container (WHP: /etc/whp/edge-nbthread -> lib-edge-container.sh -> docker run -e),
# so a host that does not set it renders byte-identically to before and
# HAProxy keeps choosing automatically (all CPUs in its affinity mask).
# Why a host would set 1: 2026-11-19 sdbees, thread 1 spun on a server
# lock held by a TLS health-check thread stalled in a page fault under
# memory pressure -> watchdog abort (whole edge down). With one thread
# there is no other lock holder, so the failure class cannot occur.
# Do NOT combine with cpu-map/thread-groups here: neither is rendered.
nbthread {{ nbthread }}
{%- endif %}
# SSL and Performance # SSL and Performance
tune.ssl.default-dh-param 2048 tune.ssl.default-dh-param 2048
+32 -6
View File
@@ -431,11 +431,36 @@ frontend web
# suffix matching (/blog/wp-admin/admin-ajax.php ends with # suffix matching (/blog/wp-admin/admin-ajax.php ends with
# /wp-admin/admin-ajax.php) while rejecting an inserted directory. # /wp-admin/admin-ajax.php) while rejecting an inserted directory.
# #
# install.php is DELIBERATELY NOT allowlisted. It is legitimately # The WordPress install/setup screens ARE exempt (wp_admin_install below):
# reachable without a cookie during a fresh install, but it is also a # exactly /wp-admin/setup-config.php and /wp-admin/install.php. A fresh
# standing scanner target and a real takeover vector on a site that was # WordPress with no wp-config.php redirects EVERY request to
# half-installed and then abandoned. Anyone genuinely installing uses the # /wp-admin/setup-config.php, and a person doing a manual install has no
# per-site exempt-list opt-out below instead. # cookie by definition -- gating those two pages bounced the installer to
# wp-login.php?redirect_to=/wp-admin/setup-config.php (a login form that
# can never succeed on a site with no database) and, worse, that URL then
# tripped CRS 930120 ("config.php" in ARGS:redirect_to) so the visitor saw
# the WAF block page instead of WordPress's own setup screen. WordPress
# itself refuses both once the site is installed (setup-config.php exits
# "wp-config.php already exists"; install.php shows "Already Installed"
# when the options table has siteurl), so the exemption exposes nothing on
# a finished site. RESIDUAL RISK (known tradeoff of exempting these two pages,
# requested 2026-11-19): (1) WordPress files present but NO wp-config.php
# (half upload, deleted by mistake, mid-restore/transfer): any visitor can
# run setup-config.php with their own database and then install.php, i.e.
# take the site over (admin -> plugin upload -> code execution). Scanners
# probe for exactly this. (2) A half-installed site (wp-config.php present,
# no tables, or a $table_prefix pointing at no tables) lets any visitor
# finish install.php?step=2 and choose the admin account. The old gate
# blocked cookieless scanners from both on edge-fronted sites (not a real
# defence: has_wp_logged_in only checks the cookie NAME, so a targeted
# attacker could always send one); WordPress itself never did.
# Matching is exact (path_end on the normalised path,
# case-sensitive): /wp-admin/setup-config.php.php, /wp-admin/Install.php,
# /wp-admin/install.php/x, /wp-admin/evil/install.php are all still gated.
# upgrade.php is NOT exempt: WordPress only sends logged-in users there
# (admin_init), and a logged-in user carries the cookie, so it needs no
# exemption. The install screens' CSS/JS come from the css|js|images dirs
# and load-styles.php / load-scripts.php, already allowed above.
# #
# Honors the same whitelist as every other rule in this frontend # Honors the same whitelist as every other rule in this frontend
# (RFC1918 / trusted_ips.list / trusted_ips.map), and a per-site opt-out # (RFC1918 / trusted_ips.list / trusted_ips.map), and a per-site opt-out
@@ -515,6 +540,7 @@ frontend web
# the intended "reject a literal backslash" semantics. # the intended "reject a literal backslash" semantics.
acl wp_admin_safe_path path_reg ^/[^/\\\\] acl wp_admin_safe_path path_reg ^/[^/\\\\]
acl wp_admin_allowed path_end /wp-admin/admin-ajax.php /wp-admin/admin-post.php /wp-admin/load-styles.php /wp-admin/load-scripts.php acl wp_admin_allowed path_end /wp-admin/admin-ajax.php /wp-admin/admin-post.php /wp-admin/load-styles.php /wp-admin/load-scripts.php
acl wp_admin_install path_end /wp-admin/setup-config.php /wp-admin/install.php
# The (?!.*\.php) lookahead is DEFENCE IN DEPTH, not the primary fix. This # The (?!.*\.php) lookahead is DEFENCE IN DEPTH, not the primary fix. This
# ACL grants an un-gated bypass to everything under wp-admin/css|js|images, # ACL grants an un-gated bypass to everything under wp-admin/css|js|images,
# and it used to anchor its prefix but not its suffix, so # and it used to anchor its prefix but not its suffix, so
@@ -589,7 +615,7 @@ frontend web
http-request deny deny_status 403 if wp_admin_word path_has_encoded_sep !has_wp_logged_in !wp_gate_exempt !is_local !is_trusted_ip !is_whitelisted http-request deny deny_status 403 if wp_admin_word path_has_encoded_sep !has_wp_logged_in !wp_gate_exempt !is_local !is_trusted_ip !is_whitelisted
http-request deny deny_status 403 if wp_admin_path !wp_admin_safe_path !has_wp_logged_in !wp_gate_exempt !is_local !is_trusted_ip !is_whitelisted http-request deny deny_status 403 if wp_admin_path !wp_admin_safe_path !has_wp_logged_in !wp_gate_exempt !is_local !is_trusted_ip !is_whitelisted
http-request set-var(txn.wp_login_url) path,regsub(/wp-admin/.*,/wp-login.php,i) if wp_admin_path http-request set-var(txn.wp_login_url) path,regsub(/wp-admin/.*,/wp-login.php,i) if wp_admin_path
http-request redirect code 302 location %[var(txn.wp_login_url)]?redirect_to=%[path,url_enc] if wp_admin_path wp_admin_safe_path !wp_admin_allowed !wp_admin_asset !has_wp_logged_in !wp_gate_exempt !is_local !is_trusted_ip !is_whitelisted http-request redirect code 302 location %[var(txn.wp_login_url)]?redirect_to=%[path,url_enc] if wp_admin_path wp_admin_safe_path !wp_admin_allowed !wp_admin_install !wp_admin_asset !has_wp_logged_in !wp_gate_exempt !is_local !is_trusted_ip !is_whitelisted
# IP blocking using map file (manual blocks only) # IP blocking using map file (manual blocks only)
# Map file format: /etc/haproxy/blocked_ips.map contains "<ip_or_cidr> 1" per line # Map file format: /etc/haproxy/blocked_ips.map contains "<ip_or_cidr> 1" per line