Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
27 changes: 25 additions & 2 deletions cmake/AgenttyTests.cmake
Original file line number Diff line number Diff line change
Expand Up @@ -310,8 +310,7 @@ target_compile_definitions(ws_bind_probe PRIVATE
# exec_exit_probe: does a (sandboxed) command come back when it exits, or only
# at its timeout? Same sources and rationale as ws_bind_probe; run by hand:
# cmake --build build --target exec_exit_probe && ./build/exec_exit_probe <dir> [on|off] [syscall_mode]
add_executable(exec_exit_probe EXCLUDE_FROM_ALL
${CMAKE_SOURCE_DIR}/tests/exec_exit_probe.cpp
set(_AGENTTY_EXEC_SANDBOX_SOURCES
${CMAKE_SOURCE_DIR}/tests/sandbox_config_race_stubs.cpp
${CMAKE_SOURCE_DIR}/src/tool/util/sandbox.cpp
${CMAKE_SOURCE_DIR}/src/tool/util/sandbox_claybin.cpp
Expand All @@ -327,6 +326,9 @@ add_executable(exec_exit_probe EXCLUDE_FROM_ALL
${CMAKE_SOURCE_DIR}/src/util/home_dir.cpp
${CMAKE_SOURCE_DIR}/src/util/user_root.cpp
${CMAKE_SOURCE_DIR}/src/util/teardown.cpp)
add_executable(exec_exit_probe EXCLUDE_FROM_ALL
${CMAKE_SOURCE_DIR}/tests/exec_exit_probe.cpp
${_AGENTTY_EXEC_SANDBOX_SOURCES})
target_include_directories(exec_exit_probe PRIVATE ${CMAKE_SOURCE_DIR}/include)
target_link_libraries(exec_exit_probe PRIVATE
claybin nlohmann_json::nlohmann_json Threads::Threads maya::app)
Expand All @@ -340,6 +342,27 @@ endif()
target_compile_definitions(exec_exit_probe PRIVATE
AGENTTY_MCP=0)

# Real native Linux x86_64 multilib enforcement, not a plan/mock test.
# Missing host multilib or sandbox capabilities are explicit CTest skips;
# run sandbox_multilib_test --require to make those failures instead.
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|amd64|AMD64)$"
AND NOT CMAKE_CROSSCOMPILING)
add_executable(sandbox_multilib_test
${CMAKE_SOURCE_DIR}/tests/sandbox_multilib_test.cpp
${_AGENTTY_EXEC_SANDBOX_SOURCES})
target_include_directories(sandbox_multilib_test PRIVATE ${CMAKE_SOURCE_DIR}/include)
target_link_libraries(sandbox_multilib_test PRIVATE
claybin nlohmann_json::nlohmann_json Threads::Threads maya::app)
if(TARGET mcp::tools)
target_link_libraries(sandbox_multilib_test PRIVATE mcp::tools)
endif()
target_compile_definitions(sandbox_multilib_test PRIVATE AGENTTY_MCP=0)
agentty_test(sandbox_multilib_test MODE raw TIMEOUT 180 LABELS sandbox multilib)
add_test(NAME sandbox_multilib_test COMMAND sandbox_multilib_test)
set_tests_properties(sandbox_multilib_test PROPERTIES
SKIP_RETURN_CODE 77 TIMEOUT 180 LABELS "sandbox;multilib")
endif()

# sandbox_audit: what does agentty ACTUALLY enforce on THIS host?
#
# Not a test -- it asserts nothing. It prints the real posture, capability by
Expand Down
8 changes: 8 additions & 0 deletions src/tool/util/sandbox.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -406,6 +406,14 @@ void relax_wx_for_jit(claybin_backend::Posture& p, std::string_view cmd) {
}
#else
for (const char* r : kSystemReadRoots) p.system_read_roots.emplace_back(r);
#if defined(__linux__)
// /usr/lib32 (and Debian's /usr/lib/i386-linux-gnu) are already under
// the read-only /usr bind. Separate top-level multilib roots are optional.
for (const char* r : {"/lib32", "/libx32"}) {
std::error_code ec;
if (fs::is_directory(r, ec)) p.system_read_roots.emplace_back(r);
}
#endif
for (const char* f : kEtcReadable) p.etc_readable.emplace_back(f);
if (cfg.fs_scope == sandbox_cfg::FsScope::Toolchain) {
if (const char* home = std::getenv("HOME"); home && *home) {
Expand Down
50 changes: 50 additions & 0 deletions src/tool/util/sandbox_claybin.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -42,6 +42,7 @@
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <filesystem>
#include <string>
#include <string_view>
#include <utility>
Expand All @@ -66,6 +67,7 @@ extern "C" char** environ;
#include "claybin/policy/profiles.hpp"

#if defined(__linux__)
#include "claybin/policy/profiles_i386.hpp"
#include <arpa/inet.h>
#include <netinet/in.h>
#include "claybin/broker/notify.hpp"
Expand Down Expand Up @@ -272,6 +274,25 @@ namespace {

// ── the read set, from the SHARED lists ───────────────────────────────
for (const auto& root : p.system_read_roots) {
#if defined(__linux__)
// A bind follows the SOURCE symlink and creates a real directory at
// the destination. Flattening /lib -> usr/lib makes the loader's
// ../lib32/ld-linux.so.2 resolve to /lib32 rather than /usr/lib32.
// Recreate only the well-known merged-/usr aliases; /usr is already
// read-only. Never follow an alias into an unrelated host directory.
if (root == "/bin" || root == "/sbin" || root == "/lib" ||
root == "/lib64" || root == "/lib32" || root == "/libx32") {
std::error_code ec;
const auto target = std::filesystem::read_symlink(root, ec);
if (!ec) {
const auto resolved = std::filesystem::canonical(root, ec);
if (!ec && resolved.string().starts_with("/usr/")) {
d = std::move(d).symlink(target.string(), root);
continue;
}
}
}
#endif
// /usr and /bin must exist for a shell to run at all; the rest are
// best-effort, matching --ro-bind-try.
if (root == "/usr" || root == "/bin")
Expand Down Expand Up @@ -520,6 +541,35 @@ namespace {
std::span<const std::uint32_t>{kFamilies},
clay::SysAction::errno_, 97 /* EAFNOSUPPORT */);
}
#endif
#if defined(__linux__) && defined(__x86_64__)
// Enabling the second ABI is explicit in Claybin; never reinterpret native
// syscall numbers as compatibility numbers. A kernel without IA32 emulation
// still rejects i386 exec with ENOEXEC, without changing native execution.
auto compat = p.syscall_mode == 0 ? SyscallPolicy::everything()
: (p.syscall_mode == 2 && p.net_mode == 1
? profiles_i386::compiler() : profiles_i386::compiler_with_network());
if (p.wx_protect) {
// Legacy mmap hides prot behind a pointer and cannot be inspected.
compat.deny(90, 38 /* ENOSYS */);
for (auto nr : {192u /* mmap2 */, 125u /* mprotect */, 380u /* pkey_mprotect */})
compat.deny_arg_all(nr, 2, 6, SysAction::errno_, 1);
} else {
for (auto nr : {192u, 125u, 380u}) compat.drop_arg_rules(nr, 2);
}
if (p.syscall_mode != 0) {
static constexpr std::uint32_t families[] = {1, 2, 10};
compat.allow_arg32_only(359 /* socket */, 0, std::span<const std::uint32_t>{families},
SysAction::errno_, 97);
compat.allow_arg32_only(360 /* socketpair */, 0, std::span<const std::uint32_t>{families},
SysAction::errno_, 97);
// socketcall hides the socket family in guest memory; allowing it would
// bypass the family filter above. Modern i386 libc uses direct calls.
compat.deny(102 /* socketcall */, 38);
}
// Compatibility ptrace/signal calls remain denied, not sent to a broker
// whose syscall decoding currently understands only the native ABI.
d = std::move(d).syscall_profile_i386(std::move(compat));
#endif
d = std::move(d).syscall_profile(std::move(sp));

Expand Down
213 changes: 213 additions & 0 deletions tests/sandbox_multilib_test.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,213 @@
// Native multilib coverage of the shipped set_config -> init -> shell path.
// Run with --require to treat missing host capabilities as failures.
#include "agentty/tool/util/sandbox.hpp"
#include "agentty/tool/util/subprocess.hpp"
#include "agentty/domain/sandbox_config.hpp"
#include "agentty/util/io.hpp"

#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <stdexcept>
#include <string>
#include <vector>
#if defined(__linux__)
#include <unistd.h>
#endif

namespace sb = agentty::tools::util::sandbox;
namespace util = agentty::tools::util;
// Same narrow tool-layer stub as exec_exit_probe / sandbox_live_check.
namespace agentty::tools::util { void set_workspace_root(Io, std::filesystem::path); }

namespace {
std::string quote(const std::string& s) {
std::string out = "'";
for (char c : s) out += c == '\'' ? "'\\''" : std::string(1, c);
return out + "'";
}
void save(const std::filesystem::path& p, const char* text) {
std::ofstream f(p);
f << text;
if (!f) throw std::runtime_error("cannot write fixture: " + p.string());
}
bool expect(const char* label, const util::SubprocessResult& r, int code) {
if (r.started && !r.timed_out && r.exit_code == code) {
std::printf("PASS: %s (exit %d)\n", label, code);
return true;
}
std::fprintf(stderr, "FAIL: %s: started=%d timeout=%d exit=%d expected=%d\n%s%s\n",
label, int(r.started), int(r.timed_out), r.exit_code, code,
r.start_error.c_str(), r.output.c_str());
return false;
}
int skip(bool require, const std::string& why) {
std::fprintf(stderr, "%s: %s\n", require ? "FAIL (--require)" : "SKIP", why.c_str());
return require ? 1 : 77;
}
}

int main(int argc, char** argv) {
bool require = false;
bool explicit_loader = false;
for (int i = 1; i < argc; ++i) {
const std::string arg(argv[i]);
if (arg == "--require") require = true;
else if (arg == "--explicit-loader") explicit_loader = true;
else {
std::fprintf(stderr, "usage: %s [--require] [--explicit-loader]\n", argv[0]);
return 1;
}
}
#if !defined(__linux__) || !defined(__x86_64__)
return skip(require, "requires native Linux x86_64");
#else
std::string pattern = (std::filesystem::current_path() / "agentty-multilib-XXXXXX").string();
const char* made = ::mkdtemp(pattern.data());
if (!made) { std::perror("mkdtemp"); return 1; }
const std::filesystem::path root(made);
struct Cleanup {
std::filesystem::path p;
~Cleanup() {
std::error_code ec;
std::filesystem::remove_all(p, ec);
std::filesystem::remove(p.string() + "-outside", ec);
}
} cleanup{root};
try {
const std::string outside = root.string() + "-outside";
save(outside, "host-writable sentinel\n");
const auto host = [&](const std::string& cmd) {
return util::run_command_s("cd " + quote(root.string()) + " && " + cmd,
64 * 1024, std::chrono::seconds{30});
};
// Do not customize PT_INTERP: the system's default i386 loader is the regression.
save(root / "baseline.c", "int main(void) { return 42; }\n");
if (!expect("compile native baseline", host("gcc -m64 baseline.c -o baseline64"), 0)) return 1;
if (!expect("host native baseline", host("./baseline64"), 42)) return 1;

save(root / "library.c", "int multilib_answer(void) { return 42; }\n");
save(root / "dynamic.c", R"C(
#include <dlfcn.h>
int main(void) {
void *h = dlopen("./libmultilib.so", RTLD_NOW);
if (!h) return 10;
int (*answer)(void) = (int (*)(void))dlsym(h, "multilib_answer");
if (!answer) return 11;
int result = answer();
return dlclose(h) == 0 ? result : 12;
}
)C");
save(root / "restrictions.c", R"C(
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <linux/sched.h>
#include <unistd.h>
static int denied(void) { return errno == EPERM || errno == EACCES || errno == EROFS; }
int main(int argc, char **argv) {
if (argc != 3) return 20;
if (!strcmp(argv[1], "write")) {
int fd = open("workspace-write", O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (fd < 0 || write(fd, "ok", 2) != 2 || close(fd)) return 21;
fd = open(argv[2], O_WRONLY | O_TRUNC);
if (fd >= 0) { close(fd); return 22; }
return denied() ? 0 : 23;
}
if (!strcmp(argv[1], "unshare")) {
(void)syscall(SYS_unshare, CLONE_NEWUSER);
return 24; /* Hard denied in both ABIs, not a brokered syscall. */
}
if (!strcmp(argv[1], "rwx")) {
void *p = mmap(0, 4096, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (p != MAP_FAILED) { munmap(p, 4096); return 25; }
return denied() ? 0 : 26;
}
if (!strcmp(argv[1], "mprotect")) {
void *p = mmap(0, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (p == MAP_FAILED) return 27;
errno = 0;
int ok = mprotect(p, 4096, PROT_READ | PROT_WRITE | PROT_EXEC) == -1 && denied();
munmap(p, 4096);
return ok ? 0 : 28;
}
return 29;
}
)C");
if (!expect("compile native restrictions", host("gcc -m64 restrictions.c -o restrictions64"), 0)) return 1;

util::set_workspace_root(agentty::IoAccess::grant(), root);
agentty::sandbox_cfg::Config cfg; // Default balanced/compiler policy; no relaxed syscall overrides.
cfg.configured = true;
// Visible and host-writable, but deliberately not in write_paths.
cfg.read_paths.push_back(outside);
cfg.net_mode = agentty::sandbox_cfg::NetMode::None;
sb::set_config(cfg);
if (!sb::init(sb::Mode::On) || !sb::is_active())
return skip(require, "real sandbox unavailable: " + sb::describe_state());
if (sb::requested_mode() != sb::Mode::On || sb::detected_backend() != sb::Backend::Claybin) {
std::fprintf(stderr, "FAIL: expected Mode::On and claybin: %s\n", sb::describe_state().c_str());
return 1;
}
const auto sandbox = [&](const std::string& cmd) {
return sb::run_shell_command("cd " + quote(root.string()) + " && " + cmd,
64 * 1024, std::chrono::seconds{30});
};
// Once init claims a real backend, execution failures are not downgraded to skips.
bool ok = expect("sandbox native baseline", sandbox("./baseline64"), 42);
const auto restrictions = [&](const char* bits) {
bool passed = true;
for (const char* check : {"write", "rwx", "mprotect"}) {
const std::string cmd = "./restrictions" + std::string(bits) + " " + check + " " + quote(outside);
passed = expect(cmd.c_str(), sandbox(cmd), 0) && passed;
}
// unshare is deliberately KILL in both profiles: SIGSYS maps to 159.
const std::string cmd = "./restrictions" + std::string(bits) + " unshare " + quote(outside);
return expect(cmd.c_str(), sandbox(cmd), 159) && passed;
};
ok = restrictions("64") && ok;
if (!ok) return 1;

// Only i386 coverage may be skipped after the native sandbox checks pass.
const auto multilib = host("gcc -m32 baseline.c -o baseline32");
if (!multilib.started || multilib.timed_out) {
expect("multilib compiler invocation", multilib, 0);
return 1;
}
if (multilib.exit_code != 0)
return skip(require, "i386 coverage only: gcc -m32 cannot build the minimal libc fixture:\n" + multilib.output);
const auto runtime = host("./baseline32");
if (runtime.started && !runtime.timed_out &&
(runtime.exit_code == 126 || runtime.exit_code == 127)) {
if (explicit_loader) {
std::fprintf(stderr, "DIAGNOSTIC ONLY: explicit loader does not satisfy default-interpreter coverage\n");
const auto compiled = host("gcc -m32 baseline.c -Wl,--dynamic-linker=/usr/lib32/ld-linux.so.2 -o diagnostic32");
if (expect("diagnostic explicit-loader compile", compiled, 0) &&
expect("diagnostic explicit-loader host baseline", host("./diagnostic32"), 42))
expect("diagnostic explicit-loader sandbox baseline", sandbox("./diagnostic32"), 42);
}
return skip(require, "i386 coverage only: host cannot execute default-interpreter ELF (kernel/loader unavailable):\n" + runtime.output);
}
if (!expect("host i386 baseline", runtime, 42)) return 1;
// After the capability probe, fixture failures are never capability skips.
for (const auto& cmd : std::vector<std::string>{
"gcc -m32 -fPIC -shared library.c -o libmultilib.so",
"gcc -m32 dynamic.c -ldl -o dynamic32",
"gcc -m32 restrictions.c -o restrictions32"})
if (!expect(cmd.c_str(), host(cmd), 0)) return 1;
if (!expect("host i386 dlopen", host("./dynamic32"), 42)) return 1;
ok = expect("sandbox default-interpreter i386 baseline", sandbox("./baseline32"), 42) && ok;
ok = expect("sandbox i386 dlopen shared library", sandbox("./dynamic32"), 42) && ok;
ok = restrictions("32") && ok;
return ok ? 0 : 1;
} catch (const std::exception& e) {
std::fprintf(stderr, "FAIL: %s\n", e.what());
return 1;
}
#endif
}
Loading