// Part of libddnatv-hook.so, included by ddnatv-hook.c (one translation unit, so the // parts share their static functions and are built with the same command as before). // // The SIGSYS handler for system calls Android's seccomp filter blocks, and the signal hooks that // keep programs from replacing or blocking it. #ifndef DDNATV_HOST_TEST #ifndef SYS_SECCOMP #define SYS_SECCOMP 1 #endif static int (*get_real_sigaction(void))(int, const struct sigaction *, struct sigaction *); // A program's own SIGSYS handler, for the traps of a seccomp filter it installed itself (Firefox's // and Chromium's sandboxes emulate the calls they trap there). Android's app filter traps with data // 0; such a sandbox's traps carry their own nonzero data, which the kernel gives as si_errno. static struct sigaction g_app_sigsys; static int g_app_sigsys_set = 0; static void remember_app_sigsys(const struct sigaction *act, struct sigaction *oldact) { if (oldact) { if (g_app_sigsys_set) { *oldact = g_app_sigsys; } else { memset(oldact, 0, sizeof(*oldact)); oldact->sa_handler = SIG_DFL; } } if (act) { g_app_sigsys = *act; g_app_sigsys_set = act->sa_handler != SIG_DFL && act->sa_handler != SIG_IGN; } } // Intercept SECCOMP blocked syscalls (SIGSYS), resolve sandbox/landlock gracefully, and advance PC static void ddnatv_sigsys_handler(int sig, siginfo_t *info, void *ctx) { if (!ctx || !info) return; if (info->si_code != SYS_SECCOMP) { int (*real_sig)(int, const struct sigaction *, struct sigaction *) = get_real_sigaction(); if (real_sig) { struct sigaction sa_dfl; memset(&sa_dfl, 0, sizeof(sa_dfl)); sa_dfl.sa_handler = SIG_DFL; sigemptyset(&sa_dfl.sa_mask); real_sig(sig, &sa_dfl, NULL); } raise(sig); return; } if (info->si_errno != 0 && g_app_sigsys_set) { if (g_app_sigsys.sa_flags & SA_SIGINFO) g_app_sigsys.sa_sigaction(sig, info, ctx); else g_app_sigsys.sa_handler(sig); return; } ucontext_t *uctx = (ucontext_t *)ctx; int sys_nr = info->si_syscall; long ret_val = is_sigsys_synthetic_success_syscall(sys_nr) ? 0 : -ENOSYS; #if defined(__aarch64__) uctx->uc_mcontext.regs[0] = (uint64_t)ret_val; if (uctx->uc_mcontext.pc >= 4) { uint32_t insn_at_pc = 0; uint32_t insn_before_pc = 0; memcpy(&insn_at_pc, (const void *)uctx->uc_mcontext.pc, sizeof(insn_at_pc)); memcpy(&insn_before_pc, (const void *)(uctx->uc_mcontext.pc - 4), sizeof(insn_before_pc)); // On SECCOMP_RET_TRAP, the kernel already advanced PC past svc #0 (*(pc - 4) is svc #0). // Only advance PC if PC itself points to svc #0 and *(pc - 4) does not. int at_is_svc = ((insn_at_pc & 0xffe0001fU) == 0xd4000001U); int prev_is_svc = ((insn_before_pc & 0xffe0001fU) == 0xd4000001U); if (at_is_svc && !prev_is_svc) { uctx->uc_mcontext.pc += 4; } } #elif defined(__arm__) uctx->uc_mcontext.arm_r0 = (unsigned long)ret_val; if (uctx->uc_mcontext.arm_pc >= 4) { if (uctx->uc_mcontext.arm_cpsr & 0x20) { uint16_t insn_at_pc = 0; uint16_t insn_before_pc = 0; memcpy(&insn_at_pc, (const void *)uctx->uc_mcontext.arm_pc, sizeof(insn_at_pc)); memcpy(&insn_before_pc, (const void *)(uctx->uc_mcontext.arm_pc - 2), sizeof(insn_before_pc)); int at_is_svc = ((insn_at_pc & 0xff00U) == 0xdf00U); int prev_is_svc = ((insn_before_pc & 0xff00U) == 0xdf00U); if (at_is_svc && !prev_is_svc) { uctx->uc_mcontext.arm_pc += 2; } } else { uint32_t insn_at_pc = 0; uint32_t insn_before_pc = 0; memcpy(&insn_at_pc, (const void *)uctx->uc_mcontext.arm_pc, sizeof(insn_at_pc)); memcpy(&insn_before_pc, (const void *)(uctx->uc_mcontext.arm_pc - 4), sizeof(insn_before_pc)); int at_is_svc = ((insn_at_pc & 0x0f000000U) == 0x0f000000U); int prev_is_svc = ((insn_before_pc & 0x0f000000U) == 0x0f000000U); if (at_is_svc && !prev_is_svc) { uctx->uc_mcontext.arm_pc += 4; } } } #elif defined(__x86_64__) && defined(REG_RAX) uctx->uc_mcontext.gregs[REG_RAX] = (greg_t)ret_val; if (uctx->uc_mcontext.gregs[REG_RIP] >= 2) { unsigned char insn_at[2] = {0}; unsigned char insn_prev[2] = {0}; memcpy(insn_at, (const void *)uctx->uc_mcontext.gregs[REG_RIP], sizeof(insn_at)); memcpy(insn_prev, (const void *)(uctx->uc_mcontext.gregs[REG_RIP] - 2), sizeof(insn_prev)); int at_is_sys = (insn_at[0] == 0x0f && insn_at[1] == 0x05); int prev_is_sys = (insn_prev[0] == 0x0f && insn_prev[1] == 0x05); if (at_is_sys && !prev_is_sys) { uctx->uc_mcontext.gregs[REG_RIP] += 2; } } #elif defined(__i386__) && defined(REG_EAX) uctx->uc_mcontext.gregs[REG_EAX] = (greg_t)ret_val; if (uctx->uc_mcontext.gregs[REG_EIP] >= 2) { unsigned char insn_at[2] = {0}; unsigned char insn_prev[2] = {0}; memcpy(insn_at, (const void *)uctx->uc_mcontext.gregs[REG_EIP], sizeof(insn_at)); memcpy(insn_prev, (const void *)(uctx->uc_mcontext.gregs[REG_EIP] - 2), sizeof(insn_prev)); int at_is_sys = (insn_at[0] == 0xcd && insn_at[1] == 0x80); int prev_is_sys = (insn_prev[0] == 0xcd && insn_prev[1] == 0x80); if (at_is_sys && !prev_is_sys) { uctx->uc_mcontext.gregs[REG_EIP] += 2; } } #endif } static int (*get_real_sigaction(void))(int, const struct sigaction *, struct sigaction *) { static int (*real_sigaction)(int, const struct sigaction *, struct sigaction *) = NULL; if (!real_sigaction) { real_sigaction = (int (*)(int, const struct sigaction *, struct sigaction *))dlsym(RTLD_NEXT, "sigaction"); if (!real_sigaction) { real_sigaction = (int (*)(int, const struct sigaction *, struct sigaction *))dlsym(RTLD_DEFAULT, "sigaction"); } } return real_sigaction; } __attribute__((constructor(101))) static void install_sigsys_handler(void) { int (*real_sig)(int, const struct sigaction *, struct sigaction *) = get_real_sigaction(); if (!real_sig) return; struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_sigaction = ddnatv_sigsys_handler; sa.sa_flags = SA_SIGINFO | SA_RESTART; sigemptyset(&sa.sa_mask); real_sig(SIGSYS, &sa, NULL); } int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact) { int (*real_sig)(int, const struct sigaction *, struct sigaction *) = get_real_sigaction(); if (!real_sig) return -1; if (signum == SIGSYS) { if (act && act->sa_sigaction == ddnatv_sigsys_handler) { return real_sig(signum, act, oldact); } remember_app_sigsys(act, oldact); return 0; } return real_sig(signum, act, oldact); } int rt_sigaction(int signum, const struct sigaction *act, struct sigaction *oldact, size_t sigsetsize) { static int (*orig_rt_sigaction)(int, const struct sigaction *, struct sigaction *, size_t) = NULL; if (!orig_rt_sigaction) orig_rt_sigaction = (int (*)(int, const struct sigaction *, struct sigaction *, size_t))dlsym(RTLD_NEXT, "rt_sigaction"); if (signum == SIGSYS) { if (act && act->sa_sigaction == ddnatv_sigsys_handler) { return orig_rt_sigaction ? orig_rt_sigaction(signum, act, oldact, sigsetsize) : 0; } remember_app_sigsys(act, oldact); return 0; } return orig_rt_sigaction ? orig_rt_sigaction(signum, act, oldact, sigsetsize) : -1; } int __libc_sigaction(int signum, const struct sigaction *act, struct sigaction *oldact) { return sigaction(signum, act, oldact); } typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler) { static sighandler_t (*orig_signal)(int, sighandler_t) = NULL; if (!orig_signal) orig_signal = (sighandler_t (*)(int, sighandler_t))dlsym(RTLD_NEXT, "signal"); if (signum == SIGSYS) { struct sigaction act, old; memset(&act, 0, sizeof(act)); act.sa_handler = handler; remember_app_sigsys(&act, &old); return old.sa_handler; } return orig_signal ? orig_signal(signum, handler) : NULL; } int sigprocmask(int how, const sigset_t *set, sigset_t *oldset) { static int (*orig_sigprocmask)(int, const sigset_t *, sigset_t *) = NULL; if (!orig_sigprocmask) orig_sigprocmask = (int (*)(int, const sigset_t *, sigset_t *))dlsym(RTLD_NEXT, "sigprocmask"); if (set && (how == SIG_BLOCK || how == SIG_SETMASK)) { sigset_t mod_set = *set; sigdelset(&mod_set, SIGSYS); return orig_sigprocmask ? orig_sigprocmask(how, &mod_set, oldset) : 0; } return orig_sigprocmask ? orig_sigprocmask(how, set, oldset) : 0; } int pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset) { static int (*orig_pthread_sigmask)(int, const sigset_t *, sigset_t *) = NULL; if (!orig_pthread_sigmask) orig_pthread_sigmask = (int (*)(int, const sigset_t *, sigset_t *))dlsym(RTLD_NEXT, "pthread_sigmask"); if (set && (how == SIG_BLOCK || how == SIG_SETMASK)) { sigset_t mod_set = *set; sigdelset(&mod_set, SIGSYS); return orig_pthread_sigmask ? orig_pthread_sigmask(how, &mod_set, oldset) : 0; } return orig_pthread_sigmask ? orig_pthread_sigmask(how, set, oldset) : 0; } int rt_sigprocmask(int how, const sigset_t *set, sigset_t *oldset, size_t sigsetsize) { static int (*orig_rt_sigprocmask)(int, const sigset_t *, sigset_t *, size_t) = NULL; if (!orig_rt_sigprocmask) orig_rt_sigprocmask = (int (*)(int, const sigset_t *, sigset_t *, size_t))dlsym(RTLD_NEXT, "rt_sigprocmask"); if (set && (how == SIG_BLOCK || how == SIG_SETMASK)) { sigset_t mod_set; memcpy(&mod_set, set, sizeof(mod_set)); sigdelset(&mod_set, SIGSYS); return orig_rt_sigprocmask ? orig_rt_sigprocmask(how, &mod_set, oldset, sigsetsize) : 0; } return orig_rt_sigprocmask ? orig_rt_sigprocmask(how, set, oldset, sigsetsize) : 0; } #endif /* !DDNATV_HOST_TEST */