AskaEth/Unlucky-Launcher
1
0 Fork 0
Code Issues Pull Requests Actions 5 Packages Projects Releases Wiki Activity

fix(app-iced, presenter): M114 r2 —— 登录失败走结构化错误码 + i18n，修 4 条 p2 与 3 条看图意见

Browse Source 
p1（语言泄漏）：后端诊断串不再上屏
- presenter 新增 LoginFailure 原因码（denied / whitelist_pending / unreachable /
  not_authlib_server / bad_credentials / no_profile / store_failed / other）
- 页面按码查 i18n 出标题+正文+「Code: …」，原文只进日志/详细信息
- 进行中（Requesting）也走 i18n，不再复读后端中文状态串
- presenter/state 不再发中文 toast（成败由页面按 i18n 画）
- 新增守门测试：注入带 AADSTS 的失败事件，断言英文视图无 CJK 且含 code

p2-1 复制：on_account 返回 Task，page_messages 把 iced::clipboard::write 交回 runtime
p2-2 可见失败态：新增 AccountNotice（added/removed/switched/名字非法/重名/落盘失败/
      找不到），页面用 M3 内联 alert 画（不是 toast）；离线名字先按 3–16 位规则校验，
      失败不再清空输入
p2-3 重新登录按账户类型分派：微软→授权码流；第三方→预填服务器/登录名并提示补密码；
      离线→明确说明没有可重登的服务器账户
p2-4 入口收敛：删 chip 行；空态=三卡片；有账号时三卡收进 Add an account（按钮不再绑死微软轨）

看图意见/tower 三条：
- 失败横幅改成 M3 alert（SurfaceContainerHigh + 描边，errorContainer 只作图标块，
  不再通栏实心红）；色值本身经复审像素采样确认是 90/30 档，未改角色
- 当前账户卡补齐与列表一致的「服务器/登录名」行；无皮肤时明说 No skin available
- 页面级 scrollable 加 8px 右 gutter，滚动条不再压卡片
- 倒计时改 mm:ss（15:00 left），数字与冒号语言无关

p3（顺带）：AuthlibRequest / Form 手写 Debug 脱敏密码；HTTP 响应体与 base64 输出加上限；
离线提示文案与行为对齐；删除无人使用的 key；皮肤测试断言帽子层真的 blend

测试：app-iced lib 418 绿、presenter 151 / i18n 24 绿（workspace 全量另跑）
This commit is contained in:
AskaEth committed 2026-11-05 05:09:51 +08:00
1 parent 1ff00bbe50
commit 8d8552113a
31 files changed
+1540 -497
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

crates/presenter/src/host/accounts/authlib.rs
+83 -131
View File
@@ -22,42 +22,81 @@ use unlucky_core::auth::microsoft::now_ms;
use unlucky_core::auth::{AccountStore, Secret};
use unlucky_core::download::blocking::block_on;
use crate::dto::{AuthlibLoginView, AuthlibRequest, SkinImage, REDACTED};
use crate::dto::{AuthlibLoginView, AuthlibRequest, LoginFailure, SkinImage};
mod util;
pub use util::scrub_known;
use util::{base64_decode, client_token, get_bytes, get_text};
use super::super::engine;
use super::super::env::HostEnv;
use super::super::job::{spawn, HostTask, JobSender};
use super::LoginJob;
/// 一次 GET 的超时上限（秒）：服务器不可达时要能失败，而不是挂住 UI 的登录面板。
const HTTP_TIMEOUT_SECS: u64 = 15;
/// 校验认证服务器地址（「校验」按钮的后端）。
///
/// # Errors
///
/// 地址不合法、网络不可达、HTTP 非 2xx、响应不是 authlib-injector 的服务发现 JSON 时，
/// 返回**具名**的用户可读文案（这是任务要求的「失败态 + 具名错误」）。
pub fn probe_authlib(env: &HostEnv, input: &str) -> Result<(String, AuthlibServerMeta), String> {
let api_root = normalize_api_root(input).map_err(|error| error.to_string())?;
let (status, text) = get_text(env, &api_root)?;
pub fn probe_authlib(env: &HostEnv, input: &str) -> Result<(String, AuthlibServerMeta), Failure> {
let api_root = normalize_api_root(input)
.map_err(|error| Failure::new(LoginFailure::Other, error.to_string()))?;
let (status, text) =
get_text(env, &api_root).map_err(|error| Failure::new(LoginFailure::Unreachable, error))?;
if !(200..300).contains(&status) {
return Err(format!(
"服务器返回 HTTP {status}（{api_root} 不像可用的 authlib 认证服务器）"
return Err(Failure::new(
LoginFailure::NotAuthlibServer,
format!("服务器返回 HTTP {status}（{api_root} 不像可用的 authlib 认证服务器）"),
));
}
let value: serde_json::Value = serde_json::from_str(&text).map_err(|_| {
format!("响应不是 JSON：{api_root} —— 可能填成了网页地址，而不是 API 根（通常以 /api/yggdrasil/ 结尾）")
Failure::new(
LoginFailure::NotAuthlibServer,
format!("响应不是 JSON：{api_root} —— 可能填成了网页地址，而不是 API 根（通常以 /api/yggdrasil/ 结尾）"),
)
})?;
if value.get("meta").is_none() && value.get("skinDomains").is_none() {
return Err(
"响应里没有 meta / skinDomains：这看起来不是 authlib-injector 服务器".to_string(),
);
return Err(Failure::new(
LoginFailure::NotAuthlibServer,
"响应里没有 meta / skinDomains：这看起来不是 authlib-injector 服务器",
));
}
let meta = AuthlibServerMeta::from_value(&value);
Ok((api_root, meta))
}
/// 第三方轨的失败：**原因码 + 原文**（原文进日志，页面据码出 i18n）。
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Failure {
/// 原因码
pub code: LoginFailure,
/// 原始诊断（已脱敏）
pub detail: String,
}
impl Failure {
fn new(code: LoginFailure, detail: impl Into<String>) -> Self {
Self {
code,
detail: detail.into(),
}
}
/// `AuthError` → 原因码（只看变体）。
fn from_error(error: &unlucky_core::auth::AuthError) -> Self {
use unlucky_core::auth::AuthError;
let code = match error {
AuthError::Network { .. } | AuthError::Timeout { .. } => LoginFailure::Unreachable,
AuthError::Denied { .. } => LoginFailure::BadCredentials,
AuthError::Store { .. } => LoginFailure::StoreFailed,
_ => LoginFailure::Other,
};
Self::new(code, error.to_string())
}
}
/// 起一次第三方轨登录（后台线程）。
pub fn start_login(env: HostEnv, tx: JobSender, job: LoginJob, request: AuthlibRequest) {
spawn("authlib-login", move || {
@@ -68,7 +107,7 @@ pub fn start_login(env: HostEnv, tx: JobSender, job: LoginJob, request: AuthlibR
let (api_root, meta) = match probe_authlib(&env, &request.server) {
Ok(found) => found,
Err(reason) => return fail(&tx, reason),
Err(failure) => return fail(&tx, failure),
};
let server_name = meta
.name
@@ -83,7 +122,7 @@ pub fn start_login(env: HostEnv, tx: JobSender, job: LoginJob, request: AuthlibR
let auth = match AuthlibAuth::new() {
Ok(auth) => auth,
Err(error) => return fail(&tx, error.to_string()),
Err(error) => return fail(&tx, Failure::new(LoginFailure::Other, error.to_string())),
};
let client_token = Secret::new(client_token());
let password_text = std::mem::take(&mut request.password);
@@ -108,11 +147,17 @@ pub fn start_login(env: HostEnv, tx: JobSender, job: LoginJob, request: AuthlibR
Some(account.as_str()),
)));
}
Err(reason) => fail(&tx, reason),
Err(failure) => fail(&tx, failure),
},
// 错误原文里可能有服务端回显的凭据：先按**形状**脱敏（`AuthlibLoginView::failed`），
// 再按**已知值**兜一遍（万一服务端把密码原样回显）。
Err(error) => fail(&tx, scrub_known(&error.to_string(), &password_text)),
Err(error) => {
let failure = Failure::from_error(&error);
fail(
&tx,
Failure::new(failure.code, scrub_known(&failure.detail, &password_text)),
);
}
}
drop(password_text);
});
@@ -134,7 +179,7 @@ pub fn spawn_probe(env: HostEnv, tx: JobSender, server: String) {
&api_root, &name,
))));
}
Err(reason) => fail(&tx, reason),
Err(failure) => fail(&tx, failure),
}
});
}
@@ -192,14 +237,12 @@ fn store(
session: AuthlibSession,
api_root: &str,
login_name: &str,
) -> Result<String, String> {
) -> Result<String, Failure> {
let profile = session
.selected_profile
.clone()
.filter(|profile| !profile.name.trim().is_empty() && !profile.id.is_empty())
.ok_or_else(|| {
"服务器没有返回角色：这个账号可能还没在皮肤站里创建角色（建好后再试）".to_string()
})?;
.ok_or_else(|| Failure::new(LoginFailure::NoProfile, "服务器没有返回角色"))?;
let mut meta = AccountMeta::new(
CoreAccountKind::AuthlibInjector,
profile.id,
@@ -213,7 +256,7 @@ fn store(
account_store
.insert(meta, Credentials::AuthlibInjector(session))
.and_then(|()| account_store.save())
.map_err(|error| format!("账户入库失败：{error}"))?;
.map_err(|error| Failure::new(LoginFailure::StoreFailed, error.to_string()))?;
Ok(name)
}
@@ -225,112 +268,19 @@ fn stage(tx: &JobSender, server: &str, message: &str) {
}
/// 失败收尾：**先脱敏再上屏**（服务端错误原文里可能带 token）。
fn fail(tx: &JobSender, message: String) {
let _ = tx.send(HostTask::Authlib(Box::new(AuthlibLoginView::failed(
message,
/// 失败收尾：原文进日志，页面拿**原因码**（复审 r1 P1-1）。
fn fail(tx: &JobSender, failure: Failure) {
eprintln!(
"[auth] authlib 失败（{}）：{}",
failure.code.code(),
failure.detail
);
let _ = tx.send(HostTask::Authlib(Box::new(AuthlibLoginView::failed_as(
failure.code,
failure.detail,
))));
}
/// 启动器侧生成的 `clientToken`（Yggdrasil 要求刷新/校验都带，且服务端回传必须一致）。
fn client_token() -> String {
use std::hash::{BuildHasher, Hasher};
let mut out = String::with_capacity(32);
for salt in 0..2u64 {
// `RandomState` 每个实例自带随机种子（标准库给的是进程级随机），不引第三方随机库。
let mut hasher = std::collections::hash_map::RandomState::new().build_hasher();
hasher.write_u64(now_ms() ^ salt);
hasher.write_u32(std::process::id());
out.push_str(&format!("{:016x}", hasher.finish()));
}
out
}
/// GET 文本（状态码 + 正文）。
///
/// 客户端来自**既有的下载引擎**（`host::engine::engine`）：代理/超时/证书栈与本仓的下载器
/// 完全同源，不在这里另起一套 HTTP 配置（本 crate 也没有 reqwest 依赖，拿到的只是它的 `&Client`）。
fn get_text(env: &HostEnv, url: &str) -> Result<(u16, String), String> {
let engine = engine::engine(env);
let client = engine.client();
let url = url.to_string();
block_on(async move {
let reply = client
.get(&url)
.timeout(std::time::Duration::from_secs(HTTP_TIMEOUT_SECS))
.send()
.await
.map_err(|error| format!("服务器不可达：{error}"))?;
let status = reply.status().as_u16();
let text = reply
.text()
.await
.map_err(|error| format!("读取响应失败：{error}"))?;
Ok((status, text))
})
}
/// GET 字节（皮肤图片）。
fn get_bytes(env: &HostEnv, url: &str) -> Result<(u16, Vec<u8>), String> {
let engine = engine::engine(env);
let client = engine.client();
let url = url.to_string();
block_on(async move {
let reply = client
.get(&url)
.timeout(std::time::Duration::from_secs(HTTP_TIMEOUT_SECS))
.send()
.await
.map_err(|error| format!("皮肤图片不可达：{error}"))?;
let status = reply.status().as_u16();
let bytes = reply
.bytes()
.await
.map_err(|error| format!("读取皮肤图片失败：{error}"))?
.to_vec();
Ok((status, bytes))
})
}
/// base64 解码（标准字母表，容忍 URL-safe 变体与缺失填充）。
///
/// 为什么自己写：textures 属性是 base64 编码的 JSON，而本 crate 不能引第三方解码库
/// （依赖最小化）；这段是 40 行的确定性算法，配单测比拖一个依赖更划算。
fn base64_decode(input: &str) -> Result<Vec<u8>, String> {
let mut out = Vec::with_capacity(input.len() / 4 * 3);
let mut buffer: u32 = 0;
let mut bits = 0u32;
for byte in input.bytes() {
let value = match byte {
b'A'..=b'Z' => byte - b'A',
b'a'..=b'z' => byte - b'a' + 26,
b'0'..=b'9' => byte - b'0' + 52,
b'+' | b'-' => 62,
b'/' | b'_' => 63,
b'=' | b'\n' | b'\r' | b' ' => continue,
other => return Err(format!("base64 里有非法字符：{:?}", other as char)),
};
buffer = (buffer << 6) | u32::from(value);
bits += 6;
if bits >= 8 {
bits -= 8;
out.push(u8::try_from((buffer >> bits) & 0xFF).unwrap_or(0));
}
}
if out.is_empty() {
return Err("base64 内容为空".to_string());
}
Ok(out)
}
/// 错误文案里可能混进已知凭据值：按值再兜一遍（形状脱敏由 `AuthlibLoginView::failed` 做）。
#[must_use]
pub fn scrub_known(message: &str, secret: &str) -> String {
if secret.is_empty() {
return message.to_string();
}
message.replace(secret, REDACTED)
}
#[cfg(test)]
mod tests {
use super::*;
@@ -361,6 +311,8 @@ mod tests {
assert!(a.chars().all(|c| c.is_ascii_hexdigit()));
}
use crate::dto::REDACTED;
#[test]
fn known_secret_is_scrubbed_from_error_text() {
let text = scrub_known("登录失败：hunter2 被拒绝", "hunter2");
@@ -376,10 +328,10 @@ mod tests {
let _ = std::fs::remove_dir_all(&dir);
let env = HostEnv::at_root(&dir);
std::fs::create_dir_all(env.layout.cache()).expect("cache");
let error = probe_authlib(&env, " ").expect_err("空地址必须报错");
assert!(error.contains("不能为空"), "{error}");
let error = probe_authlib(&env, "https://").expect_err("只给协议头也必须报错");
assert!(!error.is_empty());
let failure = probe_authlib(&env, " ").expect_err("空地址必须报错");
assert!(failure.detail.contains("不能为空"), "{failure:?}");
let failure = probe_authlib(&env, "https://").expect_err("只给协议头也必须报错");
assert!(!failure.detail.is_empty());
std::fs::remove_dir_all(&dir).ok();
}
}
crates/presenter/src/host/accounts/authlib/util.rs
+129
View File
@@ -0,0 +1,129 @@
//! authlib 轨的 HTTP 基座与纯函数小工具：`clientToken` 生成、GET 文本/字节、base64 解码、按已知值脱敏。
//!
//! 从 `authlib.rs` 拆出来守 400 行硬线。网络只走**既有下载引擎**的客户端
//! （`host::engine::engine(env).client()`）：代理/超时/证书栈与下载器同源，本 crate 不新增依赖。
use unlucky_core::auth::microsoft::now_ms;
use unlucky_core::download::blocking::block_on;
use crate::dto::REDACTED;
use super::super::super::engine;
use super::super::super::env::HostEnv;
/// 一次 GET 的超时上限（秒）：服务器不可达时要能失败，而不是挂住 UI 的登录面板。
pub(super) const HTTP_TIMEOUT_SECS: u64 = 15;
/// 单次 GET 的响应体上限（字节）：用户能填任意 URL，服务发现 JSON/皮肤 PNG 都远小于它。
pub(super) const MAX_BODY_BYTES: usize = 512 * 1024;
/// base64 解码输出上限（textures 属性是个小 JSON）。
pub(super) const MAX_BASE64_BYTES: usize = 64 * 1024;
/// 启动器侧生成的 `clientToken`（Yggdrasil 要求刷新/校验都带，且服务端回传必须一致）。
pub(super) fn client_token() -> String {
use std::hash::{BuildHasher, Hasher};
let mut out = String::with_capacity(32);
for salt in 0..2u64 {
// `RandomState` 每个实例自带随机种子（标准库给的是进程级随机），不引第三方随机库。
let mut hasher = std::collections::hash_map::RandomState::new().build_hasher();
hasher.write_u64(now_ms() ^ salt);
hasher.write_u32(std::process::id());
out.push_str(&format!("{:016x}", hasher.finish()));
}
out
}
/// GET 文本（状态码 + 正文）。
///
/// 客户端来自**既有的下载引擎**（`host::engine::engine`）：代理/超时/证书栈与本仓的下载器
/// 完全同源，不在这里另起一套 HTTP 配置（本 crate 也没有 reqwest 依赖，拿到的只是它的 `&Client`）。
pub(super) fn get_text(env: &HostEnv, url: &str) -> Result<(u16, String), String> {
let engine = engine::engine(env);
let client = engine.client();
let url = url.to_string();
block_on(async move {
let reply = client
.get(&url)
.timeout(std::time::Duration::from_secs(HTTP_TIMEOUT_SECS))
.send()
.await
.map_err(|error| format!("服务器不可达：{error}"))?;
let status = reply.status().as_u16();
let text = reply
.text()
.await
.map_err(|error| format!("读取响应失败：{error}"))?;
Ok((status, text))
})
}
/// GET 字节（皮肤图片）。
pub(super) fn get_bytes(env: &HostEnv, url: &str) -> Result<(u16, Vec<u8>), String> {
let engine = engine::engine(env);
let client = engine.client();
let url = url.to_string();
block_on(async move {
let reply = client
.get(&url)
.timeout(std::time::Duration::from_secs(HTTP_TIMEOUT_SECS))
.send()
.await
.map_err(|error| format!("皮肤图片不可达：{error}"))?;
let status = reply.status().as_u16();
let bytes = reply
.bytes()
.await
.map_err(|error| format!("读取皮肤图片失败：{error}"))?
.to_vec();
if bytes.len() > MAX_BODY_BYTES {
return Err(format!(
"图片过大（{} 字节，上限 {MAX_BODY_BYTES}）",
bytes.len()
));
}
Ok((status, bytes))
})
}
/// base64 解码（标准字母表，容忍 URL-safe 变体与缺失填充）。
///
/// 为什么自己写：textures 属性是 base64 编码的 JSON，而本 crate 不能引第三方解码库
/// （依赖最小化）；这段是 40 行的确定性算法，配单测比拖一个依赖更划算。
pub(super) fn base64_decode(input: &str) -> Result<Vec<u8>, String> {
let mut out = Vec::with_capacity(input.len() / 4 * 3);
let mut buffer: u32 = 0;
let mut bits = 0u32;
for byte in input.bytes() {
let value = match byte {
b'A'..=b'Z' => byte - b'A',
b'a'..=b'z' => byte - b'a' + 26,
b'0'..=b'9' => byte - b'0' + 52,
b'+' | b'-' => 62,
b'/' | b'_' => 63,
b'=' | b'\n' | b'\r' | b' ' => continue,
other => return Err(format!("base64 里有非法字符：{:?}", other as char)),
};
buffer = (buffer << 6) | u32::from(value);
bits += 6;
if bits >= 8 {
bits -= 8;
out.push(u8::try_from((buffer >> bits) & 0xFF).unwrap_or(0));
}
if out.len() > MAX_BASE64_BYTES {
return Err(format!("base64 输出超过上限 {MAX_BASE64_BYTES} 字节"));
}
}
if out.is_empty() {
return Err("base64 内容为空".to_string());
}
Ok(out)
}
/// 错误文案里可能混进已知凭据值：按值再兜一遍（形状脱敏由 `AuthlibLoginView::failed` 做）。
#[must_use]
pub fn scrub_known(message: &str, secret: &str) -> String {
if secret.is_empty() {
return message.to_string();
}
message.replace(secret, REDACTED)
}
crates/presenter/src/host/accounts/failure.rs
+76
View File
@@ -0,0 +1,76 @@
//! 账户写操作的失败分类 + 离线名字契约（M114 r2）。
//!
//! 分类**只看 `AuthError` 的变体与 ascii 码**，不看中文文案——文案随时会改，
//! 而页面据 `AccountNoticeCode` 选 i18n，两边必须能独立演进。
use unlucky_core::auth::AuthError;
use crate::dto::{AccountNoticeCode, LoginFailure};
/// 账户写操作的失败：**结构化码 + 原文**（原文只进日志/详细信息，不上屏）。
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AccountFailure {
/// 结果码（页面据此选 i18n）
pub code: AccountNoticeCode,
/// 原始诊断（已脱敏）
pub detail: String,
}
impl AccountFailure {
/// 按 core 的错误类型分类（不看中文文案，只看变体）。
pub(super) fn classify(error: AuthError, fallback: AccountNoticeCode) -> Self {
let code = match &error {
unlucky_core::auth::AuthError::Conflict { .. } => AccountNoticeCode::AccountExists,
unlucky_core::auth::AuthError::NotFound { .. } => AccountNoticeCode::NotFound,
unlucky_core::auth::AuthError::Malformed(_) => AccountNoticeCode::OfflineNameInvalid,
unlucky_core::auth::AuthError::Store { .. } => AccountNoticeCode::StoreFailed,
_ => fallback,
};
Self {
code,
detail: error.to_string(),
}
}
}
/// 离线名字的界面契约（3–16 位 ascii 字母/数字/下划线）。core 侧还有一道同名规则做兜底。
#[must_use]
pub fn valid_offline_name(name: &str) -> bool {
let len = name.chars().count();
(3..=16).contains(&len) && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
}
/// `AuthError` → 原因码（**只看变体与 ascii 码，不看中文文案**）。
pub(super) fn classify(error: &AuthError) -> LoginFailure {
match error {
AuthError::Network { .. } | AuthError::Timeout { .. } => LoginFailure::Unreachable,
AuthError::Denied { code, description } => {
if mentions_whitelist(code) || mentions_whitelist(description) {
LoginFailure::NotWhitelisted
} else {
LoginFailure::Denied
}
}
AuthError::Response(detail) => {
let blob = format!("{detail:?}");
if mentions_whitelist(&blob) {
LoginFailure::NotWhitelisted
} else {
LoginFailure::Denied
}
}
AuthError::Xbox { .. } | AuthError::CredentialExpired => LoginFailure::Denied,
AuthError::Store { .. } => LoginFailure::StoreFailed,
_ => LoginFailure::Other,
}
}
/// 是否属于「应用注册未获批」这一类（AADSTS7000218 / consent required / whitelist）。
pub(super) fn mentions_whitelist(text: &str) -> bool {
let lowered = text.to_lowercase();
lowered.contains("aadsts7000218")
|| lowered.contains("aadsts65001")
|| lowered.contains("consent")
|| lowered.contains("whitelist")
|| lowered.contains("not approved")
}