fix: repair Android 36 runtime edge cases

This commit is contained in:
xXJsonDeruloXx committed 2026-10-22 10:46:06 -04:00
commit 42239e0097
25 files changed
+539 -29

No files matched your search

@@ -119,6 +119,7 @@ if [ -n "${BL_VK_DRIVER:-}" ]; then
unset bl_icd_lib
fi
export GAMESCOPE_FORCE_VULKAN_REALTIME=${BL_GAMESCOPE_REALTIME:-0}
rm -rf /tmp/.droiddeck-rx
start_agent() {
[ -n "${BL_LAUNCH_DIR:-}" ] && [ -x /usr/local/bin/droiddeck-agent ] || return 0
+143 -2
View File
@@ -3,8 +3,15 @@
#include <errno.h>
#include <string.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/auxv.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <sys/statvfs.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <limits.h>
#if defined(__aarch64__) || defined(NOEXEC_TEST)
@@ -36,11 +43,145 @@ __attribute__((constructor)) static void noexec_init(void) {
real_mprotect = (int (*)(void *, size_t, int))dlsym(RTLD_NEXT, "mprotect");
}
static int private_file_mapping(uintptr_t start, uintptr_t end) {
int fd = (int)syscall(SYS_openat, AT_FDCWD, "/proc/self/maps", O_RDONLY | O_CLOEXEC);
if (fd < 0) return 0;
char buf[4096], line[1024];
size_t used = 0;
int found = 0, done = 0;
ssize_t n;
while (!done && (n = syscall(SYS_read, fd, buf, sizeof buf)) > 0) {
for (ssize_t i = 0; i < n && !done; i++) {
if (buf[i] != '\n') {
if (used < sizeof line - 1) line[used++] = buf[i];
continue;
}
line[used] = 0;
used = 0;
char *p = line;
uintptr_t lo = strtoull(p, &p, 16), hi = strtoull(p + 1, &p, 16);
if (start < lo || start >= hi) continue;
done = 1;
char *perms = p + 1;
if (end > hi || perms[3] != 'p') break;
char *path = strchr(perms, '/');
struct statvfs vfs;
found = path && !(statvfs(path, &vfs) == 0 && (vfs.f_flag & ST_NOEXEC));
}
}
syscall(SYS_close, fd);
return found;
}
static const char default_rx_dir[] = "/tmp/.droiddeck-rx";
static const char *rx_directory(void) {
#ifdef NOEXEC_TEST
const char *directory = getenv("DROIDDECK_NOEXEC_CACHE_DIR");
if (directory && *directory) return directory;
#endif
return default_rx_dir;
}
static uint64_t fnv1a(const unsigned char *p, size_t n) {
uint64_t h = 1469598103934665603ULL;
for (size_t i = 0; i < n; i++) {
h ^= p[i];
h *= 1099511628211ULL;
}
return h;
}
static char *put_hex(char *out, uint64_t v) {
for (int shift = 60; shift >= 0; shift -= 4) *out++ = "0123456789abcdef"[(v >> shift) & 15];
return out;
}
static int same_content(int fd, const unsigned char *p, size_t len) {
char buf[16384];
for (size_t off = 0; off < len;) {
size_t want = len - off < sizeof buf ? len - off : sizeof buf;
if (syscall(SYS_pread64, fd, buf, want, off) != (long)want || memcmp(buf, p + off, want)) return 0;
off += want;
}
return 1;
}
static int write_all(int fd, const unsigned char *p, size_t len) {
for (size_t off = 0; off < len;) {
long n = syscall(SYS_write, fd, p + off, len - off);
if (n <= 0) return -1;
off += (size_t)n;
}
return 0;
}
static int rebake_shared(void *addr, size_t len, int prot) {
const char *directory = rx_directory();
size_t directory_len = strlen(directory);
if (!directory_len || directory_len + 40 >= PATH_MAX) return -1;
char path[PATH_MAX], staged[PATH_MAX];
char *end = path + directory_len;
memcpy(path, directory, directory_len);
if (end[-1] != '/') *end++ = '/';
*end++ = '/';
end = put_hex(end, fnv1a(addr, len));
*end++ = '-';
end = put_hex(end, len);
*end = 0;
int fd = (int)syscall(SYS_openat, AT_FDCWD, path, O_RDONLY | O_CLOEXEC);
if (fd >= 0 && !same_content(fd, addr, len)) {
syscall(SYS_close, fd);
return -1;
}
if (fd < 0) {
syscall(SYS_mkdirat, AT_FDCWD, directory, 0700);
memcpy(staged, path, (size_t)(end - path));
char *tail = put_hex(staged + (end - path), (uint64_t)syscall(SYS_gettid));
*tail = 0;
int out = (int)syscall(SYS_openat, AT_FDCWD, staged, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0600);
if (out < 0) return -1;
int bad = write_all(out, addr, len);
syscall(SYS_close, out);
if (bad || syscall(SYS_renameat, AT_FDCWD, staged, AT_FDCWD, path)) {
syscall(SYS_unlinkat, AT_FDCWD, staged, 0);
return -1;
}
fd = (int)syscall(SYS_openat, AT_FDCWD, path, O_RDONLY | O_CLOEXEC);
if (fd < 0) return -1;
}
long mapped = syscall(SYS_mmap, addr, len, prot, MAP_PRIVATE | MAP_FIXED, fd, 0);
syscall(SYS_close, fd);
return mapped == (long)addr ? 0 : -1;
}
static int rebake(void *addr, size_t len, int prot) {
size_t page = getauxval(AT_PAGESZ);
if (page) len = (len + page - 1) & ~(page - 1);
if (real_mprotect(addr, len, PROT_READ)) return -1;
if (!rebake_shared(addr, len, prot)) return 0;
void *copy = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (copy == MAP_FAILED) return -1;
memcpy(copy, addr, len);
if (mmap(addr, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0) == MAP_FAILED) {
munmap(copy, len);
return -1;
}
memcpy(addr, copy, len);
munmap(copy, len);
__builtin___clear_cache((char *)addr, (char *)addr + len);
return real_mprotect(addr, len, prot);
}
int mprotect(void *addr, size_t len, int prot) {
if (!real_mprotect) noexec_init();
int result = real_mprotect(addr, len, prot);
if (result && errno == EACCES && (prot & PROT_EXEC) && in_fex()) {
result = real_mprotect(addr, len, prot & ~PROT_EXEC);
if (result && errno == EACCES && (prot & PROT_EXEC)) {
if (in_fex()) {
result = real_mprotect(addr, len, prot & ~PROT_EXEC);
} else if (len && private_file_mapping((uintptr_t)addr, (uintptr_t)addr + len)) {
result = rebake(addr, len, prot);
}
if (result) errno = EACCES;
}
return result;
+120
View File
@@ -70,5 +70,125 @@ class NoexecPreloadTest(unittest.TestCase):
self.assertEqual(refused[1:], ["protect 13", "read -"])
EXECMOD = r"""
#define _GNU_SOURCE
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <unistd.h>
static int private_file(void *addr) {
FILE *maps = fopen("/proc/self/maps", "r");
char line[512];
int found = 0;
while (maps && fgets(line, sizeof line, maps)) {
unsigned long lo, hi;
char perms[5];
if (sscanf(line, "%lx-%lx %4s", &lo, &hi, perms) != 3) continue;
if ((unsigned long)addr >= lo && (unsigned long)addr < hi) {
found = perms[3] == 'p' && strchr(line, '/') != NULL;
break;
}
}
if (maps) fclose(maps);
return found;
}
int mprotect(void *addr, size_t len, int prot) {
if ((prot & PROT_EXEC) && private_file(addr)) {
errno = EACCES;
return -1;
}
return (int)syscall(SYS_mprotect, addr, len, prot);
}
"""
CALLER = r"""
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
int main(int argc, char **argv) {
int fd = open(argv[1], O_RDWR);
unsigned char *code = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
#if defined(__aarch64__)
static const unsigned int body[] = {0x52800540, 0xd65f03c0};
#else
static const unsigned char body[] = {0xb8, 0x2a, 0x00, 0x00, 0x00, 0xc3};
#endif
memcpy(code + 64, body, sizeof body);
int result = mprotect(code, 4096, PROT_READ | PROT_EXEC);
printf("protect %d\n", result ? errno : 0);
__builtin___clear_cache((char *)code, (char *)code + 4096);
if (!result) printf("call %d\n", ((int (*)(void))(code + 64))());
printf("data %d\n", code[0]);
char line[512];
FILE *maps = fopen("/proc/self/maps", "r");
while (maps && fgets(line, sizeof line, maps)) {
unsigned long lo, hi;
if (sscanf(line, "%lx-%lx", &lo, &hi) == 2 && (unsigned long)code >= lo && (unsigned long)code < hi)
printf("shared %d\n", strstr(line, ".droiddeck-rx") != NULL);
}
return 0;
}
"""
@unittest.skipUnless(shutil.which("cc") and os.uname().sysname == "Linux", "needs cc on Linux")
class ExecmodRebakeTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = Path(tempfile.mkdtemp())
cls.lib = cls.tmp / "libnoexec.so"
subprocess.run(["cc", "-O2", "-Wall", "-Werror", "-fPIC", "-shared", "-pthread", "-DNOEXEC_TEST", "-o", str(cls.lib),
str(PRELOAD / "noexec.c"), str(PRELOAD / "fsync.c"), str(PRELOAD / "robust.c"), "-ldl"], check=True)
(cls.tmp / "execmod.c").write_text(EXECMOD)
cls.execmod = cls.tmp / "libexecmod.so"
subprocess.run(["cc", "-O2", "-fPIC", "-shared", "-o", str(cls.execmod), str(cls.tmp / "execmod.c")], check=True)
(cls.tmp / "caller.c").write_text(CALLER)
cls.caller = cls.tmp / "wine"
subprocess.run(["cc", "-O2", "-o", str(cls.caller), str(cls.tmp / "caller.c")], check=True)
cls.image = cls.tmp / "ntdll.dll"
cls.image.write_bytes(bytes([7]) + bytes(4095))
@classmethod
def tearDownClass(cls):
shutil.rmtree(cls.tmp, ignore_errors=True)
def setUp(self):
self.cache = self.tmp / self._testMethodName / "rx"
self.cache.mkdir(parents=True)
def tearDown(self):
shutil.rmtree(self.tmp / self._testMethodName, ignore_errors=True)
def run_with(self, *libs):
env = dict(os.environ, LD_PRELOAD=":".join(str(lib) for lib in libs),
DROIDDECK_NOEXEC_CACHE_DIR=str(self.cache))
result = subprocess.run([str(self.caller), str(self.image)], env=env, capture_output=True, text=True, check=True)
return result.stdout.split()
def test_a_refused_relocated_image_runs_from_anonymous_memory(self):
self.assertEqual(self.run_with(self.lib, self.execmod), ["protect", "0", "call", "42", "data", "7", "shared", "1"])
def test_processes_share_one_copy_of_the_code(self):
self.run_with(self.lib, self.execmod)
self.run_with(self.lib, self.execmod)
self.assertEqual(len(os.listdir(self.cache)), 1)
def test_without_the_preload_the_refusal_stands(self):
self.assertEqual(self.run_with(self.execmod), ["protect", "13", "data", "7", "shared", "0"])
def test_the_file_itself_is_not_changed(self):
self.run_with(self.lib, self.execmod)
self.assertEqual(self.image.read_bytes()[:65], bytes([7]) + bytes(64))
if __name__ == "__main__":
unittest.main()