// SPDX-License-Identifier: GPL-2.0/* * Test the 'L' (loader substitution) flag of binfmt_misc. A matched * binary runs as the MAIN image - a fully native exec - with the * registered interpreter substituted for its PT_INTERP. The payload * (binfmt_loader_payload) asserts the native identity from inside. * * The substitute is a copy of the system loader found via our own * PT_INTERP; magic matching pokes a marker into the ELF header's * e_ident padding, which kernel and loader ignore. * * Needs root for the registration; no bpf toolchain involved. */#define _GNU_SOURCE#include <elf.h>#include <link.h>#include <signal.h>#include <stddef.h>#include <stdio.h>#include <stdlib.h>#include <sys/mman.h>#include <sys/ptrace.h>#include <sys/syscall.h>#include <sys/wait.h> #include "binfmt_misc_common.h"#include "kselftest_harness.h" #define ENTRY "test_loader"#define INTERP_PATH "/tmp/binfmt_loader_interp"#define MOVED_PATH INTERP_PATH ".moved"#define TARGET_PATH "/tmp/binfmt_loader_target.ldrtest"#define STATIC_PATH "/tmp/binfmt_loader_static.ldrtest"#define FOREIGN_PATH "/tmp/binfmt_loader_foreign.ldrtest"#define SCRIPT_PATH "/tmp/binfmt_loader_script.ldrtest"#define M_RULE ":" ENTRY ":M:9:" LOADER_MARKER "::" INTERP_PATH ":L"#define E_RULE ":" ENTRY ":E::ldrtest::" INTERP_PATH ":L"#define FL_RULE ":" ENTRY ":E::ldrtest::" INTERP_PATH ":FL" /* Execute the binary from an inaccessible O_CLOEXEC memfd. */static int run_memfd(const char *path){ int status; pid_t pid; pid = fork(); if (pid == 0) { char *argv[] = { PAYLOAD_ARGV0, PAYLOAD_ARG1, PAYLOAD_ARG2, NULL }; char buf[4096]; int in, mfd; ssize_t n; mfd = memfd_create("loader-test", MFD_CLOEXEC); in = open(path, O_RDONLY); if (mfd < 0 || in < 0) _exit(125); while ((n = read(in, buf, sizeof(buf))) > 0) if (write(mfd, buf, n) != n) _exit(125); close(in); setenv("BINFMT_TEST_MEMFD", "1", 1); unsetenv("BINFMT_TEST_BINARY"); syscall(SYS_execveat, mfd, "", argv, environ, AT_EMPTY_PATH); _exit(126); } if (pid < 0 || waitpid(pid, &status, 0) != pid || !WIFEXITED(status)) return -1; return WEXITSTATUS(status);} /* * The differentiator against the transparent mode: at PTRACE_EVENT_EXEC * the identity is already complete - exe, auxv and the stat code markers * are mutually consistent with no window a debugger could observe. */static int ptrace_probe(const char *target){ unsigned long auxv[2 * 64], base = 0, entry = 0, at_flags = 0; unsigned long start_code = 0, end_code = 0; int status, fd, execfd_seen = 0, failed = 0; char path[64], buf[PATH_MAX]; ssize_t n; pid_t pid; int i; pid = fork(); if (pid == 0) { ptrace(PTRACE_TRACEME, 0, NULL, NULL); raise(SIGSTOP); execl(target, PAYLOAD_ARGV0, PAYLOAD_ARG1, PAYLOAD_ARG2, (char *)NULL); _exit(126); } if (pid < 0) return -1; if (waitpid(pid, &status, 0) != pid || !WIFSTOPPED(status)) goto fail_kill; if (ptrace(PTRACE_SETOPTIONS, pid, NULL, (void *)PTRACE_O_TRACEEXEC)) goto fail_kill; if (ptrace(PTRACE_CONT, pid, NULL, NULL)) goto fail_kill; if (waitpid(pid, &status, 0) != pid || !WIFSTOPPED(status) || status >> 8 != (SIGTRAP | (PTRACE_EVENT_EXEC << 8))) { fprintf(stderr, "no exec stop (status %#x)\n", status); goto fail_kill; } snprintf(path, sizeof(path), "/proc/%d/exe", pid); n = readlink(path, buf, sizeof(buf) - 1); if (n <= 0) { failed = 1; } else { buf[n] = '\0'; if (strcmp(buf, target)) { fprintf(stderr, "exe at exec stop: %s\n", buf); failed = 1; } } snprintf(path, sizeof(path), "/proc/%d/auxv", pid); fd = open(path, O_RDONLY); if (fd < 0) { n = -1; } else { n = read(fd, auxv, sizeof(auxv)); close(fd); } if (n <= 0) { failed = 1; n = 0; } for (i = 0; i + 1 < (int)(n / sizeof(unsigned long)); i += 2) { switch (auxv[i]) { case AT_BASE: base = auxv[i + 1]; break; case AT_ENTRY: entry = auxv[i + 1]; break; case AT_FLAGS: at_flags = auxv[i + 1]; break; case AT_EXECFD: execfd_seen = 1; break; } } if (stat_codes(pid, &start_code, &end_code)) failed = 1; if (!base || execfd_seen || at_flags) { fprintf(stderr, "auxv at exec stop not native\n"); failed = 1; } if (!start_code || entry < start_code || entry >= end_code) { fprintf(stderr, "auxv/stat inconsistent at exec stop\n"); failed = 1; } if (ptrace(PTRACE_CONT, pid, NULL, NULL)) goto fail_kill; if (waitpid(pid, &status, 0) != pid || !WIFEXITED(status) || WEXITSTATUS(status)) failed = 1; return failed ? -1 : 0; fail_kill: kill(pid, SIGKILL); waitpid(pid, &status, 0); return -1;} FIXTURE(loader) { bool have_static;}; FIXTURE_SETUP(loader){ unsigned short foreign_machine = 0xdead; char src[PATH_MAX], loader[PATH_MAX]; if (getuid() != 0) SKIP(return, "test must be run as root"); if (!binfmt_misc_available()) SKIP(return, "no binfmt_misc"); if (find_loader(loader, sizeof(loader))) SKIP(return, "cannot determine own PT_INTERP"); ASSERT_EQ(copy_file(loader, INTERP_PATH), 0); ASSERT_EQ(artifact_path(src, sizeof(src), "binfmt_loader_payload"), 0); ASSERT_EQ(copy_file(src, TARGET_PATH), 0); ASSERT_EQ(patch_file(TARGET_PATH, EI_PAD, LOADER_MARKER, strlen(LOADER_MARKER)), 0); /* The same payload with a machine type this kernel cannot load. */ ASSERT_EQ(copy_file(src, FOREIGN_PATH), 0); ASSERT_EQ(patch_file(FOREIGN_PATH, EI_PAD, LOADER_MARKER, strlen(LOADER_MARKER)), 0); ASSERT_EQ(patch_file(FOREIGN_PATH, offsetof(ElfW(Ehdr), e_machine), &foreign_machine, sizeof(foreign_machine)), 0); self->have_static = artifact_path(src, sizeof(src), "binfmt_loader_payload_static") == 0 && copy_file(src, STATIC_PATH) == 0; setenv("BINFMT_TEST_BINARY", TARGET_PATH, 1); setenv("BINFMT_TEST_INTERP", INTERP_PATH, 1); /* Everything below needs the flag; find out once. */ if (write_reg(E_RULE)) { ASSERT_EQ(errno, EINVAL); SKIP(return, "kernel without the 'L' flag"); } unregister(ENTRY);} FIXTURE_TEARDOWN(loader){ unregister(ENTRY); if (access(MOVED_PATH, F_OK) == 0) rename(MOVED_PATH, INTERP_PATH); unlink(TARGET_PATH); unlink(STATIC_PATH); unlink(FOREIGN_PATH); unlink(SCRIPT_PATH); unlink(INTERP_PATH);} /* Grammar sanity check: the same entry without 'L' has to register. */TEST_F(loader, plain_entry_registers){ ASSERT_EQ(write_reg(":" ENTRY ":E::ldrtest::" INTERP_PATH ":"), 0);} /* 'L' is a native exec: every classic-dispatch flag is rejected. */TEST_F(loader, rejects_classic_flags){ static const char * const combos[] = { "LT", "LP", "LC", "LO" }; char rule[PATH_MAX]; unsigned int i; for (i = 0; i < ARRAY_SIZE(combos); i++) { int rc; snprintf(rule, sizeof(rule), ":" ENTRY ":E::ldrtest::" INTERP_PATH ":%s", combos[i]); rc = write_reg(rule); EXPECT_EQ(rc, -1) TH_LOG("'%s' was not rejected", combos[i]); if (rc == 0) { unregister(ENTRY); continue; } EXPECT_EQ(errno, EINVAL); }} /* * Without 'F' the interpreter is opened when the binary is executed, so a * relative path would be resolved against the caller's working directory. */TEST_F(loader, rejects_relative_interpreter){ static const char * const flags[] = { "L", "C" }; char rule[PATH_MAX]; unsigned int i; for (i = 0; i < ARRAY_SIZE(flags); i++) { int rc; snprintf(rule, sizeof(rule), ":" ENTRY ":E::ldrtest::binfmt_loader_interp:%s", flags[i]); rc = write_reg(rule); EXPECT_EQ(rc, -1) TH_LOG("'%s' accepted a relative interpreter", flags[i]); if (rc == 0) { unregister(ENTRY); continue; } EXPECT_EQ(errno, EINVAL); }} TEST_F(loader, extension_matched){ ASSERT_EQ(write_reg(E_RULE), 0); EXPECT_EQ(run_payload(TARGET_PATH), 0);} TEST_F(loader, magic_matched){ ASSERT_EQ(write_reg(M_RULE), 0); EXPECT_EQ(run_payload(TARGET_PATH), 0);} /* * The differentiator against the transparent mode: at PTRACE_EVENT_EXEC the * identity is already complete, with no window a debugger could observe. */TEST_F(loader, exec_stop_consistency){ ASSERT_EQ(write_reg(E_RULE), 0); EXPECT_EQ(ptrace_probe(TARGET_PATH), 0);} /* A binary without PT_INTERP drops the override and runs natively. */TEST_F(loader, static_binary_runs_natively){ if (!self->have_static) SKIP(return, "no static payload built"); ASSERT_EQ(write_reg(E_RULE), 0); setenv("BINFMT_TEST_BINARY", STATIC_PATH, 1); setenv("BINFMT_TEST_STATIC", "1", 1); EXPECT_EQ(run_payload(STATIC_PATH), 0); unsetenv("BINFMT_TEST_STATIC"); setenv("BINFMT_TEST_BINARY", TARGET_PATH, 1);} /* * A '#!' file that matched an 'L' entry is claimed by binfmt_script, which * sits ahead of binfmt_elf. The substitute the entry staged has to be * released when the interpreter replaces the file, not leaked. */TEST_F(loader, script_claims_the_file){ static const char script[] = "#!/bin/sh\nexit 0\n"; int fd; unlink(SCRIPT_PATH); fd = open(SCRIPT_PATH, O_WRONLY | O_CREAT | O_EXCL, 0755); ASSERT_GE(fd, 0); ASSERT_EQ(write(fd, script, sizeof(script) - 1), (ssize_t)sizeof(script) - 1); ASSERT_EQ(close(fd), 0); ASSERT_EQ(write_reg(E_RULE), 0); EXPECT_EQ(run_payload(SCRIPT_PATH), 0); /* A leaked substitute keeps its write denial on the loader. */ fd = open(INTERP_PATH, O_WRONLY); EXPECT_GE(fd, 0) TH_LOG("loader still write denied (errno %d)", errno); if (fd >= 0) close(fd);} /* Nothing needs the binary's path, so an inaccessible fd works. */TEST_F(loader, inaccessible_memfd){ ASSERT_EQ(write_reg(M_RULE), 0); EXPECT_EQ(run_memfd(TARGET_PATH), 0);} /* The whole exec of a wrong-arch binary fails as if unhandled. */TEST_F(loader, foreign_arch_enoexec){ ASSERT_EQ(write_reg(M_RULE), 0); EXPECT_EQ(run_payload(FOREIGN_PATH), RUN_ENOEXEC);} /* 'F' pre-opens the substitute, so it survives losing its path. */TEST_F(loader, fixed_interpreter_survives_rename){ ASSERT_EQ(write_reg(FL_RULE), 0); ASSERT_EQ(rename(INTERP_PATH, MOVED_PATH), 0); EXPECT_EQ(run_payload(TARGET_PATH), 0);} TEST_HARNESS_MAIN
// SPDX-License-Identifier: GPL-2.0
/*
* Test the 'L' (loader substitution) flag of binfmt_misc. A matched
* binary runs as the MAIN image - a fully native exec - with the
* registered interpreter substituted for its PT_INTERP. The payload
* (binfmt_loader_payload) asserts the native identity from inside.
*
* The substitute is a copy of the system loader found via our own
* PT_INTERP; magic matching pokes a marker into the ELF header's
* e_ident padding, which kernel and loader ignore.
*
* Needs root for the registration; no bpf toolchain involved.
*/
#define _GNU_SOURCE
#include <elf.h>
#include <link.h>
#include <signal.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/ptrace.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include "binfmt_misc_common.h"
#include "kselftest_harness.h"
#define ENTRY "test_loader"
#define INTERP_PATH "/tmp/binfmt_loader_interp"
#define MOVED_PATH INTERP_PATH ".moved"
#define TARGET_PATH "/tmp/binfmt_loader_target.ldrtest"
#define STATIC_PATH "/tmp/binfmt_loader_static.ldrtest"
#define FOREIGN_PATH "/tmp/binfmt_loader_foreign.ldrtest"
#define SCRIPT_PATH "/tmp/binfmt_loader_script.ldrtest"
#define M_RULE ":" ENTRY ":M:9:" LOADER_MARKER "::" INTERP_PATH ":L"
#define E_RULE ":" ENTRY ":E::ldrtest::" INTERP_PATH ":L"
#define FL_RULE ":" ENTRY ":E::ldrtest::" INTERP_PATH ":FL"
/* Execute the binary from an inaccessible O_CLOEXEC memfd. */
static int run_memfd(const char *path)
{
int status;
pid_t pid;
pid = fork();
if (pid == 0) {
char *argv[] = { PAYLOAD_ARGV0, PAYLOAD_ARG1, PAYLOAD_ARG2, NULL };
char buf[4096];
int in, mfd;
ssize_t n;
mfd = memfd_create("loader-test", MFD_CLOEXEC);
in = open(path, O_RDONLY);
if (mfd < 0 || in < 0)
_exit(125);
while ((n = read(in, buf, sizeof(buf))) > 0)
if (write(mfd, buf, n) != n)
_exit(125);
close(in);
setenv("BINFMT_TEST_MEMFD", "1", 1);
unsetenv("BINFMT_TEST_BINARY");
syscall(SYS_execveat, mfd, "", argv, environ, AT_EMPTY_PATH);
_exit(126);
}
if (pid < 0 || waitpid(pid, &status, 0) != pid || !WIFEXITED(status))
return -1;
return WEXITSTATUS(status);
}
/*
* The differentiator against the transparent mode: at PTRACE_EVENT_EXEC
* the identity is already complete - exe, auxv and the stat code markers
* are mutually consistent with no window a debugger could observe.
*/
static int ptrace_probe(const char *target)
{
unsigned long auxv[2 * 64], base = 0, entry = 0, at_flags = 0;
unsigned long start_code = 0, end_code = 0;
int status, fd, execfd_seen = 0, failed = 0;
char path[64], buf[PATH_MAX];
ssize_t n;
pid_t pid;
int i;
pid = fork();
if (pid == 0) {
ptrace(PTRACE_TRACEME, 0, NULL, NULL);
raise(SIGSTOP);
execl(target, PAYLOAD_ARGV0, PAYLOAD_ARG1, PAYLOAD_ARG2, (char *)NULL);
_exit(126);
}
if (pid < 0)
return -1;
if (waitpid(pid, &status, 0) != pid || !WIFSTOPPED(status))
goto fail_kill;
if (ptrace(PTRACE_SETOPTIONS, pid, NULL, (void *)PTRACE_O_TRACEEXEC))
goto fail_kill;
if (ptrace(PTRACE_CONT, pid, NULL, NULL))
goto fail_kill;
if (waitpid(pid, &status, 0) != pid || !WIFSTOPPED(status) ||
status >> 8 != (SIGTRAP | (PTRACE_EVENT_EXEC << 8))) {
fprintf(stderr, "no exec stop (status %#x)\n", status);
goto fail_kill;
}
snprintf(path, sizeof(path), "/proc/%d/exe", pid);
n = readlink(path, buf, sizeof(buf) - 1);
if (n <= 0) {
failed = 1;
} else {
buf[n] = '\0';
if (strcmp(buf, target)) {
fprintf(stderr, "exe at exec stop: %s\n", buf);
failed = 1;
}
}
snprintf(path, sizeof(path), "/proc/%d/auxv", pid);
fd = open(path, O_RDONLY);
if (fd < 0) {
n = -1;
} else {
n = read(fd, auxv, sizeof(auxv));
close(fd);
}
if (n <= 0) {
failed = 1;
n = 0;
}
for (i = 0; i + 1 < (int)(n / sizeof(unsigned long)); i += 2) {
switch (auxv[i]) {
case AT_BASE:
base = auxv[i + 1];
break;
case AT_ENTRY:
entry = auxv[i + 1];
break;
case AT_FLAGS:
at_flags = auxv[i + 1];
break;
case AT_EXECFD:
execfd_seen = 1;
break;
}
}
if (stat_codes(pid, &start_code, &end_code))
failed = 1;
if (!base || execfd_seen || at_flags) {
fprintf(stderr, "auxv at exec stop not native\n");
failed = 1;
}
if (!start_code || entry < start_code || entry >= end_code) {
fprintf(stderr, "auxv/stat inconsistent at exec stop\n");
failed = 1;
}
if (ptrace(PTRACE_CONT, pid, NULL, NULL))
goto fail_kill;
if (waitpid(pid, &status, 0) != pid || !WIFEXITED(status) ||
WEXITSTATUS(status))
failed = 1;
return failed ? -1 : 0;
fail_kill:
kill(pid, SIGKILL);
waitpid(pid, &status, 0);
return -1;
}
FIXTURE(loader) {
bool have_static;
};
FIXTURE_SETUP(loader)
{
unsigned short foreign_machine = 0xdead;
char src[PATH_MAX], loader[PATH_MAX];
if (getuid() != 0)
SKIP(return, "test must be run as root");
if (!binfmt_misc_available())
SKIP(return, "no binfmt_misc");
if (find_loader(loader, sizeof(loader)))
SKIP(return, "cannot determine own PT_INTERP");
ASSERT_EQ(copy_file(loader, INTERP_PATH), 0);
ASSERT_EQ(artifact_path(src, sizeof(src), "binfmt_loader_payload"), 0);
ASSERT_EQ(copy_file(src, TARGET_PATH), 0);
ASSERT_EQ(patch_file(TARGET_PATH, EI_PAD, LOADER_MARKER,
strlen(LOADER_MARKER)), 0);
/* The same payload with a machine type this kernel cannot load. */
ASSERT_EQ(copy_file(src, FOREIGN_PATH), 0);
ASSERT_EQ(patch_file(FOREIGN_PATH, EI_PAD, LOADER_MARKER,
strlen(LOADER_MARKER)), 0);
ASSERT_EQ(patch_file(FOREIGN_PATH, offsetof(ElfW(Ehdr), e_machine),
&foreign_machine, sizeof(foreign_machine)), 0);
self->have_static =
artifact_path(src, sizeof(src), "binfmt_loader_payload_static") == 0 &&
copy_file(src, STATIC_PATH) == 0;
setenv("BINFMT_TEST_BINARY", TARGET_PATH, 1);
setenv("BINFMT_TEST_INTERP", INTERP_PATH, 1);
/* Everything below needs the flag; find out once. */
if (write_reg(E_RULE)) {
ASSERT_EQ(errno, EINVAL);
SKIP(return, "kernel without the 'L' flag");
}
unregister(ENTRY);
}
FIXTURE_TEARDOWN(loader)
{
unregister(ENTRY);
if (access(MOVED_PATH, F_OK) == 0)
rename(MOVED_PATH, INTERP_PATH);
unlink(TARGET_PATH);
unlink(STATIC_PATH);
unlink(FOREIGN_PATH);
unlink(SCRIPT_PATH);
unlink(INTERP_PATH);
}
/* Grammar sanity check: the same entry without 'L' has to register. */
TEST_F(loader, plain_entry_registers)
{
ASSERT_EQ(write_reg(":" ENTRY ":E::ldrtest::" INTERP_PATH ":"), 0);
}
/* 'L' is a native exec: every classic-dispatch flag is rejected. */
TEST_F(loader, rejects_classic_flags)
{
static const char * const combos[] = { "LT", "LP", "LC", "LO" };
char rule[PATH_MAX];
unsigned int i;
for (i = 0; i < ARRAY_SIZE(combos); i++) {
int rc;
snprintf(rule, sizeof(rule),
":" ENTRY ":E::ldrtest::" INTERP_PATH ":%s", combos[i]);
rc = write_reg(rule);
EXPECT_EQ(rc, -1)
TH_LOG("'%s' was not rejected", combos[i]);
if (rc == 0) {
unregister(ENTRY);
continue;
}
EXPECT_EQ(errno, EINVAL);
}
}
/*
* Without 'F' the interpreter is opened when the binary is executed, so a
* relative path would be resolved against the caller's working directory.
*/
TEST_F(loader, rejects_relative_interpreter)
{
static const char * const flags[] = { "L", "C" };
char rule[PATH_MAX];
unsigned int i;
for (i = 0; i < ARRAY_SIZE(flags); i++) {
int rc;
snprintf(rule, sizeof(rule),
":" ENTRY ":E::ldrtest::binfmt_loader_interp:%s",
flags[i]);
rc = write_reg(rule);
EXPECT_EQ(rc, -1)
TH_LOG("'%s' accepted a relative interpreter", flags[i]);
if (rc == 0) {
unregister(ENTRY);
continue;
}
EXPECT_EQ(errno, EINVAL);
}
}
TEST_F(loader, extension_matched)
{
ASSERT_EQ(write_reg(E_RULE), 0);
EXPECT_EQ(run_payload(TARGET_PATH), 0);
}
TEST_F(loader, magic_matched)
{
ASSERT_EQ(write_reg(M_RULE), 0);
EXPECT_EQ(run_payload(TARGET_PATH), 0);
}
/*
* The differentiator against the transparent mode: at PTRACE_EVENT_EXEC the
* identity is already complete, with no window a debugger could observe.
*/
TEST_F(loader, exec_stop_consistency)
{
ASSERT_EQ(write_reg(E_RULE), 0);
EXPECT_EQ(ptrace_probe(TARGET_PATH), 0);
}
/* A binary without PT_INTERP drops the override and runs natively. */
TEST_F(loader, static_binary_runs_natively)
{
if (!self->have_static)
SKIP(return, "no static payload built");
ASSERT_EQ(write_reg(E_RULE), 0);
setenv("BINFMT_TEST_BINARY", STATIC_PATH, 1);
setenv("BINFMT_TEST_STATIC", "1", 1);
EXPECT_EQ(run_payload(STATIC_PATH), 0);
unsetenv("BINFMT_TEST_STATIC");
setenv("BINFMT_TEST_BINARY", TARGET_PATH, 1);
}
/*
* A '#!' file that matched an 'L' entry is claimed by binfmt_script, which
* sits ahead of binfmt_elf. The substitute the entry staged has to be
* released when the interpreter replaces the file, not leaked.
*/
TEST_F(loader, script_claims_the_file)
{
static const char script[] = "#!/bin/sh\nexit 0\n";
int fd;
unlink(SCRIPT_PATH);
fd = open(SCRIPT_PATH, O_WRONLY | O_CREAT | O_EXCL, 0755);
ASSERT_GE(fd, 0);
ASSERT_EQ(write(fd, script, sizeof(script) - 1),
(ssize_t)sizeof(script) - 1);
ASSERT_EQ(close(fd), 0);
ASSERT_EQ(write_reg(E_RULE), 0);
EXPECT_EQ(run_payload(SCRIPT_PATH), 0);
/* A leaked substitute keeps its write denial on the loader. */
fd = open(INTERP_PATH, O_WRONLY);
EXPECT_GE(fd, 0)
TH_LOG("loader still write denied (errno %d)", errno);
if (fd >= 0)
close(fd);
}
/* Nothing needs the binary's path, so an inaccessible fd works. */
TEST_F(loader, inaccessible_memfd)
{
ASSERT_EQ(write_reg(M_RULE), 0);
EXPECT_EQ(run_memfd(TARGET_PATH), 0);
}
/* The whole exec of a wrong-arch binary fails as if unhandled. */
TEST_F(loader, foreign_arch_enoexec)
{
ASSERT_EQ(write_reg(M_RULE), 0);
EXPECT_EQ(run_payload(FOREIGN_PATH), RUN_ENOEXEC);
}
/* 'F' pre-opens the substitute, so it survives losing its path. */
TEST_F(loader, fixed_interpreter_survives_rename)
{
ASSERT_EQ(write_reg(FL_RULE), 0);
ASSERT_EQ(rename(INTERP_PATH, MOVED_PATH), 0);
EXPECT_EQ(run_payload(TARGET_PATH), 0);
}
TEST_HARNESS_MAIN