chore(security): cve-audit regression checks and make target

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-24 03:10:28 +02:00
co-authored by Claude Sonnet 5.5
parent 81120b113b
commit e8f2a32b9a
35 changed files with 1650 additions and 1 deletions
+7 -1
View File
@@ -128,6 +128,12 @@ audit-check: audit-tests
@for t in $(AUDIT_TEST_BINS); do echo "== $$t"; ./$$t || exit 1; done
@echo "audit: all suites green"
# --- cve-audit (audit/: vulnerability-class regression checks against this ---
# tree's built artifacts; see audit/README.md. Distinct from audit-check/
# audit-tests above, which exercise src/audit's compliance hash-chain module.
cve-audit: all
$(MAKE) -C audit -j8 test MOLO_BUILD=$(abspath build)
# --- operability production link (INTEGRATION: with the base tree present ---
# the real supervisor/common Clock/KvStore/Observer satisfy the includes, so
# their TU definitions ride along on the test link lines).
@@ -135,4 +141,4 @@ OPERABILITY_TEST_SRCS += src/supervisor/common/clock.cpp
OPERABILITY_TEST_SRCS += src/supervisor/common/kv_store.cpp
OPERABILITY_TEST_SRCS += src/supervisor/common/observer.cpp
.PHONY: all test clean interop lint data-all data-test data-clean realtime-test cli-test audit-check
.PHONY: all test clean interop lint data-all data-test data-clean realtime-test cli-test audit-check cve-audit
+2
View File
@@ -0,0 +1,2 @@
__pycache__/
*.pyc
+7
View File
@@ -0,0 +1,7 @@
# MOLO-CLI-001: see README.md in this directory.
MOLO_BUILD ?= $(abspath ../../build)
export MOLO_BUILD
.PHONY: test
test:
@python3 reproduce.py
+50
View File
@@ -0,0 +1,50 @@
# MOLO-CLI-001: shell command injection in `molo new <name>`
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
In-house finding (not a public CVE), CWE-78 ("Improper Neutralization of Special
Elements used in an OS Command").
## Where
`src/cli/cli/cli_app.cpp`, `cmd_new`:
```cpp
opts.name = args.positionals[0];
...
std::string dir = opts.name;
ScaffoldResult result = scaffolder.scaffold(dir, opts);
```
`src/cli/cli/scaffolder.cpp`, `Scaffolder::scaffold`:
```cpp
std::string cmd = "git -C \"" + dir + "\" init -q 2>/dev/null";
if (system(cmd.c_str()) != 0) { ... }
```
`dir` is the project name exactly as typed on the command line, checked only for
length (1-64 chars, `kMaxProjectName`). It is concatenated inside one pair of double
quotes and handed to `system()`, a real shell. A name containing a `"` ends that
quoted argument early; anything after it is ordinary shell syntax.
## Relevance
`molo new <name>` is the first command in the README's own quickstart. Project names
are often copied from elsewhere (a ticket title, a client's brand name, a CI
variable) rather than hand-typed, which is exactly the kind of untrusted-but-looks-
like-a-filename input this bug class targets.
## What the check does
Runs `molo new 'x"; touch <marker>; echo "' --force` in a scratch directory and checks
whether the injected `touch` created the marker file. PASS means it did not (the name
is now escaped or passed to `git` without a shell); FAIL means the command ran.
## Caveats
This proves injection with a benign `touch`, not a demonstration of what an attacker
could do with it; `system()` runs as the invoking user with that user's full
permissions, so the practical impact is whatever that user could already do by hand.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+34
View File
@@ -0,0 +1,34 @@
#!/usr/bin/env python3
# MOLO-CLI-001: shell command injection in `molo new <name>`. See README.md.
import os
import subprocess
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "lib"))
import molo_audit as m
def main():
m.arm_watchdog(30)
if not os.path.exists(m.MOLO):
m.verdict_skip("%s not built (run make)" % m.MOLO)
tmp = m.scratch_dir()
marker = os.path.join(tmp, "pwned")
name = 'x"; touch %s; echo "' % marker # breaks out of the double-quoted -C arg
subprocess.run([m.MOLO, "new", name, "--force"], cwd=tmp,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=20)
if os.path.exists(marker):
m.verdict_fail(
"`molo new %r` ran an injected `touch` command via the unescaped "
"system(\"git -C \\\"\" + dir + \"\\\" init ...\") call in "
"src/cli/cli/scaffolder.cpp; the project name reaches a shell with no "
"quoting beyond a single pair of double quotes" % name
)
m.verdict_pass("the injected command did not run; scaffolder.cpp no longer "
"passes the project name through a shell unescaped")
if __name__ == "__main__":
main()
+17
View File
@@ -0,0 +1,17 @@
# MOLO-DAV-001: see README.md in this directory. ResourceTree is
# self-contained (no deps beyond its own header).
CXX ?= g++
ROOT := $(abspath ../..)
SRC := $(ROOT)/src
BUILD := $(abspath ../../build/audit-dav-001)
SOURCES := reproduce.cpp $(SRC)/realtime/webdav/server/resource_tree.cpp
BIN := $(BUILD)/reproduce
.PHONY: test
test: $(BIN)
@$(BIN)
$(BIN): $(SOURCES)
@mkdir -p $(BUILD)
@$(CXX) -std=c++23 -Wall -Wextra -O1 -I$(SRC) -o $(BIN) $(SOURCES)
+56
View File
@@ -0,0 +1,56 @@
# MOLO-DAV-001: WebDAV COPY into its own subtree never terminates
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
In-house finding (not a public CVE). CWE-674 ("Uncontrolled Recursion") plus CWE-400
(uncontrolled resource consumption); RFC 4918 9.8.3 and 9.9.3 require a WebDAV server
to reject exactly this COPY/MOVE shape with 403 Forbidden before doing anything.
## Where
`src/realtime/webdav/server/resource_tree.cpp`, `ResourceTree::copy`:
```cpp
std::string prefix = src + "/";
for (const auto& [k, v] : entries_) {
if (k == src || k.compare(0, prefix.size(), prefix) == 0) {
...
entries_[target] = v; // <-- inserts into the map being iterated
...
}
}
```
There is no check anywhere that `dst` is not inside `src` (only `src == dst`, line 159,
which this shape does not trigger). When `dst` falls lexically after the iterator's
current position in the sorted `std::map`, the newly inserted entry (`dst` + the
relative suffix) is reached later by the same ongoing iteration, because `entries_`'s
`end()` sentinel is unaffected by insertion. Copying `/dav/a` to `/dav/a/b` inserts
`/dav/a/b/b`, which the loop then visits and inserts `/dav/a/b/b/b`, and so on,
forever, each entry copying the full body bytes of everything under `src` again.
`ResourceTree::move` (next function) calls `copy` first, so it inherits the same bug
and then also deletes the whole source subtree afterward if `copy` ever did return.
## Relevance
A WebDAV COPY or MOVE with an attacker-chosen `Destination` header that happens to
be a path under the source directory (a single HTTP request, no special privilege)
pins a server thread forever and grows its memory without bound, an unauthenticated
remote DoS against anything that mounts this `ResourceTree` behind a COPY/MOVE route.
## What the check does
`ResourceTree` is pure in-memory state with no I/O (confirmed against its header,
which never mentions a socket or filesystem call), so the check drives it directly:
creates `/dav/a` with one file, then calls `copy("/dav/a", "/dav/a/b", true, created)`
under a 10-second watchdog. PASS means `copy` returned within the deadline; FAIL means
the watchdog fired, proving the loop does not converge.
## Caveats
No COPY/MOVE HTTP route is wired to a live server binary in `example/` today (the
example's simplified `fw::WebdavStore` only exposes GET/PUT/DELETE/PROPFIND), so this
exercises the real class directly rather than over a socket; the class is the one
`src/realtime/webdav/server/copy_move_handler.cpp` calls for every real COPY/MOVE.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+62
View File
@@ -0,0 +1,62 @@
// MOLO-DAV-001: WebDAV COPY into the source's own subtree never
// terminates and grows memory without bound. See README.md.
//
// ResourceTree is pure in-memory state (no I/O, no server loop), so this
// check drives it directly rather than needing a server: no COPY/MOVE
// route is wired to a live binary in example/ today, but this is the
// same ResourceTree::copy every real COPY handler calls
// (copy_move_handler.cpp).
#include <csignal>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <unistd.h>
#include "realtime/webdav/server/resource_tree.h"
using molo::realtime::webdav::server::ResourceTree;
namespace {
constexpr unsigned kWatchdogSecs = 10;
void on_alarm(int) {
// _exit, not exit: the process may be mid-way through growing a
// std::map without bound; do not run destructors over it.
const char msg[] =
"FAIL: ResourceTree::copy(\"/dav/a\", \"/dav/a/b\", ...) did not return within "
"10s; it inserts into entries_ (a std::map) while range-iterating that same "
"map (resource_tree.cpp), so copying a collection into its own subtree "
"(dst inside src) keeps discovering newly-inserted entries ahead of the "
"iterator and never converges (CWE-674, uncontrolled recursion/expansion; "
"unbounded memory growth, CWE-400)\n";
::write(2, msg, sizeof(msg) - 1);
_exit(1);
}
} // namespace
int main() {
std::signal(SIGALRM, on_alarm);
::alarm(kWatchdogSecs);
ResourceTree tree("/dav");
if (!tree.mkcol("/dav/a")) {
std::printf("SKIP: could not set up /dav/a (unexpected ResourceTree API change)\n");
return 0;
}
std::vector<uint8_t> body{'h', 'i'};
tree.put("/dav/a/file.txt", body);
bool created = false;
// Destination is INSIDE the source collection: exactly the shape RFC 4918
// 9.8.3/9.9.3 says a server must reject with 403 before doing anything.
bool ok = tree.copy("/dav/a", "/dav/a/b", /*overwrite=*/true, created);
// If we get here at all, the loop terminated. Whether copy() returned
// true or false, check it did not blow up the tree size either.
std::printf("copy() returned %s\n", ok ? "true" : "false");
std::printf(
"PASS: ResourceTree::copy into its own subtree returned (did not hang)\n");
return 0;
}
+18
View File
@@ -0,0 +1,18 @@
# MOLO-EXPOSE-001: see README.md in this directory. UpstreamHostAllowed is a
# pure function with no deps beyond its own header, so the harness links
# only reproduce.cpp and upstream.cpp.
CXX ?= g++
ROOT := $(abspath ../..)
SRC := $(ROOT)/src
BUILD := $(abspath ../../build/audit-expose-001)
SOURCES := reproduce.cpp $(SRC)/realtime/expose/upstream.cpp
BIN := $(BUILD)/reproduce
.PHONY: test
test: $(BIN)
@$(BIN)
$(BIN): $(SOURCES)
@mkdir -p $(BUILD)
@$(CXX) -std=c++23 -Wall -Wextra -O1 -I$(SRC) -o $(BIN) $(SOURCES)
+53
View File
@@ -0,0 +1,53 @@
# MOLO-EXPOSE-001: expose upstream allow-list bypass via hostname prefix
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
In-house finding (not a public CVE). CWE-184 ("Incomplete List of Disallowed Inputs"),
the same bug shape behind many documented SSRF / allow-list-bypass CVEs that trust a
string-prefix or substring test to stand in for a real IP-range check.
## Where
`src/realtime/expose/upstream.cpp`, `UpstreamHostAllowed`:
```cpp
if(h.rfind("10.",0)==0)return true;
if(h.rfind("192.168.",0)==0)return true;
...
if(h.rfind("169.254.",0)==0||h.rfind("fe80",0)==0||h.rfind("FE80",0)==0)return true;
```
`reverse.md` documents the policy as "upstream host must be loopback / RFC1918 /
link-local unless `allow_public` is set" (section 7), i.e. this function is meant to
be a strict allow-list that keeps `molo expose` upstreams pointed at the local
machine or its private network. `rfind(prefix, 0) == 0` only checks that `host`
*starts with* the literal text `"10."`, `"192.168."` etc; it is not an IP-address
parse. A DNS name like `10.evil.com` or `127.evil.com` starts with that text too, and
resolves to whatever public IP its owner points it at.
## Relevance
This is the one guard standing between "an exposer may only tunnel to something on
its own machine or LAN" and "an exposer can tunnel to any host on the internet it can
name," for any deployment that has not explicitly opted into `allow_public`. A caller
that relies on this function to keep `molo expose` from being turned into an open
proxy gets a false sense of enforcement.
## What the check does
Compiles a tiny harness directly against the real `upstream.cpp` (a pure function,
no I/O, no server needed) and calls `UpstreamHostAllowed` with five public hostnames
chosen to share a prefix with a private-range literal, plus two real private
literals as sanity controls. PASS requires every public hostname to be rejected and
every private literal to be accepted; FAIL means at least one public hostname was
misclassified as private.
## Caveats
This checks the string-matching logic in isolation; it does not drive a live
`molo expose` registration end to end, because doing so would require resolving a
real external DNS name to prove the end effect, which this audit's own ground rules
avoid making the check depend on (network access). The misclassification itself is
provable with no network.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+59
View File
@@ -0,0 +1,59 @@
// MOLO-EXPOSE-001: UpstreamHostAllowed's private/local allow-list is a
// bare string-prefix test, so a public hostname that merely starts with a
// private-looking label (e.g. "10.evil.com") is misclassified as private
// and let through when it should be rejected. See README.md.
//
// UpstreamHostAllowed is a pure function (no I/O, no server needed): the
// real policy check reverse.md documents and src/realtime/expose/tunnel.cpp
// calls before registering an upstream.
#include <cstdio>
#include "realtime/expose/upstream.h"
using molo::realtime::expose::UpstreamHostAllowed;
struct Case {
const char* host;
bool should_be_private; // the correct verdict: is this really loopback/RFC1918/link-local?
};
int main() {
// These are real public DNS names (any attacker can register one) that
// share a prefix with a private-range literal. The correct verdict for
// all of them is "not private".
static const Case kCases[] = {
{"10.evil.com", false},
{"127.evil.com", false},
{"192.168.attacker.net", false},
{"169.254.attacker.net", false},
{"172.99.evil.com", false},
// Sanity controls: a real private literal must still pass.
{"10.0.0.5", true},
{"192.168.1.1", true},
};
int failures = 0;
for (const auto& c : kCases) {
bool allowed = UpstreamHostAllowed(c.host, /*allow_public=*/false);
bool wrong = allowed != c.should_be_private;
std::printf("%-28s allowed=%-5s want_private=%-5s %s\n", c.host,
allowed ? "true" : "false", c.should_be_private ? "true" : "false",
wrong ? "MISMATCH" : "ok");
if (wrong) failures++;
}
if (failures > 0) {
std::printf(
"FAIL: %d/%zu cases misclassified; UpstreamHostAllowed (src/realtime/expose/"
"upstream.cpp) uses host.rfind(\"10.\",0)==0 style bare prefix tests, so a "
"public hostname that starts with a private-looking label is accepted as "
"private even though DNS will resolve it to an arbitrary public (or "
"attacker-controlled) address: an allow-list bypass in the policy reverse.md "
"documents as \"upstream host must be loopback / RFC1918 / link-local unless "
"allow_public is set\" (CWE-184, incomplete allow-list)\n",
failures, sizeof(kCases) / sizeof(kCases[0]));
return 1;
}
std::printf("PASS: all %zu cases classified correctly\n", sizeof(kCases) / sizeof(kCases[0]));
return 0;
}
+7
View File
@@ -0,0 +1,7 @@
# MOLO-H1-001: see README.md in this directory.
MOLO_BUILD ?= $(abspath ../../build)
export MOLO_BUILD
.PHONY: test
test:
@python3 reproduce.py
+54
View File
@@ -0,0 +1,54 @@
# MOLO-H1-001: chunked-body cap bypass via chunk-size addition overflow
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
In-house finding (not a public CVE), modeled on the same bug class as CVE-2022-29361-style
chunked-transfer-coding integer handling and the general HTTP request-smuggling /
resource-exhaustion family (CWE-190 integer overflow leading to CWE-400 uncontrolled
resource consumption).
## Where
`src/runtime/http/v1/parser.cpp`, `Parser::FeedChunkSize`:
```cpp
if (body_.size() + size > body_cap_) {
state_ = State::Failed;
return ParseResult::Error413;
}
```
`size` is attacker-controlled (parsed from the chunk-size line, up to 16 hex digits,
already overflow-checked against `SIZE_MAX` on its own). `body_.size() + size` is not
checked for overflow. A chunk declaring size `0xFFFFFFFFFFFFFFFF` on top of a non-empty
`body_` wraps the sum to a small number, so the cap comparison passes when it should
fail with 413. `chunk_left_` is then set to the huge declared size, and every
subsequent byte the client sends is appended to `body_` in `FeedChunkData` with no
further cap check until that one chunk ends (which an attacker need never do).
## Relevance
`kBodyMaxDefault` (10 MiB, `src/runtime/caps.h`) is the framework's hard ceiling on
request body size, the exact kind of static ceiling `AGENTS.md`/the base rules require
("every knob has a hard static cap"). This bug makes that ceiling bypassable by anyone
who can open an HTTP/1.1 connection and send one request: memory grows without bound as
long as the client keeps writing, which is an unauthenticated remote DoS lever against
any MoloApp server (the living example, or any app built with `molo new`).
## What the check does
Starts `build/bin/runtime_interop_server` on a scratch port, opens a real TCP
connection, sends `POST /echo` with `Transfer-Encoding: chunked`, announces the
overflowing chunk size, then streams 14 MiB of chunk "data" past the 10 MiB cap and
confirms the server never responds 413 or closes the connection, i.e. the cap was
bypassed. PASS means a future fix (checking `size > body_cap_ - body_.size()`) made the
server reject before the cap, or the overflow attempt itself failed to run (SKIP covers
a missing build).
## Caveats
This is a size-cap bypass proven by pushing memory growth past the configured ceiling,
not a crash; it stops at the harness's own 64 MiB send cap (`molo_audit.MAX_SEND_BYTES`)
regardless of verdict, so the check itself never becomes the DoS it is checking for.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+73
View File
@@ -0,0 +1,73 @@
#!/usr/bin/env python3
# MOLO-H1-001: chunked-body cap bypass via chunk-size addition overflow.
# See README.md in this directory. Drives build/bin/runtime_interop_server
# over a real socket; nothing here is a canned unit test.
import os
import sys
import time
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "lib"))
import molo_audit as m
BODY_CAP_DEFAULT = 10 * 1024 * 1024 # runtime::caps::kBodyMaxDefault
PUSH_BYTES = BODY_CAP_DEFAULT + 4 * 1024 * 1024 # comfortably over the cap
def main():
m.arm_watchdog()
srv, _tmp = m.start_interop()
port = srv.port
s = m.connect(port)
s.sendall(b"POST /echo HTTP/1.1\r\nHost: x\r\nTransfer-Encoding: chunked\r\n\r\n")
# One ordinary 1-byte chunk, then a chunk-size whose declared length is
# 2**64-1. body_.size()(=1) + size overflows size_t and wraps to 0, so
# the "body_.size() + size > body_cap_" cap check at parser.cpp passes
# when it should reject with 413.
s.sendall(b"1\r\nA\r\n")
s.sendall(b"ffffffffffffffff\r\n")
sent = 0
chunk = b"B" * (1024 * 1024)
rejected_or_closed = False
s.setblocking(False)
import select
while sent < PUSH_BYTES:
try:
s.sendall(chunk)
sent += len(chunk)
except (BlockingIOError, InterruptedError):
time.sleep(0.02)
continue
except OSError:
rejected_or_closed = True
break
r, _, _ = select.select([s], [], [], 0)
if r:
data = s.recv(4096)
if not data or b" 413 " in data or b" 400 " in data:
rejected_or_closed = True
break
if not srv.alive():
m.verdict_skip("server process died (unrelated to this check)")
s.close()
rss = srv.rss_kb()
srv.stop()
if rejected_or_closed:
m.verdict_pass(
"server rejected or closed before %d bytes crossed the %d-byte body cap"
% (sent, BODY_CAP_DEFAULT)
)
if sent >= PUSH_BYTES:
m.verdict_fail(
"sent %d bytes of chunk body (cap is %d) with no 413/close: the chunk-size "
"overflow in FeedChunkSize (body_.size()+size wraps) bypasses kBodyMaxDefault "
"entirely; peak RSS ~%d KiB" % (sent, BODY_CAP_DEFAULT, rss)
)
m.verdict_fail("loop ended ambiguously after %d bytes" % sent)
if __name__ == "__main__":
main()
+7
View File
@@ -0,0 +1,7 @@
# MOLO-H2-001: see README.md in this directory.
MOLO_BUILD ?= $(abspath ../../build)
export MOLO_BUILD
.PHONY: test
test:
@python3 reproduce.py
+42
View File
@@ -0,0 +1,42 @@
# MOLO-H2-001: HTTP/2 Rapid Reset
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
CVE-2023-44487 (CVSS varies by vendor, widely rated High; the class, not a specific
MoloApp CVE). CISA/CERT advisory, disclosed October 2023.
## Source
- [CISA advisory AA23-230A / the "HTTP/2 Rapid Reset" disclosure](https://www.cisa.gov/news-events/alerts/2023/10/10/http2-rapid-reset-vulnerability-impacting-web-servers)
## Relevance to MoloApp
A client opens a stream with HEADERS and immediately cancels it with RST_STREAM,
over and over on one connection. Each cycle costs the server a handler dispatch but
never counts against a concurrent-stream limit, because the stream is gone by the
time the next one opens. This is the mechanism that drove the October 2023
multi-vendor HTTP/2 incident across nginx, Envoy, Go net/http2 and others.
`src/runtime/http/v2/connection.cpp` enforces `kH2MaxConcurrentStreamsDefault` (100,
`src/runtime/caps.h`) by counting open streams, and `OnRst` (around line 535) erases
the stream entry the moment an RST_STREAM arrives. There is no counter for how many
streams a connection has opened-then-reset, and no backoff or GOAWAY triggered by a
high reset rate, so the one cap this framework relies on for HTTP/2 concurrency never
engages against this pattern.
## What the check does
Starts `build/bin/runtime_interop_server`, opens one real h2c prior-knowledge
connection, and sends 4000 HEADERS(END_HEADERS|END_STREAM)+RST_STREAM(NO_ERROR) pairs
for distinct odd stream IDs in one connection. PASS requires the server to push back
(GOAWAY, or refuse to echo an RST_STREAM for all of them) while staying up; FAIL means
every pair was accepted with no backpressure signal.
## Caveats
This check measures whether a *rate-limiting signal* exists, not whether the process
survives a sustained attack at scale; it stops at 4000 pairs (the harness's own
`flood()` cap), far below what a real attacker would send, specifically so the check
itself never becomes a denial-of-service tool.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+59
View File
@@ -0,0 +1,59 @@
#!/usr/bin/env python3
# MOLO-H2-001: HTTP/2 Rapid Reset (CVE-2023-44487 class). See README.md.
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "lib"))
import molo_audit as m
STREAMS = 4000 # well above kH2MaxConcurrentStreamsDefault (100)
def main():
m.arm_watchdog()
srv, _tmp = m.start_interop()
port = srv.port
h2 = m.H2(port, initial_settings=[(3, 1000)]) # offer a generous own limit
h2.settle(0.3)
def req_then_rst(i):
sid = 2 * i + 1
block = m.hpack_request(path="/echo")
out = m.frame(m.T_HEADERS, m.F_END_HEADERS | m.F_END_STREAM, sid, block)
out += m.frame(m.T_RST, 0, sid, (0).to_bytes(4, "big")) # NO_ERROR, immediate
return out
sent = m.flood(h2, req_then_rst, STREAMS, batch=50)
h2.settle(1.0)
crashed = not srv.alive()
pushed_back = h2.closed or h2.goaway is not None
rss = srv.rss_kb()
h2.close()
srv.stop()
if crashed:
m.verdict_fail(
"server process died after %d HEADERS+RST(0) pairs on one connection" % sent
)
if pushed_back and sent < STREAMS:
m.verdict_pass(
"server cut the connection (GOAWAY=%s) after %d/%d pairs instead of accepting "
"an unbounded stream-open/reset churn, and stayed up (RSS ~%d KiB)"
% (h2.goaway, sent, STREAMS, rss)
)
if sent >= STREAMS and not pushed_back:
m.verdict_fail(
"all %d request+immediate-RST_STREAM pairs (40x kH2MaxConcurrentStreamsDefault) "
"were accepted on one connection with no GOAWAY and no stream-reset rate limit; "
"src/runtime/http/v2/connection.cpp has no per-connection reset counter, so the "
"concurrent-stream cap never engages because each stream is torn down before the "
"next HEADERS arrives, and the handler is already dispatched for every one of "
"them (RSS ~%d KiB)" % (sent, rss)
)
m.verdict_fail("ambiguous outcome after %d/%d pairs (crashed=%s, pushed_back=%s)"
% (sent, STREAMS, crashed, pushed_back))
if __name__ == "__main__":
main()
+7
View File
@@ -0,0 +1,7 @@
# MOLO-H2-002: see README.md in this directory.
MOLO_BUILD ?= $(abspath ../../build)
export MOLO_BUILD
.PHONY: test
test:
@python3 reproduce.py
+45
View File
@@ -0,0 +1,45 @@
# MOLO-H2-002: HTTP/2 "MadeYouReset"
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
CVE-2025-8671, disclosed August 2025 via CERT/CC. Affected a wide vendor list (Apache
Tomcat as CVE-2025-48989, F5, Fastly, Netty, gRPC, Varnish and others); the class, not
a MoloApp-specific assignment.
## Source
- [CERT/CC VU#767506](https://www.kb.cert.org/vuls/id/767506)
## Relevance to MoloApp
Rapid Reset (CVE-2023-44487, [MOLO-H2-001](../MOLO-H2-001/)) is mitigated by many
implementations by rate-limiting client-sent RST_STREAM frames. MadeYouReset sidesteps
that by getting the *server* to send the RST_STREAM instead, for example via a
protocol violation on the stream (an invalid WINDOW_UPDATE, a bad frame, a flow-control
violation) that triggers a stream-level error. The handler dispatch and teardown cost
is the same as Rapid Reset, but a mitigation that only counts client RST_STREAM frames
never sees it, because the client never sends one.
`src/runtime/http/v2/connection.cpp` has no counter for streams the server itself
resets (confirmed in the audit of `OnRst`, the flow-control-error branches around
line 446/524/610): each one frees the stream slot the same way a client-sent RST does,
with no cap, matching [MOLO-H2-001](../MOLO-H2-001/)'s finding that the concurrent-stream
limit never engages against a churn attack.
## What the check does
Opens one h2c connection to `build/bin/runtime_interop_server` and, for 4000 distinct
streams, sends HEADERS (no END_STREAM, so the stream stays open) followed by a
WINDOW_UPDATE with a zero increment on that same stream, a flow-control violation that
RFC 9113 6.9 requires the server to answer with RST_STREAM. PASS requires the
connection to be cut (GOAWAY or close) before all 4000 are processed; FAIL means the
server resets every stream itself with no backpressure, exactly the MadeYouReset shape.
## Caveats
This is the server-triggered-reset mechanism, not a claim of in-the-wild exploitation
(CERT/CC and vendor advisories note no known exploitation at disclosure time either).
Capped at 4000 streams by the harness so the check itself cannot become the DoS it
tests for.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+65
View File
@@ -0,0 +1,65 @@
#!/usr/bin/env python3
# MOLO-H2-002: "MadeYouReset" (CVE-2025-8671 class). See README.md.
# Rapid Reset (MOLO-H2-001) has the client send the RST_STREAM. Here the
# client provokes the SERVER into sending the reset instead (an invalid
# WINDOW_UPDATE on each stream), which Rapid-Reset mitigations that only
# count client-sent RST_STREAM frames do not see at all.
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "lib"))
import molo_audit as m
STREAMS = 4000
def main():
m.arm_watchdog()
srv, _tmp = m.start_interop()
port = srv.port
h2 = m.H2(port, initial_settings=[(3, 1000)])
h2.settle(0.3)
def req_then_bad_window(i):
sid = 2 * i + 1
block = m.hpack_request(path="/echo")
# HEADERS without END_STREAM: stream stays open, awaiting body.
out = m.frame(m.T_HEADERS, m.F_END_HEADERS, sid, block)
# A zero WINDOW_UPDATE increment is a stream error (FLOW_CONTROL_ERROR):
# RFC 9113 6.9 forbids it. This makes the SERVER emit the RST_STREAM.
out += m.frame(m.T_WINDOW, 0, sid, (0).to_bytes(4, "big"))
return out
sent = m.flood(h2, req_then_bad_window, STREAMS, batch=50)
h2.settle(1.0)
crashed = not srv.alive()
server_rsts = h2.count(m.T_RST)
pushed_back = h2.closed or h2.goaway is not None
rss = srv.rss_kb()
h2.close()
srv.stop()
if crashed:
m.verdict_fail("server process died after %d provoked resets" % sent)
if pushed_back and sent < STREAMS:
m.verdict_pass(
"server cut the connection (GOAWAY=%s) after %d/%d provoked server-side "
"resets instead of an unbounded churn, and stayed up (RSS ~%d KiB)"
% (h2.goaway, sent, STREAMS, rss)
)
if sent >= STREAMS and not pushed_back:
m.verdict_fail(
"all %d streams were opened and server-reset (%d RST_STREAM observed) on one "
"connection with no GOAWAY and no limit on server-initiated resets; a "
"mitigation that only rate-limits client-sent RST_STREAM (as Rapid Reset "
"fixes typically do) would still miss this, because connection.cpp's own "
"reset path (OnRst/flow-control-error branches) frees the stream slot with "
"no counter either (RSS ~%d KiB)" % (sent, server_rsts, rss)
)
m.verdict_fail("ambiguous outcome after %d/%d (crashed=%s, pushed_back=%s)"
% (sent, STREAMS, crashed, pushed_back))
if __name__ == "__main__":
main()
+7
View File
@@ -0,0 +1,7 @@
# MOLO-H2-003: see README.md in this directory.
MOLO_BUILD ?= $(abspath ../../build)
export MOLO_BUILD
.PHONY: test
test:
@python3 reproduce.py
+42
View File
@@ -0,0 +1,42 @@
# MOLO-H2-003: HTTP/2 CONTINUATION flood
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
CVE-2024-27316 (Apache httpd, fixed 2.4.59) and the same-family CVE-2024-27983
(Node.js), CVE-2024-27919 (Envoy), CVE-2024-2653 (amphp/http); the class ("HTTP/2
CONTINUATION Flood"), not a MoloApp-specific CVE. Disclosed by Bartek Nowotarski to
CERT/CC, April 2024.
## Source
- [CERT/CC advisory on the CONTINUATION flood](https://kb.cert.org/vuls/id/421644)
## Relevance to MoloApp
A HEADERS frame without END_HEADERS opens a header block that is only closed by a
later CONTINUATION frame carrying END_HEADERS. The 2024 disclosure found that many
implementations cap the *total header bytes* accumulated across that run of frames,
but not the *count* of CONTINUATION frames or the time spent collecting them, so a
client can send an effectively unbounded number of empty (or near-empty)
CONTINUATION frames, each costing a 9-byte frame-header parse and a dispatch through
the connection's frame loop, without ever tripping the byte-count guard.
`src/runtime/http/v2/hpack.cpp`/`connection.cpp` cap the accumulated header block at
`kH2HeaderListMax` (64 KiB) by bytes, confirmed in the audit; nothing there counts
CONTINUATION frames or bounds how long one stream's header block may stay open.
## What the check does
Opens one h2c connection, sends a HEADERS frame without END_HEADERS on stream 1
(leaving the header block open), then floods up to 200,000 zero-length CONTINUATION
frames on that stream. PASS requires the connection to be cut before all of them are
accepted; FAIL means the server parses an unbounded run of empty CONTINUATION frames
with no byte growth and no cutoff.
## Caveats
200,000 is the harness's own ceiling, not a claim about the attack's real cost at
scale; a genuine attack sends far more, and this check is capped specifically so
running it cannot itself become the resource-exhaustion attack it is checking for.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+58
View File
@@ -0,0 +1,58 @@
#!/usr/bin/env python3
# MOLO-H2-003: HTTP/2 CONTINUATION flood (CVE-2024-27316 class). See README.md.
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "lib"))
import molo_audit as m
# Each CONTINUATION frame below adds 0 header bytes, so the kH2HeaderListMax
# byte-count guard never trips. Capped so the check itself cannot hang the
# box: this is far below what a real attack would send, enough only to
# prove the connection has no frame-count or time floor on an open header
# block, only a byte-count one.
FRAMES = 200000
def main():
m.arm_watchdog()
srv, _tmp = m.start_interop()
port = srv.port
h2 = m.H2(port)
h2.settle(0.2)
sid = 1
# Open a header block with HEADERS (no END_HEADERS): one real byte of
# header data, then an endless run of empty CONTINUATION frames.
h2.raw(m.frame(m.T_HEADERS, 0, sid, b"\x82")) # :method GET, block left open
sent = m.flood(h2, lambda i: m.frame(m.T_CONT, 0, sid, b""), FRAMES, batch=2000)
h2.settle(1.0)
crashed = not srv.alive()
pushed_back = h2.closed or h2.goaway is not None
rss = srv.rss_kb()
h2.close()
srv.stop()
if crashed:
m.verdict_fail("server process died after %d empty CONTINUATION frames" % sent)
if pushed_back and sent < FRAMES:
m.verdict_pass(
"server cut the connection (GOAWAY=%s) after %d/%d empty CONTINUATION "
"frames instead of parsing an unbounded run of them, and stayed up "
"(RSS ~%d KiB)" % (h2.goaway, sent, FRAMES, rss)
)
if sent >= FRAMES and not pushed_back:
m.verdict_fail(
"all %d empty CONTINUATION frames on one open header block were accepted "
"with no GOAWAY; kH2HeaderListMax (connection.cpp) only caps accumulated "
"header BYTES, so a flood of zero-length CONTINUATION frames costs the "
"server a 9-byte-frame parse each with no floor on frame count or time "
"spent in one header block (RSS ~%d KiB)" % (sent, rss)
)
m.verdict_fail("ambiguous outcome after %d/%d (crashed=%s, pushed_back=%s)"
% (sent, FRAMES, crashed, pushed_back))
if __name__ == "__main__":
main()
+7
View File
@@ -0,0 +1,7 @@
# MOLO-H2-004: see README.md in this directory.
MOLO_BUILD ?= $(abspath ../../build)
export MOLO_BUILD
.PHONY: test
test:
@python3 reproduce.py
+38
View File
@@ -0,0 +1,38 @@
# MOLO-H2-004: HTTP/2 control-frame flood, unbounded ack queue
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
CVE-2019-9511/9512/9515/9518, the 2019 Netflix/Google "HTTP/2 DoS" disclosure batch
("Ping Flood" is CVE-2019-9512 specifically); the class, not a MoloApp-specific CVE.
## Source
- [CISA advisory on the 2019 HTTP/2 implementation flaws](https://www.cisa.gov/news-events/alerts/2019/08/13/http2-implementations-vulnerable-denial-service)
## Relevance to MoloApp
Every PING frame a client sends must be answered with a PING ack; a client that keeps
sending PINGs but never reads its socket can make the server queue an unbounded
amount of outbound ack data, if nothing caps either the rate of control frames
processed or the size of the output queue built up for a non-reading peer. This is
the "Ping Flood" shape from the 2019 disclosure batch.
`src/runtime/http/v2/connection.cpp`'s `EnqueueControl` (around line 87) queues an ack
for every PING with no per-connection rate cap on control frames and no ceiling on
`out_queued_bytes_` tied to a slow/non-reading peer (confirmed in the audit); the only
backpressure path found applies to file-backed response bodies, not control frames.
## What the check does
Opens one h2c connection to `build/bin/runtime_interop_server`, sends up to 300,000
PING frames without ever reading the socket, and checks whether the server cuts the
connection (GOAWAY/close) before accepting all of them. PASS means it did; FAIL means
every PING was accepted with no limit on the resulting queue of unread ack bytes.
## Caveats
This measures whether a floor exists on a single connection's queued-but-unread
output, not the server's behavior across many connections at once. Capped at 300,000
frames (about 5 MB of acks) so the check cannot itself exhaust the test host's memory.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+52
View File
@@ -0,0 +1,52 @@
#!/usr/bin/env python3
# MOLO-H2-004: HTTP/2 PING/SETTINGS flood, unbounded ack queue
# (CVE-2019-9511/9515/9518 "HTTP/2 DoS" family class). See README.md.
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "lib"))
import molo_audit as m
PINGS = 300000 # each ack queued is 17 bytes; capped well under MAX_SEND_BYTES
def main():
m.arm_watchdog()
srv, _tmp = m.start_interop()
port = srv.port
h2 = m.H2(port)
h2.settle(0.2)
# Never read the server's responses: this isolates whether an unread
# peer causes unbounded buffering of queued PING acks server-side,
# rather than measuring our own receive behavior.
sent = m.flood(h2, lambda i: m.frame(m.T_PING, 0, 0, b"01234567"), PINGS, batch=5000)
h2.settle(1.0)
crashed = not srv.alive()
pushed_back = h2.closed or h2.goaway is not None
rss = srv.rss_kb()
h2.close()
srv.stop()
if crashed:
m.verdict_fail("server process died after %d unread PING frames" % sent)
if pushed_back and sent < PINGS:
m.verdict_pass(
"server cut the connection (GOAWAY=%s) after %d/%d unread PINGs instead of "
"queueing an unbounded run of acks, and stayed up (RSS ~%d KiB)"
% (h2.goaway, sent, PINGS, rss)
)
if sent >= PINGS and not pushed_back:
m.verdict_fail(
"all %d PING frames were accepted with no GOAWAY and no limit on queued "
"acks while the client never read a byte back; EnqueueControl "
"(connection.cpp) has no cap on control-frame rate or on out_queued_bytes_ "
"for an unread peer, so a connection can be made to buffer an unbounded "
"amount of PING-ack output (RSS ~%d KiB)" % (sent, rss)
)
m.verdict_fail("ambiguous outcome after %d/%d (crashed=%s, pushed_back=%s)"
% (sent, PINGS, crashed, pushed_back))
if __name__ == "__main__":
main()
+7
View File
@@ -0,0 +1,7 @@
# MOLO-STATIC-001: see README.md in this directory.
MOLO_BUILD ?= $(abspath ../../build)
export MOLO_BUILD
.PHONY: test
test:
@python3 reproduce.py
+50
View File
@@ -0,0 +1,50 @@
# MOLO-STATIC-001: static-file jail escape via a symlinked intermediate directory
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
In-house finding (not a public CVE), modeled on the general symlink-following path
traversal class (CWE-61, "UNIX Symbolic Link Following") that underlies many static
file server CVEs (for example nginx's historical alias-traversal advisories and
assorted CMS/static-server CVEs that rely on `O_NOFOLLOW` being assumed sufficient).
## Where
`src/runtime/static/disk_provider.cpp`, `DiskProvider::open`:
```cpp
int fd = openat(root_fd_, path.c_str(), O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
```
`O_NOFOLLOW` only blocks the kernel from dereferencing a symlink at the **final**
component of `path`. If an **earlier** path segment is a symlink pointing outside the
jailed root, the kernel follows it transparently while resolving the rest of the path,
and `openat` succeeds. The `realpath`-based containment check a few lines below only
runs when this `openat` call fails and `follow_symlinks_` (default `false`,
`disk_provider.h`) is true, so the strict, default configuration never reaches any
containment check at all for this shape of symlink.
## Relevance
`DiskProvider` is MoloApp's jailed static-file backend, the piece responsible for
keeping `/static/*` requests inside the configured root. This defeats that jail with
a single symlink an attacker needs only the ability to place inside the served
directory tree (a common outcome of an unrelated file-upload or archive-extraction
feature elsewhere in an app, or simply a misconfigured deploy that leaves a
developer's symlink in place).
## What the check does
Builds a scratch directory with `www/escape -> outside/` (a symlink one level inside
the served root) and `outside/secret.txt` holding a marker string, starts
`build/bin/runtime_interop_server` on that root with `follow_symlinks` at its default
(`false`), and requests `GET /static/escape/secret.txt`. PASS means the jail held
(404); FAIL means the marker string came back.
## Caveats
This does not test the `follow_symlinks=true` code path's own documented TOCTOU
window (that path already states its own limitation in a code comment); it tests the
supposedly-strict default, which the code comments do not flag as vulnerable to this
shape of symlink at all.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+55
View File
@@ -0,0 +1,55 @@
#!/usr/bin/env python3
# MOLO-STATIC-001: static-file jail escape via a symlinked intermediate
# directory, even with follow_symlinks=false (the default). See README.md.
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "lib"))
import molo_audit as m
SECRET = b"MOLO-AUDIT-OUTSIDE-SECRET\n"
def main():
m.arm_watchdog()
if not os.path.exists(m.INTEROP):
m.verdict_skip("%s not built (run make)" % m.INTEROP)
tmp = m.scratch_dir()
www = os.path.join(tmp, "www")
outside = os.path.join(tmp, "outside")
os.makedirs(www)
os.makedirs(outside)
with open(os.path.join(outside, "secret.txt"), "wb") as f:
f.write(SECRET)
# The symlink itself is the LAST path component only when resolving the
# link; "escape/secret.txt" makes it an INTERMEDIATE component, which
# openat's O_NOFOLLOW does not protect (it only blocks the final
# component of the path actually opened).
os.symlink(outside, os.path.join(www, "escape"))
srv = m.Server([m.INTEROP, "0", www])
port = srv.port
resp, _ = m.h1(port, b"GET /static/escape/secret.txt HTTP/1.1\r\nHost: x\r\n"
b"Connection: close\r\n\r\n", 1.5)
srv.stop()
if SECRET in resp:
m.verdict_fail(
"GET /static/escape/secret.txt returned the file from outside the static "
"root (follow_symlinks left at its default of false); DiskProvider::open "
"(disk_provider.cpp) uses openat(..., O_NOFOLLOW) which blocks a symlink "
"only as the FINAL path component, so a symlinked directory earlier in "
"the path is followed transparently, escaping the jail"
)
if m.status_lines(resp) == [404]:
m.verdict_pass(
"GET /static/escape/secret.txt was refused (404); the jail held against a "
"symlinked intermediate directory"
)
m.verdict_fail("unexpected response, neither the secret nor a clean 404: %r" % resp[:200])
if __name__ == "__main__":
main()
+24
View File
@@ -0,0 +1,24 @@
# MOLO-WS-001: see README.md in this directory. Compiles a tiny harness
# directly against the real HandshakeValidator (no server binary wires it
# to a live upgrade route today; see README "What the check does").
CXX ?= g++
ROOT := $(abspath ../..)
SRC := $(ROOT)/src
BUILD := $(abspath ../../build/audit-ws-001)
SOURCES := reproduce.cpp \
$(SRC)/realtime/websocket/server/handshake_validator.cpp \
$(SRC)/realtime/shared/sha1.cpp \
$(SRC)/realtime/shared/base64.cpp \
$(SRC)/realtime/shared/realtime_metrics.cpp \
$(SRC)/realtime/shared/http_seam.cpp
BIN := $(BUILD)/reproduce
.PHONY: test
test: $(BIN)
@$(BIN)
$(BIN): $(SOURCES)
@mkdir -p $(BUILD)
@$(CXX) -std=c++23 -Wall -Wextra -O1 -I$(SRC) -o $(BIN) $(SOURCES)
+46
View File
@@ -0,0 +1,46 @@
# MOLO-WS-001: WebSocket handshake has no Origin check (CSWSH)
**Scope:** [audit](../README.md) · [README](../../README.md) · [AGENTS](../../AGENTS.md)
CWE-1385 ("Missing Origin Validation in WebSockets"). Real-world instances of this
exact class include CVE-2024-23898 (Jenkins CLI, CVSS 9), CVE-2024-26135
(MeshCentral, CVSS 8.8) and CVE-2023-0957 (Gitpod, CVSS 8.2); the class, not a
MoloApp-specific CVE.
## Source
- [CERT/CC-adjacent writeups and NVD entries for CVE-2024-23898 and CVE-2024-26135](https://www.cve.org/CVERecord?id=CVE-2024-23898)
## Relevance to MoloApp
A browser attaches the page's `Origin` to a WebSocket handshake automatically and also
attaches same-site cookies, the same way it would to any other cross-site request.
If the server accepts the handshake without checking `Origin` against an allow-list,
any page an authenticated victim visits can open a WebSocket to the app and ride the
victim's session, a Cross-Site WebSocket Hijacking. Unlike ordinary CSRF, the
`Sec-Fetch-Site` and SameSite-cookie defenses that `CsrfGuard` relies on for regular
requests do not automatically apply to the opening handshake unless the WebSocket
layer checks `Origin` itself.
`src/realtime/websocket/server/handshake_validator.cpp`, `HandshakeValidator::validate`
checks method, `Upgrade`, `Connection`, the key's shape, version and subprotocol; it
never reads `Origin`, and `HandshakeConfig` (`handshake_validator.h`) has no
allowed-origins field to check against.
## What the check does
This class is "a pure function of request plus config: no I/O" (the header's own
comment) and is not wired to any upgrade route in the example app today, so there is
no live server to drive it through; the check instead compiles a tiny harness
(`reproduce.cpp`) against the real `handshake_validator.cpp`/`sha1.cpp`/`base64.cpp`/
`realtime_metrics.cpp` and calls `HandshakeValidator::validate` directly with a
well-formed handshake carrying `Origin: https://evil.example`. PASS means a future
origin check rejected it; FAIL means it was accepted (`ok == true`).
## Caveats
This is not a claim that an upgrade route exists in the shipped example today; it is
a check on the shared validator every real route would have to use, matching the
header's own description of the class as I/O-free and route-independent.
Run: `make test` in this directory, or `make -C audit test` from the repo root.
+48
View File
@@ -0,0 +1,48 @@
// MOLO-WS-001: WebSocket handshake accepts a cross-origin request with no
// Origin check, enabling Cross-Site WebSocket Hijacking. See README.md.
//
// There is no server binary that wires HandshakeValidator up to a live
// socket (example/fw's /ws/chat route never upgrades), so this check
// drives the real class directly, the same code every real upgrade path
// in src/realtime/websocket/server calls, with no server loop needed:
// HandshakeValidator::validate is documented as "Pure function of request
// plus config: no I/O."
#include <cstdio>
#include <cstdlib>
#include "realtime/websocket/server/handshake_validator.h"
using molo::realtime::websocket::server::HandshakeConfig;
using molo::realtime::websocket::server::HandshakeValidator;
namespace shared = molo::realtime::shared;
int main() {
shared::HttpRequest req;
req.method = "GET";
req.path = "/ws/chat";
req.headers.emplace("Upgrade", "websocket");
req.headers.emplace("Connection", "Upgrade");
req.headers.emplace("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ=="); // RFC 6455 example
req.headers.emplace("Sec-WebSocket-Version", "13");
// The victim's browser would attach this automatically; a same-site
// server has no business accepting it from an attacker's origin.
req.headers.emplace("Origin", "https://evil.example");
HandshakeValidator v(HandshakeConfig{});
auto result = v.validate(req);
if (result.ok) {
std::printf(
"FAIL: handshake for Origin: https://evil.example was accepted (status %d, "
"Sec-WebSocket-Accept: %s); HandshakeValidator::validate "
"(src/realtime/websocket/server/handshake_validator.cpp) never reads the "
"Origin header and HandshakeConfig has no allowed-origins field, so any "
"cross-site page can open this WebSocket carrying the victim's cookies "
"(CSWSH, CWE-1385)\n",
result.response.status, result.accept_key.c_str());
return 1;
}
std::printf("PASS: handshake for a cross-origin request was rejected (%s)\n",
result.failure_reason.c_str());
return 0;
}
+33
View File
@@ -0,0 +1,33 @@
# Runs every regression check under audit/ against this tree's built artifacts
# (build/bin/runtime_interop_server, build/example/living-server, build/molo, and
# a few checks that compile a tiny harness straight from src/).
# Usage:
# make -C audit test # sequential, stops at the first FAIL
# make -C audit -j8 test # concurrent, one job per check directory (recursive make)
# make -C audit report # runs every check, never stops, prefixes output with the check id
# make -C audit list # names the check directories this covers
#
# Each check's Makefile delegates to that directory's reproduce.py or reproduce.cpp,
# which prints exactly one of PASS, FAIL or SKIP and exits 0 for PASS/SKIP, 1 for FAIL.
# "test" is the hard cap: this file does not invent new checks, it only fans out to
# the fixed, named list below. See README.md.
MOLO_BUILD ?= $(abspath ../build)
CHECKS := $(sort $(wildcard MOLO-*))
export MOLO_BUILD
.PHONY: test $(CHECKS) list report
test: $(CHECKS)
@echo "audit: $(words $(CHECKS)) checks run against $(MOLO_BUILD)"
$(CHECKS):
@$(MAKE) -s -C $@ test MOLO_BUILD=$(MOLO_BUILD)
list:
@for c in $(CHECKS); do echo $$c; done
report:
@status=0; for c in $(CHECKS); do \
$(MAKE) -s -C $$c test MOLO_BUILD=$(MOLO_BUILD) 2>&1 | sed "s/^/$$c: /" || status=1; \
done; exit $$status
+92
View File
@@ -0,0 +1,92 @@
# audit
**Scope:** [README](../README.md) · [AGENTS](../AGENTS.md)
A fixed, named set of regression checks for vulnerability classes relevant to the
mechanisms MoloApp actually has (an in-house HTTP/1 and HTTP/2 server, an in-house
WebSocket/WebDAV/reverse-tunnel realtime stack, a shell-invoking CLI, in-house
crypto and an ORM), each in its own directory with where the problem lives, why it
matters to MoloApp specifically, and a check that reproduces it against real,
built artifacts. Modeled on the `audit/` convention used by the `doos` project:
capped to the issues that target code paths MoloApp actually has, not "every CVE",
consistent with the base rule that every automated process gets a fixed, named
ceiling instead of an open-ended scope.
Most of these are **in-house findings** from reading this codebase, not public CVE
assignments (MoloApp is not itself a CVE-tracked project); each README still cites
the real-world vulnerability *class* it is modeled on, with sources, so the check's
severity and shape can be judged against known precedent.
A check here answers one question: does *this build*, today, reproduce the exposure
described. It is not a claim that MoloApp is unaffected by anything not listed here.
## Running it
```
make # build/bin/runtime_interop_server, build/example/living-server, build/molo
make -C audit test # sequential
make -C audit -j8 test # concurrent, one job per check
make -C audit report # runs all, never stops, one line prefix per check
make -C audit list # names the check directories
```
Each check is independent, writes only under its own `mktemp -d` (Python checks) or
is a pure in-memory harness (C++ checks), and cleans up on exit. A check that needs
something the host does not have (an unbuilt binary) prints `SKIP` with the reason
and exits 0; it never reports PASS for a precondition it could not test. Every check
runs under a hard wall-clock watchdog (`audit/lib/molo_audit.py`'s `arm_watchdog`, or
an `alarm()` call in the C++ harnesses) so a check that finds a genuine hang reports
FAIL instead of wedging the suite.
## Verdicts
| Verdict | Meaning |
|---|---|
| `PASS` | This build does not reproduce the exposure described, under the conditions this check creates. |
| `FAIL` | It does. Treat as a regression; the check prints what it observed. |
| `SKIP` | The check's precondition was not met on this host (missing build). Not a verdict on MoloApp. |
## How a check drives the real thing
Three kinds of real artifact, no mocks:
- **Over a real socket**, against `build/bin/runtime_interop_server` (the runtime's
own interop test server: real HTTP/1.1, real h2c HTTP/2, real compression, real
static files, nothing stubbed) or `build/example/living-server`. These checks live
in `audit/lib/molo_audit.py`'s `H2`/`h1` helpers: a minimal HTTP/2 client speaking
real frames, and raw-socket HTTP/1.1, both stdlib-only Python.
- **Through the real CLI**, `build/molo`, run as a subprocess against a scratch
directory.
- **Against the real class directly**, for the handful of classes (`src/realtime/
websocket/server/handshake_validator.cpp`, `src/realtime/webdav/server/
resource_tree.cpp`, `src/realtime/expose/upstream.cpp`) that are pure, I/O-free
logic not yet wired to any route in the shipped example (`example/fw/` is
explicitly a skeleton still being re-bound to `src/`, per the main README). Each
such check's README says so and compiles a tiny harness straight from the real
`.cpp` file, the same code any real route would call, rather than skipping the
class entirely.
## What is deliberately not here
No kernel-level memory-corruption exploit code, and no check that requires outbound
network access (DNS resolution, reaching a real external host) to prove its point.
Everything here drives a MoloApp artifact through its real inputs inside a scratch
directory or a loopback socket; nothing here targets any host other than the one
running the check, and nothing here is a weaponized exploit for an unrelated target.
## The list
| Check | Mechanism | Modeled on |
|---|---|---|
| [MOLO-H1-001](MOLO-H1-001/) | HTTP/1 chunked-body cap bypass via chunk-size addition overflow | CWE-190 / request-smuggling-adjacent resource exhaustion |
| [MOLO-H2-001](MOLO-H2-001/) | HTTP/2 stream-open/reset churn, no rate limit | CVE-2023-44487 "Rapid Reset" |
| [MOLO-H2-002](MOLO-H2-002/) | HTTP/2 server-triggered reset churn | CVE-2025-8671 "MadeYouReset" |
| [MOLO-H2-003](MOLO-H2-003/) | HTTP/2 empty-CONTINUATION flood, byte cap only | CVE-2024-27316 "CONTINUATION flood" |
| [MOLO-H2-004](MOLO-H2-004/) | HTTP/2 PING flood to an unread peer, no queue cap | CVE-2019-9511/9512/9515/9518 HTTP/2 DoS batch |
| [MOLO-STATIC-001](MOLO-STATIC-001/) | Static-file jail escape via a symlinked intermediate directory | CWE-61 symlink following |
| [MOLO-CLI-001](MOLO-CLI-001/) | Shell command injection in `molo new <name>` | CWE-78 OS command injection |
| [MOLO-WS-001](MOLO-WS-001/) | WebSocket handshake has no Origin check | CWE-1385 / CVE-2024-23898-class CSWSH |
| [MOLO-DAV-001](MOLO-DAV-001/) | WebDAV COPY into its own subtree never terminates | CWE-674 uncontrolled recursion |
| [MOLO-EXPOSE-001](MOLO-EXPOSE-001/) | `expose` upstream allow-list bypassed by hostname prefix | CWE-184 incomplete allow-list / SSRF-adjacent |
Back to [README](../README.md), [AGENTS](../AGENTS.md).
+367
View File
@@ -0,0 +1,367 @@
"""Shared harness for the audit/ checks. Spec: audit/README.md.
Every check is a reproduce.py that imports this module, starts a scratch
server (or none), probes it over a real socket and ends in exactly one of
verdict_pass / verdict_fail / verdict_skip. Everything here has a hard cap:
check wall time (WATCHDOG_SECS), bytes sent, frames sent, read waits.
Python 3 stdlib only. No third-party dependency.
"""
import atexit
import os
import select
import shutil
import signal
import socket
import struct
import subprocess
import sys
import tempfile
import time
WATCHDOG_SECS = 90 # hard ceiling per check, see audit/README.md
READ_SLICE_SECS = 0.2 # select granularity
MAX_SEND_BYTES = 64 * 1024 * 1024 # no check may push more than this
ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
BUILD = os.environ.get("MOLO_BUILD", os.path.join(ROOT, "build"))
INTEROP = os.environ.get("MOLO_INTEROP", os.path.join(BUILD, "bin", "runtime_interop_server"))
LIVING = os.environ.get("MOLO_LIVING", os.path.join(BUILD, "example", "living-server"))
MOLO = os.environ.get("MOLO_BIN", os.path.join(BUILD, "molo"))
_cleanups = []
def _run_cleanups():
while _cleanups:
try:
_cleanups.pop()()
except Exception:
pass
atexit.register(_run_cleanups)
def _finish(tag, msg, code):
print("%s: %s" % (tag, msg))
sys.stdout.flush()
_run_cleanups()
os._exit(code)
def verdict_pass(msg):
_finish("PASS", msg, 0)
def verdict_skip(msg):
_finish("SKIP", msg, 0)
def verdict_fail(msg):
_finish("FAIL", msg, 1)
def _watchdog(signum, frame):
verdict_fail("check exceeded its %ds budget (server hang or unbounded work)" % WATCHDOG_SECS)
def arm_watchdog(secs=WATCHDOG_SECS):
signal.signal(signal.SIGALRM, _watchdog)
signal.alarm(secs)
def scratch_dir():
d = tempfile.mkdtemp(prefix="molo-audit-")
_cleanups.append(lambda: shutil.rmtree(d, ignore_errors=True))
return d
class Server:
"""A scratch server process on 127.0.0.1, killed on exit."""
def __init__(self, argv, ready_prefix="READY", ready_secs=10):
self.proc = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
text=True, cwd=argv_cwd(argv))
_cleanups.append(self.stop)
self.port = None
deadline = time.time() + ready_secs
while time.time() < deadline:
line = self.proc.stdout.readline()
if not line:
break
if line.startswith(ready_prefix) or "http://127.0.0.1:" in line:
self.port = int(line.strip().split(":")[-1].split()[-1])
break
if self.port is None:
verdict_skip("server did not report READY: %s" % " ".join(argv))
def rss_kb(self):
try:
with open("/proc/%d/status" % self.proc.pid) as f:
for ln in f:
if ln.startswith("VmRSS:"):
return int(ln.split()[1])
except OSError:
pass
return -1
def alive(self):
return self.proc.poll() is None
def stop(self):
if self.proc.poll() is None:
self.proc.kill()
try:
self.proc.wait(timeout=3)
except Exception:
pass
def argv_cwd(argv):
return None
def start_interop(www_files=None):
"""Start runtime_interop_server on an ephemeral port with a scratch www dir.
Returns (server, tmpdir). tmpdir/www is served, tmpdir/secret.txt is outside it."""
if not os.path.exists(INTEROP):
verdict_skip("%s not built (run make)" % INTEROP)
tmp = scratch_dir()
www = os.path.join(tmp, "www")
os.makedirs(www)
with open(os.path.join(www, "hello.txt"), "w") as f:
f.write("hello\n")
with open(os.path.join(www, "big.bin"), "wb") as f:
f.write(os.urandom(200 * 1024))
with open(os.path.join(tmp, "secret.txt"), "w") as f:
f.write("MOLO-AUDIT-SECRET-OUTSIDE-WWW\n")
for name, data in (www_files or {}).items():
with open(os.path.join(www, name), "wb") as f:
f.write(data)
return Server([INTEROP, "0", www]), tmp
def start_living():
if not os.path.exists(LIVING):
verdict_skip("%s not built (run make)" % LIVING)
s = socket.socket()
s.bind(("127.0.0.1", 0))
port = s.getsockname()[1]
s.close()
srv = Server([LIVING, str(port)], ready_prefix="living example")
return srv
# ---------------------------------------------------------------- HTTP/1
def connect(port, timeout=5):
s = socket.create_connection(("127.0.0.1", port), timeout=timeout)
return s
def recv_all(s, secs=1.0, cap=4 * 1024 * 1024):
"""Read until the peer closes, the cap is hit, or `secs` pass without data."""
buf = b""
s.setblocking(False)
end = time.time() + secs
closed = False
while time.time() < end and len(buf) < cap:
r, _, _ = select.select([s], [], [], READ_SLICE_SECS)
if r:
try:
d = s.recv(65536)
except (ConnectionResetError, BrokenPipeError):
closed = True
break
if not d:
closed = True
break
buf += d
end = time.time() + secs
return buf, closed
def h1(port, data, secs=1.0):
"""Send raw bytes, return (response bytes, closed_by_peer)."""
s = connect(port)
try:
s.sendall(data)
except OSError:
pass
out = recv_all(s, secs)
s.close()
return out
def status_lines(resp):
"""All 'HTTP/1.1 NNN' status codes found at line starts, in order."""
codes = []
for ln in resp.split(b"\r\n"):
if ln.startswith(b"HTTP/1.") and len(ln) >= 12:
try:
codes.append(int(ln[9:12]))
except ValueError:
pass
return codes
def alive_h1(port):
try:
resp, _ = h1(port, b"GET /echo HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n", 1.5)
return 200 in status_lines(resp)
except OSError:
return False
# ---------------------------------------------------------------- HTTP/2
PREFACE = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
T_DATA, T_HEADERS, T_PRIORITY, T_RST, T_SETTINGS, T_PUSH, T_PING, T_GOAWAY, T_WINDOW, T_CONT = range(10)
F_ACK = 0x1
F_END_STREAM = 0x1
F_END_HEADERS = 0x4
def frame(ftype, flags, sid, payload=b""):
n = len(payload)
return struct.pack(">BHBBI", (n >> 16) & 0xFF, n & 0xFFFF, ftype, flags, sid & 0x7FFFFFFF) + payload
def settings(pairs=()):
return frame(T_SETTINGS, 0, 0, b"".join(struct.pack(">HI", k, v) for k, v in pairs))
def _lit(idx, value):
v = value.encode() if isinstance(value, str) else value
return bytes([idx]) + bytes([len(v)]) + v if len(v) < 127 else None
def hpack_request(method="GET", path="/", authority="x", extra=()):
"""Header block using only static-table refs and plain literals."""
block = b"\x82" if method == "GET" else b"\x83" # :method GET / POST
block += b"\x86" # :scheme http
block += _lit(0x04, path) # :path (literal, name idx 4)
block += _lit(0x01, authority) # :authority (name idx 1)
for name, value in extra:
n, v = name.encode(), value.encode()
block += b"\x00" + bytes([len(n)]) + n + bytes([len(v)]) + v
return block
def hpack_int(prefix_bits, first_byte_flags, value):
mx = (1 << prefix_bits) - 1
if value < mx:
return bytes([first_byte_flags | value])
out = bytearray([first_byte_flags | mx])
value -= mx
while value >= 128:
out.append((value & 0x7F) | 0x80)
value >>= 7
out.append(value)
return bytes(out)
def parse_frames(buf):
frames = []
i = 0
while len(buf) - i >= 9:
n = (buf[i] << 16) | (buf[i + 1] << 8) | buf[i + 2]
if len(buf) - i - 9 < n:
break
ftype, flags = buf[i + 3], buf[i + 4]
sid = struct.unpack(">I", buf[i + 5:i + 9])[0] & 0x7FFFFFFF
frames.append((ftype, flags, sid, buf[i + 9:i + 9 + n]))
i += 9 + n
return frames, buf[i:]
class H2:
"""Prior-knowledge h2c client. Tracks every frame the server sends back."""
def __init__(self, port, initial_settings=()):
self.s = connect(port)
self.s.setblocking(False)
self.rbuf = b""
self.frames = []
self.closed = False
self.goaway = None # error code
self.sent = 0
self.sent_bytes = 0
self.raw(PREFACE + settings(initial_settings))
def _drain_read(self, secs=0.0):
try:
r, _, _ = select.select([self.s], [], [], secs)
while r:
d = self.s.recv(262144)
if not d:
self.closed = True
break
self.rbuf += d
r, _, _ = select.select([self.s], [], [], 0)
except (ConnectionResetError, BrokenPipeError, OSError):
self.closed = True
fr, self.rbuf = parse_frames(self.rbuf)
for f in fr:
self.frames.append(f)
if f[0] == T_GOAWAY and self.goaway is None:
self.goaway = struct.unpack(">I", f[3][4:8])[0] if len(f[3]) >= 8 else 0
return fr
def raw(self, data):
"""Blocking-ish send that keeps reading so a full buffer cannot deadlock."""
if self.sent_bytes + len(data) > MAX_SEND_BYTES:
verdict_fail("harness cap: refusing to send more than %d bytes" % MAX_SEND_BYTES)
view = memoryview(data)
deadline = time.time() + 20
while view and not self.closed and time.time() < deadline:
self._drain_read(0)
try:
_, w, _ = select.select([], [self.s], [], 0.05)
if w:
n = self.s.send(view[:65536])
view = view[n:]
self.sent_bytes += n
except (BlockingIOError, InterruptedError):
continue
except (ConnectionResetError, BrokenPipeError, OSError):
self.closed = True
return not view
def cut(self):
"""True once the server tore the connection down or sent GOAWAY."""
return self.closed or self.goaway is not None
def settle(self, secs=1.0):
end = time.time() + secs
while time.time() < end and not self.closed:
self._drain_read(0.1)
def count(self, ftype, flags_mask=None):
return sum(1 for f in self.frames
if f[0] == ftype and (flags_mask is None or f[1] & flags_mask))
def status_of(self, sid):
""":status first byte guess for a stream: 0x88 => 200 indexed."""
for f in self.frames:
if f[0] == T_HEADERS and f[2] == sid:
return f[3]
return None
def close(self):
try:
self.s.close()
except OSError:
pass
def flood(h2, make_frame, count, batch=100):
"""Send `count` frames in batches, stop early when the server cuts. Returns frames sent."""
sent = 0
while sent < count and not h2.cut():
n = min(batch, count - sent)
h2.raw(b"".join(make_frame(sent + i) for i in range(n)))
sent += n
h2.settle(1.0)
return sent