feat(app-iced): M114 账户页三轨登录(微软正版 / 第三方皮肤站 / 本地档案)

- 账户页:当前账户卡 + 全部账户列表 + 空态三入口 + 皮肤区;五项动作(添加/切换/删除/重新登录/校验)
- 三轨添加流程:设备码(用户码+链接+倒计时+过期重试+取消)、授权码(浏览器+可复制链接+取消)、
  本地档案(名字校验)、第三方站(服务地址 + 服务发现校验 + 密码登录,密码掩码且用完即弃)
- 导航:账户为一等页,入口是轨底头像位(未登录=描边剪影 / 已登录=首字母块+名字;窄高收成图标条)
- 凭据红线:DTO 侧形状脱敏 + 状态层二次脱敏 + 密码掩码;Inject-JWT 测试断言视图模型干净(已做变异取证)
- presenter:authlib 登录/服务发现/皮肤抓取(复用下载引擎的 HTTP 客户端,无新增依赖)、
  皮肤原图经 DTO 到 UI 裁剪成头像(既有 image 依赖,未改 Cargo.toml)
- i18n:新增 account 域 51 条中英文案(离线档案口径全量写入),金表同步
This commit is contained in:
AskaEth committed 2026-11-05 05:08:35 +08:00
1 parent e7b04c4afe
commit 1ff00bbe50
43 files changed
+4343 -117

No files matched your search

+8
View File
@@ -25,6 +25,11 @@ use super::env::HostEnv;
use super::job::{spawn, HostTask, JobSender};
use super::opener;
/// 第三方轨(服务发现 / 密码登录 / 皮肤抓取)。
pub mod authlib;
pub use authlib::{fetch_skin, spawn_probe, start_login as start_authlib_login};
/// 账户列表(公开字段)。
pub fn accounts(env: &HostEnv, active: Option<&str>) -> Vec<AccountView> {
let store = AccountStore::open(env.layout.auth_data());
@@ -39,6 +44,9 @@ pub fn accounts(env: &HostEnv, active: Option<&str>) -> Vec<AccountView> {
login_name: meta.login_name.clone().unwrap_or_default(),
created: display_ms(meta.created_at_ms),
active: active.is_some_and(|id| id == meta.id.as_str()),
server_url: meta.server_url.clone().unwrap_or_default(),
// 皮肤是网络产物:列表先给 `None`,host 抓到之后按账户 id 盖回去(见 `CoreHost`)
skin: None,
})
.collect()
}
@@ -0,0 +1,385 @@
//! 第三方轨(authlib-injector):服务发现校验、密码登录、皮肤原图抓取。
//!
//! 全部跑在后台线程里(网络),出口只有 [`AuthlibLoginView`] / [`SkinImage`]——
//! 密码与 accessToken 在调用栈里就地丢弃,永不进 DTO 回程(M114 凭据红线)。
//!
//! ## 三条流的坐标
//!
//! | 动作 | 端点 | 产出 |
//! |---|---|---|
//! | 服务发现(「校验」按钮) | `GET {apiRoot}` | 服务器名 / skinDomains(`meta` 缺失即判「不是认证服务器」) |
//! | 登录 | `POST {apiRoot}authserver/authenticate` | `AuthlibSession`(入库,不外传) |
//! | 皮肤 | `GET {apiRoot}sessionserver/session/minecraft/profile/{uuid}` → textures → 皮肤 URL | 皮肤 PNG 原图 |
//!
//! `core::download::http::build_client` 是唯一的 HTTP 基座(复用下载器的客户端配置),
//! 所以本 crate **不新增任何依赖**(`presenter-no-ui` 与依赖最小化同时成立)。
use unlucky_core::auth::account::{AccountKind as CoreAccountKind, AccountMeta, Credentials};
use unlucky_core::auth::authlib::{
normalize_api_root, AuthlibAuth, AuthlibServerMeta, AuthlibSession,
};
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 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)?;
if !(200..300).contains(&status) {
return Err(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/ 结尾)")
})?;
if value.get("meta").is_none() && value.get("skinDomains").is_none() {
return Err(
"响应里没有 meta / skinDomains:这看起来不是 authlib-injector 服务器".to_string(),
);
}
let meta = AuthlibServerMeta::from_value(&value);
Ok((api_root, meta))
}
/// 起一次第三方轨登录(后台线程)。
pub fn start_login(env: HostEnv, tx: JobSender, job: LoginJob, request: AuthlibRequest) {
spawn("authlib-login", move || {
let mut request = request;
// 日志只打脱敏形态;密码在下面用完立刻丢弃。
eprintln!("[auth] authlib 登录开始({})", request.redacted());
stage(&tx, &request.server, "正在校验服务器地址…");
let (api_root, meta) = match probe_authlib(&env, &request.server) {
Ok(found) => found,
Err(reason) => return fail(&tx, reason),
};
let server_name = meta
.name
.clone()
.filter(|name| !name.trim().is_empty())
.unwrap_or_else(|| api_root.clone());
stage(
&tx,
&api_root,
&format!("服务器 {server_name} 可用,正在登录…"),
);
let auth = match AuthlibAuth::new() {
Ok(auth) => auth,
Err(error) => return fail(&tx, error.to_string()),
};
let client_token = Secret::new(client_token());
let password_text = std::mem::take(&mut request.password);
let password = Secret::new(password_text.clone());
let login_name = request.login.clone();
let result = block_on(auth.authenticate(&api_root, &login_name, &password, &client_token));
drop(password);
if job.is_cancelled() {
let _ = tx.send(HostTask::Authlib(Box::default()));
return;
}
match result {
Ok(session) => match store(&env, session, &api_root, &login_name) {
Ok(account) => {
let _ = tx.send(HostTask::Authlib(Box::new(AuthlibLoginView::succeeded(
&server_name,
&account,
))));
let _ = tx.send(HostTask::Accounts(super::accounts(
&env,
Some(account.as_str()),
)));
}
Err(reason) => fail(&tx, reason),
},
// 错误原文里可能有服务端回显的凭据:先按**形状**脱敏(`AuthlibLoginView::failed`),
// 再按**已知值**兜一遍(万一服务端把密码原样回显)。
Err(error) => fail(&tx, scrub_known(&error.to_string(), &password_text)),
}
drop(password_text);
});
}
/// 只校验服务器地址(「校验服务器」按钮);结果走同一条 `AuthlibLoginChanged`。
pub fn spawn_probe(env: HostEnv, tx: JobSender, server: String) {
spawn("authlib-probe", move || {
stage(&tx, &server, "正在校验服务器地址…");
match probe_authlib(&env, &server) {
Ok((api_root, meta)) => {
let name = meta
.name
.as_deref()
.map(str::trim)
.filter(|name| !name.is_empty())
.map_or_else(|| api_root.clone(), str::to_string);
let _ = tx.send(HostTask::Authlib(Box::new(AuthlibLoginView::reachable(
&api_root, &name,
))));
}
Err(reason) => fail(&tx, reason),
}
});
}
/// 抓第三方轨账户的皮肤原图(`profile_id` → textures → 皮肤 URL → PNG 字节)。
///
/// # Errors
///
/// 服务器不可达、响应缺 textures、纹理不是 PNG 时返回原因(调用方按「没有皮肤」处理)。
pub fn fetch_skin(env: &HostEnv, api_root: &str, profile_id: &str) -> Result<SkinImage, String> {
let base = normalize_api_root(api_root).map_err(|error| error.to_string())?;
let url = format!("{base}sessionserver/session/minecraft/profile/{profile_id}");
let (status, text) = get_text(env, &url)?;
if !(200..300).contains(&status) {
return Err(format!("皮肤接口返回 HTTP {status}"));
}
let value: serde_json::Value =
serde_json::from_str(&text).map_err(|error| format!("皮肤接口响应不是 JSON:{error}"))?;
let encoded = value
.get("properties")
.and_then(|properties| properties.as_array())
.and_then(|properties| {
properties
.iter()
.find(|entry| entry.get("name").and_then(|name| name.as_str()) == Some("textures"))
})
.and_then(|entry| entry.get("value"))
.and_then(|value| value.as_str())
.ok_or_else(|| "档案里没有 textures 属性".to_string())?;
let raw = base64_decode(encoded)?;
let textures: serde_json::Value =
serde_json::from_slice(&raw).map_err(|error| format!("textures 属性解不开:{error}"))?;
let skin_url = textures
.get("textures")
.and_then(|textures| textures.get("SKIN"))
.and_then(|skin| skin.get("url"))
.and_then(|url| url.as_str())
.ok_or_else(|| "textures 里没有 SKIN 条目".to_string())?;
let (status, bytes) = get_bytes(env, skin_url)?;
if !(200..300).contains(&status) {
return Err(format!("皮肤图片返回 HTTP {status}"));
}
if !bytes.starts_with(b"\x89PNG") {
return Err("皮肤图片不是 PNG".to_string());
}
Ok(SkinImage {
png: bytes,
source: skin_url.to_string(),
})
}
/// 入库(元数据 + 凭据分文件);返回展示名。
fn store(
env: &HostEnv,
session: AuthlibSession,
api_root: &str,
login_name: &str,
) -> Result<String, String> {
let profile = session
.selected_profile
.clone()
.filter(|profile| !profile.name.trim().is_empty() && !profile.id.is_empty())
.ok_or_else(|| {
"服务器没有返回角色:这个账号可能还没在皮肤站里创建角色(建好后再试)".to_string()
})?;
let mut meta = AccountMeta::new(
CoreAccountKind::AuthlibInjector,
profile.id,
profile.name,
now_ms(),
);
meta.login_name = Some(login_name.to_string());
meta.server_url = Some(api_root.to_string());
let name = meta.display_name().to_string();
let mut account_store = AccountStore::open(env.layout.auth_data());
account_store
.insert(meta, Credentials::AuthlibInjector(session))
.and_then(|()| account_store.save())
.map_err(|error| format!("账户入库失败:{error}"))?;
Ok(name)
}
/// 发一条「进行中」状态(UI 据此只转圈不误报)。
fn stage(tx: &JobSender, server: &str, message: &str) {
let _ = tx.send(HostTask::Authlib(Box::new(AuthlibLoginView::running(
server, message,
))));
}
/// 失败收尾:**先脱敏再上屏**(服务端错误原文里可能带 token)。
fn fail(tx: &JobSender, message: String) {
let _ = tx.send(HostTask::Authlib(Box::new(AuthlibLoginView::failed(
message,
))));
}
/// 启动器侧生成的 `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::*;
#[test]
fn base64_decodes_textures_payload() {
// `{"textures":{}}` 的 base64
let encoded = "eyJ0ZXh0dXJlcyI6e319";
assert_eq!(base64_decode(encoded).expect("解码"), br#"{"textures":{}}"#);
// URL-safe 变体 + 填充 + 换行都要吃
assert_eq!(
base64_decode("eyJ0ZXh0dXJlcyI6e319\n").expect("解码"),
br#"{"textures":{}}"#
);
assert!(base64_decode("!!!").is_err());
assert!(base64_decode("").is_err());
}
#[test]
fn client_token_is_stable_length_and_unique() {
let a = client_token();
let b = client_token();
assert_eq!(a.len(), 32);
assert_ne!(
a, b,
"两次生成的 clientToken 不能相同(会被服务端当成重放)"
);
assert!(a.chars().all(|c| c.is_ascii_hexdigit()));
}
#[test]
fn known_secret_is_scrubbed_from_error_text() {
let text = scrub_known("登录失败:hunter2 被拒绝", "hunter2");
assert!(!text.contains("hunter2"), "{text}");
assert!(text.contains(REDACTED));
assert_eq!(scrub_known("普通错误", ""), "普通错误");
}
#[test]
fn a_web_page_address_is_rejected_with_a_named_error() {
// 不发网络请求:只测「规范化 + 空输入」这条不联网的分支
let dir = std::env::temp_dir().join(format!("ull-authlib-probe-{}", std::process::id()));
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());
std::fs::remove_dir_all(&dir).ok();
}
}
+22
View File
@@ -154,9 +154,31 @@ impl CoreHost {
job.cancel();
}
self.login = None;
// 第三方轨的面板也归这条「关掉登录面板」:两条轨都不该留一个转不完的圈
if let Some(job) = &self.authlib {
job.cancel();
}
self.authlib = None;
self.send(CoreEvent::DeviceLoginChanged(
crate::dto::DeviceLoginView::new(),
));
self.send(CoreEvent::AuthlibLoginChanged(
crate::dto::AuthlibLoginView::new(),
));
}
AppCommand::AddAuthlibAccount(request) => {
self.authlib = Some(LoginJob::new());
let job = self.authlib.clone().unwrap_or_default();
self.send(CoreEvent::AuthlibLoginChanged(
crate::dto::AuthlibLoginView::running(&request.server, "正在校验服务器地址…"),
));
accounts::start_authlib_login(self.env.clone(), self.tx.clone(), job, request);
}
AppCommand::ProbeAuthlibServer(server) => {
// 只探活:后台线程跑服务发现,结果回到同一条 `AuthlibLoginChanged`
let env = self.env.clone();
let tx = self.tx.clone();
accounts::spawn_probe(env, tx, server);
}
AppCommand::InstallJava(vendor) => {
self.java_busy = true;
+7
View File
@@ -91,6 +91,13 @@ impl CoreHost {
self.refresh_instances();
}
HostTask::Login(view) => self.send(CoreEvent::DeviceLoginChanged(*view)),
HostTask::Authlib(view) => self.send(CoreEvent::AuthlibLoginChanged(*view)),
HostTask::Avatar { id, skin } => {
// 抓到/没抓到都记下来(`None` = 试过了,不再重试),再把列表盖好发出去
self.skins.insert(id, skin);
self.attach_skins();
self.send(CoreEvent::AccountsChanged(self.accounts.clone()));
}
HostTask::Java(page) => self.send(CoreEvent::JavaChanged(*page)),
HostTask::Logs {
sessions,
+14 -3
View File
@@ -7,9 +7,11 @@
use std::sync::mpsc::{Receiver, Sender};
use crate::dto::{
AccountView, ContentResults, DeviceLoginView, DiagnosisReport, InstallProgressView, InstanceId,
InstanceRuntime, JavaPageView, LaunchFinished, LiveLogBatch, LoaderKind, LogLine, LogOutcome,
LogSession, NoticeView, PackEvent, SessionId, VersionSummary,
// 主线(M109 ContentResults / M105 LoaderKind / M113 PackEvent)与 M114 的账户轨并集。
AccountView, AuthlibLoginView, ContentResults, DeviceLoginView, DiagnosisReport,
InstallProgressView, InstanceId, InstanceRuntime, JavaPageView, LaunchFinished, LiveLogBatch,
LoaderKind, LogLine, LogOutcome, LogSession, NoticeView, PackEvent, SessionId, SkinImage,
VersionSummary,
};
use crate::toast::Toast;
@@ -66,6 +68,15 @@ pub enum HostTask {
Accounts(Vec<AccountView>),
/// 设备码登录状态
Login(Box<DeviceLoginView>),
/// 第三方轨(authlib-injector)登录/校验状态
Authlib(Box<AuthlibLoginView>),
/// 账户皮肤抓取结果(`skin = None` = 没取到;UI 退回首字母块)
Avatar {
/// 账户 id
id: String,
/// 皮肤原图
skin: Option<SkinImage>,
},
/// Java 页(发行版/回退链/运行时)
Java(Box<JavaPageView>),
/// 日志页快照(会话列表 + 选中会话的行 + 诊断)
+57 -2
View File
@@ -37,8 +37,8 @@ use std::collections::{BTreeMap, BTreeSet, VecDeque};
use std::time::Duration;
use crate::dto::{
AccountView, AppCommand, AppEvent, Backend, CoreEvent, DiagnosisReport, InstallProgressView,
InstanceRuntime, JavaChainStep, NoticeView,
AccountKind, AccountView, AppCommand, AppEvent, Backend, CoreEvent, DiagnosisReport,
InstallProgressView, InstanceRuntime, JavaChainStep, NoticeView, SkinImage,
};
use crate::mock::MockBackend;
use crate::toast::{Toast, ToastKind};
@@ -72,6 +72,13 @@ pub struct CoreHost {
active_account: Option<String>,
accounts: Vec<AccountView>,
login: Option<LoginJob>,
/// 第三方轨(authlib)登录任务句柄(与微软两条流共用取消语义,但**不复用槽位**:
/// 两条轨同时点「登录」时各自的结果不能互相踩)
authlib: Option<LoginJob>,
/// 已抓到的皮肤(账户 id → 原图;`None` = 试过但没取到,不再重试)
skins: BTreeMap<String, Option<SkinImage>>,
/// 已经发起过皮肤抓取的账户 id(防每次刷新都重新抓一遍)
skin_requested: BTreeSet<String>,
java_chain: Vec<JavaChainStep>,
java_busy: bool,
java_message: String,
@@ -126,6 +133,9 @@ impl CoreHost {
active_account: None,
accounts: Vec::new(),
login: None,
authlib: None,
skins: BTreeMap::new(),
skin_requested: BTreeSet::new(),
java_chain: Vec::new(),
java_busy: false,
java_message: String::new(),
@@ -219,9 +229,54 @@ impl CoreHost {
self.active_account = self.accounts.first().map(|account| account.id.clone());
self.accounts = accounts::accounts(&self.env, self.active_account.as_deref());
}
self.attach_skins();
self.request_skins();
self.send(CoreEvent::AccountsChanged(self.accounts.clone()));
}
/// 把已抓到的皮肤盖到账户视图上。
///
/// 只盖第三方轨:离线档案没有皮肤,微软轨不做真头像(M114 口径)——
/// 「没有皮肤就画首字母块」,绝不给假皮肤/白块。
fn attach_skins(&mut self) {
for account in &mut self.accounts {
if account.kind != AccountKind::Authlib {
account.skin = None;
continue;
}
if let Some(skin) = self.skins.get(&account.id) {
account.skin = skin.clone();
}
}
}
/// 给还没抓过皮肤的第三方轨账户起后台抓取(每个账户只抓一次)。
///
/// 抓不到就记 `None`:错误在面板上不显示(皮肤是装饰,不是业务失败),但也不会重试刷屏。
fn request_skins(&mut self) {
let mut pending = Vec::new();
for account in &self.accounts {
if account.kind != AccountKind::Authlib || account.server_url.trim().is_empty() {
continue;
}
if self.skin_requested.insert(account.id.clone()) {
pending.push((
account.id.clone(),
account.server_url.clone(),
account.profile_id.clone(),
));
}
}
for (id, server, profile) in pending {
let tx = self.tx.clone();
let env = self.env.clone();
job::spawn("account-skin", move || {
let skin = accounts::fetch_skin(&env, &server, &profile).ok();
let _ = tx.send(HostTask::Avatar { id, skin });
});
}
}
fn refresh_java(&mut self) {
let page = java::page(
&self.env,