皮梦の茶馆

联系皮梦

Sun, 10 May 2026 00:00:00 GMT

国内一些社交平台的联系方式#

国外联系方式#

没有的兄弟，没有的

如何绑定奈伊Bot查询b50

Sat, 16 May 2026 00:00:00 GMT

0x00 事先准备#

水鱼查分器 / 落雪查分器账号（任选其一，若没有先注册）
进入奈伊群

注意

奈伊群改为邀请制群聊，如有需要请找可能的群友拉你入群

一个舞萌账号

0x01 绑定步骤#

绑定水鱼 / 绑定落雪

水鱼绑定#

水鱼Token获取#

打开水鱼官网，如果没有水鱼账号，先注册一个账号

水鱼查分器

然后点击右上角的编辑个人资料

水鱼查分器

找到NaiiBot，直接发起临时会话
发送你在水鱼Token获取中获取到的 成绩导入Token

使用 tokenbind <水鱼Token> 进行绑定

从舞萌公众号获取二维码，然后长按识别二维码，长按全选识别到的内容

使用 maibind <识别到的内容> 进行绑定

点我前往功能详情

落雪绑定#

若没有落雪账号，可参考下面注册一个

落雪查分器注册

注册完后按照图示点击开启权限，否则将无法正常获取成绩和帮助导入成绩

lxns_setting

找到NaiiBot，直接发起临时会话

WARNING

注意： 直接点击头像私聊即可，无需加好友

发送 lxbind 获取绑定地址

L_lxbind

然后打开这个链接，登录你刚刚注册的落雪账号

完成后应该来到这个界面，点击授权

lxbind

授权成功后会得到一个授权码，将其复制

lxbind2

直接将这个授权码发送到刚刚发送 lxbind 的地方

L_lxbind_success

提示 授权完成。 即表示绑定成功

从舞萌公众号获取二维码，然后长按识别二维码，长按全选识别到的内容

使用 maibind <识别到的内容> 进行绑定

0x02 功能#

发送 导 syup 可以将你的成绩直接上传到水鱼 / 落雪（若两个都绑定了，则会同时上传）

导

发送 数据源 [0|1] 按需切换数据源，0为水鱼，1为落雪

切换数据源

发送 b50 即可从查分器获取你的b50成绩，然后生成图片

发送 kw 获取详细个人数据

使用 Python 实现 Windows Hello 鉴权

Mon, 11 May 2026 00:00:00 GMT

前排提醒

本篇由AI编写

免责说明

本文只讨论在自己的 Windows 设备上做本机身份确认。

它不是绕过系统验证，也不是提权工具。不要把它用在窃取、保存、转发他人凭据的场景里。

0x00 前言#

有些小工具会遇到这种需求：

打开加密文件前，确认一下当前操作者是不是本人
执行敏感操作前，弹一次系统级验证
写桌面脚本时，不想自己做一套密码输入框
希望优先使用 Windows Hello、PIN、指纹或人脸识别

在 Windows 上，比较合适的方式是直接调系统提供的凭据 UI。

这样做的好处是：密码框、PIN、指纹、人脸这些入口都由系统接管，脚本本身不需要自己画登录框，也不用处理一堆奇怪的输入法、焦点、遮挡问题。

源码下载：windows hello.py

0x01 效果#

直接运行脚本：

Terminal window

1
python ".\windows hello.py"

如果系统已经配置了 Windows Hello，正常情况下会弹出 Windows 安全验证窗口。用户可以按系统支持的方式验证身份：

Windows Hello PIN
指纹
面部识别
当前账户密码
Microsoft 账户或本地账户凭据

验证完成后，脚本会输出类似结果：

1
Windows Hello 身份验证
2
------------------------------
3
提示：如果系统配置了指纹/人脸/PIN，对话框会显示相应选项
4

5
结果: 身份验证通过
6
用户: Alice
7
验证通过，执行敏感操作...

如果用户点了取消，脚本会停止后续敏感操作。

0x02 实现思路#

整套流程可以分成 4 步：

使用 CredUIPromptForWindowsCredentialsW 弹出 Windows 凭据 / Windows Hello 对话框
使用 CredUnPackAuthenticationBufferW 解包系统返回的认证数据
使用 LogonUserW 尝试验证用户名和密码
及时释放系统分配的内存和登录 token 句柄

脚本里主要用到了 3 个系统 DLL：

DLL	作用
`credui.dll`	弹出 Windows 凭据 UI，并解包认证缓冲区
`advapi32.dll`	调用 `LogonUserW` 验证凭据
`kernel32.dll`	释放句柄、释放系统分配的内存

Python 这边不需要安装第三方库，直接用标准库里的 ctypes 调 Windows API。

0x03 定义 Windows API 结构体#

Windows API 通常不是 Python 风格的函数，它更像 C 语言接口。调用前要把结构体、缓冲区和指针都准备好。

这里的 CREDUI_INFO 对应 Windows 凭据窗口的基本信息：

1
class CREDUI_INFO(ctypes.Structure):
2
    """对应 Windows API 的 CREDUI_INFO 结构体。"""
3

4
    _fields_ = [
5
        ("cbSize", wintypes.DWORD),
6
        ("hwndParent", wintypes.HWND),
7
        ("pszMessageText", wintypes.LPCWSTR),
8
        ("pszCaptionText", wintypes.LPCWSTR),
9
        ("hbmBanner", wintypes.HBITMAP),
10
    ]

几个字段的作用也比较直观：

cbSize：结构体大小，Windows API 用它判断传入结构是否正确
hwndParent：父窗口句柄，脚本里没有 GUI，所以传 None
pszMessageText：窗口正文提示
pszCaptionText：窗口标题
hbmBanner：横幅图片，这里不使用

调用前要给 cbSize 赋值：

1
ui_info = CREDUI_INFO()
2
ui_info.cbSize = ctypes.sizeof(CREDUI_INFO)
3
ui_info.hwndParent = None
4
ui_info.pszMessageText = message
5
ui_info.pszCaptionText = caption
6
ui_info.hbmBanner = None

这一步少了的话，API 很容易直接返回参数错误。

0x04 弹出 Windows Hello / 凭据窗口#

核心调用在这里：

1
result = credui.CredUIPromptForWindowsCredentialsW(
2
    ctypes.byref(ui_info), 0, ctypes.byref(auth_package),
3
    None, 0, ctypes.byref(out_buffer), ctypes.byref(out_size),
4
    ctypes.byref(save), flags
5
)

比较关键的是 flags：

1
CREDUIWIN_AUTHPACKAGE_ONLY = 0x10
2
CREDUIWIN_ENUMERATE_CURRENT_USER = 0x200
3

4
flags = CREDUIWIN_AUTHPACKAGE_ONLY | CREDUIWIN_ENUMERATE_CURRENT_USER

其中：

CREDUIWIN_AUTHPACKAGE_ONLY：让系统使用合适的认证包
CREDUIWIN_ENUMERATE_CURRENT_USER：优先枚举当前登录用户

如果用户取消窗口，Windows 会返回 1223：

1
if result == ERROR_CANCELLED:
2
    return False, "用户取消了验证", None

如果返回值不是 0，说明对话框调用失败。

1
if result != 0:
2
    return False, f"对话框调用失败 (错误码: {result})", None

小提示

CredUIPromptForWindowsCredentialsW 只是负责弹出系统验证窗口，并返回认证缓冲区。

真正要不要继续执行后面的敏感操作，应该由你自己的程序逻辑决定。

0x05 解包用户名和密码#

凭据窗口返回的不是普通字符串，而是一块打包后的认证缓冲区。要继续处理，需要用 CredUnPackAuthenticationBufferW 拆出来：

1
username = ctypes.create_unicode_buffer(CREDUI_MAX_USERNAME_LENGTH)
2
domain = ctypes.create_unicode_buffer(CREDUI_MAX_DOMAIN_LENGTH)
3
password = ctypes.create_unicode_buffer(CREDUI_MAX_PASSWORD_LENGTH)
4

5
username_size = wintypes.DWORD(CREDUI_MAX_USERNAME_LENGTH)
6
domain_size = wintypes.DWORD(CREDUI_MAX_DOMAIN_LENGTH)
7
password_size = wintypes.DWORD(CREDUI_MAX_PASSWORD_LENGTH)
8

9
credui.CredUnPackAuthenticationBufferW(
10
    0, out_buffer, out_size.value,
11
    username, ctypes.byref(username_size),
12
    domain, ctypes.byref(domain_size),
13
    password, ctypes.byref(password_size)
14
)

这里用到的缓冲区长度来自 Windows SDK 里的 CREDUI_MAX_* 常量：

1
CREDUI_MAX_USERNAME_LENGTH = 513
2
CREDUI_MAX_DOMAIN_LENGTH = 256
3
CREDUI_MAX_PASSWORD_LENGTH = 256

有些账户名会带域名，例如：

1
DESKTOP-123456\Alice

所以脚本里加了一个小函数，把 domain\user 拆成两段：

1
def parse_username(full_username):
2
    if '\\' in full_username:
3
        domain, user = full_username.rsplit('\\', 1)
4
        return domain, user
5
    return None, full_username

这样后面调用 LogonUserW 时就能分别传入 domain 和 username。

0x06 验证凭据#

拿到用户名、域和密码之后，就可以用 LogonUserW 做一次显式验证：

1
result = advapi32.LogonUserW(
2
    ctypes.c_wchar_p(username),
3
    ctypes.c_wchar_p(domain) if domain else None,
4
    ctypes.c_wchar_p(password) if password else None,
5
    2,
6
    0,
7
    ctypes.byref(token)
8
)

这里的两个数字分别是：

2：LOGON32_LOGON_INTERACTIVE，按交互式登录方式验证
0：LOGON32_PROVIDER_DEFAULT，使用系统默认认证提供程序

如果验证成功，系统会返回一个 token 句柄。这个句柄用完一定要关掉：

1
if result:
2
    kernel32.CloseHandle(token)
3
    return True, 0

不关闭句柄的话，短脚本一般不明显，但长时间运行的程序可能会泄漏系统资源。

0x07 错误处理#

Windows API 返回的通常是错误码，不太适合直接给用户看，所以脚本做了一层中文提示：

1
def get_error_message(code):
2
    errors = {
3
        1326: "密码错误或用户名无效",
4
        1330: "密码已过期",
5
        1385: "登录类型被拒绝（权限不足）",
6
        1314: "权限不足",
7
        5: "访问被拒绝",
8
        87: "参数错误",
9
    }
10
    return errors.get(code, f"未知错误 (代码: {code})")

几个常见错误码：

错误码	含义
`1223`	用户取消验证
`1326`	用户名或密码错误
`1330`	密码已过期
`1385`	登录类型被拒绝
`1314`	权限不足
`5`	访问被拒绝
`87`	参数错误

脚本里还处理了一个比较现实的情况：Windows Hello / PIN 通过了系统确认，但 LogonUserW 未必能按普通密码登录方式完成验证。

1
elif err_code in (1385, ERROR_PRIVILEGE_NOT_HELD):
2
    return True, f"身份已确认 (通过 Windows Hello/PIN)", short_user

这不是在绕过验证，而是因为系统凭据 UI 已经完成了交互式身份确认，但后续的 LogonUserW 在某些账户策略或登录类型下可能没有权限继续拿 token。

0x08 释放敏感数据#

这个脚本里有两个地方需要特别注意资源释放。

第一个是密码缓冲区。解包之后，脚本会尽快把 ctypes 里的密码缓冲区清零：

1
if pwd:
2
    ctypes.memset(password, 0, ctypes.sizeof(password))

不过要注意，pwd = password.value 会把内容复制成 Python 字符串。Python 字符串的内存由解释器管理，无法像 C 缓冲区一样精确控制生命周期。

所以这个方案适合短流程身份确认，不适合把密码长期保存在程序里，更不应该写入日志或文件。

第二个是 CredUIPromptForWindowsCredentialsW 返回的 out_buffer。这块内存由系统分配，最后必须用 LocalFree 释放：

1
finally:
2
    if out_buffer.value:
3
        kernel32.LocalFree(out_buffer)

这是调用 Windows API 时很容易漏掉的一步。

0x09 完整调用方式#

脚本把整个流程封装成了一个函数：

1
success, msg, user = windows_hello_verify("请验证身份以继续操作", "安全验证")
2

3
print(f"\n结果: {msg}")
4
if user:
5
    print(f"用户: {user}")
6

7
if success:
8
    print("验证通过，执行敏感操作...")
9
else:
10
    print("验证失败，操作已取消")
11
    sys.exit(1)

如果要放进自己的脚本里，大概可以这样用：

1
success, message, user = windows_hello_verify(
2
    message="请验证身份以打开配置文件",
3
    caption="本机身份确认"
4
)
5

6
if not success:
7
    raise PermissionError(message)
8

9
open_secret_config()

比较建议的写法是：把敏感操作放在 success 之后，而不是先执行再验证。

0x0A 使用限制#

这个方案很方便，但它不是万能身份系统。

需要注意几点：

只适合 Windows，不支持 Linux / macOS
需要在当前设备上运行，不能拿来做远程 Web 登录
它不会帮你提升管理员权限，也不能替代 UAC
不建议在日志里打印用户名、域名、错误详情之外的敏感内容
如果是正式产品，应该结合更完整的权限模型、审计日志和密钥管理

说白了，它适合给本机 Python 工具加一道系统级确认。

比如你写了个脚本要删除文件、导出密钥、打开隐私数据，在真正执行前让 Windows 帮你确认一下“现在坐在电脑前的人是不是当前用户”，这类场景就很合适。

0x0B 总结#

用 Python 调 Windows Hello 的核心并不复杂，关键是理解它背后的 Windows API 流程：

CredUIPromptForWindowsCredentialsW 弹出系统验证窗口
CredUnPackAuthenticationBufferW 解包认证结果
LogonUserW 尝试做显式凭据验证
CloseHandle 和 LocalFree 释放系统资源

这种写法的好处是简单、原生、不依赖第三方库，而且用户看到的是熟悉的 Windows 安全界面。

如果只是给自己的 Python 小工具加一道本机身份确认，这套方案已经够用了。

抓包从入门到放弃（

Tue, 28 Apr 2026 00:00:00 GMT

WARNING

内容大部分由AI生成

0x00 前言#

写在前面

这篇文章说的“抓包”，专指 HTTP/HTTPS 抓包。也就是看看 App、网页、小程序在访问服务器接口时，到底发了什么、收到了什么。

不包含更底层的 TCP、UDP 那些，也不研究数据包怎么拆分的——那些太硬核，咱们先不碰。

所谓抓包，说白了就是把客户端和服务器之间的“对话”偷偷记下来，让你能看到。

平时你打开一个网页、登录一个 App、点一下刷新、提交一个表单，背后其实都在发 HTTP 请求。这些请求里藏着很多信息：访问的地址是啥、用了什么方法、带了哪些参数、有没有带 Cookie、服务器返回了什么数据……抓包工具的作用，就是把这些原本藏在程序背后的东西翻出来给你看。

通过抓包，你能知道：

点这个按钮，到底调用了哪个接口？
发请求时带了哪些参数？
服务器返回了什么内容？
请求失败到底卡在哪一步？

为什么要抓包？

因为很多时候，“页面上显示的错误提示”根本不说人话。比如只告诉你“网络错误”，但真实原因可能是 Token 过期、参数缺失、或者服务器返回了错误数据。抓包能让你看到真相。

对于开发人员来说，抓包可以调试接口、排查登录问题、分析参数传没传对、确认前后端数据是否一致。对于普通学习者来说，抓包也能帮你搞明白浏览器、App 和服务器之间到底怎么“聊天”的。

举个例子：
某个 App 弹窗说“网络错误”，你以为是没网了？其实可能是服务器拒绝了请求，或者你的登录凭证失效了。用抓包一看，哦，原来服务器返回了“401 未登录”。这一下就清楚了。

注意

抓包只是观察和调试网络请求的一种手段。请只在自己有权限的设备、账号、网站或测试环境中使用。别拿去偷看别人的隐私数据，这是底线。

所以，这篇文章不扯太深的原理，也不讲底层网络协议。
我们就从最实用、最常见的 HTTP 抓包开始，看看它能干什么、怎么用，以及为什么很多人学着学着就“放弃”了。

0x01 HTTP 抓包是什么？#

HTTP 抓包，本质上就是把一次“你看不见的后台网络请求”变成“你能读懂的聊天记录”。

没有抓包之前，你只能看到页面上的结果：

登录成功 / 登录失败
加载出来了 / 加载失败了
按钮点了没反应
提示“网络错误”

这些提示往往很模糊，就像有人只说“出错了”，但不说哪里错了。

而有了抓包，你就能看到完整的“聊天记录”。比如：

客户端说：

1
GET /api/user/profile HTTP/1.1
2
Host: example.com
3
Authorization: Bearer xxxxx

服务器回答：

1
{
2
  "code": 401,
3
  "message": "token expired"
4
}

这样一来，“网络错误”就不再是个谜。你可以清楚地看到：

请求有没有发出去？
发到哪个地址去了？
参数带全了吗？
Cookie 或 Token 还有效吗？
服务器返回了什么状态码？
返回的数据对不对？

简单理解

抓包不是“黑进服务器”，而是把你电脑或手机和服务器之间的通信记录截下来给你看。就像在电话线上装了个录音机，但前提是你有这个权利。

0x02 一次 HTTP 请求里通常有什么？#

一次 HTTP 请求，就像你给一个人写信。信上有收件地址、你的名字、你要说的事情，还有附带的资料。

常见的几个部分：

请求地址（URL）：就像收件地址，告诉服务器你要找谁。例如 https://example.com/api/user
请求方法：你是去“拿东西”（GET），还是“交东西”（POST），或者“改东西”（PUT）、“删东西”（DELETE）
请求头（Headers）：附带的说明，比如“我是用什么浏览器发起的”、“我带着什么 Token”
请求参数：具体要问的内容。比如 ?id=10001 表示“我要 id 是 10001 的用户信息”
Cookie / Token：相当于你的身份证或会员卡，告诉服务器“我是谁”
响应状态码：服务器回复的“处理结果”，比如 200 表示“一切正常”，404 表示“你找的东西不存在”
响应内容：服务器给你的具体数据，通常是 JSON 格式，也可能是 HTML 网页或图片

举个例子，你在浏览器里访问 https://example.com/api/user?id=10001，其实就是发了一个 GET 请求，意思是：“嘿，服务器，把 id 为 10001 的用户信息给我。”

如果是登录，一般用 POST 请求，就像填写一张表格交给服务器：

1
POST https://example.com/api/login
2
Content-Type: application/json
3

4
{
5
  "username": "张三",
6
  "password": "123456"
7
}

新手看抓包记录，先看什么？

不用一次看懂所有东西。先盯住这 5 个关键点：

请求地址对不对？
方法是 GET 还是 POST？，
参数有没有传错（比如用户名写反了）？
状态码是不是 200？如果不是，看看是多少。
响应内容里有没有明确的错误提示，比如“密码错误”。

0x03 为什么 HTTPS 是加密的，还能被抓包？#

你可能听说过，HTTPS 是加密的，中间人看不到内容。那为什么抓包工具还能看到呢？

其实，抓包工具并没有“破解”加密。它更像是在 “假装自己是服务器”。（两头骗哈哈）

具体来说，抓包工具会在你电脑或手机上设置一个代理。你的请求会先发给抓包工具（如果遵循了系统代理的情况下），然后抓包工具再转发给真正的服务器。就像这样：

1
你的 App → 抓包工具（假装是服务器） → 真正的服务器

对于你的 App 来说，抓包工具就是服务器。对于真正的服务器来说，抓包工具就是个普通客户端。

但是 HTTPS 有证书验证，为了防止别人冒充，App 会检查服务器的证书。为了让抓包工具能成功“冒充”，你需要把抓包工具自己签发的根证书安装到你的设备上，并信任它。（也就是自己信得过自己）

证书信任是关键

如果你没有安装并信任抓包工具的证书，HTTPS 请求就只能看到域名和连接信息，看不到具体内容。这是新手最容易卡住的地方——明明装了工具，却看不到任何请求详情。

不过，现在很多 App 会做额外的保护，比如“证书绑定”（SSL Pinning）。它们会写死只信任某个特定证书（这就是正常情况： 我只信得过我自己背下来的东西 ），就算你安装了抓包证书也没用。

别急着怪工具

如果抓不到 HTTPS 的明文内容，不一定是工具坏了。可能是证书没信任，也可能是 App 自己加了防抓包的保护。

0x04 常见的 HTTP 抓包工具#

抓包工具挺多的，不同情况下用不同的。下面这些是比较常见的：

工具	适合场景	简单说明
浏览器开发者工具	调试网页请求	最简单，按 F12 就能用，看网页请求足够了
Charles	Windows / Mac 抓包	图形界面，新手友好，手机电脑都能抓
Fiddler	Windows 抓包	老牌工具，功能强大，但界面稍微复杂
mitmproxy	命令行 / 自动化脚本	适合进阶玩家，可以用 Python 写脚本处理请求
Proxyman	Mac 抓包	界面漂亮，抓手机 App 很方便
HTTP Toolkit	桌面端调试	现代化界面，一键开启抓包，适合快速查看
Reqable	手机/电脑协同抓包	支持多平台协同抓包，适合手机抓包，电脑查看

如果你只是看看网页接口，直接用浏览器自带的开发者工具就行。

打开 Chrome 或 Edge，按键盘上的 F12，然后点 Network 标签。刷新页面，就能看到所有请求。

新手路线推荐

建议先从浏览器开发者工具入手。搞懂请求地址、参数、Headers、响应内容分别是什么之后，再去玩 Charles 或 mitmproxy，会顺手很多。

0x05 浏览器里怎么简单 “抓包” ？#

用浏览器开发者工具抓包，按下面几步走就行：

打开你要看的网页
按 F12/ Ctrl+Shift+I 打开开发者工具
点击顶部的 Network / 网络 标签
刷新页面（或者点一下页面上的按钮）
在列表里点击某一条请求
右边会出现三个常用标签：Headers、Payload、Response
Firefox Console

具体看什么？

Headers（头部）#

这里能看到请求地址、方法、状态码、还有请求头（比如 Cookie、User-Agent）。

例如：

1
Request URL: https://phira-mp-status-test.dmocken.top/api/check?server=yee.autos:2000
2
Request Method: GET
3
Status Code: 200

Payload（参数）#

这里能看到请求时带的参数。

GET 请求的参数通常在 URL 上，比如 ?id=123
POST 请求的参数通常在 Payload / 载荷里，比如 {"username":"张三"}

Response（响应）#

这里能看到服务器返回的数据。很多接口会返回 JSON 格式，比如：

1
{
2
  "success": true,
3
  "server": "yee.autos:2000",
4
  "timestamp": "2026-04-28T11:04:47.211Z",
5
  "total_response_time": 305,
6
  "login_time": 0,
7
  "token_from_cache": true,
8
  "login_method": "cache",
9
  "kv_overhead_time": 42,
10
  "connect_time": 93,
11
  "server_response_time": 170,
12
  "tcp_total_time": 263,
13
  "message": "连接成功并收到有效响应",
14
  "stage": "SUCCESS",
15
  "backoff_status": {
16
    "active": false,
17
    "consecutive_failures": 0,
18
    "current_delay_ms": 0,
19
    "remaining_time_ms": 0
20
  }
21
}

一个小技巧

有时候页面显示错误，但状态码是 200（也就是 HTTP 层面成功了）。这时候别急着怪网络，去看 Response 里的业务错误信息。比如服务器返回：

1
{
2
  "success": false,
3
  "message": "尝试登录失败"
4
}

虽然状态码是 200，但实际上用户并未登录。

0x06 状态码怎么看？#

HTTP 状态码是服务器给的“一句话总结”。你可以把它理解为服务员对上菜结果的快速反馈：

状态码	含义（人话版）
`200`	一切正常，你要的东西在这
`301 / 302`	你要的东西搬到别的地方去了，我告诉你新地址
`400`	你给的请求有问题，比如参数格式不对
`401`	你没登录，或者登录凭证过期了
`403`	你登录了，但没权限看这个
`404`	你要的接口不存在，地址写错了
`429`	你刷得太快了，服务器叫你缓一缓
`500`	服务器自己出错了表示我爆了
`502 / 503 / 504`	服务器暂时挂了或太忙，稍后再试

别只看状态码

状态码只是第一层判断。有些接口即使返回 200，也可能在 JSON 里说“其实失败了”。就像外卖 App 显示“下单成功”，但店家实际回复“卖完了，没货了”。

例子：

1
{
2
  "success": false,
3
  "message": "参数错误"
4
}

虽然状态码是 200，但业务上是失败的。

0x07 抓包常用来解决什么问题？#

抓包最实用的地方就是帮你找到问题到底出在哪。

登录失败#

登录接口有没有发出去？（有时候按钮根本没触发请求）
用户名、密码这些参数传对了吗？
有没有缺少必要的 Token 或验证码？
服务器返回了什么错误，比如“密码错误”还是“账号不存在”？

页面加载不出来#

数据接口返回 404 还是 500？
是不是被跨域挡住了？（浏览器里常见）
返回的数据是不是空的？
前端是不是解析出错了（比如服务端返回了 HTML 但前端期待 JSON）？

App 提示“网络错误”#

请求真的发出去了吗？还是代理没设好？
HTTPS 证书有没有问题（比如抓包证书没装好）？
服务器返回了什么具体错误？
Token 是不是过期了？

接口返回的数据不对#

参数有没有传错（比如把“page=1”传成了“page=0”）？
筛选条件少传了一个？
是不是请求到了测试环境而不是正式环境？
后端返回的字段名和接口文档不一致？

抓包的核心思路

不要猜。一步一步看：

请求有没有发出去？
如果发了，请求地址/参数/头都对吗？
服务器返回了什么状态码？
响应内容里的业务错误信息说了什么？这样一步步排查，大概率能找到原因。

0x08 抓包时要注意什么？#

抓包虽然好用，但也有一些坑和雷区。

尤其是抓 HTTPS 的时候，你会看到 Cookie、Token、手机号、邮箱这些敏感信息。如果随便截图发到网上，可能会泄露隐私。

不要随便分享抓包截图

在问别人问题或者发日志之前，记得把敏感信息打码或替换掉。特别要注意：

Cookie
Token
Authorization（授权头）
手机号
邮箱
身份证号
订单号
用户 ID
真实的接口密钥

一个安全的做法是把敏感字段替换成奇奇怪怪的东西，比如：

1
Authorization: Bearer 114514191919810
2
Cookie: abcdefghijklmnop
3
phone: 13888888888

警告

抓包只能用于学习、调试自己有权分析的请求。

别去抓别人的账号数据、聊天记录、或者你没授权的接口。这是基本道德，也是法律问题

对的没错，出事别找我（（

0x09 抓包为什么会“从入门到放弃”？#

因为一开始你会觉得抓包很简单：

打开工具，设个代理，刷新页面，请求就出来了。

但当你真正开始用的时候，各种奇怪问题就来了：

代理设好了，但啥请求都没有（工具没抓到？）
HTTPS 证书装了，但还是看不到内容（难道没生效？）
浏览器能抓到，换到 App 就抓不到了（App 不走代理？）
App 一开代理就直接断网（它检测到代理了？）
请求列表一大堆，根本不知道看哪个
参数几十个，看得眼花缭乱
返回的内容被压缩、加密，或者乱码
接口有个签名，你改个参数就报错
Token、Cookie、Session 混在一起，理不清

于是，抓包就从：

“我就想看看请求”
→ 一步步变成：
“为什么它不走代理？”
“为什么证书不管用？”
“为什么请求解不开？”
“为什么我改了一个参数就 403？”
“为什么这个 sign 每次都变？”

最后成功进入 “从入门到放弃” 的经典环节。

这其实很正常

抓包工具只是个放大镜。真正复杂的东西，在于 App 自己的保护机制：证书绑定、签名算法、反抓包检测等等。这不是你一两天就能搞定的。

所以这篇文章的目标，不是教你怎么“突破一切限制”，而是先把最基础、最常见的 HTTP 抓包流程讲清楚。

你先知道自己看到了什么，再去理解为什么会这样。

本文的目标人群

这不是一篇网络协议教程，也不是逆向破解教程。它只是想让你：

能看懂一次常见的 HTTP 请求
能用抓包结果辅助排查问题

如果你只是想知道：

这个按钮点下去，到底请求了啥？
这个接口为啥返回错误？
这个 App 到底有没有连上服务器？

那么 HTTP 抓包就是为你准备的入门工具。

抓包实战之——APP登录篇

Tue, 28 Apr 2026 00:00:00 GMT

0x00 被测环境#

本篇使用 Reqable 双端协同工具进行演示，使用 Phira 作为被测APP，使用 Mumu模拟器 作为已经被Root的设备（配置SSL证书信任需要）

Mumu模拟器需要打开可写系统盘，并开启Root权限

Mumu模拟器可写系统盘

Mumu模拟器 Root

0x01 安装抓包工具#

Mumu模拟器主页

安装如图工具（Reqable、MT管理器）和被测软件

电脑版 Reqable

0x02 工具配置#

打开 Reqable ，同意用户许可协议

Reqable APP

工作模式选择 协同模式

Reqable APP

点击左上角三横，打开配置菜单

Reqable APP

找到 远程设备

Reqable APP

选择 扫描二维码

Reqable APP

然后选择实时截屏，打开电脑的 Reqable ，找到类似手机的图标

Reqable Desktop

将 Mumu模拟器的扫码框移动到 Reqable 电脑版的二维码上面，此时应该扫码成功，然后提示 设备已连接（如下图）

Reqable APP

重要

如果使用真实手机，请别忘了电脑和手机需要保持在一个 WiFi/网络下

然后点击右上角黄色感叹号，和电脑同步一遍证书（此处不再截图演示）

然后打开三横菜单，找到证书管理，此时顶上 安装根证书到本机 底下应为红色的 证书未安装 属于正常情况，下面将进行安装证书

点击 安装根证书到本机

Reqable APP Cert

点击红框标记的下划线地方（你的证书名字正常和我的是不一样的，以你那边的为准即可）

然后会弹出一个保存文件名的选项，此时保持默认即可，然后点击保存

Reqable APP Cert

然后先把 Reqable 关掉，打开 MT管理器

此时应该会自动弹出超级用户访问权限的提示，点击 永久记住此选择 ，然后选择允许

MT管理器

左边列表依次点击 Download → Reqable，此时应该能见到刚刚你保存的证书文件

MT管理器

然后右侧列表点击上方 .. 回退到系统根目录（即左上角从 /storage/emulated/0/ 到 / ，往下滑找到 system

MT管理器

依次点击 etc → security → cacerts ，会来到一个很多看起来像 “乱码” 的文件列表，无需理会，接下来，长按左边 Reqable 保存的证书文件，在弹出的提示框点击复制

注意

如果出现了 挂载读写失败 ，则检查被测环境中的可写系统盘是否已经配置正确，如果配置正确，请重启一遍 Mumu模拟器后重试

alt text

完成后，右侧列表应多出一个左边的文件

MT管理器

然后打开 Reqable ，此时应该不会出现证书警告

Reqable APP

0x03 实战#

点击右下角箭头，此时开始监听http包体

小建议

可以打开 Mumu模拟器的分离标签页功能以获得更好的体验

打开被测软件，如果一切正常，在电脑 Reqable 上能看到被测APP的一些请求

被测APP

我们正常尝试这个被测APP的登录操作

0x04 收尾#

好的，一下就遇到了内置SSL证书的被测APP，先跑路，后面再补充这个文章（（（

镜像源和常用命令汇总

Thu, 09 Apr 2026 00:00:00 GMT

镜像源#

Linux 软件源#

NOTE

推荐使用 LinuxMirrors 换源脚本

换源脚本

按你当前环境选择命令，适合在同一位置切换 curl / wget 等不同写法

curlwget

当前版本：curl

复制代码

bash <(curl -sSL https://linuxmirrors.cn/main.sh)

适用于已安装 curl 的环境

备份当前的软件源列表：

Terminal window

1
sudo cp /etc/apt/sources.list /etc/apt/sources.list_bak

编辑软件源列表：

Terminal window

1
sudo vim /etc/apt/sources.list

NOTE

不会用Vim？可以使用nano或者查看教程

替换为国内镜像源

Ubuntu 镜像源探测与切换

正在使用你的浏览器探测可达性…

会将 sources.list 中的 Ubuntu 源地址批量替换为所选镜像并执行 apt update；结果仅代表你当前网络环境。

阿里云·清华·中科大·

当前命令清华(https://mirrors.tuna.tsinghua.edu.cn/ubuntu/)

复制命令

sudo sed -Ei "s|https?://[^ ]+/ubuntu/|https://mirrors.tuna.tsinghua.edu.cn/ubuntu/|g" /etc/apt/sources.list && sudo apt update

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

Python / Pypi 镜像源#

Python / PyPI 镜像源探测与切换

正在使用你的浏览器探测可达性…

绿色圆点表示当前浏览器可以连通，红色感叹号表示超时或失败；结果仅代表你当前网络环境。

清华 TUNA·华为云·阿里云·腾讯云·上海交大·中科大·

当前命令清华 TUNA(https://pypi.tuna.tsinghua.edu.cn/simple)

复制命令

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

如果你只想手动执行，也可以直接复制：

Terminal window

1
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple --upgrade pip
2
pip install -i <MIRROR_URL> numpy

Node.js#

NVM（官方Node.js管理器）：#

NVM 安装脚本地址探测与切换

正在使用你的浏览器探测可达性…

用于选择 NVM 安装脚本下载地址；结果仅代表你当前网络环境。

GitHub 官方·Gitee 加速脚本·

当前命令GitHub 官方(https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh)

复制命令

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

完成后，安装 Node.js：

Terminal window

1
nvm i 24

设置默认版本

Terminal window

1
nvm use 24
2
nvm alias default 24

NPM 镜像源#

NPM 镜像源探测与切换（当前用户）

正在使用你的浏览器探测可达性…

绿色圆点表示当前浏览器可以连通，红色感叹号表示超时或失败；结果仅代表你当前网络环境。

npmmirror·华为云·腾讯云·

当前命令npmmirror(https://registry.npmmirror.com)

复制命令

npm config set registry https://registry.npmmirror.com

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

NPM 镜像源探测与切换（全局）

正在使用你的浏览器探测可达性…

需要管理员权限时请在命令前加 sudo；结果仅代表你当前网络环境。

npmmirror·华为云·腾讯云·

当前命令npmmirror(https://registry.npmmirror.com)

复制命令

npm config -g set registry https://registry.npmmirror.com

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

Go 模块代理#

Go 模块代理探测与切换

正在使用你的浏览器探测可达性…

绿色圆点表示当前浏览器可以连通，红色感叹号表示超时或失败；结果仅代表你当前网络环境。

官方·七牛·阿里云·

当前命令七牛(https://goproxy.cn)

复制命令

go env -w GOPROXY=https://goproxy.cn,direct

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

如果你只想手动执行，也可以直接复制下面任意一条：

Terminal window

1
go env -w GOPROXY=https://goproxy.cn,direct
2
go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/,direct
3
go env -w GOPROXY=https://goproxy.io,direct

Docker#

安装脚本#

NOTE

推荐使用 LinuxMirrors 的 Docker 安装脚本，方便快捷

安装脚本

按你当前环境选择命令，适合在同一位置切换 curl / wget 等不同写法。

curlwget

当前版本：curl

复制代码

bash <(curl -sSL https://linuxmirrors.cn/docker.sh)

适用于已安装 curl 的环境。

镜像源（仅支持合法镜像）#

Docker 镜像地址探测与切换（临时拉取）

正在使用你的浏览器探测可达性…

选择镜像前缀后会生成 docker pull 示例命令；结果仅代表你当前网络环境。

毫秒镜像·轩辕镜像·1Panel·gh-proxy·

当前命令毫秒镜像(https://docker.1ms.run)

复制命令

docker pull docker.1ms.run/library/nginx:latest

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

GitHub#

仓库 / Release 加速#

CAUTION

注：不会提供GitHub能够登录的代理地址，以下地址仅用于加速GitHub的Git克隆和访问，无法登录GitHub账号

GitHub 代理地址探测与切换

正在使用你的浏览器探测可达性…

用于加速公开仓库访问与克隆，不支持 GitHub 账号登录；结果仅代表你当前网络环境。

gh-proxy.com·ghproxy.net·ghfast.top·

当前命令gh-proxy.com(https://gh-proxy.com/)

复制命令

git clone https://gh-proxy.com/https://github.com/YourName/YourRepo.git

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

我们推荐您基于开源项目搭建自己的GitHub代理加速服务 https://github.com/hunshcn/gh-proxy

GHCR （GitHub Container Registry）加速#

GHCR 镜像地址探测与切换

正在使用你的浏览器探测可达性…

用于选择 GHCR 拉取加速地址；结果仅代表你当前网络环境。

毫秒镜像·米露云·南京大学·

当前命令毫秒镜像(https://ghcr.1ms.run)

复制命令

docker pull ghcr.1ms.run/owner/image:tag

提示：浏览器探测只能反映你当前网络环境下的连通性，不能替代服务端健康检查。因浏览器局限性，测试结果不一定准确，仅供参考。

关于vivo健康的数据，我是如何获取的

Tue, 31 Mar 2026 00:00:00 GMT

警告

禁止大范围分享这篇文章！！！

如果造成vivo修改接口或者封号等后果自负！！！

求你了哥我好不容易弄到的接口了，别给我搞坏了！！

引言#

起初，我看到 u.chongxi.us 中，有心率、步数、睡眠状态的指标，他使用的三星手表，它利用了三星健康的 Webhook 功能（隐藏的开发者选项），能够实时获取数据并进行处理。

正文#

受其启发，我也想制作一个公开的 API 来获取健康数据，但是我发现，vivo 健康loT平台/开发者平台不支持个人开发者去获取个人健康数据。

正在思考破局的办法时，我突然想到了 家人共享 功能，vivo 健康支持家人共享功能，允许用户将自己的健康数据共享给家人，这样家人就可以通过手机上 vivo 健康 应用查看共享的健康数据，于是我就在想，能不能通过这个功能来获取数据呢？

然后我就安装了 Mumu模拟器 ，然后打开了Root权限，安装了 Reqable 这个抓包工具，和电脑上的 Reqable 进行联动，新建了一个 vivo账号 共享给我自己这个新的账号，然后在模拟器上登录这个新的账号，打开 vivo 健康 应用，进入 家人共享 页面，点击 接受邀请，然后果不其然，在 Reqable 上就看到了大量的请求，其中就有获取健康数据的请求 https://health.vivo.com/dailyStatus/solicitude 它返回的是一个仪表盘的数据，只包含大致的健康数据，比如步数、心率、睡眠状态等。

没想到啊没想到，vivo 你还给我留了一手，你猜怎么着，这个接口请求的时候还得带一堆请求体，还要账号认证 Token （不过还好这个 Token 是长期有效的，不然我真要骂街了，还得写登录获取Token的函数）

请求体：

1
{
2
  appVersion: '64216',
3
  androidVer: '12',
4
  openId: 'd3b576c3f8efa9f7',
5
  appName: 'health',
6
  appVer: '64216',
7
  sysVer: 'unknown',
8
  platform: 'android',
9
  'app-locale': 'zh_CN',
10
  vendor: '23117114514', // 模拟器的型号
11
  model: '23117114514', // 模拟器的型号
12
  brand: 'Mumu',
13
  'Request-Id': '1145141919810', // 请求ID
14
  Connection: 'close',
15
  'Cache-Control': 'no-cache',
16
  Host: 'health.vivo.com',
17
  'Accept-Encoding': 'gzip',
18
  'User-Agent': 'okhttp/4.11.0'
19
}

然后带上我的 vivo 账号的分享ID标识符，终于成功获取了我的健康数据，话又说回来了，实时记录的心率数据的包体是真nm的大啊，给我 Reqable 直接炸了，不过反正不是给我看的，直接让浏览器给我处理，嘻嘻，我只需要转发（肯定不能给前端展示这个Token，不然给我干了我就死了）就能美美的获取数据了

所以，你就能在皮梦死了没上看到我的健康数据了哈哈，美美收工

顺便附上一些你可能用得上的东西

数据类型和对应的接口路径

1
{
2
  pressure: { path: 'pressure', description: '压力详细数据' },
3
  calorie: { path: 'calorie', description: '卡路里详细数据' },
4
  distance: { path: 'distance', description: '距离详细数据' },
5
  rate: { path: 'rate', description: '心率详细数据' },
6
  saO2: { path: 'saO2', description: '血氧详细数据' },
7
  step: { path: 'step', description: '步数详细数据' }
8
}

实际应该给 vivo健康 请求头

1
{
2
...FIXED_HEADERS, // 上面提到的固定请求头
3
'Content-Type': 'application/x-www-form-urlencoded',
4
timestamp: Date.now().toString(),  // 动态生成毫秒时间戳
5
'Content-Length': new TextEncoder().encode(bodyString).length.toString(),  // 动态计算内容长度
6
token: token // 你的新的账号的长期有效Token
7
};

还漏了一个 URL的查询需要带上你的 sharerOpenId（此处为你抓包获得的绑定了手表的账号的 openId，注意是你从分享后的请求头，不是你的 vivo ID！！！）

就这么多，再多的都没有了（

你只需要抓个包然后结合这个文章完事就能懂了欸

给你扔个可爱的橘雪莉

流水公开

Fri, 06 Mar 2026 00:00:00 GMT

根据真实性以及本人承诺，以下是有关服务器众筹流水相关的公开记录， 数据均来自官方的流水证明材料 ，如有问题请联系官方，流水号未进行打码

以下是 2026-02-19 与众筹服务器有关的所有流水相关记录

农业银行流水

润雨云发票

微信流水1

微信流水2

微信流水3

禁用傻逼Chrome的大模型自动下载

Wed, 04 Mar 2026 00:00:00 GMT

教程#

打开你的 Chrome ，进入 chrome://flags

把 Enables optimization guide on device Prompt API for Gemini Nano Prompt API for Gemini Nano with Multimodal Input 全部改为 Disabled 禁用

截图

如果发现你的C盘还是红的

请检查 C:\Users\你的用户名\AppData\Local\Google\Chrome\User Data\OptGuideOnDeviceModel 下是不是有个 weights.bin ，tm的占用了4GB

如果找不到，说明你的Chrome更新了，请找下面这个目录

C:\Windows\SystemTemp 找到 chrome_chrome_url_fetcher_ 开头的文件夹，里面就是那个大文件

如果这里也没有

找到 chrome_chrome_Unpacker_Begin 开头的文件夹，这里也可能会有

你妈的谷歌真不当人啊，直接就往C盘拉，你也知道 OptGuideOnDeviceModel被我设置权限了拉不了你还改成 Windows 目录下，诗人啊？！

WizTree截图

前言#

电脑开机我就感觉很不对劲，怎么一卡一卡的，打开文件资源管理器一看，好家伙，C盘红了，然后打开 WizTree 一看：？怎么又是熟悉的4GB左右的文件（之前找C盘垃圾的时候看到过这个大小的文件）

然后我一找，你妈又是谷歌拉了个大模型到我的电脑，有病吗？

默认就是启用的，你以为我电脑空间很多吗？

我真服了，避雷Chrome吧

阿里云学生优惠白嫖半年服务器

Tue, 24 Feb 2026 00:00:00 GMT

WARNING

本 Post 可能含有 aff 等元素

事先准备#

一个还没注册/购买东西的阿里云账号可以在这里注册，注册完打开右上角控制台 -> 实名认证 –> 个人认证完成实名认证（注意此处的认证信息需为学生身份，并且和下面的支付宝学生认证信息相同，否则无法正常完成实名认证和领取优惠）

然后在这里购买一个 68r/年（固定刷新，一般都有）或者抢38r/年（每天10 15点刷新）的轻量服务器

完成后，前往支付宝完成一遍学生认证

支付宝搜索

完成后，前往这里完成一遍阿里云的学生认证（注意要和阿里云的实名认证信息一致）

完成后打开控制台找到轻量云服务器，打开续费界面，你就会发现，刚刚学生认证的优惠券可以在这里使用，然后免费续费半年😋

支付宝搜索

Phira-MP多人服务器测活脚本

Sun, 08 Feb 2026 00:00:00 GMT

CAUTION

请勿将本脚本用于任何形式的非法活动,包括但不限于:

攻击服务器
破坏服务器
窃取服务器数据

为什么会有这个脚本#

因为知周所众的原因，Rust 的 Phira-MP 服务端没有提供一个简单的测活接口，而其他的版本(如C#，见下图)又不好测活，于是我就基于MP接受连接时的协议，写了一个简单的测活脚本

其他

原文档

v2.0 脚本#

点击展开查看代码

1
import { connect } from 'cloudflare:sockets';
2

3
export default {
4
  async fetch(request, env) {
5
    const url = new URL(request.url)
6

7
    if (url.pathname === "/") {
8
      return json({
9
        service: "Phira Server Checker API",
10
        version: "2.0.0-cloudflare",
11
        usage: "/api/check?domain='host'&port='port'",
12
        endpoints: {
13
          check: "/api/check",
14
          health: "/health"
15
        }
16
      })
17
    }
18

19
    if (url.pathname === "/health") {
20
      return json({
21
        status: "healthy",
22
        timestamp: new Date().toISOString()
23
      })
24
    }
25

26
    if (url.pathname === "/api/check") {
27
      return handleCheck(url, env)
28
    }
29

30
    return new Response("Not Found", { status: 404 })
31
  }
32
}
33

34
/* ================= 工具函数 ================= */
35

36
function json(data, status = 200) {
37
  return new Response(JSON.stringify(data), {
38
    status,
39
    headers: { "content-type": "application/json" }
40
  })
41
}
42

43
function encodeVarint(value) {
44
  const bytes = []
45
  while (true) {
46
    let b = value & 0x7f
47
    value >>= 7
48
    if (value !== 0) b |= 0x80
49
    bytes.push(b)
50
    if (value === 0) break
51
  }
52
  return Uint8Array.from(bytes)
53
}
54

55
function concatUint8(...arrays) {
56
  const len = arrays.reduce((a, b) => a + b.length, 0)
57
  const out = new Uint8Array(len)
58
  let offset = 0
59
  for (const arr of arrays) {
60
    out.set(arr, offset)
61
    offset += arr.length
62
  }
63
  return out
64
}
65

66
/* ================= Token 缓存 ================= */
67

68
const tokenCache = new Map()
69

70
async function login(email, password) {
71
  const key = `${email}:${password}`
72
  const cached = tokenCache.get(key)
73

74
  if (cached && cached.expires > Date.now()) {
75
    return cached.token
76
  }
77

78
  const body = JSON.stringify({ email, password })
79

80
  const res = await fetch("https://phira.5wyxi.com/login", {
81
    method: "POST",
82
    headers: {
83
      "Content-Type": "application/json",
84
      "Accept": "application/json",
85
      "User-Agent": "PhiraChecker/2.0"
86
    },
87
    body: body
88
  })
89

90
  if (!res.ok) {
91
      // 获取详细的错误信息
92
      const statusCode = res.status
93
      const statusText = res.statusText
94

95
      // 尝试解析错误响应体
96
      let errorBody = null
97
      const contentType = res.headers.get('content-type')
98

99
      try {
100
          if (contentType && contentType.includes('application/json')) {
101
              errorBody = await res.json()
102
          } else {
103
              errorBody = await res.text()
104
          }
105
      } catch (e) {
106
          errorBody = '无法解析响应体'
107
      }
108

109
      // 构建详细的错误信息
110
      let errorMessage = `登录失败 [HTTP ${statusCode} ${statusText}]`
111

112
      if (errorBody) {
113
          if (typeof errorBody === 'object') {
114
              // 如果返回的是 JSON，提取其中的错误信息字段（根据实际 API 调整）
115
              errorMessage += `: ${errorBody.message || errorBody.error || errorBody.detail || JSON.stringify(errorBody)}`
116
          } else {
117
              errorMessage += `: ${errorBody}`
118
          }
119
      }
120

121
      throw new Error(errorMessage)
122
  }
123

124
  const data = await res.json()
125
  if (!data.token) {
126
    throw new Error("未返回 token")
127
  }
128

129
  tokenCache.set(key, {
130
    token: data.token,
131
    expires: Date.now() + 60 * 60 * 1000
132
  })
133

134
  return data.token
135
}
136

137
/* ================= TCP 检测 ================= */
138

139
async function testConnection(host, port, token) {
140
  let socket = null;
141
  const timeoutMs = 3000;
142

143
  // 创建一个超时 Promise
144
  const timeoutPromise = new Promise((_, reject) => {
145
    setTimeout(() => reject(new Error("TIMEOUT_ERROR")), timeoutMs);
146
  });
147

148
  try {
149
    // 使用 Promise.race 竞争
150
    socket = await Promise.race([
151
      connect({ hostname: host, port }),
152
      timeoutPromise
153
    ]);
154

155
    const writer = socket.writable.getWriter();
156
    const reader = socket.readable.getReader();
157

158
    try {
159
      // 写入数据
160
      const tokenBytes = new TextEncoder().encode(token);
161
      const packet = concatUint8(
162
        new Uint8Array([0x01]),
163
        encodeVarint(tokenBytes.length),
164
        tokenBytes
165
      );
166

167
      await writer.write(new Uint8Array([0x01]));
168
      await writer.write(concatUint8(encodeVarint(packet.length), packet));
169

170
      // 读取响应（同样包裹在 race 中防止读取卡死）
171
      const { value, done } = await Promise.race([
172
        reader.read(),
173
        timeoutPromise
174
      ]);
175

176
      if (done) {
177
        return { success: false, message: "服务端在握手阶段主动断开连接 (FIN)", stage: "PROTOCOL_REJECT" };
178
      }
179

180
      if (value && value.length > 0) {
181
        return { success: true, message: "连接成功" };
182
      }
183

184
      return { success: false, message: "收到空响应", stage: "EMPTY_RESPONSE" };
185

186
    } finally {
187
      writer.releaseLock();
188
      reader.releaseLock();
189
    }
190

191
  } catch (err) {
192
    if (err.message === "TIMEOUT_ERROR") {
193
      return { success: false, message: `连接或响应超时 (${timeoutMs}ms)`, stage: "TIMEOUT" };
194
    }
195
    // 捕获具体的网络错误，如 Connection Refused
196
    return { success: false, message: `网络异常: ${err.message}`, stage: "NETWORK_ERROR" };
197
  } finally {
198
    if (socket) {
199
      try { socket.close(); } catch {}
200
    }
201
  }
202
}
203

204
/* ================= API 主逻辑 ================= */
205

206
async function handleCheck(url, env) {
207
  const domain = url.searchParams.get("domain")
208
  const portStr = url.searchParams.get("port")
209

210
  if (!domain || !portStr) {
211
    return json({ success: false, error: "缺少 domain 或 port" }, 400)
212
  }
213

214
  const port = Number(portStr)
215
  if (!Number.isInteger(port)) {
216
    return json({ success: false, error: "port 必须是整数" }, 400)
217
  }
218

219
  // 必须填写此处获取token才能正常测试
220
  const email = "test" // 账号
221
  const password = "test" // 密码
222

223
  const start = Date.now()
224

225
  try {
226
    const token = await login(email, password)
227
    const result = await testConnection(domain, port, token)
228

229
    return json({
230
      domain,
231
      port,
232
      timestamp: new Date().toISOString(),
233
      response_time: Date.now() - start,
234
      ...result
235
    }, result.success ? 200 : 502)
236

237
  } catch (e) {
238
    return json({
239
      success: false,
240
      error: e.message,
241
      response_time: Date.now() - start
242
    }, 502)
243
  }
244
}

展开收起

v2.1 脚本#

因为 v2.0 脚本有一些未知的问题，所以我又进行了一次改良，能在 Cloudflare Workers 中运行，希望能好上一些吧

并且允许了仅传入 server 参数，自动解析域名和端口，方便一些

现在大AI时代，这个脚本你只需要拿去喂AI改一下，都可以拿去做任意Bot的插件，注意保留原作者（

如果这个脚本有问题，欢迎在 GitHub 主页联系我

点击展开查看代码

1
import { connect } from 'cloudflare:sockets';
2

3
export default {
4
  async fetch(request, env) {
5
    const url = new URL(request.url)
6

7
    if (url.pathname === "/") {
8
      return json({
9
        service: "Phira Server Checker API",
10
        version: "2.1.0-cloudflare",
11
        usage: [
12
            {
13
                method: "GET",
14
                path: "/api/check",
15
                query: "server='host:port' OR domain='host'&port='port'"
16
            }
17
        ],
18
        endpoints: {
19
          check: "/api/check",
20
          health: "/health"
21
        }
22
      })
23
    }
24

25
    if (url.pathname === "/health") {
26
      return json({
27
        status: "healthy",
28
        timestamp: new Date().toISOString()
29
      })
30
    }
31

32
    if (url.pathname === "/api/check") {
33
      return handleCheck(url, env)
34
    }
35

36
    return new Response("Not Found", { status: 404 })
37
  }
38
}
39

40
/* ================= 工具函数 ================= */
41

42
function json(data, status = 200) {
43
  return new Response(JSON.stringify(data), {
44
    status,
45
    headers: { "content-type": "application/json" }
46
  })
47
}
48

49
function encodeVarint(value) {
50
  const bytes = []
51
  while (true) {
52
    let b = value & 0x7f
53
    value >>= 7
54
    if (value !== 0) b |= 0x80
55
    bytes.push(b)
56
    if (value === 0) break
57
  }
58
  return Uint8Array.from(bytes)
59
}
60

61
function concatUint8(...arrays) {
62
  const len = arrays.reduce((a, b) => a + b.length, 0)
63
  const out = new Uint8Array(len)
64
  let offset = 0
65
  for (const arr of arrays) {
66
    out.set(arr, offset)
67
    offset += arr.length
68
  }
69
  return out
70
}
71

72
/* ================= Token 缓存 ================= */
73

74
const tokenCache = new Map()
75

76
async function login(email, password) {
77
  const key = `${email}:${password}`
78
  const cached = tokenCache.get(key)
79

80
  if (cached && cached.expires > Date.now()) {
81
    return cached.token
82
  }
83

84
  const body = JSON.stringify({ email, password })
85

86
  const res = await fetch("https://phira.5wyxi.com/login", {
87
    method: "POST",
88
    headers: {
89
      "Content-Type": "application/json",
90
      "Accept": "application/json",
91
      "User-Agent": "PhiraChecker/2.1"
92
    },
93
    body: body
94
  })
95

96
  if (!res.ok) {
97
      const statusCode = res.status
98
      const statusText = res.statusText
99

100
      let errorBody = null
101
      const contentType = res.headers.get('content-type')
102

103
      try {
104
          if (contentType && contentType.includes('application/json')) {
105
              errorBody = await res.json()
106
          } else {
107
              errorBody = await res.text()
108
          }
109
      } catch (e) {
110
          errorBody = '无法解析响应体'
111
      }
112

113
      let errorMessage = `登录失败 [HTTP ${statusCode} ${statusText}]`
114

115
      if (errorBody) {
116
          if (typeof errorBody === 'object') {
117
              errorMessage += `: ${errorBody.message || errorBody.error || errorBody.detail || JSON.stringify(errorBody)}`
118
          } else {
119
              errorMessage += `: ${errorBody}`
120
          }
121
      }
122

123
      throw new Error(errorMessage)
124
  }
125

126
  const data = await res.json()
127
  if (!data.token) {
128
    throw new Error("未返回 token")
129
  }
130

131
  tokenCache.set(key, {
132
    token: data.token,
133
    expires: Date.now() + 60 * 60 * 1000
134
  })
135

136
  return data.token
137
}
138

139
/* ================= TCP 检测 ================= */
140

141
async function testConnection(host, port, token) {
142
  let socket = null;
143
  const timeoutMs = 3000;
144

145
  const timeoutPromise = new Promise((_, reject) => {
146
    setTimeout(() => reject(new Error("TIMEOUT_ERROR")), timeoutMs);
147
  });
148

149
  try {
150
    socket = await Promise.race([
151
      connect({ hostname: host, port }),
152
      timeoutPromise
153
    ]);
154

155
    const writer = socket.writable.getWriter();
156
    const reader = socket.readable.getReader();
157

158
    try {
159
      const tokenBytes = new TextEncoder().encode(token);
160
      const packet = concatUint8(
161
        new Uint8Array([0x01]),
162
        encodeVarint(tokenBytes.length),
163
        tokenBytes
164
      );
165

166
      await writer.write(new Uint8Array([0x01]));
167
      await writer.write(concatUint8(encodeVarint(packet.length), packet));
168

169
      const { value, done } = await Promise.race([
170
        reader.read(),
171
        timeoutPromise
172
      ]);
173

174
      if (done) {
175
        return { success: false, message: "服务端在握手阶段主动断开连接 (FIN)", stage: "PROTOCOL_REJECT" };
176
      }
177

178
      if (value && value.length > 0) {
179
        return { success: true, message: "连接成功" };
180
      }
181

182
      return { success: false, message: "收到空响应", stage: "EMPTY_RESPONSE" };
183

184
    } finally {
185
      writer.releaseLock();
186
      reader.releaseLock();
187
    }
188

189
  } catch (err) {
190
    if (err.message === "TIMEOUT_ERROR") {
191
      return { success: false, message: `连接或响应超时 (${timeoutMs}ms)`, stage: "TIMEOUT" };
192
    }
193
    return { success: false, message: `网络异常: ${err.message}`, stage: "NETWORK_ERROR" };
194
  } finally {
195
    if (socket) {
196
      try { socket.close(); } catch {}
197
    }
198
  }
199
}
200

201
/* ================= API 主逻辑 ================= */
202

203
async function handleCheck(url, env) {
204
  // 1. 获取参数
205
  let domain = url.searchParams.get("domain")
206
  let portStr = url.searchParams.get("port")
207
  const server = url.searchParams.get("server")
208

209
  // 2. 如果传入了 server 参数，优先解析 server
210
  // 格式如: mp2.phira.cn:12346
211
  if (server) {
212
    const lastColonIndex = server.lastIndexOf(':')
213
    if (lastColonIndex !== -1) {
214
      // 分割 host 和 port
215
      domain = server.substring(0, lastColonIndex)
216
      portStr = server.substring(lastColonIndex + 1)
217
    } else {
218
      // 如果没有冒号，假设整个字符串是 domain，仍然需要检查 port 是否存在
219
      domain = server
220
    }
221
  }
222

223
  // 3. 校验参数完整性
224
  if (!domain) {
225
    return json({ success: false, error: "缺少 server 或 domain 参数" }, 400)
226
  }
227

228
  if (!portStr) {
229
    return json({ success: false, error: "缺少 port (包含在 server 中或单独传递)" }, 400)
230
  }
231

232
  const port = Number(portStr)
233
  if (!Number.isInteger(port)) {
234
    return json({ success: false, error: "port 必须是整数" }, 400)
235
  }
236

237

238
  // 注意修改此处的邮箱和密码,否则无法登录拿到token测试连接
239
  const email = "test"
240
  const password = "test"
241

242
  const start = Date.now()
243

244
  try {
245
    const token = await login(email, password)
246
    // 这里的 domain 变量实际上就是 host
247
    const result = await testConnection(domain, port, token)
248

249
    return json({
250
      server: `${domain}:${port}`, // 返回完整的 server 格式
251
      domain,
252
      port,
253
      timestamp: new Date().toISOString(),
254
      response_time: Date.now() - start,
255
      ...result
256
    }, result.success ? 200 : 502)
257

258
  } catch (e) {
259
    return json({
260
      success: false,
261
      error: e.message,
262
      response_time: Date.now() - start
263
    }, 502)
264
  }
265
}

展开收起

成功返回示例

1
{
2
  "server": "mp2.phira.cn:12346",
3
  "domain": "mp2.phira.cn",
4
  "port": 12346,
5
  "timestamp": "2023-10-27T10:00:00.000Z",
6
  "response_time": 450,
7
  "success": true,
8
  "message": "连接成功"
9
}

v2.3 脚本#

这个版本估计是真的最后一个版本了，没啥问题，调试日志也比较详细，有问题再说吧，我安眠了

点击展开查看代码

1
import { connect } from 'cloudflare:sockets';
2

3
export default {
4
  async fetch(request, env, ctx) {
5
    const url = new URL(request.url);
6
    const method = request.method;
7

8
    // 只允许 GET 请求
9
    if (method !== 'GET') {
10
      return json({
11
        error: 'Method not allowed',
12
        allowed: ['GET']
13
      }, 405);
14
    }
15

16
    if (url.pathname === "/") {
17
      return json({
18
        service: "Phira-MP Alive Test API",
19
        version: "2.3-cloudflare",
20
        usage: [
21
          {
22
            method: "GET",
23
            path: "/api/check",
24
            query: "server='host:port' OR domain='host'&port='port'"
25
          }
26
        ],
27
        endpoints: {
28
          check: "/api/check",
29
          health: "/health"
30
        },
31
        note: "该API仅供测试使用，请勿用于非法等用途"
32
      });
33
    }
34

35
    if (url.pathname === "/health") {
36
      return json({
37
        status: "healthy",
38
        timestamp: new Date().toISOString(),
39
      });
40
    }
41

42
    if (url.pathname === "/api/check") {
43
      return handleCheck(url, env);
44
    }
45

46
    return json({ error: "Not Found" }, 404);
47
  }
48
};
49

50
/* ================= 工具函数 ================= */
51

52
function json(data, status = 200) {
53
  return new Response(JSON.stringify(data, null, 2), {
54
    status,
55
    headers: {
56
      "content-type": "application/json; charset=utf-8",
57
      "access-control-allow-origin": "*",
58
      "cache-control": "no-store, max-age=0"
59
    }
60
  });
61
}
62

63
function encodeVarint(value) {
64
  if (value < 0) {
65
    throw new Error("Varint cannot encode negative numbers");
66
  }
67

68
  const bytes = [];
69
  while (true) {
70
    let b = value & 0x7f;
71
    value >>>= 7; // 使用无符号右移
72
    if (value !== 0) b |= 0x80;
73
    bytes.push(b);
74
    if (value === 0) break;
75
  }
76
  return Uint8Array.from(bytes);
77
}
78

79
function concatUint8(...arrays) {
80
  const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
81
  const result = new Uint8Array(totalLength);
82
  let offset = 0;
83

84
  for (const arr of arrays) {
85
    result.set(arr, offset);
86
    offset += arr.length;
87
  }
88

89
  return result;
90
}
91

92
function validateHostname(hostname) {
93
  if (!hostname || typeof hostname !== 'string') return false;
94

95
  // 简单的域名/IP验证
96
  const hostnameRegex = /^[a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?)*$/;
97
  const ipRegex = /^(\d{1,3}\.){3}\d{1,3}$/;
98

99
  return hostnameRegex.test(hostname) || ipRegex.test(hostname);
100
}
101

102
function sanitizePort(port) {
103
  const portNum = Number.parseInt(port, 10);
104
  if (!Number.isInteger(portNum) || portNum < 1 || portNum > 65535) {
105
    throw new Error(`Invalid port number: ${port}. Must be 1-65535`);
106
  }
107
  return portNum;
108
}
109

110
/* ================= Token 缓存 ================= */
111

112
// 使用简单的内存缓存（在 Cloudflare Workers 中，全局变量会在热启动时保留）
113
const tokenCache = new Map();
114
const CACHE_TTL = 55 * 60 * 1000; // 55 分钟，略小于 token 有效期
115

116
async function login() {
117
  const email = ""; // 请修改此处的账号和密码，否则无法正常登录
118
  const password = "";
119
  const cacheKey = `${email}:${password}`;
120
  const now = Date.now();
121

122
  // 检查缓存
123
  const cached = tokenCache.get(cacheKey);
124
  if (cached && cached.expires > now) {
125
    return cached.token;
126
  }
127

128
  // 清理过期缓存
129
  for (const [key, value] of tokenCache.entries()) {
130
    if (value.expires <= now) {
131
      tokenCache.delete(key);
132
    }
133
  }
134

135
  try {
136
    const body = JSON.stringify({ email, password });
137
    const controller = new AbortController();
138
    const timeoutId = setTimeout(() => controller.abort(), 10000);
139

140
    const res = await fetch("https://phira.5wyxi.com/login", {
141
      method: "POST",
142
      headers: {
143
        "Content-Type": "application/json",
144
        "Accept": "application/json",
145
        "User-Agent": "PhiraChecker/2.1.0"
146
      },
147
      body: body,
148
      signal: controller.signal
149
    });
150

151
    clearTimeout(timeoutId);
152

153
    if (!res.ok) {
154
      let errorMessage = `登录失败 [HTTP ${res.status} ${res.statusText}]`;
155

156
      try {
157
        const contentType = res.headers.get('content-type');
158
        if (contentType && contentType.includes('application/json')) {
159
          const errorData = await res.json();
160
          errorMessage += `: ${errorData.message || errorData.error || JSON.stringify(errorData)}`;
161
        } else {
162
          errorMessage += `: ${await res.text()}`;
163
        }
164
      } catch (e) {
165
        errorMessage += " (无法解析响应)";
166
      }
167

168
      throw new Error(errorMessage);
169
    }
170

171
    const data = await res.json();
172
    if (!data.token || typeof data.token !== 'string') {
173
      throw new Error("登录响应中未包含有效的 token");
174
    }
175

176
    // 缓存 token
177
    tokenCache.set(cacheKey, {
178
      token: data.token,
179
      expires: now + CACHE_TTL
180
    });
181

182
    return data.token;
183
  } catch (error) {
184
    if (error.name === 'AbortError') {
185
      throw new Error("登录请求超时");
186
    }
187
    throw error;
188
  }
189
}
190

191
/* ================= TCP 检测 ================= */
192

193
async function testConnection(host, port, token) {
194
  let socket = null;
195
  let writer = null;
196
  let reader = null;
197

198
  const timeoutMs = 5000;
199
  const startTime = Date.now();
200
  const buf = []; // 字节缓冲区
201

202
  // 内部辅助函数：从 Reader 中读取数据并补充到缓冲区
203
  async function fillBuffer(targetReader) {
204
    const { value, done } = await targetReader.read();
205
    if (done) return false;
206
    if (value) {
207
      // 使用 spread 展开运算符将 Uint8Array 加入数组（适用于小数据包）
208
      buf.push(...value);
209
    }
210
    return true;
211
  }
212

213
  try {
214
    socket = connect({ hostname: host, port: port });
215

216
    // 连接超时控制
217
    await Promise.race([
218
      socket.opened,
219
      new Promise((_, reject) => setTimeout(() => reject(new Error("连接超时")), timeoutMs))
220
    ]);
221

222
    writer = socket.writable.getWriter();
223
    reader = socket.readable.getReader();
224

225
    // 1. 发送握手包 (保持原有逻辑)
226
    const tokenBytes = new TextEncoder().encode(token);
227
    const innerPacket = concatUint8(new Uint8Array([0x01]), encodeVarint(tokenBytes.length), tokenBytes);
228
    const handshakePacket = concatUint8(new Uint8Array([0x01]), encodeVarint(innerPacket.length), innerPacket);
229
    await writer.write(handshakePacket);
230

231
    // 2. 开始流式解析响应
232
    const readLogic = async () => {
233
      // --- A. 解析总长度 (VarInt) ---
234
      let totalLength = 0;
235
      let shift = 0;
236
      while (true) {
237
        if (buf.length === 0) {
238
          if (!(await fillBuffer(reader))) throw new Error("连接在读取 VarInt 时关闭");
239
        }
240
        const byte = buf.shift();
241
        totalLength |= (byte & 0x7F) << shift;
242
        if ((byte & 0x80) === 0) break;
243
        shift += 7;
244
        if (shift > 35) throw new Error("无效的 VarInt 长度");
245
      }
246

247
      // --- B. 确保缓冲区有足够的 Payload 数据 (至少 2 字节) ---
248
      // 即使 totalLength 很大，我们通常只需要前两个字节来判定状态
249
      while (buf.length < 2) {
250
        if (!(await fillBuffer(reader))) {
251
          // 如果总长度宣称有数据但流结束了，说明包不完整
252
          throw new Error("连接在读取 Payload 时意外关闭（分包丢失）");
253
        }
254
      }
255

256
      // --- C. 校验包体前缀 (0x01 0x01) ---
257
      const b1 = buf[0];
258
      const b2 = buf[1];
259

260
      if (b1 === 0x01 && b2 === 0x01) {
261
        return {
262
          success: true,
263
          message: "连接成功并收到有效响应",
264
          connection_time: Date.now() - startTime
265
        };
266
      } else {
267
        return {
268
          success: false,
269
          message: `服务器响应格式错误: 实际收到 0x${b1.toString(16).padStart(2, '0')} 0x${b2.toString(16).padStart(2, '0')}`,
270
          stage: "PROTOCOL_MISMATCH",
271
          connection_time: Date.now() - startTime
272
        };
273
      }
274
    };
275

276
    // 3. 运行逻辑并带上整体超时
277
    return await Promise.race([
278
      readLogic(),
279
      new Promise((_, reject) => setTimeout(() => reject(new Error("读取响应超时")), timeoutMs))
280
    ]);
281

282
  } catch (error) {
283
    const connectionTime = Date.now() - startTime;
284
    return {
285
      success: false,
286
      message: error.message,
287
      stage: error.message.includes("超时") ? "TIMEOUT" : "NETWORK_ERROR",
288
      connection_time: connectionTime
289
    };
290
  } finally {
291
    // 释放资源
292
    if (reader) try { reader.releaseLock(); } catch {}
293
    if (writer) try { writer.releaseLock(); } catch {}
294
    if (socket) try { socket.close(); } catch {}
295
  }
296
}
297

298
/* ================= API 主逻辑 ================= */
299

300
async function handleCheck(url, env) {
301
  const startTime = Date.now();
302

303
  try {
304
    // 1. 获取并验证参数
305
    const serverParam = url.searchParams.get("server");
306
    let host = url.searchParams.get("domain");
307
    let portStr = url.searchParams.get("port");
308

309
    // 2. 解析参数
310
    if (serverParam) {
311
      // 从 server 参数解析 host:port
312
      const lastColonIndex = serverParam.lastIndexOf(':');
313
      if (lastColonIndex === -1 || lastColonIndex === 0 || lastColonIndex === serverParam.length - 1) {
314
        return json({
315
          success: false,
316
          error: "server 参数格式错误，应为 'host:port'",
317
          example: "mp2.phira.cn:12346"
318
        }, 400);
319
      }
320

321
      host = serverParam.substring(0, lastColonIndex);
322
      portStr = serverParam.substring(lastColonIndex + 1);
323
    }
324

325
    // 3. 验证参数存在
326
    if (!host) {
327
      return json({
328
        success: false,
329
        error: "缺少主机名参数",
330
        usage: "提供 server='host:port' 或 domain='host'&port='port'"
331
      }, 400);
332
    }
333

334
    if (!portStr) {
335
      return json({
336
        success: false,
337
        error: "缺少端口参数",
338
        usage: "提供 server='host:port' 或 domain='host'&port='port'"
339
      }, 400);
340
    }
341

342
    // 4. 清理和验证输入
343
    const cleanHost = host.trim().toLowerCase();
344
    if (!validateHostname(cleanHost)) {
345
      return json({
346
        success: false,
347
        error: `无效的主机名: ${host}`,
348
        note: "主机名只能包含字母、数字、连字符和点号"
349
      }, 400);
350
    }
351

352
    let port;
353
    try {
354
      port = sanitizePort(portStr);
355
    } catch (portError) {
356
      return json({
357
        success: false,
358
        error: portError.message
359
      }, 400);
360
    }
361

362
    // 5. 获取认证令牌
363
    const token = await login();
364

365
    // 6. 测试连接
366
    const testResult = await testConnection(cleanHost, port, token);
367

368
    // 7. 返回结果
369
    const responseTime = Date.now() - startTime;
370

371
    const response = {
372
      success: testResult.success,
373
      server: `${cleanHost}:${port}`,
374
      timestamp: new Date().toISOString(),
375
      total_response_time: responseTime,
376
      connection_time: testResult.connection_time,
377
      message: testResult.message,
378
      stage: testResult.stage || (testResult.success ? "SUCCESS" : "UNKNOWN_ERROR")
379
    };
380

381
    // 添加额外的成功信息
382
    if (testResult.success && testResult.bytes_received) {
383
      response.bytes_received = testResult.bytes_received;
384
    }
385

386
    return json(response, testResult.success ? 200 : 502);
387

388
  } catch (error) {
389
    const responseTime = Date.now() - startTime;
390

391
    // 记录错误但不暴露过多内部信息
392
    console.error(`API Error: ${error.message}`, {
393
      url: url.toString(),
394
      time: responseTime
395
    });
396

397
    return json({
398
      success: false,
399
      error: error.message || "内部服务器错误",
400
      response_time: responseTime,
401
      timestamp: new Date().toISOString()
402
    }, 500);
403
  }
404
}

展开收起

响应示例：

1
{
2
  "success": true,
3
  "server": "mp2.phira.cn:12346",
4
  "timestamp": "2026-02-23T15:52:03.809Z",
5
  "total_response_time": 583,
6
  "connection_time": 402,
7
  "message": "连接成功并收到有效响应",
8
  "stage": "SUCCESS"
9
}

记一次简单木筏求生联机

Tue, 14 Oct 2025 00:00:00 GMT

游戏资源#

先下载这个联机修复的版本

天翼网盘：https://cloud.189.cn/t/bEz2yqFvYzua

（访问码：bw4e）

或者使用二维码保存到自己的云盘先
天翼云盘二维码

游戏安装步骤#

解压完之后会见到如下的文件列表

压缩包

Terminal window

1
Raft.v1.09.rar
2
│  Radmin_LAN_1.4.4642.1.exe # 联机组网工具（异地联机用）
3
└─Raft.v1.09
4
  │  dlllist.txt
5
  │  OnlineFix.ini
6
  │  OnlineFix64.dll
7
  │  Raft.exe # 游戏文件（建议放到英文目录，打开这个即可游玩）
8
  │  SteamOverlay64.dll
9
  │  steam_api64.dll
10
  │  steam_appid.txt
11
  │  StubDRM64.dll
12
  │  UnityCrashHandler64.exe
13
  │  UnityPlayer.dll
14
  │  winmm.dll
15
  │  游戏启动说明.txt
16
  ├─MonoBleedingEdge
17
  └─Raft_Data

NOTE

如果是局域网联机，可跳过安装，直接前往游玩步骤。

异地联机组网步骤（同一网络跳过这个步骤）#

房主创建一个 Radmin 网络

Radmin1

网络名字和密码随意，需要记住然后发送给朋友用于加入网络

alt text

朋友这边加入同一个 Radmin 网络（相当于加入同一局域网，游戏会自动识别然后进入同一局域网的房间）。

组网之后如下图所示

Radmin

游玩步骤#

首先下载 Steam，因为木筏求生这款游戏是基于 Steam 联机的。需要注意的是，不需要实际购买该游戏，只需后台运行 Steam 即可。然后房主和玩家互相添加好友即可，玩家之间无需互加。

（如果不知道如何安装 Steam，可以看这个视频哔哩哔哩上的 Steam 安装保姆级教程，这里就不过多赘述了。Steam 国内加速下载地址：点我下载安装 Windows Steam、UU加速器）

WARNING

房主、房客（其他玩家）需要互相添加 Steam 好友，否则将无法加入/搜索房间。

房主创建世界，难度、世界名自选，然后选择好友的名字即可加入房间。

NOTE

此处如果选择“无人可以加入”，那么相当于单人游戏。

游戏界面

好友点击“加入世界”，选择你好友的房间，点击“加入世界”即可。此方案适用于异地联机（Radmin LAN）和局域网联机（直接联机即可）。

祝游玩愉快！

我的第一篇博客

Sun, 12 Oct 2025 00:00:00 GMT

正如你所见，此处是我创建这个博客之后发布的第一篇测试推文awa

虽然刚开始很潦草，但是后面会很丰富的哦

源自这个仓库

CuteLeaf

Firefly

Waiting for api.github.com...

00K

Waiting...

皮梦 の 茶馆

联系皮梦

国内一些社交平台的联系方式#

国外联系方式#

如何绑定奈伊Bot查询b50

0x00 事先准备#

0x01 绑定步骤#

水鱼绑定#

水鱼Token获取#

落雪绑定#

0x02 功能#

使用 Python 实现 Windows Hello 鉴权

0x00 前言#

0x01 效果#

0x02 实现思路#

0x03 定义 Windows API 结构体#

0x04 弹出 Windows Hello / 凭据窗口#

0x05 解包用户名和密码#

0x06 验证凭据#

0x07 错误处理#

0x08 释放敏感数据#

0x09 完整调用方式#

0x0A 使用限制#

0x0B 总结#

抓包从入门到放弃（

0x00 前言#

0x01 HTTP 抓包是什么？#

0x02 一次 HTTP 请求里通常有什么？#

0x03 为什么 HTTPS 是加密的，还能被抓包？#

0x04 常见的 HTTP 抓包工具#

0x05 浏览器里怎么简单 “抓包” ？#

Headers（头部）#

Payload（参数）#

Response（响应）#

0x06 状态码怎么看？#

0x07 抓包常用来解决什么问题？#

登录失败#

页面加载不出来#

App 提示“网络错误”#

接口返回的数据不对#

0x08 抓包时要注意什么？#

0x09 抓包为什么会“从入门到放弃”？#

抓包实战之——APP登录篇

0x00 被测环境#

0x01 安装抓包工具#

0x02 工具配置#

0x03 实战#

0x04 收尾#

镜像源和常用命令汇总

镜像源#

Linux 软件源#

Python / Pypi 镜像源#

Node.js#

NVM（官方Node.js管理器）：#

NPM 镜像源#

Go 模块代理#

Docker#

安装脚本#

镜像源（仅支持合法镜像）#

GitHub#

仓库 / Release 加速#

GHCR （GitHub Container Registry） 加速#

关于vivo健康的数据，我是如何获取的

引言#

正文#

流水公开

禁用傻逼Chrome的大模型自动下载

教程#

前言#

阿里云学生优惠白嫖半年服务器

事先准备#

Phira-MP多人服务器测活脚本

为什么会有这个脚本#

v2.0 脚本#

v2.1 脚本#

v2.3 脚本#

记一次简单木筏求生联机

游戏资源#

游戏安装步骤#

异地联机组网步骤（同一网络跳过这个步骤）#

皮梦の茶馆

GHCR （GitHub Container Registry）加速#