Sau

Source-aware lab reference

The intended chain turns an exposed basket into a path to an internal web service, then turns a login field into shell syntax. The useful lesson is how those trust failures combine—and why this recreation's build and process settings cannot be taken for granted.

Request Baskets v1.2.1 checkoutSSRFMaltrail loginShell injectionDocker & SupervisorStatic source review
  1. 1. Public entry55555 · Request BasketsA visitor-created basket can forward requests to a chosen URL.
  2. 2. Boundary crossed127.0.0.1:80 · MaltrailThe forwarding request originates inside the container network.
  3. 3. Intended shell sinkPOST /login · usernameThe patcher tries to reintroduce a shell-backed logger; compatibility is conditional.
  4. 4. Process identity mattersSupervisor → container rootIf Maltrail starts, its service stanza does not drop privileges.
Intended chain, not a tested solve: SSRF → command injection → shell → privilege review. A successful vulnerable build would run the injection as container root already, bypassing the README's puma-to-root transition.

The lab in plain English

The project is configured to run two web services in one container. Request Baskets listens on port 55555, which Compose publishes to the host. Maltrail is configured for port 80, which is not published. An entrypoint firewall rule is intended to block non-loopback traffic to container port 80; its fallback binds Maltrail to loopback. A forwarding basket can request that internal URL and relay its response.

The second step depends on a deliberately vulnerable Maltrail patch. Its replacement string places the submitted username inside a command passed to subprocess.check_output(..., shell=True). If that replacement reaches a compatible login handler, failed login attempts can reach the shell without successful authentication. The Dockerfile, however, clones a moving upstream branch rather than the original v0.53 release.

The final README step assumes a puma shell followed by a journalctl pager escape. The checked-in Supervisor block omits user=puma. If the service starts under the supplied defaults, it runs as container root; a working injection would inherit that identity. Neither a root service nor a sudoers line proves that a particular exploit or pager route worked.

Three conditions the walkthrough does not establish

  • Compatible Maltrail source: the upstream revision inspected on 17 November 2026 uses syslog, not the subprocess logger expected by the patcher. Static comparison predicts a failed patch verification against that revision.
  • Correct first-stage identity: Maltrail is not configured to run as puma.
  • Usable pager path: journalctl is not explicitly installed, and secure-pager settings can disable shell escapes even if it is present.

See Lab build & boundaries for the evidence and conditions. No build was attempted.

Review scope: local source, the README and existing Sau PDF text extraction, plus public upstream source and documentation. No container, supplied script, payload, or generated HTML was executed. The README gives instructions and expected outcomes, not an independently verified runtime transcript.

What to notice first

  • The basket's network position differs from the external requester's position.
  • A proxied internal response proves a forwarding path, not command execution.
  • A source checkout and a displayed version label are different evidence. This build is expected to report Request Baskets' version as n/a.
  • Compose publishes only 55555, without an explicit localhost-only host bind.
  • Container root and host root are separate boundaries; this project defines no host-file mounts.

The central idea

Follow the destination, input interpretation, and process identity at every hop.

The central correction

The intended vulnerable image is not reproducibly pinned, and its puma-to-root ending is not supported by the supplied settings.

Show the bundled flag layout

The Compose default is a 32-character value. The entrypoint writes its first half to /home/puma/user.txt and its remaining half to /root/root.txt, with mode 0400 on both. The user file is assigned to puma; the root file is created by the root entrypoint. These are container paths, not mounted host files.

Default value from Sau/docker-compose.yml · not a recovered flag
0123456789abcdef0123456789abcdef

Custom values are split by length, not by a flag delimiter: for an odd length, the second half is one character longer. Change the default before sharing a running instance. The generated files and permissions have not been inspected at runtime.

How the chain works

Read against local source

The exploit path is a sequence of trust boundaries. Keep the browser-facing service, the internal HTTP request, and the shell process identity separate in your mental model.

1. The basket becomes a request proxy

The supplied command uses Request Baskets' default public mode: a visitor can create a basket with POST /api/baskets/{name}, including a forwarding configuration. Creation returns a basket token. Reading or updating an existing basket's configuration requires its token or the master token in the Authorization header; the weakness is not an unrestricted ability to reconfigure anyone else's basket.

Requests sent to /{name} or /{name}/login use the basket's collection/forwarding route, not its management API. forward_url chooses the destination, proxy_response relays its status, headers, and body, and expand_path appends the incoming path after the basket name. These field names and behaviors are checked against the v1.2.1 source, not supplied by the local README.

The basket acts as a confused deputy: a visitor controls where a request is made from the service's network context. CVE-2023-27163 covers Request Baskets SSRF through v1.2.1; the reviewed advisory identifies the management endpoint and affected range.

Illustrative configuration · fields verified in upstream v1.2.1
{
  "forward_url": "http://127.0.0.1:80/",
  "proxy_response": true,
  "expand_path": true
}
Incoming requestForwarded destinationWhat to distinguish
GET /study/GET http://127.0.0.1:80/The basket name is removed from the destination path.
POST /study/loginPOST http://127.0.0.1:80/loginMethod, body, and relevant headers are forwarded; form encoding still matters.
POST /api/baskets/studyNo forwarded login requestThis creates/configures the basket, rather than submitting a login.

These are source-derived mappings for the configuration above and a basket called study. With path expansion disabled, the destination stays at the configured URL. With response proxying disabled, the basket can forward asynchronously but return its own configured response: a plain HTTP 200 alone does not prove an internal service answered.

2. Login logging becomes command execution—if the patch fits

The patcher tries to match an older list-based logger call and replace it with the following literal string. The dangerous transition is not Base64 or a particular payload: it is attacker-controlled username becoming part of shell command source.

Sau/patch-maltrail.py · line 36, exact replacement assignment · not executed
new_code = 'subprocess.check_output("logger -p auth.info -t %s[%d] %s password for %s from %s port %s" % (NAME.lower(), os.getpid(), "Accepted" if valid else "Failed", params.get("username"), self.client_address[0], self.client_address[1]), stderr=subprocess.STDOUT, shell=True)'

If that call is installed in a reachable handler, shell metacharacters in the username can be interpreted while logging a failed attempt. Successful authentication is unnecessary; that does not mean the injection runs before every credential-checking statement. The logger's output is not returned as command output to the requester, so the intended injection is blind. A proxied page or a failed-login response does not independently prove it.

The bundled temp/exploit.py builds a reverse-shell command, encodes it as Base64, embeds it in backtick substitution, and invokes curl through os.system. Encoding is transport, not sanitization. The helper appends /login to its supplied target URL, does not create a forwarding basket, and does not start the receiving listener. It is executable exploit code, read only for this review.

Version label versus actual source

The patcher's VERSION = "0.53" substitution does not check out Maltrail v0.53 or verify the login sink. Its fallback broadly replaces shell=False); its final check only searches for shell=True anywhere in core/httpd.py. That substring is not proof of a reachable, unsanitized username sink. The build page records why the inspected upstream revision does not match.

The Dockerfile's CVE-2023-27163 comment belongs to Request Baskets. The CVE-2025-34073 record describes unauthenticated Maltrail username command injection through v0.54; it does not validate this unpinned recreation.

3. The process user determines impact

The command inherits the effective identity of the Maltrail process. The project creates puma and grants it passwordless /usr/bin/journalctl, but neither the Dockerfile nor the Maltrail service stanza selects that account for startup. The root entrypoint launches Supervisor without a privilege drop. If Maltrail starts with these defaults, it therefore runs as container root.

A working injection would already cross the intended puma privilege stage. For a genuinely unprivileged Maltrail service, the README's pager route remains conditional on executable availability, effective sudo policy, journal/output availability, an interactive terminal, and pager security. See the pager conditions; do not equate less being selected with shell escapes being enabled.

Trust-boundary map

HopTrust decisionEvidence and limit
External requester → basketAllow public basket creationCompose publishes 55555; upstream public mode is the supplied command's default. Management of existing baskets still uses tokens.
Basket → internal URLAccept a client-selected forwarding targetv1.2.1 source preserves the method/body and can proxy the response; Maltrail still needs to be listening.
HTTP form → shellInterpret username as command syntaxThe patcher's replacement contains the sink; successful application and reachability are not established.
Service → container filesRun the handler with broad privilegesStartup does not drop root; flag paths belong to the container filesystem.
Container → hostA separate isolation boundaryNo host-file mounts are defined. Container-root command execution alone does not establish host-root access.

Lab build & boundaries

Configuration review

Check whether the intended image can be built before reasoning about a shell. A version label, service stanza, and sudo rule each establish something different.

A pinned basket checkout, not a stamped version

The Dockerfile checks out Request Baskets v1.2.1 but builds it without version linker flags. Upstream version.go initializes GitVersion, GitCommit, and GitCommitShort to n/a; its build script normally supplies those values using -ldflags. Thus /api/version is expected to identify the product but report n/a for version/commit under this build. That is a static prediction, not an observed response.

Sau/Dockerfile · lines 28–31 · source excerpt, not run
    git clone --depth 1 --branch v1.2.1 https://github.com/darklynx/request-baskets.git /tmp/request-baskets && \
    mkdir -p /opt/request-baskets && \
    cd /tmp/request-baskets && \
    go build -o /opt/request-baskets/request-baskets . && \

Maltrail is unpinned and the patch is format-dependent

Sau/Dockerfile:37 uses a shallow clone without a branch, tag, or commit pin. The patcher expects a particular older logger call in core/httpd.py. At inspected upstream commit 1058820d89763fd7e1ee9a1b9572bbad53b55002 (17 November 2026 review), authentication logging instead calls Python's syslog module and sanitizes the username.

Upstream core/httpd.py · lines 1913–1922 at the inspected commit · excerpt
            username = _sanitize_auth_field(username)
            ip, port = self.client_address[0], self.client_address[1]
            outcome = "Accepted" if valid else "Failed"
            message = "%s password for %s from %s port %s" % (outcome, username, ip, port)

            if not IS_WIN:
                try:
                    import syslog
                    syslog.openlog("%s[%d]" % (NAME.lower(), os.getpid()), 0, syslog.LOG_AUTH)
                    syslog.syslog(syslog.LOG_INFO, message)

Pinned upstream evidence: the inspected file has no shell=False) target and no shell=True substring. Static comparison predicts that the local patcher's replacements leave the logger unchanged and its final check exits with an error. The following Dockerfile step requires patcher success, so that build path would stop. No patch or build was run; an older cached image or a different upstream revision can differ.

A reproducible training image needs an explicitly reviewed source revision and verification of the actual patched login function—not merely a version substitution or a file-wide substring search. This guide does not apply those changes to the supplied project.

Startup, publication, and container reachability

The root entrypoint splits the configured flag, then tries iptables -A INPUT ! -i lo -p tcp --dport 80 -j DROP. If that command fails, it rewrites HTTP_ADDRESS to 127.0.0.1. It finally executes /usr/bin/supervisord -n. The fallback message names missing NET_ADMIN as the cause, but command failure can have other causes; the message does not diagnose them.

  • Publication: Compose maps only 55555:55555; EXPOSE 80 is image metadata, not a host-port mapping.
  • Isolation: no explicit localhost host bind is given. The published basket may be reachable on host network interfaces; keep practice isolated.
  • Listeners: the basket command binds 0.0.0.0:55555; Maltrail's initial configuration is 0.0.0.0:80, subject to startup success and the fallback rewrite.
  • Forwarding: loopback traffic is permitted by the intended rule. If Maltrail listens, the basket can call 127.0.0.1:80 from the same container.
  • Scan interpretation: a scan of host port 80 is not a direct test of an unpublished container port. It may encounter an unrelated host service or host firewall; the README's “filtered or closed” result is not guaranteed by Compose.

Non-publication alone is not a universal container firewall: direct container-IP access depends on Docker mode, platform, routing, and filtering. Here the entrypoint adds the intended restriction. Compose sets privileged: false but adds NET_ADMIN; neither means the application runs as an unprivileged Unix user. No host-file mounts are declared, and container root is not proof of host compromise.

A configured user is not a configured process user

Creating puma and printing “User: puma” do not switch Maltrail's identity. The actual service stanza has no user=; Supervisor retains the root identity of the entrypoint. See the complete service snapshot.

The README proposes user=puma for the intended chain. A functioning change also needs appropriate writable paths and the right to bind port 80, or an adjusted higher port and matching forwarding/filter configuration. Privileged-port behavior depends on the actual runtime and namespace settings; it has not been tested here.

The journalctl pager route has separate prerequisites

Sau/Dockerfile · line 51 · intended sudoers rule, not effective-policy output
RUN echo 'puma ALL=(ALL) NOPASSWD: /usr/bin/journalctl' > /etc/sudoers.d/puma && \
  • Executable: Jammy's systemd package provides journalctl. The Dockerfile explicitly installs less and Supervisor, not systemd. The binary's presence and resolution at the allowed path are unverified; a sudoers entry does not install it. Jammy's merged /usr layout explains the package listing's /bin/journalctl versus the rule's /usr/bin/journalctl.
  • Policy and identity: the shell must actually be unprivileged for an escalation to exist. Effective sudo permissions and environment handling must be checked in that deployment, not inferred from a Docker ENV or user .bashrc.
  • Data: Supervisor writes ordinary log files, not systemd journal entries. No journald startup or journal population is supplied. journalctl can read existing journal files without systemd being PID 1, but neither usable files nor useful paged output are established here.
  • Terminal and paging: the intended interaction needs a usable terminal and a pager that remains open. --no-pager, missing pagers, or less's default quit-if-one-screen option can prevent that interaction.
  • Pager security: the Ubuntu 22.04 manual documents SYSTEMD_PAGERSECURE. When secure mode is active, journalctl launches less with LESSSECURE=1, disabling subprocess and file-opening features. Elevated invocations can enable secure mode automatically. SYSTEMD_PAGER=less alone is not proof that a shell escape is enabled; the manual also conditions honoring pager environment overrides on an explicit pager-security setting.

Jammy journalctl manual and GTFOBins explain the general technique and conditions. For a defensive deployment, keep secure paging enabled or remove the interactive elevated pager entirely; do not disable those protections merely to make the README's expectation appear true.

Reconciliation table

README expectationSource correctionConclusion
Identify Request Baskets v1.2.1 from its responsePlain build leaves upstream version variables at n/a.Checkout version is source evidence, not a guaranteed banner.
Maltrail is patched to v0.53Unpinned clone; inspected upstream no longer has the expected logger.Label does not establish release or successful injection patch.
Injection gives a puma shellRoot entrypoint; no Maltrail user=.A working injection would inherit container root under the supplied defaults.
Use sudo journalctl to become rootRule exists; binary, journals, secure-pager state, and effective policy are unverified.Do not claim a working escalation from the rule alone.
Host scan shows port 80 filtered/closedContainer port 80 is not host-published.Distinguish host scan results from container listener/filter behavior.
Maltrail “patched” for CVE-2023-27163That CVE is Request Baskets SSRF.Attribute the two weaknesses to separate components.

Walkthrough map

Source-derived checkpoints

Each stage should establish one fact before advancing. The examples below are inert documentation for a future owned, isolated lab—not requests or commands run during this review.

Scope before commands

Use these examples only after you deliberately start a reviewed local instance and confirm that it is isolated. 127.0.0.1:55555 in a curl example means the Docker host as seen by that curl process; 127.0.0.1:80 in the basket configuration means the basket's container. Do not substitute unrelated targets. The moving Maltrail build issue must be resolved before a complete chain can be expected.

  1. Establish build provenance and service health

    Record the actual image/source revisions and inspect the patched login function. A build status line saying “v0.53” is not evidence that the expected sink was installed. The README's later health checks are:

    README health checks · future local lab only · not run
    docker logs sau
    docker exec sau supervisorctl status

    Checkpoint: both intended services are actually running, and the specific vulnerable handler has been reviewed. A failed patch or restarting process is a build/startup problem, not a failed payload.

  2. Identify the published basket service

    Illustrative product check · not sent
    curl -i http://127.0.0.1:55555/api/version

    Expected from source: the product metadata is Request Baskets; this plain build is expected to leave version/commit fields at n/a. Use the v1.2.1 checkout as build provenance, not an invented banner. A host-port-80 scan does not establish whether the unpublished internal service exists.

  3. Create your own forwarding basket

    The following illustrative request combines the loopback target from the local README with API fields verified in upstream v1.2.1. It is not a verbatim README command.

    Illustrative SSRF setup · owned local lab only · not sent
    curl -i -H 'Content-Type: application/json' \
      --data '{"forward_url":"http://127.0.0.1:80/","proxy_response":true,"expand_path":true}' \
      http://127.0.0.1:55555/api/baskets/study

    Expected from source: a new basket in public mode returns HTTP 201 with a token. A name conflict is not proof the existing basket is yours; do not modify it without its token. Preserve your token for authenticated configuration inspection or updates. Creating the basket does not itself prove Maltrail is reachable.

  4. Separate the network pivot from the login probe

    Illustrative forwarding and ordinary-login controls · not sent
    curl -i http://127.0.0.1:55555/study/
    curl -i --data-urlencode 'username=review-check' \
      http://127.0.0.1:55555/study/login

    The first request should relay the internal root-page response if Maltrail is listening. The second is an ordinary form POST forwarded to /login, not an injection payload. A failed-login response can confirm a reachable endpoint, but not shell execution. Check the response body and service identity, rather than accepting any 200 or 401 as sufficient proof.

    Checkpoint: an identified internal response through the basket. Keep management requests at /api/baskets/study distinct from collected/forwarded requests at /study/…. Form encoding is also separate: + represents a space, and arbitrary values need correct encoding.

  5. Inspect the sink before testing command execution

    Trace the submitted username into the actual patched command string. On a compatible, deliberately vulnerable lab, the README suggests a short delay and then an out-of-band callback to a listener you control. Compare a timing candidate against an ordinary failed-login control: application delays and forwarding latency can also slow responses. An observed delay is a signal to corroborate, not automatic proof.

    The supplied helper appends /login, sends a shell-substitution payload, and attempts a callback. It does not create the basket or listener; its Base64 transport and quoting are not universal. A callback failure can reflect routing or encoding rather than absence of the sink. No helper or probe was executed here.

    Checkpoint: command-execution evidence tied to the reviewed handler, separate from SSRF evidence. The current upstream syslog implementation cannot be assumed to implement the intended patched sink.

  6. Check the shell's identity, then the intended pager conditions

    README identity/policy checks · inside a future authorized lab shell · not run
    id
    whoami
    sudo -l

    The supplied defaults predict container root if a working injection produces a shell. Do not describe an additional puma-to-root escalation in that case. If the service has actually been corrected to run as puma, check the allowed executable, environment policy, available journals, terminal state, and SYSTEMD_PAGERSECURE/LESSSECURE behavior described on the build page.

    Checkpoint: actual identity and effective policy. A less prompt with secure mode enabled is not a demonstrated escape, and a passwordless rule for a missing binary cannot supply one.

  7. Read the flag paths according to actual permissions

    The entrypoint creates two halves of the deployment's flag at /home/puma/user.txt and /root/root.txt, both mode 0400. Read them only within your authorized lab and combine user then root. Do not treat the documented Compose default as a recovered runtime result.

    Checkpoint: access is explained by the observed process identity, and any reported value comes from that deployment. Container-root access may make both files readable without the intended two-stage progression.

Troubleshooting without changing the hypothesis blindly

SymptomFirst evidence to inspect
Patch verification failsThe actual Maltrail revision, logger implementation, and exact replacement match—not a different payload.
Version says n/aMissing linker-injected version metadata; the Dockerfile's checkout still supplies provenance.
Basket already exists or API returns 401Name ownership and token requirements; distinguish creation, management, and forwarding routes.
Basket returns an empty/default 200proxy_response and the identified destination body; default basket responses are not internal-service proof.
Forwarding error or wrong pageService health, loopback context, forward_url, and expand_path; a forwarding 502 is not command execution.
Login is slow but no corroborationNormal failed-login timing, transport latency, and the actual sink before claiming injection.
Callback absentReceiving listener, reachability from the container, URL suffix, and form/command encoding.
Shell is root immediatelyMissing Supervisor user=puma; container identity is not host identity.
No journalctl, no pager, or escape disabledPackage/path availability, journal data, terminal/pager options, and secure-pager/effective-sudo settings.

Expected path versus checked-in path

The intended puma stage needs a functioning, appropriately permissioned unprivileged service, not just the extra user= line. The journalctl stage has independent installation and pager-security conditions. These are configuration decisions for a later lab revision; the supplied project files remain unchanged.

Reveal the intended chain at a glance
Reasoning outline · no payload
public basket
  → request forwarded to container loopback
  → proxied Maltrail login page
  → (if the intended patch fits) username reaches a shell-backed logger
  → command runs as the Maltrail process user
  → (if puma and pager conditions hold) intended sudo journalctl route
  → user half + root half of the deployment flag

A failed build stops the chain before a service exists. A working vulnerable image with the supplied root service identity would skip the intended puma-to-root transition.

Lessons & fixes

Defensive reading

The intended chain combines a caller-controlled destination, user input interpreted as shell syntax, and an overprivileged service. Fix each boundary rather than rely on one broken stage to hide the others.

What each weakness teaches

Design choiceWhy it mattersSafer direction
Unrestricted forwarding destinationPublic basket creation can supply a caller-controlled route to internal services.Allowlist required destinations; validate resolved IPv4/IPv6 addresses and each redirect, address DNS rebinding, and enforce network egress restrictions. Authentication alone does not make arbitrary targets safe.
Shell command assembled from form dataUsername text becomes command syntax in the intended patched logger.Prefer a logging API; if a subprocess is required, use fixed arguments and shell=False. Sanitize log control characters separately; Base64 is not a defense.
Web process runs as rootA working injection inherits container-root authority.Run services as dedicated unprivileged accounts, make code read-only where practical, and grant only needed file/network permissions.
Broad pager-capable sudo entryAn elevated utility may expose subprocess or privileged file operations beyond the intended task.Prefer a narrow root-owned helper with fixed arguments and no interactive pager. Preserve secure-pager protections; --no-pager does not by itself narrow all journalctl privileges.
Published public-mode serviceWithout an explicit local host bind, the training API may be exposed through host interfaces.Bind publication to a controlled interface, restrict access, isolate the lab network, and remove the instance after practice.
Moving upstream and weak patch verificationA release label can outlive the source pattern that created the exercise.Pin reviewed revisions, check exact patch results and handler reachability, and keep intended vulnerable training configuration separate from production fixes.

Future regression checks for a defensive version

These are acceptance criteria, not tests run here: unauthorized/private forwarding targets stay blocked across DNS and redirects; a username containing shell syntax is logged as inert data; the service has its intended unprivileged identity; and privileged log viewing exposes no interactive escape or unrelated file operation. Check these independently so a failed build cannot masquerade as a successful security fix.

Questions to answer before calling it solved

  • What exact upstream revisions and patched handler did the image contain?
  • Does the displayed version reflect that build, or an unchanged/rewritten label?
  • Which socket is host-published, and which restrictions apply to the container listener?
  • Can I distinguish basket creation, token-protected management, and forwarding?
  • Which fields control destination, path expansion, and response relay?
  • What proves SSRF, and what separately proves shell execution?
  • Does the observed process identity match the README's expected puma foothold?
  • Are journalctl availability, effective sudo policy, journal data, and secure-pager behavior established separately?
  • Are the flags two halves of one deployment value, rather than independent defaults?
  • Am I distinguishing container-root access from host-root access?
  • Which conclusions are static predictions and which would need a future runtime check?

References and evidence

The Files & source notes page lists the local source landmarks, embedded snapshots, pinned upstream comparison, package/manual references, and remaining review limits. Public advisories identify weakness classes; they do not prove the supplied image builds or that its walkthrough succeeds.

Files & source notes

Provenance & review limits

Local files establish this recreation's configuration. Upstream comparisons establish build assumptions—not a successful build. Keep both beside the intended walkthrough.

Reviewed file inventory

FileRoleReview notes
Sau/README.mdArchitecture, instructions, expected outcomes, maintainer notesRead in full; not a recorded or independently verified solve.
Sau/DockerfileBase image, dependencies, checkouts, patch, sudo ruleRead only; unpinned Maltrail, unstamped basket version, and journalctl installation gap identified.
Sau/docker-compose.ymlCapabilities, publication, flag environmentOnly 55555 published; NET_ADMIN added; no host-file mounts.
Sau/entrypoint.shFlag split, port-80 restriction, Supervisor launchRead in full; root startup and file modes distinguished from runtime verification.
Sau/services.confProcess definitionsComplete inert snapshot below; no Maltrail user=.
Sau/patch-maltrail.pyVersion rewrite and attempted logger replacementReplacement quoted on the chain page; broad fallback and weak final check inspected, not executed.
Sau/maltrail.confListen address, credentials, application settingsInitial 0.0.0.0:80; source-supplied credentials are not required for the intended injection.
Sau/temp/exploit.pyReverse-shell helperRead only; appends /login and calls os.system. Not embedded as a runnable integration.
/tmp/opencode/labs-reference/pdfs/Sau Pentesting Lab.txtExisting text extraction of the five-page supplied PDFRead as text; aligns with the README's intended chain and maintainer caveats. No extraction or PDF execution performed.
keldagrim.html, exposed-metadata.html, quizzle.html, madx.html, its-a-fly.html, once-upon-a-time.html, the-signal-that-went-silent.htmlContent, evidence, and interaction comparisonInspected as source, never launched. Left unchanged; only sau.html was revised.

Source landmarks

  • Dockerfile, lines 6–15: Ubuntu base, pager preference, explicit dependency list.
  • Dockerfile, lines 28–31: v1.2.1 basket checkout and plain Go build.
  • Dockerfile, lines 37–43: moving Maltrail clone followed by required patcher success.
  • Dockerfile, lines 51–56: intended sudo rule and pager environment preparation.
  • patch-maltrail.py, lines 21, 34–38: version substitution, exact match, and username-containing replacement.
  • patch-maltrail.py, lines 43 and 64–68: file-wide fallback and substring-only verification.
  • entrypoint.sh, lines 5–12, 20–27, 37: flag ownership/modes, filter/fallback, and root Supervisor launch.
  • services.conf, lines 1–14: both commands, with no service-user selection.
  • temp/exploit.py, lines 28 and 33–36: URL suffix, encoded callback command, form transport, and local shell invocation.
Read services.conf · complete inert snapshot

This is the supplied process configuration, not the README's proposed puma fix. Displaying or copying it does not start a service.

Sau/services.conf · all 14 lines
[program:maltrail]
command=python3 /opt/maltrail/server.py
directory=/opt/maltrail
autostart=true
autorestart=true
stderr_logfile=/var/log/maltrail/maltrail.err.log
stdout_logfile=/var/log/maltrail/maltrail.out.log

[program:request-baskets]
command=/opt/request-baskets/request-baskets -p 55555 -l 0.0.0.0
autostart=true
autorestart=true
stderr_logfile=/var/log/request-baskets.err.log
stdout_logfile=/var/log/request-baskets.out.log
Read docker-compose.yml · complete inert snapshot, including default flag
Sau/docker-compose.yml · all 13 lines
services:
  sau:
    build: .
    container_name: sau
    privileged: false
    cap_add:
      - NET_ADMIN
    ports:
      - "55555:55555"
    environment:
      # This allows you to set the flag when running 'docker-compose up'
      - FLAG=${FLAG:-0123456789abcdef0123456789abcdef}
    restart: unless-stopped
Read the entrypoint flag logic · exact excerpt
Sau/entrypoint.sh · lines 5–12 · never invoked
if [ -n "$FLAG" ]; then
    len=${#FLAG}
    half=$((len / 2))
    echo "${FLAG:0:$half}" > /home/puma/user.txt
    chown puma:puma /home/puma/user.txt
    chmod 0400 /home/puma/user.txt
    echo "${FLAG:$half}" > /root/root.txt
    chmod 0400 /root/root.txt

Discrepancy and uncertainty register

IssueEvidenceBoundary on the conclusion
Vulnerable Maltrail buildUnpinned clone; inspected revision uses syslog and lacks the patcher's targets.Static comparison predicts patch failure at that revision, not the contents of any prebuilt/cached image.
Version labelsBasket metadata defaults to n/a; Maltrail label is rewritten.Neither displayed label alone establishes the installed release or sink.
Maltrail identityRoot startup and no user=.If started under the supplied defaults, it is container root. A successful injection has not been demonstrated.
Pager escalationSudo rule exists; no explicit systemd install or journal setup; secure mode can disable escapes.Binary, data, terminal, environment/policy, and escape behavior remain unverified.
Port 80 and host isolationNo port-80 publication or host-file mounts; filter/fallback is container-local.Do not infer a host scan result, absolute isolation, or host-root access from this configuration alone.
CVE attributionCVE-2023-27163 is Request Baskets SSRF; CVE-2025-34073 covers Maltrail injection.Correct attribution does not validate this recreation's patch.
Flag evidenceSource defines default, paths, split, and permissions.No deployment's generated flag files were read; defaults are not recovered results.
Review statusFiles and public sources read; no runtime or browser execution.Build, exploitation, live responses, and interaction behavior remain untested.

Public references consulted

Read as public text/source during the 17 November 2026 review. These optional links require internet only when selected; no remote source, font, or PDF is fetched by this HTML.

Review boundaries and offline behavior

  • Checked statically: supplied configuration, replacement string and fallback, upstream API/version behavior, pinned logger compatibility, and markup/navigation logic.
  • Instructional or expected: README walkthrough outcomes and illustrative future-lab requests. There is no recorded successful exploitation here.
  • Not performed: project/script or HTML execution, build/startup, live lab request, payload/helper run, package installation, flag retrieval, browser preview, or interaction test.
  • Not established: actual image contents, effective runtime sudo/environment settings, actual listening sockets/firewall rules, journal availability, or host compromise.
  • Not embedded: original PDF, application checkout, executable, or full exploit helper. Source excerpts and the two complete configuration snapshots are inert text.
  • Only changed: this standalone sau.html; the supplied project and other reference pages were left untouched.
  • Offline controls: local hash navigation, theme selection, printing, and copying only. Theme storage is best-effort; copying falls back to a local text-selection method, then manual selection if blocked. Arrow shortcuts do not override form controls, text selection, or code/table scrolling.
  • Printing: print styles include all six pages. With JavaScript available, printing also opens optional source/flag sections and restores their on-screen open/closed choices afterward. Without JavaScript, open those sections manually before printing.
No runnable exploit form, automatic target request, external asset, or lab launcher. With JavaScript disabled, all six articles and ordinary navigation links remain available.