fix(security): M64 P1 三条 root 命令注入 — 外部串改 execv 传 argv、电源键下线、press_ms clamp

P1-1 Wi-Fi SSID/PSK 注入（netmgrd + launcherd 回退两处同步）：
- 不再拼 `set_network %d ssid '"%s"'` 交给 sh -c；新增 wpa_exec()/nm_direct_wpa_exec()
  以 fork+execv 传 argv（含 resolve_bin 解析绝对路径，替代 `PATH=...` 前缀）。
- 共用 nm_wifi_args.h：nm_wifi_ssid_ok/n_wifi_psk_ok/nm_wpa_quote/nm_wpa_set_argv，
  两份实现同一套规则（只修一处等于没修）。
- 约束层：SSID 1..32B、禁控制字符；PSK ≤63 或 64 hex、禁控制字符；`"`/`\` 按
  wpa_supplicant 语法转义。shell 元字符不再需要拒绝——execv 下没有 shell 解析。

P1-2 MeowPanel App 安装/导出/卸载注入：
- install/export/remove 改 run_argv()（fork+execv，PATH 只在子进程 setenv）。
- 包名统一 mp_pkg_ok()（仅 [a-z0-9._-]，拒 `..`，与 nyai.c valid_pkg 同规则）→ 修 P2-7。
- `{path}` 追加 mp_path_unsafe()（与 mp_fonts/nyai 同一拒绝集）作第二道。

P1-3 /api/key/* 电源键：
- keycode_to_device 删除 KEY_POWER；116 进红线（403），前端遥控板电源/长按电源按钮移除。
- press_ms 全局 clamp 0..1000（单键与批量），`long` 缺省取上限。
- 按下→等待→抬起改独立线程（inject_key_async），不再阻塞单线程 8080 服务。

测试（宿主，反向控制）：test_nm_wifi_args.c / test_mp_argsafe.c —— 同一套审计恶意串
（`a' ; id ; '`、`x';id;'`、`/tmp/a';id>/tmp/pwn;'.mpk`、`MeowAPPs/..`）在修复前实现下
注入成功（stdout 含 uid=）／放行，在修复后实现下不执行／拒绝。另含「两处实现同步」检查。

未刷机、未连设备、未发 /api/key 请求；只改源码，未提交二进制。

patch_v2/meow_launcherd/netmgr_ipc.c

@@ -11,6 +11,9 @@
  * 只读观测（wlan_connected()/hci_powered() 读 /sys 链路态）仍在 net.c；此处只接权威操作。
  */
 #include "meow_launcher_internal.h"
+/* M64 P1-1：SSID/PSK 校验与 wpa 字面量转义。与 netmgrd 共用同一头文件——回退路径只修一处
+ * 等于没修（netmgrd 不可达时攻击者正是走这里），两边必须同一套规则。 */
+#include "../meow_netmgrd/nm_wifi_args.h"
 
 #define NETMGR_SOCK_DEFAULT "/usr/data/meow_net.sock"
 /* NETMGR_UNREACH 定义在 meow_launcher_internal.h（测试/调用方共用） */
@@ -424,6 +427,88 @@ static int nm_direct_wpa(char *out, int cap, const char *args, int tmo)
     return l;
 }
 
+/* ---- M64 P1-1：外部可控字符串（SSID/PSK）只走这一条，execv 传 argv，不经过 shell ----
+ * 修复前：nm_direct_wpa("set_network %d ssid '\"%s\"'", id, ssid) → popen(sh -c)。
+ * 恶意 AP 广播 SSID=`a' ; id ; '` 即可 root 执行。现在引号/分号/反引号只是 argv 里的字节。 */
+static int nm_wpa_bin(char *out, size_t cap)
+{
+    static const char *dirs[] = { "/sbin", "/usr/sbin", "/bin", "/usr/bin", NULL };
+    for (int i = 0; dirs[i]; i++) {
+        snprintf(out, cap, "%s/wpa_cli", dirs[i]);
+        if (access(out, X_OK) == 0) return 0;
+    }
+    return -1;
+}
+
+static long nm_mono_ms(void)
+{
+    struct timespec tp;
+    clock_gettime(CLOCK_MONOTONIC, &tp);
+    return tp.tv_sec * 1000L + tp.tv_nsec / 1000000L;
+}
+
+/* 执行 `wpa_cli -i wlan0 <args...>`（execv，无 shell）。args 以 NULL 结尾。
+ * 返回 stdout 字节数（-1=起不来），tmo 内有界收割，语义对齐 nm_direct_wpa。 */
+static int nm_direct_wpa_exec(char *out, int cap, char *const *args, int tmo)
+{
+    if (cap > 0) out[0] = 0;
+    char bin[128];
+    if (nm_wpa_bin(bin, sizeof bin) < 0) return -1;
+    char *argv[10];
+    int n = 0;
+    argv[n++] = bin;
+    argv[n++] = "-i";
+    argv[n++] = "wlan0";
+    for (int i = 0; args[i] && n < (int)(sizeof argv / sizeof argv[0]) - 1; i++) argv[n++] = args[i];
+    argv[n] = NULL;
+
+    int pfd[2];
+    if (pipe(pfd) < 0) return -1;
+    pid_t pid = fork();
+    if (pid < 0) { close(pfd[0]); close(pfd[1]); return -1; }
+    if (pid == 0) {
+        dup2(pfd[1], 1);
+        int dn = open("/dev/null", O_WRONLY);
+        if (dn >= 0) { dup2(dn, 2); close(dn); }
+        close(pfd[0]); close(pfd[1]);
+        execv(bin, argv);
+        _exit(127);
+    }
+    close(pfd[1]);
+    int off = 0, timed = 0;
+    long deadline = nm_mono_ms() + (tmo > 0 ? tmo : 1);
+    while (off < cap - 1) {
+        long remain = deadline - nm_mono_ms();
+        if (remain <= 0) { timed = 1; break; }
+        struct pollfd pf = { pfd[0], POLLIN, 0 };
+        int pr = poll(&pf, 1, (int)remain);
+        if (pr < 0) { if (errno == EINTR) continue; timed = 1; break; }
+        if (pr == 0) { timed = 1; break; }
+        ssize_t rd = read(pfd[0], out + off, (size_t)(cap - 1 - off));
+        if (rd <= 0) break;
+        off += (int)rd;
+    }
+    out[off] = 0;
+    close(pfd[0]);
+    if (timed) kill(pid, SIGKILL);
+    int st = 0;
+    waitpid(pid, &st, 0);
+    return off;
+}
+
+/* set_network <id> <field> <字符串值>：值按 wpa_supplicant 语法加引号（转义 `"`/`\`），
+ * 整条命令以 argv 传入。value 必须先过 nm_wifi_ssid_ok()/nm_wifi_psk_ok()。 */
+static int nm_direct_wpa_set(char *out, int cap, int id, const char *field, const char *val, int tmo)
+{
+    char idbuf[16], quoted[128];
+    char *args[5];
+    if (nm_wpa_set_argv(idbuf, sizeof idbuf, quoted, sizeof quoted, id, field, val, args) < 0) {
+        if (cap > 0) out[0] = 0;
+        return -1;
+    }
+    return nm_direct_wpa_exec(out, cap, args, tmo);
+}
+
 static int nm_direct_save_config(void)
 {
     char out[128];
@@ -436,6 +521,15 @@ static int nm_direct_save_config(void)
 static int nm_direct_connect_ex(const char *ssid, const char *psk, int hidden, char *err, int elen)
 {
     char out[1024]; char args[256];
+    /* M64 P1-1：回退路径自己再校验一次（不依赖调用方；两条路径同一套规则）。 */
+    if (!nm_wifi_ssid_ok(ssid)) {
+        if (err) snprintf(err, elen, "ssid 非法（长度 1..32 字节，禁控制字符）");
+        return MEOW_ERR_INVAL;
+    }
+    if (!nm_wifi_psk_ok(psk)) {
+        if (err) snprintf(err, elen, "psk 非法（≤63 字符口令或 64 位 hex，禁控制字符）");
+        return MEOW_ERR_INVAL;
+    }
     int id = -1;
     if (nm_direct_wpa(out, sizeof out, "list_networks", 1500) > 0) {
         char *ln = strtok(out, "\n");
@@ -472,13 +566,12 @@ static int nm_direct_connect_ex(const char *ssid, const char *psk, int hidden, c
         id = atoi(out);
         if (id < 0) { if (err) snprintf(err, elen, "add_network 无 id"); return MEOW_ERR_INVAL; }
         created = 1;
-        snprintf(args, sizeof args, "set_network %d ssid '\"%s\"'", id, ssid);
+        /* M64 P1-1：ssid/psk 走 execv（nm_direct_wpa_set），不再拼 popen(sh -c)。 */
-        nm_direct_wpa(out, sizeof out, args, 1500);
+        nm_direct_wpa_set(out, sizeof out, id, "ssid", ssid, 1500);
-        if (psk && psk[0]) { snprintf(args, sizeof args, "set_network %d psk '\"%s\"'", id, psk); nm_direct_wpa(out, sizeof out, args, 1500); }
+        if (psk && psk[0]) { nm_direct_wpa_set(out, sizeof out, id, "psk", psk, 1500); }
         else { snprintf(args, sizeof args, "set_network %d key_mgmt NONE", id); nm_direct_wpa(out, sizeof out, args, 1500); }
     } else if (psk && psk[0]) {
-        snprintf(args, sizeof args, "set_network %d psk '\"%s\"'", id, psk);
+        nm_direct_wpa_set(out, sizeof out, id, "psk", psk, 1500);
-        nm_direct_wpa(out, sizeof out, args, 1500);
     }
     if (hidden) { snprintf(args, sizeof args, "set_network %d scan_ssid 1", id); nm_direct_wpa(out, sizeof out, args, 1500); }
     snprintf(args, sizeof args, "enable_network %d", id); nm_direct_wpa(out, sizeof out, args, 1500);
@@ -519,6 +612,15 @@ static int nm_direct_connect_ex(const char *ssid, const char *psk, int hidden, c
 int nm_wifi_connect_ex(const char *ssid, const char *psk, int hidden, char *err, int elen)
 {
     if (!ssid || !ssid[0]) { if (err) snprintf(err, elen, "ssid 缺失"); return MEOW_ERR_INVAL; }
+    /* M64 P1-1：IPC 路径与直连回退同一套校验（netmgrd 侧还会再校验一次）。 */
+    if (!nm_wifi_ssid_ok(ssid)) {
+        if (err) snprintf(err, elen, "ssid 非法（长度 1..32 字节，禁控制字符）");
+        return MEOW_ERR_INVAL;
+    }
+    if (!nm_wifi_psk_ok(psk)) {
+        if (err) snprintf(err, elen, "psk 非法（≤63 字符口令或 64 位 hex，禁控制字符）");
+        return MEOW_ERR_INVAL;
+    }
     char arg[132];
     snprintf(arg, sizeof arg, "%s,%s", ssid, psk ? psk : "");   /* 带空 psk → netmgrd 复用既有网络 */
     char text[192];

patch_v2/meow_netmgrd/meow_netmgrd.c

@@ -51,6 +51,7 @@
 #include <linux/inet_diag.h>
 
 #include "meow_ipc.h"    /* 帧格式/消息号 + MSG_NET_*(0x00E0-0x00EF) + m_net_*（号段 0x00E0-0x00EF） */
+#include "nm_wifi_args.h" /* M64 P1-1：SSID/PSK 参数校验 + wpa 字面量转义（与 launcherd 回退共用） */
 
 /* ---------------- 路径（全部可经 env 覆盖，宿主/qemu 桩测试用） ---------------- */
 static char g_net_dir[128]     = "/sys/class/net";                 /* MEOW_NET_DIR */
@@ -303,8 +304,10 @@ static int reap_bounded(pid_t pid, const char *cmd, int *st)
 }
 
 /* 带四态结果的执行器（res 可为 NULL，等价于旧 run_cmd）。返回 stdout 字节数（-1=起不来）。
+ * argv != NULL → execv(argv)（不经过 shell，M64 P1）；argv == NULL → sh -c cmd（仅常量命令）。
  * stdout 超容量时继续排空（丢弃），保证子进程不被 EPIPE/SIGPIPE 提前打断、退出码可信。 */
-static int run_cmd_ex(char *buf, int cap, int tmo_ms, const char *cmd, runcmd_res_t *res)
+static int run_exec_ex(char *buf, int cap, int tmo_ms, char *const *argv, const char *cmd,
+                       runcmd_res_t *res)
 {
     runcmd_res_t lr;
     runcmd_res_t *r = res ? res : &lr;
@@ -312,6 +315,7 @@ static int run_cmd_ex(char *buf, int cap, int tmo_ms, const char *cmd, runcmd_re
     r->exit_code = -1;
     r->status = RUNCMD_EXEC;
     if (cap > 0) buf[0] = 0;
+    const char *label = argv ? argv[0] : cmd;
 
     int op[2], ep[2];
     if (pipe(op) < 0) return -1;
@@ -322,7 +326,11 @@ static int run_cmd_ex(char *buf, int cap, int tmo_ms, const char *cmd, runcmd_re
         dup2(op[1], 1);
         dup2(ep[1], 2);          /* M49：stderr 不再丢 /dev/null，失败时留一段进错误文案 */
         close(op[0]); close(op[1]); close(ep[0]); close(ep[1]);
+        if (argv) {
+            execv(argv[0], argv);
+        } else {
             execl("/bin/sh", "sh", "-c", cmd, (char *)0);
+        }
         _exit(127);
     }
     close(op[1]); close(ep[1]);
@@ -370,7 +378,7 @@ static int run_cmd_ex(char *buf, int cap, int tmo_ms, const char *cmd, runcmd_re
 
     if (timed_out) kill(pid, SIGKILL);       /* 已经超时：不再多等 300ms */
     int st = 0;
-    int reaped = reap_bounded(pid, cmd, &st);
+    int reaped = reap_bounded(pid, label, &st);
     r->bytes = off;
     r->truncated = trunc;
     if (reaped) {
@@ -388,7 +396,19 @@ static int run_cmd_ex(char *buf, int cap, int tmo_ms, const char *cmd, runcmd_re
 /* 兼容外壳：返回读到的字节数（-1=起不来），语义与 P1 之前一致（调用点无需改动）。 */
 static int run_cmd(char *buf, int cap, int tmo_ms, const char *cmd)
 {
-    return run_cmd_ex(buf, cap, tmo_ms, cmd, NULL);
+    return run_exec_ex(buf, cap, tmo_ms, NULL, cmd, NULL);
+}
+
+/* 带四态结果的兼容外壳（res 可为 NULL）。 */
+static int run_cmd_ex(char *buf, int cap, int tmo_ms, const char *cmd, runcmd_res_t *res)
+{
+    return run_exec_ex(buf, cap, tmo_ms, NULL, cmd, res);
+}
+
+/* argv 形态（M64 P1：外部可控字符串只走这里，永不拼 shell）。 */
+static int run_argv(char *buf, int cap, int tmo_ms, char *const *argv)
+{
+    return run_exec_ex(buf, cap, tmo_ms, argv, NULL, NULL);
 }
 
 /* 失败时的一句话原因（有界；stderr 有料就带上，最多 120B，避免报文过长）。 */
@@ -3147,7 +3167,27 @@ static const char *str_capsafe(const char *s, char *tmp, size_t cap)
     return tmp;
 }
 
-/* wpa_cli 单命令封装：拼 PATH 前缀 + 有界收割（RUNCMD_TMO_MS）。返回 run_cmd 读到的字节数。 */
+/* 在固件标准目录里解析可执行文件（等价旧 `PATH=/bin:/sbin:/usr/bin:/usr/sbin` 前缀，
+ * 但不再让 shell 去查 PATH）。g_* 可被 MEOW_* 环境变量覆盖为绝对路径（调试用）。 */
+static int resolve_bin(const char *name, char *out, size_t cap)
+{
+    if (!name || !name[0]) return -1;
+    if (strchr(name, '/')) {
+        if (access(name, X_OK) < 0) return -1;
+        snprintf(out, cap, "%s", name);
+        return 0;
+    }
+    static const char *dirs[] = { "/bin", "/sbin", "/usr/bin", "/usr/sbin", NULL };
+    for (int i = 0; dirs[i]; i++) {
+        snprintf(out, cap, "%s/%s", dirs[i], name);
+        if (access(out, X_OK) == 0) return 0;
+    }
+    return -1;
+}
+
+/* wpa_cli 单命令封装：拼 PATH 前缀 + 有界收割（RUNCMD_TMO_MS）。返回 run_cmd 读到的字节数。
+ * args 只允许**编译期常量**（scan/list_networks/status/...）。任何来自 IPC/用户/AP 广播的
+ * 字符串必须走 wpa_exec()（execv，无 shell）——M64 P1-1 之前正是这里把 SSID 拼进了 sh -c。 */
 static int wpa_cmd(char *out, int cap, const char *args)
 {
     char cmd[512];
@@ -3155,6 +3195,34 @@ static int wpa_cmd(char *out, int cap, const char *args)
     return run_cmd(out, cap, RUNCMD_TMO_MS, cmd);
 }
 
+/* 执行 wpa_cli（execv 传 argv，不经过 shell）。args 以 NULL 结尾、不含 wpa_cli 本身。
+ * 返回 stdout 字节数（-1=二进制找不到/起不来）。
+ * `' ; ` $ & | < >` 在这里只是 argv 里的普通字节——这条路径上不存在 shell 解析。 */
+static int wpa_exec(char *out, int cap, char *const *args)
+{
+    char bin[256];
+    if (resolve_bin(g_wpa_cli, bin, sizeof bin) < 0) { if (cap > 0) out[0] = 0; return -1; }
+    char *argv[12];
+    int n = 0;
+    argv[n++] = bin;
+    for (int i = 0; args[i] && n < (int)(sizeof argv / sizeof argv[0]) - 1; i++) argv[n++] = args[i];
+    argv[n] = NULL;
+    return run_argv(out, cap, RUNCMD_TMO_MS, argv);
+}
+
+/* set_network <id> <field> <值>：字符串字段按 wpa_supplicant 语法加双引号（纯正确性转义，
+ * 与 shell 无关），整条命令以 argv 传入。val 必须先过 nm_wifi_ssid_ok/nm_wifi_psk_ok。 */
+static int wpa_set_string(char *out, int cap, int id, const char *field, const char *val)
+{
+    char idbuf[16], quoted[160];
+    char *args[5];
+    if (nm_wpa_set_argv(idbuf, sizeof idbuf, quoted, sizeof quoted, id, field, val, args) < 0) {
+        if (cap > 0) out[0] = 0;
+        return -1;
+    }
+    return wpa_exec(out, cap, args);
+}
+
 /* WiFi 设置页 bug4-②（2026-09-15）：list_networks/scan_results 对非 ASCII 字节输出 \xNN 转义
  * （中文 SSID）——还原为原始字节串再与输入 SSID 做同表示比较；不还原则中文 SSID 永不命中
  * 既有网络 → 新建同名 open 记录顶影原记录。net.c wpa_decode_ssid / netmgr_ipc.c nm_decode_ssid
@@ -3265,6 +3333,16 @@ static void wifi_connect_ex(const char *arg, ctl_result_t *r, int hidden)
     str_capsafe(ssid, tmp_ssid, sizeof tmp_ssid);
     str_capsafe(psk, tmp_psk, sizeof tmp_psk);
     if (!tmp_ssid[0]) { ctl_sets(r, MEOW_ERR_INVAL, "connect: ssid 缺失"); return; }
+    /* M64 P1-1：SSID/PSK 是外部可控串（附近 AP 广播 / 用户输入）。长度与控制字符在这里
+     * 收口；执行侧已改 execv 传 argv（wpa_set_string），shell 元字符不再有语义。 */
+    if (!nm_wifi_ssid_ok(tmp_ssid)) {
+        ctl_sets(r, MEOW_ERR_INVAL, "connect: ssid 非法（长度 1..32 字节，禁控制字符）");
+        return;
+    }
+    if (!nm_wifi_psk_ok(tmp_psk)) {
+        ctl_sets(r, MEOW_ERR_INVAL, "connect: psk 非法（≤63 字符口令或 64 位 hex，禁控制字符）");
+        return;
+    }
 
     /* 找既有网络：list_networks → 匹配 ssid（剥引号 + \xNN 还原后同表示比较）；命中则复用其 id。 */
     char cmd[256];
@@ -3304,16 +3382,19 @@ static void wifi_connect_ex(const char *arg, ctl_result_t *r, int hidden)
         id = atoi(out);
         if (id < 0) { ctl_sets(r, MEOW_ERR_INVAL, "connect: add_network 无 id"); return; }
         created = 1;
-        snprintf(cmd, sizeof cmd, "set_network %d ssid '\"%s\"'", id, tmp_ssid);
+        /* M64 P1-1：ssid/psk 走 execv 传 argv（wpa_set_string），不再拼 `sh -c`。
-        wpa_cmd(out, sizeof out, cmd);
+         * 修复前是 `set_network %d ssid '\"%s\"'` —— 单引号里套双引号，SSID 带 `'` 即逸出。 */
-        if (tmp_psk[0]) snprintf(cmd, sizeof cmd, "set_network %d psk '\"%s\"'", id, tmp_psk);
+        wpa_set_string(out, sizeof out, id, "ssid", tmp_ssid);
-        else            snprintf(cmd, sizeof cmd, "set_network %d key_mgmt NONE", id);
+        if (tmp_psk[0]) {
+            wpa_set_string(out, sizeof out, id, "psk", tmp_psk);
+        } else {
+            snprintf(cmd, sizeof cmd, "set_network %d key_mgmt NONE", id);
             wpa_cmd(out, sizeof out, cmd);
+        }
     } else if (tmp_psk[0]) {
         /* bug4-①/bug1-④：命中既有网络且调用方带了新 psk → 先更新凭据再连
          * （旧记录密码错误可经扫描路径重输修复；psk 为空则不动既有凭据）。 */
-        snprintf(cmd, sizeof cmd, "set_network %d psk '\"%s\"'", id, tmp_psk);
+        wpa_set_string(out, sizeof out, id, "psk", tmp_psk);
-        wpa_cmd(out, sizeof out, cmd);
     }
     if (hidden) {
         /* bug2：隐藏 AP 必须 scan_ssid=1，supplicant 才会主动发 Probe Request（命中既有也要补）。 */

patch_v2/meow_netmgrd/nm_wifi_args.h

@@ -0,0 +1,108 @@
+/* nm_wifi_args.h — wpa_cli 参数安全（M64 P1-1：SSID/PSK → root 命令注入）。
+ *
+ * 修复前：SSID/PSK 被拼成 `set_network <id> ssid '"<ssid>"'`，再交给
+ * `execl("/bin/sh","sh","-c",cmd)` 执行（meow_netmgrd.c:3307/3154/325；同一实现复制在
+ * meow_launcherd/netmgr_ipc.c:475 的直连回退）。单引号里套双引号，SSID 自己带 `'` 就能
+ * 闭合引号——附近恶意 AP 广播 SSID=`a' ; id ; '`，用户点连接即 root 执行。
+ *
+ * 修复分两层，本头只放「可在宿主上直接单测」的纯函数：
+ *   1) 彻底层：调用方改用 fork+execv 传 argv（见 meow_netmgrd.c:wpa_exec /
+ *      netmgr_ipc.c:nm_direct_wpa_exec）。不再有 shell，`' ; ` $ & | < >` 全部只是
+ *      普通字节，既不需要也不敢拒绝（"Bob's WiFi" 是合法 SSID）。
+ *   2) 约束层：SSID/PSK 按 802.11 与 wpa_supplicant 语法收口（长度、控制字符）；
+ *      拼 wpa 字面量时转义 `"` 与 `\`——这两个字符破坏的是 supplicant 的引号解析，
+ *      与 shell 无关，属于正确性要求。
+ *
+ * 两份实现（netmgrd 与 launcherd 回退）共用本头：只修一处等于没修——launcherd 那条
+ * 路径正是 netmgrd 不可达时的回退，攻击者可以制造 netmgrd 不可达（M64 任务书 P1-1）。
+ */
+#ifndef NM_WIFI_ARGS_H
+#define NM_WIFI_ARGS_H
+
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+#define NM_WIFI_SSID_MAX 32   /* 802.11 SSID 字节上限 */
+#define NM_WIFI_PSK_MAX  63   /* WPA passphrase 上限（8..63 字符）；64 位 hex PSK 另算 */
+
+/* wpa_supplicant 的 ctrl_iface 是行协议：值里出现 \n/\r 会截断或伪造命令，
+ * 其它控制字符也进不了 SSID/PSK 的合法字符集。 */
+static inline int nm_wifi_ctl_free(const char *s, size_t n)
+{
+    for (size_t i = 0; i < n; i++) {
+        unsigned char c = (unsigned char)s[i];
+        if (c < 0x20 || c == 0x7f) return 0;
+    }
+    return 1;
+}
+
+static inline int nm_wifi_ssid_ok(const char *s)
+{
+    if (!s) return 0;
+    size_t n = strlen(s);
+    if (n == 0 || n > NM_WIFI_SSID_MAX) return 0;
+    return nm_wifi_ctl_free(s, n);
+}
+
+/* 空串 = 开放网络（调用方按 key_mgmt NONE 处理）；≤63 字节口令；64 位 hex PSK。
+ * 不强制 8 字符下限：WPA 会自行拒绝过短口令，而面板/设置页对「密码错」的既有文案依赖
+ * 把它交给 supplicant 判定（M64 只收口注入面与行协议，不改失败语义）。 */
+static inline int nm_wifi_psk_ok(const char *s)
+{
+    if (!s || !s[0]) return 1;
+    size_t n = strlen(s);
+    if (!nm_wifi_ctl_free(s, n)) return 0;
+    if (n <= NM_WIFI_PSK_MAX) return 1;
+    if (n == 64) {
+        for (size_t i = 0; i < n; i++) {
+            char c = s[i];
+            if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')))
+                return 0;
+        }
+        return 1;
+    }
+    return 0;
+}
+
+/* 把值拼成 wpa_supplicant 的字面量 `"..."`（ssid/psk 这两个字段要求带引号）。
+ * 只转义 `"` 与 `\`——它们在 supplicant 的 parse_string 里有特殊含义。
+ * 返回 0 成功；-1 = 含控制字符或缓冲不足。 */
+static inline int nm_wpa_quote(const char *val, char *out, size_t cap)
+{
+    if (!val || !out) return -1;
+    size_t n = strlen(val);
+    if (!nm_wifi_ctl_free(val, n)) return -1;
+    size_t need = 3;   /* 开引号 + 闭引号 + NUL */
+    for (size_t i = 0; i < n; i++) need += (val[i] == '"' || val[i] == '\\') ? 2 : 1;
+    if (need > cap) return -1;
+    size_t o = 0;
+    out[o++] = '"';
+    for (size_t i = 0; i < n; i++) {
+        char c = val[i];
+        if (c == '"' || c == '\\') out[o++] = '\\';
+        out[o++] = c;
+    }
+    out[o++] = '"';
+    out[o] = 0;
+    return 0;
+}
+
+/* 组装 `set_network <id> <field> <"value">` 的 argv（argv[0] 由调用方补 wpa_cli 路径）。
+ * 生产代码（netmgrd wpa_set_string / launcherd nm_direct_wpa_set）与宿主测试共用这一份，
+ * 保证测试断言的就是实际下发的那条命令。返回 0 成功；-1 = 值不合法/缓冲不足。 */
+static inline int nm_wpa_set_argv(char *idbuf, size_t idcap, char *quoted, size_t qcap,
+                                  int id, const char *field, const char *val, char *argv[5])
+{
+    if (!field || !argv) return -1;
+    if (nm_wpa_quote(val, quoted, qcap) < 0) return -1;
+    snprintf(idbuf, idcap, "%d", id);
+    argv[0] = (char *)"set_network";
+    argv[1] = idbuf;
+    argv[2] = (char *)field;
+    argv[3] = quoted;
+    argv[4] = NULL;
+    return 0;
+}
+
+#endif /* NM_WIFI_ARGS_H */

patch_v2/meow_netmgrd/test_nm_wifi_args.c

@@ -0,0 +1,181 @@
+/* test_nm_wifi_args.c — M64 P1-1 宿主回归：SSID/PSK 参数安全 + 反向控制。
+ *
+ * 纯宿主测试：不连设备、不启服务、不发 /api/key/<code>，只用本进程 + sh + execv。
+ *
+ * 编译运行（在 patch_v2/meow_netmgrd 下）：
+ *   cc -O1 -Wall -Wextra -I. test_nm_wifi_args.c -o ~/tmp/test_nm_wifi_args
+ *   ~/tmp/test_nm_wifi_args
+ *
+ * 反向控制：同一套用例分别喂给
+ *   ① 「修复前实现」复刻（legacy_build：`set_network %d ssid '"%s"'` → sh -c）→ 必须注入成功；
+ *   ② 修复后实现（nm_wifi_ssid_ok/nm_wpa_set_argv + execv 传 argv）→ 必须不执行任何 shell。
+ * 只有 ①成立、②不成立，才证明这套改动真的拦住了东西（而不是「本来就不会中」）。
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include "nm_wifi_args.h"
+
+static char g_self[512];
+static int  g_fail;
+
+#define CHECK(cond, ...) do {                                  \
+        if (!(cond)) { printf("  FAIL: "); printf(__VA_ARGS__); printf("\n"); g_fail = 1; } \
+        else { printf("  PASS: "); printf(__VA_ARGS__); printf("\n"); }                     \
+    } while (0)
+
+/* 复刻修复前 meow_netmgrd.c:3154 + :3307 的拼法：SSID 塞进单引号内的双引号，整行交给 sh -c。
+ * （值是 `a' ; id ; '` 时，第一个 `'` 就把单引号闭合了。） */
+static void legacy_build(const char *field, const char *val, char *out, size_t cap)
+{
+    char args[256];
+    snprintf(args, sizeof args, "set_network 0 %s '\"%s\"'", field, val);
+    snprintf(out, cap, "PATH=/bin:/sbin:/usr/bin:/usr/sbin wpa_cli %s 2>/dev/null", args);
+}
+
+static int run_shell(const char *cmd, char *out, int cap)
+{
+    out[0] = 0;
+    FILE *f = popen(cmd, "r");
+    if (!f) return -1;
+    size_t off = fread(out, 1, (size_t)cap - 1, f);
+    out[off] = 0;
+    return pclose(f);
+}
+
+/* 用 execv 跑一条 argv，子进程是本程序的 --stub-argv 形态（把收到的 argv 原样打印）。
+ * 这就是修复后的下发方式：wpa_cli 收到的是 argv，不经 shell。 */
+static int run_argv_stub(char *const *args, char *out, int cap)
+{
+    out[0] = 0;
+    int pfd[2];
+    if (pipe(pfd) < 0) return -1;
+    pid_t pid = fork();
+    if (pid < 0) { close(pfd[0]); close(pfd[1]); return -1; }
+    if (pid == 0) {
+        dup2(pfd[1], 1);
+        dup2(pfd[1], 2);
+        close(pfd[0]); close(pfd[1]);
+        char *av[10];
+        int n = 0;
+        av[n++] = (char *)"test_nm_wifi_args";
+        av[n++] = (char *)"--stub-argv";
+        for (int i = 0; args[i] && n < 9; i++) av[n++] = args[i];
+        av[n] = NULL;
+        execv(g_self, av);
+        _exit(127);
+    }
+    close(pfd[1]);
+    size_t off = 0;
+    for (;;) {
+        size_t room = (off + 1 < (size_t)cap) ? (size_t)cap - 1 - off : 0;
+        if (!room) break;
+        ssize_t rd = read(pfd[0], out + off, room);
+        if (rd <= 0) break;
+        off += (size_t)rd;
+    }
+    out[off] = 0;
+    close(pfd[0]);
+    int st = 0;
+    waitpid(pid, &st, 0);
+    return st;
+}
+
+/* 旧实现「接受」判定：str_capsafe（meow_netmgrd.c:3140）只 trim 空白，不校验字符。 */
+static int legacy_ssid_accepted(const char *s)
+{
+    return s && s[0];
+}
+
+/* 一条用例的双跑：旧实现必须中招，新实现必须只把值当字节。 */
+static void case_attack(const char *label, const char *field, const char *val)
+{
+    char cmd[512], out[4096];
+    printf("== %s ==\n  value=%s\n", label, val);
+
+    /* ① 反向控制：修复前 */
+    CHECK(legacy_ssid_accepted(val), "修复前判定放行该值（无字符校验）");
+    legacy_build(field, val, cmd, sizeof cmd);
+    printf("  修复前命令：%s\n", cmd);
+    run_shell(cmd, out, sizeof out);
+    CHECK(strstr(out, "uid=") != NULL, "修复前被注入：值里的 `id` 在 root 语境执行（stdout 含 uid=）");
+
+    /* ② 修复后 */
+    char idbuf[16], quoted[160];
+    char *args[5];
+    int rc = nm_wpa_set_argv(idbuf, sizeof idbuf, quoted, sizeof quoted, 0, field, val, args);
+    CHECK(rc == 0, "修复后可构造 argv（execv 传参，值里的元字符无 shell 语义）");
+    char *full[7] = { (char *)"wpa_cli", args[0], args[1], args[2], args[3], NULL };
+    run_argv_stub(full, out, sizeof out);
+    printf("  修复后子进程收到的 argv：\n%s", out);
+    CHECK(strstr(out, "uid=") == NULL, "修复后没有 shell：值里的 `id` 不执行");
+    CHECK(strstr(out, quoted) != NULL, "值原样作为**单个** argv 元素到达（未断词）");
+}
+
+int main(int argc, char **argv)
+{
+    if (argc > 1 && !strcmp(argv[1], "--stub-argv")) {   /* execv 桩：打印收到的 argv */
+        for (int i = 2; i < argc; i++) printf("ARG[%d]=%s\n", i - 2, argv[i]);
+        return 0;
+    }
+    ssize_t l = readlink("/proc/self/exe", g_self, sizeof g_self - 1);
+    if (l <= 0) snprintf(g_self, sizeof g_self, "%s", argv[0]);
+    else g_self[l] = 0;
+
+    printf("== M64 P1-1 反向控制：修复前注入 / 修复后不注入 ==\n");
+    /* 审计给出的真实恶意串：附近 AP 广播的 SSID 与用户输入的 PSK。 */
+    case_attack("SSID 注入（审计原串）", "ssid", "a' ; id ; '");
+    case_attack("PSK 注入（审计原串）", "psk", "x';id;'");
+
+    printf("== 约束层：长度 / 控制字符 ==\n");
+    CHECK(nm_wifi_ssid_ok("a' ; id ; '") == 1, "`a' ; id ; '` 通过校验（11B＜32B，是合法 SSID；靠 execv 中立化）");
+    CHECK(nm_wifi_ssid_ok("Home2G") == 1, "普通 SSID 通过");
+    CHECK(nm_wifi_ssid_ok("中文网络") == 1, "UTF-8 中文 SSID 通过（12B）");
+    CHECK(nm_wifi_ssid_ok("") == 0, "空 SSID 拒绝");
+    CHECK(nm_wifi_ssid_ok("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") == 0, "33 字节 SSID 拒绝（802.11 上限 32）");
+    CHECK(nm_wifi_ssid_ok("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") == 1, "32 字节 SSID 通过");
+    CHECK(nm_wifi_ssid_ok("a\nset_network 0 psk \"x\"") == 0, "含 \\n 的 SSID 拒绝（wpa ctrl_iface 行协议）");
+    CHECK(nm_wifi_ssid_ok("a\x7f" "b") == 0, "含 DEL 的 SSID 拒绝");
+    CHECK(nm_wifi_ssid_ok("a\tb") == 0, "含 TAB 的 SSID 拒绝");
+
+    CHECK(nm_wifi_psk_ok("") == 1, "空 PSK（开放网络）通过");
+    CHECK(nm_wifi_psk_ok("pass1234") == 1, "普通口令通过");
+    CHECK(nm_wifi_psk_ok("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef") == 1,
+          "64 位 hex PSK 通过");
+    CHECK(nm_wifi_psk_ok("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz") == 0,
+          "64 字符非 hex 拒绝（≠ 合法 PSK）");
+    CHECK(nm_wifi_psk_ok("x';id;'") == 1, "`x';id;'` 通过（＝合法口令字节，靠 execv 中立化）");
+    CHECK(nm_wifi_psk_ok("a\nb") == 0, "含 \\n 的 PSK 拒绝");
+
+    printf("== wpa_supplicant 字面量：只转义 \" 与 \\ ==\n");
+    {
+        char q[64];
+        CHECK(nm_wpa_quote("a\"b\\c", q, sizeof q) == 0 && !strcmp(q, "\"a\\\"b\\\\c\""),
+              "`a\"b\\c` → %s", q);
+        CHECK(nm_wpa_quote("a' ; id ; '", q, sizeof q) == 0 && !strcmp(q, "\"a' ; id ; '\""),
+              "shell 元字符原样保留 → %s", q);
+        CHECK(nm_wpa_quote("a\nb", q, sizeof q) == -1, "控制字符拒绝（不落盘、不进 ctrl_iface）");
+        CHECK(nm_wpa_quote("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", q, 8) == -1, "缓冲不足返回 -1");
+    }
+
+    printf("== 两处实现同步（只修一处等于没修）==\n");
+    {
+        static const char *files[] = { "meow_netmgrd.c", "../meow_launcherd/netmgr_ipc.c" };
+        for (int i = 0; i < 2; i++) {
+            FILE *f = fopen(files[i], "r");
+            if (!f) { printf("  SKIP: 读不到 %s（从 patch_v2/meow_netmgrd 下运行才检查）\n", files[i]); continue; }
+            char buf[400000];
+            size_t n = fread(buf, 1, sizeof buf - 1, f);
+            buf[n] = 0;
+            fclose(f);
+            CHECK(strstr(buf, "nm_wpa_set_argv") != NULL, "%s 使用共享的 nm_wpa_set_argv", files[i]);
+            CHECK(strstr(buf, "ssid '\"") == NULL, "%s 不再有 `ssid '\\\"` 拼法", files[i]);
+        }
+    }
+
+    printf(g_fail ? "\nRESULT: FAIL\n" : "\nRESULT: ALL PASS\n");
+    return g_fail ? 1 : 0;
+}

patch_v2/meowpanel/README.md

@@ -142,7 +142,7 @@ http://<host>.local:8080/
 | POST | `/api/apps/install` | 经 `nyai install`（multipart 或 path） | ✅ |
 | GET | `/api/apps/:pkg/export` | `nyai export` 下载流 | ✅ |
 | DELETE | `/api/apps/:pkg` | `nyai remove [--purge]` | ✅ |
-| POST | `/api/key/:code` | 按键注入（tap/long） | ✅（物理键红线内） |
+| POST | `/api/key/:code` | 按键注入（tap/long；`ms` clamp 0..1000；电源 116 已下线） | ✅（物理键红线内） |
 | POST | `/api/key` | 批量/顺序注入 | ✅ |
 | GET | `/api/logs` | `MeowOS/logs` 文件列表（每文件含 `group` 来源分组） | ✅（无卡→503） |
 | GET | `/api/logs/crash` | **崩溃汇总**：解析最新 `crash_<bootts>.log`（meow_crash 落盘格式）→ 每实体崩溃数 + 最近崩溃时间/信号 + dmesg 计数 | ✅（无卡→503；无 crash 日志→空汇总） |
@@ -218,8 +218,11 @@ http://<host>.local:8080/
 ### 5.5 nyai 对接
 - 包管理器 CLI 绝对路径 `/usr/data/mnt/sd_0/MeowOS/opt/bin/nyai`（M2.12+ 固件经 `meow_card_path.sh` 前插 PATH，可直接调；
   本后端用绝对路径，兼容更早固件）。包名 = `app.json` 的 `package` = `.mpk` 文件名茎。
-- `install`：multipart 上传 `.mpk` 落临时文件（`MeowOS/tmp/`）或 JSON `{path}` → `nyai install <file>`；用 `popen` 捕获输出+退出码，
+- `install`：multipart 上传 `.mpk` 落临时文件（`MeowOS/tmp/`）或 JSON `{path}` → `nyai install <file>`；用 `fork`+`execv`
+  传 argv 捕获输出+退出码（不经 shell，M64 P1-2：修复前是 `popen("... '<nyai>' install '<path>'")`，路径里一个 `'` 即 root 执行），
   非 0 → 422。`export`：`nyai export <pkg> <tmp>` → 以 `Content-Disposition: attachment` 流式下发。`remove`：`nyai remove <pkg> [--purge]`。
+- **参数校验**（M64 P1-2 / P2-7）：包名统一 `mp_pkg_ok()`（仅 `[a-z0-9._-]`，拒 `..`/前导尾点，与 nyai.c `valid_pkg()` 同规则）
+  → 非法 → 400；`{path}` 再按 `mp_path_unsafe()`（与 mp_fonts/nyai 同一拒绝集）挡一道，防调用被改回 shell 拼接。
 - `GET /api/apps` / `:pkg` 详情：直接扫描 `MeowAPPs/<dir>/app.json`（手写 JSON 解析提取 name/version/exec/framework/immersive/fullscreen），
   不依赖 nyai（nyai 未部署时列表/详情仍可用）。解析失败项 `invalid:true`。
 - `nyai` 未部署 → install/export/remove 返回 500（带 nyai 输出）。
@@ -228,9 +231,15 @@ http://<host>.local:8080/
 - **复用现有先例**：`patch_v2/uinput_tap/uinput_tap.c` 的 `write`-到-evdev 注入机制。launcher 实际轮询
   `meow_launcher_internal.h`：`/dev/input/event0`（md-gpio-keys: POWER/PREVIOUS）、`/dev/input/event2`
   （jz adc keyboard: VOL/PLAY/NEXT）。后端 open `O_WRONLY` 写 `EV_KEY press/release + SYN_REPORT` 即可到达 launcher 按键处理。
-- **物理键红线**（APPS.md / 任务约束）：只注入音量(114/115)/电源(116)/播放(164)/上下曲(163/165)；
+- **物理键红线**（APPS.md / 任务约束 + M64 P1-3）：只注入音量(114/115)/播放(164)/上下曲(163/165)；
-  **禁止注入 返回(158)/主页(172)/确认(28)/退出(96)** → 403 `FORBIDDEN`。
+  **禁止注入 返回(158)/主页(172)/确认(28)/退出(96)/电源(116)** → 403 `FORBIDDEN`。
-- `tap`（默认，抬起间隔 80ms）、`long`（按住 ms，缺省 3000）；`hold` → 501。
+  电源键（`/dev/input/event0` 的 KEY_POWER）已从 `keycode_to_device` 移除：设备端
+  `power.forceoff_ms` 缺省 8000ms 且**从按下起算**，注入它等于绕过 `/api/system/shutdown` 的二次确认
+  （一条 `{"press":"long","ms":8000}` 即强制关机）。电源/关机只走 `/api/system/shutdown`（前端有确认弹窗）。
+- `tap`（默认，抬起间隔 80ms）、`long`（按住 ms，缺省 1000）；`hold` → 501。
+  **`ms` 全局 clamp 到 0..1000**（`mp_key_clamp_ms`），单键与批量同一上限。
+- 注入在**独立线程**里做按下→等待→抬起（`inject_key_async`）：修复前是在请求线程 `usleep(ms)`，
+  一个键请求就把单线程 8080 服务整段阻塞。设备 fd 仍由请求线程同步 open，打不开 → 500。
 - 局限：若 `/dev/input/event0/event2` 在设备上不可写（权限/路径差异），注入失败 → 500；注入为**即时性注入**，
   不在 launcher 内维护长按状态机（与实体按键的 `longpressed` 语义近似，见 README 已知边界）。
 

patch_v2/meowpanel/src/mp.h

@@ -323,7 +323,7 @@ int files_list(int sock, const char *relpath);
 char *read_text_file_limited(const char *abs, long long *size, int *truncated);
 int keycode_to_device(int code, const char **dev);
 int inject_key_event(const char *dev, int code, int down);
-int inject_key_release(int code, int press_ms);
+int inject_key_async(int code, int press_ms);   /* M64 P1-3：释放放独立线程，不阻塞 panel */
 int read_small_file(const char *path, char *buf, int cap);
 int apps_scan_dir(const char *appdir, const char *name, sbuf_t *out, int want_detail);
 void req_free(req_t *r);
@@ -436,6 +436,7 @@ int sha256_file_hex(const char *path, char out[65]);
 int api_fonts_import(int sock, const req_t *r);
 int api_fonts_export(int sock, const req_t *r);
 int run_cmd(const char *cmd, char *out, int outcap);
+int run_argv(char *out, int outcap, const char *const argv[]);   /* M64 P1-2：execv 形态，无 shell */
 int api_apps_list(int sock);
 int api_apps_info(int sock, const char *pkg);
 int multipart_extract_file(const req_t *r, const char *outpath);

patch_v2/meowpanel/src/mp_apps.c

@@ -1,5 +1,6 @@
 /* mp_apps.c — 应用域：MeowAPPs 扫描 + nyai 安装/导出/移除。 */
 #include "mp.h"
+#include "mp_argsafe.h"   /* M64 P1-2：包名/路径判定（与 nyai.c:125/137 同规则） */
 
 
 int apps_scan_dir(const char *appdir, const char *name, sbuf_t *out, int want_detail)
@@ -115,7 +116,8 @@ int api_apps_list(int sock)
 int api_apps_info(int sock, const char *pkg)
 {
     if (!tf_present()) return send_err(sock, 503, "NO_CARD", "未识别到 TF 卡");
-    if (strchr(pkg, '/') || strchr(pkg, ':')) return send_err(sock, 400, "BAD_REQUEST", "包名非法");
+    /* M64 P1-2 / P2-7：旧判定只拒 `/` 与 `:`，`..` 与 `x';id;'` 都能过。 */
+    if (!mp_pkg_ok(pkg)) return send_err(sock, 400, "BAD_REQUEST", "包名非法");
     char appdir[1024];
     snprintf(appdir, sizeof appdir, "%s/%s", MEOWAPPS_DIR, pkg);
     struct stat st;
@@ -164,10 +166,12 @@ int api_apps_install(int sock, const req_t *r)
         snprintf(mpkpath, sizeof mpkpath, "%s", tmp);
     }
     if (access(mpkpath, R_OK) < 0) return send_err(sock, 404, "NOT_FOUND", ".mpk 文件不存在");
-    char cmd[1400];
+    /* M64 P1-2：`{path}` 是外部可控串（旧实现直接塞进 popen 的 shell 行）。execv 传入后
-    snprintf(cmd, sizeof cmd, "PATH=/bin:/sbin:/usr/bin:/usr/sbin '%s' install '%s' 2>&1", nyai_bin(), mpkpath);
+     * 元字符已无语义；这里仍按 nyai/mp_fonts 同一拒绝集挡住，防调用被改回 run_cmd。 */
+    if (mp_path_unsafe(mpkpath)) return send_err(sock, 400, "BAD_REQUEST", "路径含非法字符");
     char out[4096];
-    int code = run_cmd(cmd, out, sizeof out);
+    const char *argv[] = { nyai_bin(), "install", mpkpath, NULL };
+    int code = run_argv(out, sizeof out, argv);
     if (code != 0) return send_err(sock, 422, "UNSUPPORTED", out[0] ? out : "nyai install 失败");
     /* 包名 = 文件名茎；版本从 app.json 读 */
     char stem[256];
@@ -205,17 +209,16 @@ int api_apps_install(int sock, const req_t *r)
 int api_apps_export(int sock, const char *pkg)
 {
     if (!tf_present()) return send_err(sock, 503, "NO_CARD", "未识别到 TF 卡");
-    if (strchr(pkg, '/') || strchr(pkg, ':')) return send_err(sock, 400, "BAD_REQUEST", "包名非法");
+    if (!mp_pkg_ok(pkg)) return send_err(sock, 400, "BAD_REQUEST", "包名非法");
     char tmp[1100];
     char card_tmp[1200];
     snprintf(card_tmp, sizeof card_tmp, "%s/tmp", TF_CARD_DIR);
     mkdir(card_tmp, 0777);
     snprintf(tmp, sizeof tmp, "%s/tmp/%s.mpk", TF_CARD_DIR, pkg);
     unlink(tmp);
-    char cmd[1400];
-    snprintf(cmd, sizeof cmd, "PATH=/bin:/sbin:/usr/bin:/usr/sbin '%s' export '%s' '%s' 2>&1", nyai_bin(), pkg, tmp);
     char out[1024];
-    int code = run_cmd(cmd, out, sizeof out);
+    const char *argv[] = { nyai_bin(), "export", pkg, tmp, NULL };
+    int code = run_argv(out, sizeof out, argv);
     if (code != 0 || access(tmp, R_OK) < 0) return send_err(sock, 500, "INTERNAL", out[0] ? out : "nyai export 失败");
     char dn[256];
     snprintf(dn, sizeof dn, "%s.mpk", pkg);
@@ -225,14 +228,19 @@ int api_apps_export(int sock, const char *pkg)
 int api_apps_remove(int sock, const char *pkg, const req_t *r)
 {
     if (!tf_present()) return send_err(sock, 503, "NO_CARD", "未识别到 TF 卡");
-    if (strchr(pkg, '/') || strchr(pkg, ':')) return send_err(sock, 400, "BAD_REQUEST", "包名非法");
+    if (!mp_pkg_ok(pkg)) return send_err(sock, 400, "BAD_REQUEST", "包名非法");
     char purgebuf[8] = "0";
     if (r->query[0]) qparam(r->query, "purge", purgebuf, sizeof purgebuf);
     int use_purge = atoi(purgebuf);
-    char cmd[1400];
-    snprintf(cmd, sizeof cmd, "PATH=/bin:/sbin:/usr/bin:/usr/sbin '%s' remove '%s'%s 2>&1", nyai_bin(), pkg, use_purge ? " --purge" : "");
     char out[1024];
-    int code = run_cmd(cmd, out, sizeof out);
+    const char *argv[6];
+    int n = 0;
+    argv[n++] = nyai_bin();
+    argv[n++] = "remove";
+    argv[n++] = pkg;
+    if (use_purge) argv[n++] = "--purge";
+    argv[n] = NULL;
+    int code = run_argv(out, sizeof out, argv);
     if (code != 0) return send_err(sock, 500, "INTERNAL", out[0] ? out : "nyai remove 失败");
     sbuf_t s = {0};
     sA(&s, "{\"removed\":true,\"purged\":%s}", use_purge ? "true" : "false");

patch_v2/meowpanel/src/mp_argsafe.h

@@ -0,0 +1,63 @@
+/* mp_argsafe.h — MeowPanel 参数安全（M64 P1-2 / P1-3 纯函数，宿主可直接单测）。
+ *
+ * 只放「无副作用、不依赖 panel 运行态」的判定函数：这样 test_mp_argsafe.c 能把它和
+ * 反向控制（修复前的等价判定）跑在同一套用例上，证明校验真的拦住了东西。
+ *
+ * P1-2：App 安装/导出/卸载把外部串拼进 `PATH=... '<nyai>' install '<path>'` 再 popen。
+ *   修复：调用侧改 execv 传 argv（mp_util.c:run_argv），元字符失去 shell 语义；名字类
+ *   参数（包名）仍按结构拒绝——包名本就只有 [a-z0-9._-]，没有兼容代价。
+ * P1-3：/api/key/<code> 的 press_ms 无上下限（一条 `{"press":"tap","ms":8000}` 即强制关机）。
+ *   修复：电源键从 keycode_to_device 移除 + press_ms 全局 clamp。
+ */
+#ifndef MP_ARGSAFE_H
+#define MP_ARGSAFE_H
+
+#include <stddef.h>
+#include <string.h>
+
+/* 包名合法：仅 [a-z0-9._-]，拒绝 "." / ".." / 前导或尾随 '.'。
+ * 规则与 nyai.c:125 valid_pkg() 完全一致（两个二进制各自的私有实现，靠同一份规则收敛）：
+ * 只收小写是安全要求——exFAT 名字比较不区分大小写，放过大写就能用 "OS.MEOW.READER"
+ * 落到已装的 MeowAPPs/os.meow.reader 上并绕过 is_system_pkg() 的签名门。
+ * 同时修掉 P2-7：旧判定只拒 `/` 与 `:`，`MeowAPPs/..` 与 `x';id;'` 都能过。 */
+static inline int mp_pkg_ok(const char *s)
+{
+    if (!s || !*s) return 0;
+    if (s[0] == '.') return 0;                    /* "." / ".." / 隐藏名 */
+    size_t n = strlen(s);
+    if (s[n - 1] == '.') return 0;                /* exFAT/Windows 尾点映射怪癖 */
+    for (; *s; s++) {
+        unsigned char c = (unsigned char)*s;
+        if (!((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
+              c == '.' || c == '-' || c == '_')) return 0;
+    }
+    return 1;
+}
+
+/* 路径/参数里不许出现的字符（拒绝集与 mp_fonts.c:22 unsafe_path、nyai.c:137 一致）。
+ * execv 已让它们不具备 shell 语义；这里保留为第二道，防后人把调用改回 popen/run_cmd。 */
+static inline int mp_path_unsafe(const char *s)
+{
+    return s && strpbrk(s, " ;`$'\"&|<>") != NULL;
+}
+
+/* /api/key/<code> 按压时长上限（ms）。设备端 power.forceoff_ms 缺省 8000ms、从按下起算，
+ * 修复前 ms 无上限 → 一条请求即强制关机（用户已被关机两次）。 */
+#define MP_KEY_PRESS_MS_MAX 1000
+
+static inline int mp_key_clamp_ms(int ms)
+{
+    if (ms < 0) return 0;
+    if (ms > MP_KEY_PRESS_MS_MAX) return MP_KEY_PRESS_MS_MAX;
+    return ms;
+}
+
+/* 禁止注入的键码（APPS.md 物理键红线 + M64 P1-3 电源键）。
+ * 116=KEY_POWER：设备端强制关机计时从按下起算，注入它等于绕过 /api/system/shutdown 的
+ * 二次确认（用户已因此被关机两次）。修复前这里只有 158/172/32/28/96。 */
+static inline int mp_key_forbidden(int code)
+{
+    return code == 116 || code == 158 || code == 172 || code == 32 || code == 28 || code == 96;
+}
+
+#endif /* MP_ARGSAFE_H */

patch_v2/meowpanel/src/mp_key.c

@@ -1,14 +1,20 @@
 /* mp_key.c — 远程控制域：按键注入（写 /dev/input/event* EV_KEY，物理键红线内）。 */
 #include "mp.h"
+#include "mp_argsafe.h"   /* M64 P1-3：press_ms 上限 */
+#include <pthread.h>      /* 按键释放放独立线程：不再用 usleep 阻塞单线程 panel */
 
 #define PWR_KEYDEV   "/dev/input/event0"
 #define ADC_KEYDEV   "/dev/input/event2"
 
 
+/* M64 P1-3：电源键（116）不再可注入。
+ * 修复前 KEY_POWER → /dev/input/event0，而设备端 power.forceoff_ms 缺省 8000ms 且**从按下
+ * 起算**——一条 `{"press":"long","ms":8000}` 即强制关机，绕过 /api/system/shutdown 的前端
+ * 二次确认（用户已因此被关机两次）。电源只走 /api/system/shutdown（带确认弹窗）。
+ * 前端 mp_pages.js 的遥控板电源/长按电源按钮已一并移除。 */
 int keycode_to_device(int code, const char **dev)
 {
     switch (code) {
-    case KEY_POWER:        *dev = PWR_KEYDEV; return KEY_POWER;
     case KEY_PREVIOUSSONG: *dev = PWR_KEYDEV; return KEY_PREVIOUSSONG;
     case KEY_VOLUMEUP:     *dev = ADC_KEYDEV; return KEY_VOLUMEUP;
     case KEY_VOLUMEDOWN:   *dev = ADC_KEYDEV; return KEY_VOLUMEDOWN;
@@ -18,37 +24,63 @@ int keycode_to_device(int code, const char **dev)
     }
 }
 
-int inject_key_event(const char *dev, int code, int down)
+static int write_key_fd(int fd, int code, int down)
 {
-    int fd = open(dev, O_WRONLY | O_NONBLOCK);
-    if (fd < 0) return -1;
     struct input_event ev;
     memset(&ev, 0, sizeof ev);
     ev.type = EV_KEY;
     ev.code = code;
     ev.value = down ? 1 : 0;
-    int ok = (write(fd, &ev, sizeof ev) == (ssize_t)sizeof ev);
+    if (write(fd, &ev, sizeof ev) != (ssize_t)sizeof ev) return -1;
-    if (ok) {
     memset(&ev, 0, sizeof ev);
     ev.type = EV_SYN;
     ev.code = SYN_REPORT;
     ev.value = 0;
-        ok = (write(fd, &ev, sizeof ev) == (ssize_t)sizeof ev);
+    if (write(fd, &ev, sizeof ev) != (ssize_t)sizeof ev) return -1;
-    }
+    return 0;
-    close(fd);
-    return ok ? 0 : -1;
 }
 
-int inject_key_release(int code, int press_ms)
+int inject_key_event(const char *dev, int code, int down)
+{
+    int fd = open(dev, O_WRONLY | O_NONBLOCK);
+    if (fd < 0) return -1;
+    int ok = write_key_fd(fd, code, down);
+    close(fd);
+    return ok;
+}
+
+typedef struct { int fd; int code; int press_ms; } keyjob_t;
+
+/* 按下→等→松开在独立线程里做。修复前是请求线程里 usleep(press_ms)（还无上限）：
+ * 一个键请求就把单线程 8080 服务整段阻塞住。press_ms 已 clamp 到 ≤1000ms，
+ * 线程是 drop 型（detach，自带 job 内存与 fd），请求线程立即返回。
+ * 设备 fd 仍由请求线程同步 open（失败立刻如实报 500，保住原有错误语义）。 */
+static void *keyjob_run(void *arg)
+{
+    keyjob_t *j = arg;
+    if (write_key_fd(j->fd, j->code, 1) == 0) {
+        usleep((useconds_t)(j->press_ms > 0 ? j->press_ms : 80) * 1000);
+        write_key_fd(j->fd, j->code, 0);
+    }
+    close(j->fd);
+    free(j);
+    return NULL;
+}
+
+int inject_key_async(int code, int press_ms)
 {
     const char *dev = NULL;
-    int kc = keycode_to_device(code, &dev);
+    if (keycode_to_device(code, &dev) < 0) return -1;
-    if (kc < 0) return -1;
+    int fd = open(dev, O_WRONLY | O_NONBLOCK);
-    int release_ms = press_ms > 0 ? press_ms : 0;
+    if (fd < 0) return -1;
-    if (inject_key_event(dev, code, 1) < 0) return -1;
+    keyjob_t *j = malloc(sizeof *j);
-    if (release_ms > 0) usleep((useconds_t)release_ms * 1000);
+    if (!j) { close(fd); return -1; }
-    else usleep(80 * 1000);
+    j->fd = fd;
-    if (inject_key_event(dev, code, 0) < 0) return -1;
+    j->code = code;
+    j->press_ms = mp_key_clamp_ms(press_ms);
+    pthread_t t;
+    if (pthread_create(&t, NULL, keyjob_run, j) != 0) { close(fd); free(j); return -1; }
+    pthread_detach(t);
     return 0;
 }
 
@@ -72,16 +104,19 @@ int api_key_single(int sock, int code, const req_t *r)
     if (strcmp(press, "tap") && strcmp(press, "long"))
         return send_err(sock, 400, "BAD_REQUEST", "press 非法");
     if (press_ms <= 0) {
-        if (!strcmp(press, "long")) press_ms = 3000;
+        if (!strcmp(press, "long")) press_ms = MP_KEY_PRESS_MS_MAX;
     }
-    /* 物理键红线：禁止映射 返回(158)/主页(172)/确认/exit（APPS.md）。 */
+    /* M64 P1-3：ms 无上下限时 `{"press":"long","ms":8000}` 直接强制关机（forceoff 从按下起算）。 */
-    if (code == 158 || code == 172 || code == 32 || code == 28 || code == 96)
+    press_ms = mp_key_clamp_ms(press_ms);
-        return send_err(sock, 403, "FORBIDDEN", "该键码（返回/主页/确认）按物理键红线禁止映射");
+    /* 物理键红线：禁止映射 返回(158)/主页(172)/确认/exit（APPS.md）；电源(116) 已于 M64
+     * 从 keycode_to_device 移除，这里再显式拦一次，防将来有人把它加回去。 */
+    if (mp_key_forbidden(code))
+        return send_err(sock, 403, "FORBIDDEN", "该键码（电源/返回/主页/确认）禁止注入");
     const char *tmpdev = NULL;
     int dispatchable = (keycode_to_device(code, &tmpdev) >= 0);
     if (!dispatchable)
-        return send_err(sock, 422, "UNSUPPORTED", "不支持的键码（仅音量/电源/播放/上下曲）");
+        return send_err(sock, 422, "UNSUPPORTED", "不支持的键码（仅音量/播放/上下曲）");
-    if (inject_key_release(code, press_ms) < 0)
+    if (inject_key_async(code, press_ms) < 0)
         return send_err(sock, 500, "INTERNAL", "按键注入失败（无法打开输入设备）");
     sbuf_t s = {0};
     sA(&s, "{\"code\":%d,\"press\":\"%s\",\"dispatched\":true}", code, press);
@@ -106,12 +141,13 @@ int api_key_batch(int sock, const req_t *r)
         jv_t *m = jv_obj_get(k, "ms");
         if (!c || c->type != J_NUM) continue;
         int code = (int)c->inum;
-        if (code == 158 || code == 172) continue;   /* 红线跳过 */
+        if (mp_key_forbidden(code)) continue;   /* 红线跳过（电源/返回/主页） */
         int press_ms = (m && m->type == J_NUM) ? (int)m->inum : 0;
-        if (p && p->type == J_STR && !strcmp(p->str, "long") && press_ms <= 0) press_ms = 3000;
+        if (p && p->type == J_STR && !strcmp(p->str, "long") && press_ms <= 0) press_ms = MP_KEY_PRESS_MS_MAX;
+        press_ms = mp_key_clamp_ms(press_ms);   /* M64 P1-3：与单键同一上限 */
         const char *tmpdev = NULL;
         if (keycode_to_device(code, &tmpdev) < 0) continue;
-        if (inject_key_release(code, press_ms) < 0) continue;
+        if (inject_key_async(code, press_ms) < 0) continue;
         if (!first) sA(&s, ",");
         first = 0;
         sA(&s, "%d", code);

patch_v2/meowpanel/src/mp_util.c

@@ -360,6 +360,46 @@ int run_cmd(const char *cmd, char *out, int outcap)
     return code;
 }
 
+/* 执行子进程（execv 传 argv，不经过 shell）并收 stdout+stderr；返回退出码（-1=起不来）。
+ * M64 P1-2：外部可控串（mpk 路径、包名）只走这条——修复前是拼 `PATH=... '<nyai>' install
+ * '<path>'` 再 popen，路径里一个 `'` 就是 root 命令执行。语义对齐 run_cmd（输出有界截断）。 */
+int run_argv(char *out, int outcap, const char *const argv[])
+{
+    if (outcap <= 0 || !out || !argv || !argv[0]) return -1;
+    out[0] = 0;
+    int pfd[2];
+    if (pipe(pfd) < 0) return -1;
+    pid_t pid = fork();
+    if (pid < 0) { close(pfd[0]); close(pfd[1]); return -1; }
+    if (pid == 0) {
+        dup2(pfd[1], 1);
+        dup2(pfd[1], 2);
+        close(pfd[0]); close(pfd[1]);
+        /* nyai 内部还要找 busybox/tar：PATH 在子进程里设，仍然不经过 shell。 */
+        setenv("PATH", "/bin:/sbin:/usr/bin:/usr/sbin", 1);
+        execv(argv[0], (char *const *)argv);
+        _exit(127);
+    }
+    close(pfd[1]);
+    size_t off = 0;
+    char discard[256];
+    for (;;) {
+        char *dst;
+        size_t room;
+        if (off + 1 < (size_t)outcap) { dst = out + off; room = (size_t)outcap - 1 - off; }
+        else { dst = discard; room = sizeof discard; }
+        ssize_t rd = read(pfd[0], dst, room);
+        if (rd <= 0) break;
+        if (dst != discard) off += (size_t)rd;
+    }
+    close(pfd[0]);
+    out[off] = 0;
+    int st = 0;
+    if (waitpid(pid, &st, 0) < 0) return -1;
+    if (WIFEXITED(st)) return WEXITSTATUS(st);
+    return -1;
+}
+
 int64_t now_mono_ms(void)
 {
     struct timespec ts;

patch_v2/meowpanel/test_mp_argsafe.c

@@ -0,0 +1,115 @@
+/* test_mp_argsafe.c — M64 P1-2 / P1-3 宿主回归：App 安装路径与包名、按键时长与键码红线。
+ *
+ * 纯宿主测试：不连设备、不启面板服务、不发 /api/key/<code> 请求。
+ *
+ * 编译运行（在 patch_v2/meowpanel 下）：
+ *   cc -O1 -Wall -Wextra -I src test_mp_argsafe.c -o ~/tmp/test_mp_argsafe
+ *   ~/tmp/test_mp_argsafe
+ *
+ * 反向控制：同一套用例分别喂给
+ *   ① 「修复前实现」复刻（legacy_pkg_accepts = mp_apps.c:228 旧判定；legacy_path_build =
+ *      mp_apps.c:168 旧拼后再 popen）→ 必须放行/注入成功；
+ *   ② 修复后实现（mp_pkg_ok/mp_path_unsafe/mp_key_clamp_ms/mp_key_forbidden）→ 必须拒绝。
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "mp_argsafe.h"
+
+static int g_fail;
+
+#define CHECK(cond, ...) do {                                  \
+        if (!(cond)) { printf("  FAIL: "); printf(__VA_ARGS__); printf("\n"); g_fail = 1; } \
+        else { printf("  PASS: "); printf(__VA_ARGS__); printf("\n"); }                     \
+    } while (0)
+
+/* 修复前 mp_apps.c:118/208/228 的包名判定：只拒 `/` 与 `:`。 */
+static int legacy_pkg_accepts(const char *pkg)
+{
+    return pkg && !strchr(pkg, '/') && !strchr(pkg, ':');
+}
+
+/* 修复前 mp_apps.c:168 的拼法 + mp_util.c:run_cmd 的 popen。 */
+static void legacy_path_build(const char *mpk, char *out, size_t cap)
+{
+    snprintf(out, cap, "PATH=/bin:/sbin:/usr/bin:/usr/sbin '%s' install '%s' 2>&1",
+             "/usr/bin/nyai", mpk);
+}
+
+static int run_shell(const char *cmd, char *out, int cap)
+{
+    out[0] = 0;
+    FILE *f = popen(cmd, "r");
+    if (!f) return -1;
+    size_t off = fread(out, 1, (size_t)cap - 1, f);
+    out[off] = 0;
+    return pclose(f);
+}
+
+int main(void)
+{
+    printf("== M64 P1-2 反向控制：包名 ==================================================\n");
+    /* 审计给出的真实恶意串。 */
+    static const char *bad_pkgs[] = { "x';id;'", "MeowAPPs/..", "..", ".", "..foo", "foo.",
+                                      "OS.MEOW.READER", "os.meow.reader/../x", "a b", "" };
+    for (unsigned i = 0; i < sizeof bad_pkgs / sizeof bad_pkgs[0]; i++) {
+        const char *p = bad_pkgs[i];
+        int old_acc = legacy_pkg_accepts(p);
+        int new_acc = mp_pkg_ok(p);
+        CHECK(!new_acc, "拒绝包名 `%s`（修复前：%s）", p, old_acc ? "放行 → 可注入" : "也拒");
+    }
+    /* 反向控制的正向对照：旧判定确实放行了这两条。 */
+    CHECK(legacy_pkg_accepts("x';id;'") == 1, "反向控制：修复前放行 `x';id;'`（DELETE /api/apps/x';id;'）");
+    /* P2-7 的穿越面是裸 `..`（拼接后 = MEOWAPPS_DIR/.. ）；`MeowAPPs/..` 含 `/` 反而被旧判定挡住。 */
+    CHECK(legacy_pkg_accepts("..") == 1, "反向控制：修复前放行裸 `..`（MEOWAPPS_DIR/.. 目录穿越）");
+
+    static const char *good_pkgs[] = { "os.meow.reader", "os.meow.app-1", "a_b-c.d", "reader" };
+    for (unsigned i = 0; i < sizeof good_pkgs / sizeof good_pkgs[0]; i++)
+        CHECK(mp_pkg_ok(good_pkgs[i]) == 1, "接受合法包名 `%s`", good_pkgs[i]);
+
+    printf("== M64 P1-2 反向控制：安装路径 ==============================================\n");
+    {
+        /* 审计原串（含 `>` 重定向，写文件的那半句在宿主上不执行——只做字符串判定）。 */
+        const char *audit = "/tmp/a';id>/tmp/pwn;'.mpk";
+        CHECK(mp_path_unsafe(audit) == 1, "拒绝审计原路径 `%s`", audit);
+        CHECK(mp_path_unsafe("/usr/data/mnt/sd_0/MeowOS/tmp/upload.mpk") == 0,
+              "接受面板自己生成的上传临时路径");
+        CHECK(mp_path_unsafe("/sdcard/MeowApps/reader-v1.mpk") == 0, "接受普通路径");
+
+        /* 执行级证明：结构同审计串、但注入体换成 `id`（不写任何文件）。
+         * ① 修复前：值进 shell → `id` 执行。 */
+        const char *pwn = "/tmp/a';id;'.mpk";
+        char cmd[512], out[4096];
+        legacy_path_build(pwn, cmd, sizeof cmd);
+        printf("  修复前命令：%s\n", cmd);
+        run_shell(cmd, out, sizeof out);
+        CHECK(strstr(out, "uid=") != NULL, "修复前被注入：路径里的 `id` 执行（stdout 含 uid=）");
+        /* ② 修复后：同一串被 mp_path_unsafe 拒掉，且永远不会到达 shell。 */
+        CHECK(mp_path_unsafe(pwn) == 1, "修复后同一串在调用 execv 之前就被拒");
+    }
+
+    printf("== M64 P1-3：press_ms clamp ================================================\n");
+    CHECK(mp_key_clamp_ms(-5) == 0, "-5 → 0");
+    CHECK(mp_key_clamp_ms(0) == 0, "0 → 0（注入侧按 80ms tap 节奏处理）");
+    CHECK(mp_key_clamp_ms(80) == 80, "80 → 80");
+    CHECK(mp_key_clamp_ms(1000) == 1000, "1000 → 1000（上限）");
+    CHECK(mp_key_clamp_ms(3000) == 1000, "3000 → 1000（前端旧 `long` 默认值被收口）");
+    CHECK(mp_key_clamp_ms(8000) == 1000, "8000 → 1000（设备端 forceoff_ms 缺省值：一条请求即强制关机）");
+    CHECK(mp_key_clamp_ms(2147483647) == 1000, "INT_MAX → 1000");
+
+    printf("== M64 P1-3：键码红线 ======================================================\n");
+    /* 修复前 mp_key.c:78 只拦 158/172/32/28/96。 */
+    static const int codes[] = { 116, 158, 172, 32, 28, 96 };
+    for (unsigned i = 0; i < sizeof codes / sizeof codes[0]; i++)
+        CHECK(mp_key_forbidden(codes[i]) == 1, "禁止键码 %d", codes[i]);
+    CHECK(116 == 116 && !(116 == 158 || 116 == 172 || 116 == 32 || 116 == 28 || 116 == 96),
+          "反向控制：修复前的红线**放行** 116（KEY_POWER）");
+    static const int allowed[] = { 114, 115, 163, 164, 165 };
+    for (unsigned i = 0; i < sizeof allowed / sizeof allowed[0]; i++)
+        CHECK(mp_key_forbidden(allowed[i]) == 0, "允许键码 %d（音量/上下曲/播放）", allowed[i]);
+
+    printf(g_fail ? "\nRESULT: FAIL\n" : "\nRESULT: ALL PASS\n");
+    return g_fail ? 1 : 0;
+}

patch_v2/meowpanel/web/mp_pages.js

@@ -2293,7 +2293,6 @@ const { $, $$, LOG_GROUP_NAME, SPARK_MAX, api, apiDownload, applyTheme, authMode
     h += remoteBtn('play', 'play', '播放/暂停', '媒体播放/暂停切换（code=164）');
     h += remoteBtn('next', 'next', '下一曲', '下一曲（code=163）');
     h += remoteBtn('prev', 'prev', '上一曲', '上一曲（code=165）');
-    h += remoteBtn('power', 'power', '电源', '电源键（单击；code=116）');
     h += remoteBtn('back', 'back', '返回', '左缘右滑返回（注入设备已识别的返回手势）');
     h += remoteBtn('home', 'home', '回桌面', '底部上滑回桌面（注入设备已识别的回桌面手势）');
     h += '</div>';
@@ -2302,9 +2301,9 @@ const { $, $$, LOG_GROUP_NAME, SPARK_MAX, api, apiDownload, applyTheme, authMode
       '<input type="range" id="ctl-bright" min="' + ctlBright.min + '" max="' + ctlBright.max + '" value="' + ctlBright.value + '">' +
       '<span class="muted" id="ctl-bright-val" style="min-width:40px;text-align:right">' + ctlBright.value + '</span>' +
       '</div>';
-    h += '<button class="btn" id="ctl-powerlong">' + (MP_ICONS.power || '') + ' <span>长按电源（电源菜单）</span></button>';
     h += '<p class="muted" style="margin-top:8px;line-height:1.8">滑动手势（在遥控板上）：上滑＝音量＋ · 下滑＝音量－ · 左滑＝下一曲 · 右滑＝上一曲 · 左缘右滑＝返回。<br>' +
-      '<b>返回/回桌面</b>走手势注入（<code>/api/input/gesture</code>，模拟设备已识别的左缘右滑/底部上滑），<b>不走</b>被物理键红线禁注入的 <code>/api/key</code> 158/172。</p>';
+      '<b>返回/回桌面</b>走手势注入（<code>/api/input/gesture</code>，模拟设备已识别的左缘右滑/底部上滑），<b>不走</b>被物理键红线禁注入的 <code>/api/key</code> 158/172。<br>' +
+      '<b>电源/关机</b>不走按键注入（<code>/api/key/116</code> 已下线：设备端强制关机计时从按下起算，一条请求即关机）——请到「系统」页用<b>关机</b>（带二次确认）。</p>';
     h += '</div>';
     return h;
   }
@@ -2769,12 +2768,10 @@ const { $, $$, LOG_GROUP_NAME, SPARK_MAX, api, apiDownload, applyTheme, authMode
         else if (a === 'play') sendKey(164, 'tap');
         else if (a === 'next') sendKey(163, 'tap');
         else if (a === 'prev') sendKey(165, 'tap');
-        else if (a === 'power') sendKey(116, 'tap');
         else if (a === 'back') sendGesture('back');
         else if (a === 'home') sendGesture('home');
         return;
       }
-      if (e.target.closest('#ctl-powerlong')) { sendKey(116, 'long', 3000); return; }
       if (e.target.closest('#screen-img') || e.target.closest('#screen-canvas')) { screenTap(e); return; }
     });
     // 滑动手势（仅遥控板）；屏幕区点击=注入，不参与手势