wind-explorer/friendolls
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

minecraft skins!

Browse Source
This commit is contained in:
wind-explorer
2026-08-29 01:41:59 +08:00
parent 9d695e704e
commit b6401a79a3
29 changed files with 1466 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/Cargo.toml
+1
View File
@@ -24,6 +24,7 @@ tauri-plugin-opener = "2"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
base64 = "0.22.1"
sha2 = "0.10"
image = { version = "0.25", default-features = false, features = ["gif", "jpeg", "png", "webp"] }
lazy_static = "1.5.0"
ed25519-dalek = "3.0.0"
src-tauri/migrations/20260828000000_add_skin_hashes.sql
+2
View File
@@ -0,0 +1,2 @@
ALTER TABLE profile ADD COLUMN skin_hash TEXT;
ALTER TABLE friends ADD COLUMN skin_hash TEXT;
src-tauri/src/friends/mod.rs
+22 -7
View File
@@ -13,6 +13,7 @@ use crate::keypair::AppKeypair;
pub struct Friend {
pub id: String,
pub display_name: Option<String>,
pub skin_hash: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type, Event)]
@@ -23,7 +24,7 @@ pub struct FriendsChanged {
pub(crate) async fn all(database: &AppDatabase) -> Result<Vec<Friend>, sqlx::Error> {
sqlx::query_as::<_, Friend>(
"SELECT id, display_name FROM friends \
"SELECT id, display_name, skin_hash FROM friends \
ORDER BY display_name IS NULL, display_name COLLATE NOCASE, id",
)
.fetch_all(database.pool())
@@ -38,17 +39,26 @@ async fn emit_changed(handle: &AppHandle, database: &AppDatabase) -> Result<(),
.map_err(db::command_error)
}
async fn update_display_names(
async fn update_profiles(
database: &AppDatabase,
profiles: &[wyd_common::Profile],
) -> Result<bool, sqlx::Error> {
let mut transaction = database.pool().begin().await?;
let mut changed = false;
for profile in profiles {
if profile
.skin_hash
.as_deref()
.is_some_and(|hash| !wyd_common::is_skin_hash(hash))
{
continue;
}
let result = sqlx::query(
"UPDATE friends SET display_name = ?1 WHERE id = ?2 AND display_name IS NOT ?1",
"UPDATE friends SET display_name = ?1, skin_hash = ?2 \
WHERE id = ?3 AND (display_name IS NOT ?1 OR skin_hash IS NOT ?2)",
)
.bind(&profile.display_name)
.bind(&profile.skin_hash)
.bind(&profile.id)
.execute(&mut *transaction)
.await?;
@@ -71,7 +81,7 @@ pub(crate) async fn apply_profile_sync(
database: &AppDatabase,
profiles: Vec<wyd_common::Profile>,
) -> Result<bool, String> {
let changed = update_display_names(database, &profiles)
let changed = update_profiles(database, &profiles)
.await
.map_err(db::command_error)?;
if changed {
@@ -97,6 +107,7 @@ pub async fn create_friend(
let friend = Friend {
id,
display_name: None,
skin_hash: None,
};
sqlx::query("INSERT INTO friends (id, display_name) VALUES (?1, NULL)")
.bind(&friend.id)
@@ -132,7 +143,7 @@ pub async fn get_friend(
database: State<'_, AppDatabase>,
id: String,
) -> Result<Option<Friend>, String> {
sqlx::query_as::<_, Friend>("SELECT id, display_name FROM friends WHERE id = ?1")
sqlx::query_as::<_, Friend>("SELECT id, display_name, skin_hash FROM friends WHERE id = ?1")
.bind(id)
.fetch_optional(database.pool())
.await
@@ -191,16 +202,18 @@ mod tests {
.unwrap();
assert!(
update_display_names(
update_profiles(
&database,
&[
wyd_common::Profile {
id: "friend-id".to_owned(),
display_name: "New".to_owned(),
skin_hash: Some("a".repeat(64)),
},
wyd_common::Profile {
id: "missing".to_owned(),
display_name: "Name".to_owned(),
skin_hash: None,
},
],
)
@@ -208,11 +221,12 @@ mod tests {
.unwrap()
);
assert!(
!update_display_names(
!update_profiles(
&database,
&[wyd_common::Profile {
id: "friend-id".to_owned(),
display_name: "New".to_owned(),
skin_hash: Some("a".repeat(64)),
}],
)
.await
@@ -223,6 +237,7 @@ mod tests {
[Friend {
id: "friend-id".to_owned(),
display_name: Some("New".to_owned()),
skin_hash: Some("a".repeat(64)),
}]
);
}
src-tauri/src/lib.rs
+2
View File
@@ -9,6 +9,7 @@ mod network;
mod profile;
mod puppet;
mod remotes;
mod skins;
mod ufa;
mod ui;
mod user;
@@ -76,6 +77,7 @@ fn specta_builder() -> tauri_specta::Builder<tauri::Wry> {
network::list_statuses,
network::list_friend_statuses,
network::resolve_friend_display_name,
skins::resolve_skin,
images::pick_and_send_image,
images::send_image_bytes,
interactions::send_interaction,
src-tauri/src/network/connection.rs
+392
View File
@@ -0,0 +1,392 @@
use std::collections::HashMap;
use std::time::Duration;
use futures_util::{SinkExt, StreamExt};
use tauri::{AppHandle, Manager};
use tokio::sync::{mpsc, oneshot, watch};
use tokio_tungstenite::tungstenite::Message;
use wyd_common::{
ClientMessage, InteractionDeliveryStatus, Profile, ServerMessage, friends_bytes,
interaction_bytes, message_bytes, profile_bytes, register_bytes,
};
use super::presence::FriendPresence;
use super::{
ConnectionState, Statuses, apply_friend_presence_change, changed, update_friend_presence,
};
use crate::db::AppDatabase;
use crate::friends;
use crate::interactions;
use crate::keypair::AppKeypair;
use crate::live_data::LiveData;
use crate::remotes::Remote;
pub(super) struct InteractionRequest {
pub(super) interaction_id: String,
pub(super) recipient_id: String,
pub(super) payload: String,
pub(super) response: oneshot::Sender<InteractionDeliveryStatus>,
}
pub(super) struct ProfileLookupRequest {
pub(super) request_id: String,
pub(super) user_id: String,
pub(super) response: oneshot::Sender<Option<String>>,
}
pub(super) struct SkinLookupRequest {
pub(super) request_id: String,
pub(super) user_id: String,
pub(super) skin_hash: String,
pub(super) response: oneshot::Sender<Option<String>>,
}
pub(super) struct ConnectionInputs {
pub(super) profiles: watch::Receiver<crate::user::User>,
pub(super) friends: watch::Receiver<Vec<String>>,
pub(super) keypair: AppKeypair,
pub(super) live_data: mpsc::Receiver<String>,
pub(super) interactions: mpsc::Receiver<InteractionRequest>,
pub(super) profile_lookups: mpsc::Receiver<ProfileLookupRequest>,
pub(super) skin_lookups: mpsc::Receiver<SkinLookupRequest>,
}
pub(super) async fn run(
handle: AppHandle,
statuses: Statuses,
friend_presence: std::sync::Arc<FriendPresence>,
remote: Remote,
generation: u64,
mut inputs: ConnectionInputs,
) {
loop {
changed(
&handle,
&statuses,
&remote,
generation,
ConnectionState::Connecting,
);
if let Err(error) = connect(
&handle,
&statuses,
&friend_presence,
&remote,
generation,
&mut inputs,
)
.await
{
eprintln!("remote {} disconnected: {error}", remote.id);
}
apply_friend_presence_change(&handle, friend_presence.remove(&remote.id));
changed(
&handle,
&statuses,
&remote,
generation,
ConnectionState::Disconnected,
);
tokio::time::sleep(Duration::from_secs(5)).await;
}
}
async fn connect(
handle: &AppHandle,
statuses: &Statuses,
friend_presence: &FriendPresence,
remote: &Remote,
generation: u64,
inputs: &mut ConnectionInputs,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let ConnectionInputs {
profiles,
friends,
keypair,
live_data,
interactions: active_outgoing,
profile_lookups,
skin_lookups,
} = inputs;
let (socket, _) = tokio_tungstenite::connect_async(url(remote)).await?;
let (mut writer, mut reader) = socket.split();
let challenge = match recv(&mut reader).await? {
ServerMessage::Challenge { version, challenge } if version == wyd_common::VERSION => {
challenge
}
_ => return Err("server did not send a compatible challenge".into()),
};
let current = profiles.borrow_and_update().clone();
let registration_profile = Profile {
id: current.id,
display_name: current.display_name,
skin_hash: current.skin_hash,
};
let registration_friends = friends.borrow_and_update().clone();
send(
&mut writer,
&ClientMessage::Register {
signature: keypair.sign(&register_bytes(
&challenge,
&registration_profile,
&registration_friends,
)),
profile: registration_profile,
friends: registration_friends,
},
)
.await?;
if !matches!(recv(&mut reader).await?, ServerMessage::Registered) {
return Err("server rejected registration".into());
}
while live_data.try_recv().is_ok() {}
while let Ok(request) = active_outgoing.try_recv() {
let _ = request
.response
.send(InteractionDeliveryStatus::Unavailable);
}
send(&mut writer, &ClientMessage::SyncFriendProfiles).await?;
send(&mut writer, &ClientMessage::SyncFriendStatuses).await?;
changed(
handle,
statuses,
remote,
generation,
ConnectionState::Connected,
);
let mut pending_interactions = HashMap::new();
let mut pending_profile_lookups: HashMap<String, (String, oneshot::Sender<Option<String>>)> =
HashMap::new();
let mut pending_skin_lookups: HashMap<
String,
(String, String, oneshot::Sender<Option<String>>),
> = HashMap::new();
loop {
tokio::select! {
payload = live_data.recv() => {
let payload = payload.ok_or("network sender closed")?;
send(&mut writer, &ClientMessage::Signed {
signature: keypair.sign(&message_bytes(&payload)),
payload,
}).await?;
}
request = active_outgoing.recv() => {
let request = request.ok_or("interaction sender closed")?;
let signature = keypair.sign(&interaction_bytes(
&request.interaction_id,
&request.recipient_id,
&request.payload,
));
send(&mut writer, &ClientMessage::Interaction {
interaction_id: request.interaction_id.clone(),
recipient_id: request.recipient_id,
payload: request.payload,
signature,
}).await?;
pending_interactions.insert(request.interaction_id, request.response);
}
request = profile_lookups.recv() => {
let request = request.ok_or("profile lookup sender closed")?;
if request.response.is_closed() {
continue;
}
pending_profile_lookups.retain(|_, (_, response)| !response.is_closed());
send(&mut writer, &ClientMessage::ResolveProfile {
request_id: request.request_id.clone(),
user_id: request.user_id.clone(),
}).await?;
pending_profile_lookups.insert(
request.request_id,
(request.user_id, request.response),
);
}
request = skin_lookups.recv() => {
let request = request.ok_or("skin lookup sender closed")?;
if request.response.is_closed() {
continue;
}
pending_skin_lookups.retain(|_, (_, _, response)| !response.is_closed());
send(&mut writer, &ClientMessage::RequestSkin {
request_id: request.request_id.clone(),
user_id: request.user_id.clone(),
skin_hash: request.skin_hash.clone(),
}).await?;
pending_skin_lookups.insert(
request.request_id,
(request.user_id, request.skin_hash, request.response),
);
}
changed = profiles.changed() => {
changed.map_err(|_| "profile sender closed")?;
let current = profiles.borrow_and_update().clone();
let profile = Profile {
id: current.id,
display_name: current.display_name,
skin_hash: current.skin_hash,
};
send(&mut writer, &ClientMessage::ProfileUpdated {
signature: keypair.sign(&profile_bytes(&profile)),
profile,
}).await?;
}
changed = friends.changed() => {
changed.map_err(|_| "friends sender closed")?;
let friends = friends.borrow_and_update().clone();
send(&mut writer, &ClientMessage::FriendsUpdated {
signature: keypair.sign(&friends_bytes(&friends)),
friends,
}).await?;
}
message = reader.next() => match message.ok_or("server closed the socket")?? {
Message::Text(text) => match serde_json::from_str(&text)? {
ServerMessage::FriendProfileUpdated { profile } => {
let database = handle.state::<AppDatabase>();
if let Err(error) = friends::apply_profile_update(handle, &database, profile).await {
eprintln!("failed to update friend profile: {error}");
}
}
ServerMessage::FriendProfiles { profiles } => {
let database = handle.state::<AppDatabase>();
if let Err(error) = friends::apply_profile_sync(handle, &database, profiles).await {
eprintln!("failed to synchronize friend profiles: {error}");
}
}
ServerMessage::FriendStatusChanged { friend_id, online } => {
update_friend_presence(
handle,
friend_presence,
&remote.id,
friend_id,
online,
);
}
ServerMessage::FriendStatuses { friend_ids } => {
apply_friend_presence_change(
handle,
friend_presence.replace(&remote.id, friend_ids),
);
}
ServerMessage::FriendLiveData { friend_id, payload } => {
match serde_json::from_str(&payload) {
Ok(LiveData::Cursor { positions }) => {
crate::cursor::emit_position(handle, friend_id, positions);
}
Ok(LiveData::ForegroundApp { meta }) => {
crate::ufa::emit_friend_app(handle, friend_id, meta);
}
Err(error) => {
eprintln!("failed to decode friend live data: {error}");
}
}
}
ServerMessage::FriendInteraction {
interaction_id,
friend_id,
payload,
} => {
interactions::receive(handle, interaction_id, friend_id, &payload);
}
ServerMessage::InteractionDelivery { interaction_id, status } => {
if let Some(response) = pending_interactions.remove(&interaction_id) {
let _ = response.send(status);
}
}
ServerMessage::ProfileResolved { request_id, profile } => {
if let Some((user_id, response)) = pending_profile_lookups.remove(&request_id) {
let display_name = profile
.filter(|profile| profile.id == user_id)
.map(|profile| profile.display_name);
let _ = response.send(display_name);
}
}
ServerMessage::SkinRequested {
request_id,
requester_id,
skin_hash,
} => {
let data = profiles
.borrow()
.skin_hash
.as_deref()
.filter(|current_hash| *current_hash == skin_hash)
.and_then(|_| crate::skins::read_local_base64(handle, &skin_hash));
send(&mut writer, &ClientMessage::ProvideSkin {
request_id,
requester_id,
skin_hash,
data,
}).await?;
}
ServerMessage::SkinResolved {
request_id,
user_id,
skin_hash,
data,
} => {
if let Some((expected_user_id, expected_hash, response)) =
pending_skin_lookups.remove(&request_id)
{
let data = (user_id == expected_user_id && skin_hash == expected_hash)
.then_some(data)
.flatten();
let _ = response.send(data);
}
}
_ => {}
},
Message::Ping(data) => writer.send(Message::Pong(data)).await?,
Message::Close(_) => return Ok(()),
_ => {}
}
}
}
}
async fn send<S>(
writer: &mut S,
message: &ClientMessage,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
where
S: futures_util::Sink<Message> + Unpin,
S::Error: std::error::Error + Send + Sync + 'static,
{
writer
.send(Message::Text(serde_json::to_string(message)?.into()))
.await?;
Ok(())
}
async fn recv<S>(reader: &mut S) -> Result<ServerMessage, Box<dyn std::error::Error + Send + Sync>>
where
S: futures_util::Stream<Item = Result<Message, tokio_tungstenite::tungstenite::Error>> + Unpin,
{
while let Some(message) = reader.next().await {
if let Message::Text(text) = message? {
return Ok(serde_json::from_str(&text)?);
}
}
Err("server closed the socket".into())
}
fn url(remote: &Remote) -> String {
let address = remote.address.trim_end_matches('/');
let address = address
.strip_prefix("http://")
.or_else(|| address.strip_prefix("https://"))
.or_else(|| address.strip_prefix("ws://"))
.or_else(|| address.strip_prefix("wss://"))
.unwrap_or(address);
let scheme = if remote.address.starts_with("https://") || remote.address.starts_with("wss://") {
"wss"
} else {
"ws"
};
let port = remote
.port
.map(|port| format!(":{port}"))
.unwrap_or_default();
format!("{scheme}://{address}{port}/v1/ws")
}
src-tauri/src/network/mod.rs
+63 -314
View File
@@ -3,28 +3,25 @@ use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use futures_util::StreamExt;
use futures_util::stream::FuturesUnordered;
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use specta::Type;
use tauri::{AppHandle, Manager, State};
use tauri_specta::Event;
use tokio::sync::{mpsc, oneshot, watch};
use tokio_tungstenite::tungstenite::Message;
use wyd_common::{
ClientMessage, InteractionContent, InteractionDeliveryStatus, Profile, ServerMessage,
friends_bytes, interaction_bytes, message_bytes, profile_bytes, register_bytes,
};
use wyd_common::{InteractionContent, InteractionDeliveryStatus};
use crate::db::AppDatabase;
use crate::friends::{self, FriendsChanged};
use crate::interactions;
use crate::keypair::AppKeypair;
use crate::live_data::LiveData;
use crate::remotes::{self, Remote, RemotesChanged};
mod connection;
mod presence;
use connection::{ConnectionInputs, InteractionRequest, ProfileLookupRequest, SkinLookupRequest};
use presence::{Change as FriendPresenceChange, FriendPresence};
type Statuses = Arc<Mutex<HashMap<String, (u64, ConnectionStatus)>>>;
@@ -63,32 +60,11 @@ struct Connection {
sender: mpsc::Sender<String>,
interaction_sender: mpsc::Sender<InteractionRequest>,
profile_lookup_sender: mpsc::Sender<ProfileLookupRequest>,
skin_lookup_sender: mpsc::Sender<SkinLookupRequest>,
task: tauri::async_runtime::JoinHandle<()>,
generation: u64,
}
struct InteractionRequest {
interaction_id: String,
recipient_id: String,
payload: String,
response: oneshot::Sender<InteractionDeliveryStatus>,
}
struct ProfileLookupRequest {
request_id: String,
user_id: String,
response: oneshot::Sender<Option<String>>,
}
struct ConnectionInputs {
profiles: watch::Receiver<crate::user::User>,
friends: watch::Receiver<Vec<String>>,
keypair: AppKeypair,
live_data: mpsc::Receiver<String>,
interactions: mpsc::Receiver<InteractionRequest>,
profile_lookups: mpsc::Receiver<ProfileLookupRequest>,
}
pub struct Network {
connections: Mutex<HashMap<String, Connection>>,
statuses: Statuses,
@@ -100,6 +76,10 @@ pub struct Network {
}
impl Network {
pub(crate) fn public_key(&self) -> &str {
self.keypair.public_key()
}
pub fn send_live_data(&self, data: LiveData) {
let Ok(payload) = serde_json::to_string(&data) else {
eprintln!("failed to serialize live data");
@@ -222,6 +202,53 @@ impl Network {
Ok(None)
}
pub(crate) async fn request_skin(
&self,
user_id: String,
skin_hash: String,
) -> Result<Option<Vec<u8>>, String> {
if user_id == self.keypair.public_key() {
return Ok(None);
}
let senders: Vec<_> = self
.connections
.lock()
.map_err(|error| error.to_string())?
.values()
.map(|connection| connection.skin_lookup_sender.clone())
.collect();
let request_id = uuid::Uuid::new_v4().to_string();
let mut responses = Vec::new();
for sender in senders {
let (response, receiver) = oneshot::channel();
if sender
.try_send(SkinLookupRequest {
request_id: request_id.clone(),
user_id: user_id.clone(),
skin_hash: skin_hash.clone(),
response,
})
.is_ok()
{
responses.push(receiver);
}
}
let mut pending: FuturesUnordered<_> = responses
.into_iter()
.map(|response| tokio::time::timeout(Duration::from_secs(3), response))
.collect();
while let Some(result) = pending.next().await {
if let Ok(Ok(Some(data))) = result
&& let Some(bytes) = crate::skins::decode_response(&data, &skin_hash)
{
return Ok(Some(bytes));
}
}
Ok(None)
}
fn sync_remotes(&self, handle: &AppHandle, remotes: Vec<Remote>) -> Result<(), String> {
let desired: HashMap<_, _> = remotes
.into_iter()
@@ -252,13 +279,14 @@ impl Network {
let (sender, receiver) = mpsc::channel(32);
let (interaction_sender, interaction_receiver) = mpsc::channel(16);
let (profile_lookup_sender, profile_lookup_receiver) = mpsc::channel(16);
let (skin_lookup_sender, skin_lookup_receiver) = mpsc::channel(16);
set_initial(
&self.statuses,
&remote,
generation,
ConnectionState::Connecting,
);
let task = tauri::async_runtime::spawn(run(
let task = tauri::async_runtime::spawn(connection::run(
handle.clone(),
self.statuses.clone(),
self.friend_presence.clone(),
@@ -271,6 +299,7 @@ impl Network {
live_data: receiver,
interactions: interaction_receiver,
profile_lookups: profile_lookup_receiver,
skin_lookups: skin_lookup_receiver,
},
));
connections.insert(
@@ -280,6 +309,7 @@ impl Network {
sender,
interaction_sender,
profile_lookup_sender,
skin_lookup_sender,
task,
generation,
},
@@ -334,244 +364,6 @@ pub async fn init(handle: &AppHandle) -> Result<(), Box<dyn std::error::Error>>
Ok(())
}
async fn run(
handle: AppHandle,
statuses: Statuses,
friend_presence: Arc<FriendPresence>,
remote: Remote,
generation: u64,
mut inputs: ConnectionInputs,
) {
loop {
changed(
&handle,
&statuses,
&remote,
generation,
ConnectionState::Connecting,
);
if let Err(error) = connect(
&handle,
&statuses,
&friend_presence,
&remote,
generation,
&mut inputs,
)
.await
{
eprintln!("remote {} disconnected: {error}", remote.id);
}
apply_friend_presence_change(&handle, friend_presence.remove(&remote.id));
changed(
&handle,
&statuses,
&remote,
generation,
ConnectionState::Disconnected,
);
tokio::time::sleep(Duration::from_secs(5)).await;
}
}
async fn connect(
handle: &AppHandle,
statuses: &Statuses,
friend_presence: &FriendPresence,
remote: &Remote,
generation: u64,
inputs: &mut ConnectionInputs,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let ConnectionInputs {
profiles,
friends,
keypair,
live_data,
interactions: active_outgoing,
profile_lookups,
} = inputs;
let (socket, _) = tokio_tungstenite::connect_async(url(remote)).await?;
let (mut writer, mut reader) = socket.split();
let challenge = match recv(&mut reader).await? {
ServerMessage::Challenge { version, challenge } if version == wyd_common::VERSION => {
challenge
}
_ => return Err("server did not send a compatible challenge".into()),
};
let current = profiles.borrow_and_update().clone();
let registration_profile = Profile {
id: current.id,
display_name: current.display_name,
};
let registration_friends = friends.borrow_and_update().clone();
send(
&mut writer,
&ClientMessage::Register {
signature: keypair.sign(&register_bytes(
&challenge,
&registration_profile,
&registration_friends,
)),
profile: registration_profile,
friends: registration_friends,
},
)
.await?;
if !matches!(recv(&mut reader).await?, ServerMessage::Registered) {
return Err("server rejected registration".into());
}
while live_data.try_recv().is_ok() {}
while let Ok(request) = active_outgoing.try_recv() {
let _ = request
.response
.send(InteractionDeliveryStatus::Unavailable);
}
send(&mut writer, &ClientMessage::SyncFriendProfiles).await?;
send(&mut writer, &ClientMessage::SyncFriendStatuses).await?;
changed(
handle,
statuses,
remote,
generation,
ConnectionState::Connected,
);
let mut pending_interactions = HashMap::new();
let mut pending_profile_lookups: HashMap<String, (String, oneshot::Sender<Option<String>>)> =
HashMap::new();
loop {
tokio::select! {
payload = live_data.recv() => {
let payload = payload.ok_or("network sender closed")?;
send(&mut writer, &ClientMessage::Signed {
signature: keypair.sign(&message_bytes(&payload)),
payload,
}).await?;
}
request = active_outgoing.recv() => {
let request = request.ok_or("interaction sender closed")?;
let signature = keypair.sign(&interaction_bytes(
&request.interaction_id,
&request.recipient_id,
&request.payload,
));
send(&mut writer, &ClientMessage::Interaction {
interaction_id: request.interaction_id.clone(),
recipient_id: request.recipient_id,
payload: request.payload,
signature,
}).await?;
pending_interactions.insert(request.interaction_id, request.response);
}
request = profile_lookups.recv() => {
let request = request.ok_or("profile lookup sender closed")?;
if request.response.is_closed() {
continue;
}
pending_profile_lookups.retain(|_, (_, response)| !response.is_closed());
send(&mut writer, &ClientMessage::ResolveProfile {
request_id: request.request_id.clone(),
user_id: request.user_id.clone(),
}).await?;
pending_profile_lookups.insert(
request.request_id,
(request.user_id, request.response),
);
}
changed = profiles.changed() => {
changed.map_err(|_| "profile sender closed")?;
let current = profiles.borrow_and_update().clone();
let profile = Profile {
id: current.id,
display_name: current.display_name,
};
send(&mut writer, &ClientMessage::ProfileUpdated {
signature: keypair.sign(&profile_bytes(&profile)),
profile,
}).await?;
}
changed = friends.changed() => {
changed.map_err(|_| "friends sender closed")?;
let friends = friends.borrow_and_update().clone();
send(&mut writer, &ClientMessage::FriendsUpdated {
signature: keypair.sign(&friends_bytes(&friends)),
friends,
}).await?;
}
message = reader.next() => match message.ok_or("server closed the socket")?? {
Message::Text(text) => match serde_json::from_str(&text)? {
ServerMessage::FriendProfileUpdated { profile } => {
let database = handle.state::<AppDatabase>();
if let Err(error) = friends::apply_profile_update(handle, &database, profile).await {
eprintln!("failed to update friend profile: {error}");
}
}
ServerMessage::FriendProfiles { profiles } => {
let database = handle.state::<AppDatabase>();
if let Err(error) = friends::apply_profile_sync(handle, &database, profiles).await {
eprintln!("failed to synchronize friend profiles: {error}");
}
}
ServerMessage::FriendStatusChanged { friend_id, online } => {
update_friend_presence(
handle,
friend_presence,
&remote.id,
friend_id,
online,
);
}
ServerMessage::FriendStatuses { friend_ids } => {
apply_friend_presence_change(
handle,
friend_presence.replace(&remote.id, friend_ids),
);
}
ServerMessage::FriendLiveData { friend_id, payload } => {
match serde_json::from_str(&payload) {
Ok(LiveData::Cursor { positions }) => {
crate::cursor::emit_position(handle, friend_id, positions);
}
Ok(LiveData::ForegroundApp { meta }) => {
crate::ufa::emit_friend_app(handle, friend_id, meta);
}
Err(error) => {
eprintln!("failed to decode friend live data: {error}");
}
}
}
ServerMessage::FriendInteraction {
interaction_id,
friend_id,
payload,
} => {
interactions::receive(handle, interaction_id, friend_id, &payload);
}
ServerMessage::InteractionDelivery { interaction_id, status } => {
if let Some(response) = pending_interactions.remove(&interaction_id) {
let _ = response.send(status);
}
}
ServerMessage::ProfileResolved { request_id, profile } => {
if let Some((user_id, response)) = pending_profile_lookups.remove(&request_id) {
let display_name = profile
.filter(|profile| profile.id == user_id)
.map(|profile| profile.display_name);
let _ = response.send(display_name);
}
}
_ => {}
},
Message::Ping(data) => writer.send(Message::Pong(data)).await?,
Message::Close(_) => return Ok(()),
_ => {}
}
}
}
}
#[tauri::command]
#[specta::specta]
pub fn list_statuses(
@@ -702,52 +494,6 @@ fn snapshot(statuses: &Statuses) -> Result<Vec<ConnectionStatus>, String> {
Ok(statuses)
}
async fn send<S>(
writer: &mut S,
message: &ClientMessage,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
where
S: futures_util::Sink<Message> + Unpin,
S::Error: std::error::Error + Send + Sync + 'static,
{
writer
.send(Message::Text(serde_json::to_string(message)?.into()))
.await?;
Ok(())
}
async fn recv<S>(reader: &mut S) -> Result<ServerMessage, Box<dyn std::error::Error + Send + Sync>>
where
S: futures_util::Stream<Item = Result<Message, tokio_tungstenite::tungstenite::Error>> + Unpin,
{
while let Some(message) = reader.next().await {
if let Message::Text(text) = message? {
return Ok(serde_json::from_str(&text)?);
}
}
Err("server closed the socket".into())
}
fn url(remote: &Remote) -> String {
let address = remote.address.trim_end_matches('/');
let address = address
.strip_prefix("http://")
.or_else(|| address.strip_prefix("https://"))
.or_else(|| address.strip_prefix("ws://"))
.or_else(|| address.strip_prefix("wss://"))
.unwrap_or(address);
let scheme = if remote.address.starts_with("https://") || remote.address.starts_with("wss://") {
"wss"
} else {
"ws"
};
let port = remote
.port
.map(|port| format!(":{port}"))
.unwrap_or_default();
format!("{scheme}://{address}{port}/v1/ws")
}
fn friend_ids(friends: Vec<crate::friends::Friend>, own_id: &str) -> Vec<String> {
let mut ids: Vec<_> = friends
.into_iter()
@@ -770,14 +516,17 @@ mod tests {
Friend {
id: "friend-b".to_owned(),
display_name: Some("Old name".to_owned()),
skin_hash: None,
},
Friend {
id: "self".to_owned(),
display_name: None,
skin_hash: None,
},
Friend {
id: "friend-a".to_owned(),
display_name: Some("Any name".to_owned()),
skin_hash: None,
},
];
src-tauri/src/profile/mod.rs
+38 -14
View File
@@ -16,19 +16,21 @@ pub struct ProfileChanged {
}
pub async fn get(database: &AppDatabase, public_key: &str) -> Result<User, sqlx::Error> {
let display_name =
sqlx::query_scalar::<_, String>("SELECT display_name FROM profile WHERE id = ?1")
.bind(PROFILE_ID)
.fetch_one(database.pool())
.await?;
let (display_name, skin_hash) = sqlx::query_as::<_, (String, Option<String>)>(
"SELECT display_name, skin_hash FROM profile WHERE id = ?1",
)
.bind(PROFILE_ID)
.fetch_one(database.pool())
.await?;
Ok(User {
id: public_key.to_owned(),
display_name: if display_name.len() <= 0 {
display_name: if display_name.is_empty() {
"Anonymous".to_string()
} else {
display_name
},
skin_hash,
})
}
@@ -36,12 +38,16 @@ async fn update(
database: &AppDatabase,
public_key: &str,
display_name: String,
skin_hash: Option<String>,
) -> Result<User, sqlx::Error> {
sqlx::query("UPDATE profile SET display_name = ?1 WHERE id = ?2")
.bind(display_name)
.bind(PROFILE_ID)
.execute(database.pool())
.await?;
sqlx::query(
"UPDATE profile SET display_name = ?1, skin_hash = COALESCE(?2, skin_hash) WHERE id = ?3",
)
.bind(display_name)
.bind(skin_hash)
.bind(PROFILE_ID)
.execute(database.pool())
.await?;
get(database, public_key).await
}
@@ -74,8 +80,13 @@ pub async fn update_profile(
keypair: State<'_, AppKeypair>,
network: State<'_, Network>,
display_name: String,
skin_data: Option<Vec<u8>>,
) -> Result<User, String> {
let profile = update(&database, keypair.public_key(), display_name)
let skin_hash = skin_data
.as_deref()
.map(|data| crate::skins::store_local(&handle, data))
.transpose()?;
let profile = update(&database, keypair.public_key(), display_name, skin_hash)
.await
.map_err(db::command_error)?;
network.update_profile(profile.clone());
@@ -106,7 +117,7 @@ mod tests {
async fn profile_uses_the_supplied_keypair_identity() {
let database = database().await;
let profile = update(&database, "public-key", "Wind".to_owned())
let profile = update(&database, "public-key", "Wind".to_owned(), None)
.await
.expect("update profile");
@@ -115,6 +126,7 @@ mod tests {
User {
id: "public-key".to_owned(),
display_name: "Wind".to_owned(),
skin_hash: None,
}
);
assert_eq!(
@@ -122,8 +134,20 @@ mod tests {
User {
id: "rotated-public-key".to_owned(),
display_name: "Wind".to_owned(),
skin_hash: None,
}
);
let profile = update(
&database,
"public-key",
"Wind Two".to_owned(),
Some("a".repeat(64)),
)
.await
.expect("update profile and skin together");
assert_eq!(profile.display_name, "Wind Two");
assert_eq!(profile.skin_hash, Some("a".repeat(64)));
}
#[tokio::test]
@@ -136,6 +160,6 @@ mod tests {
.await
.expect("read profile columns");
assert_eq!(columns, vec!["id", "display_name"]);
assert_eq!(columns, vec!["id", "display_name", "skin_hash"]);
}
}
src-tauri/src/skins.rs
+164
View File
@@ -0,0 +1,164 @@
use std::io::Cursor;
use std::path::PathBuf;
use base64::Engine;
use base64::engine::general_purpose::STANDARD;
use sha2::{Digest, Sha256};
use tauri::{AppHandle, Manager, State};
use crate::network::Network;
const MAX_SKIN_BYTES: usize = 64 * 1024;
const SKIN_WIDTH: u32 = 64;
const SKIN_HEIGHT: u32 = 64;
fn validate_hash(hash: &str) -> Result<(), String> {
if wyd_common::is_skin_hash(hash) {
Ok(())
} else {
Err("Skin hash must be a 64-character SHA-256 value".to_owned())
}
}
fn hash(bytes: &[u8]) -> String {
format!("{:x}", Sha256::digest(bytes))
}
fn validate(bytes: &[u8]) -> Result<String, String> {
if bytes.is_empty() || bytes.len() > MAX_SKIN_BYTES {
return Err(format!(
"Skin PNG must be at most {} KiB",
MAX_SKIN_BYTES / 1024
));
}
let dimensions = image::ImageReader::with_format(Cursor::new(bytes), image::ImageFormat::Png)
.into_dimensions()
.map_err(|_| "Skin must be a valid PNG image".to_owned())?;
if dimensions != (SKIN_WIDTH, SKIN_HEIGHT) {
return Err(format!("Skin must be {SKIN_WIDTH}×{SKIN_HEIGHT} pixels"));
}
image::load_from_memory_with_format(bytes, image::ImageFormat::Png)
.map_err(|_| "Skin must be a valid PNG image".to_owned())?;
Ok(hash(bytes))
}
fn local_path(handle: &AppHandle, hash: &str) -> Result<PathBuf, String> {
Ok(handle
.path()
.app_data_dir()
.map_err(|error| error.to_string())?
.join("skins")
.join(format!("{hash}.png")))
}
fn cache_path(handle: &AppHandle, hash: &str) -> Result<PathBuf, String> {
Ok(handle
.path()
.app_cache_dir()
.map_err(|error| error.to_string())?
.join("skins")
.join(format!("{hash}.png")))
}
fn read_verified(path: PathBuf, expected_hash: &str) -> Result<Option<Vec<u8>>, String> {
let bytes = match std::fs::read(path) {
Ok(bytes) => bytes,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(error) => return Err(error.to_string()),
};
Ok(validate(&bytes)
.is_ok_and(|actual_hash| actual_hash == expected_hash)
.then_some(bytes))
}
pub(crate) fn decode_response(data: &str, expected_hash: &str) -> Option<Vec<u8>> {
if data.len() > wyd_common::MAX_SKIN_B64_SIZE {
return None;
}
let bytes = STANDARD.decode(data).ok()?;
(validate(&bytes).ok()?.as_str() == expected_hash).then_some(bytes)
}
fn write(path: PathBuf, bytes: &[u8]) -> Result<(), String> {
let parent = path
.parent()
.ok_or_else(|| "Skin path has no parent directory".to_owned())?;
std::fs::create_dir_all(parent).map_err(|error| error.to_string())?;
std::fs::write(path, bytes).map_err(|error| error.to_string())
}
pub(crate) fn read_local_base64(handle: &AppHandle, skin_hash: &str) -> Option<String> {
validate_hash(skin_hash).ok()?;
read_verified(local_path(handle, skin_hash).ok()?, skin_hash)
.ok()
.flatten()
.map(|bytes| STANDARD.encode(bytes))
}
pub(crate) fn store_local(handle: &AppHandle, data: &[u8]) -> Result<String, String> {
let skin_hash = validate(data)?;
write(local_path(handle, &skin_hash)?, data)?;
Ok(skin_hash)
}
#[tauri::command]
#[specta::specta]
pub async fn resolve_skin(
handle: AppHandle,
network: State<'_, Network>,
user_id: String,
skin_hash: String,
) -> Result<Option<String>, String> {
validate_hash(&skin_hash)?;
crate::user::validate_id(&user_id)?;
let bytes = if user_id == network.public_key() {
read_verified(local_path(&handle, &skin_hash)?, &skin_hash)?
} else if let Some(bytes) = read_verified(cache_path(&handle, &skin_hash)?, &skin_hash)? {
Some(bytes)
} else {
let Some(bytes) = network.request_skin(user_id, skin_hash.clone()).await? else {
return Ok(None);
};
write(cache_path(&handle, &skin_hash)?, &bytes)?;
Some(bytes)
};
Ok(bytes.map(|bytes| STANDARD.encode(bytes)))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_non_png_and_invalid_hashes() {
assert!(validate(b"not a png").is_err());
assert!(validate_hash("../skin").is_err());
assert!(validate_hash(&"a".repeat(64)).is_ok());
}
#[test]
fn rejects_png_dimensions_before_full_validation() {
let mut bytes = Cursor::new(Vec::new());
image::DynamicImage::new_rgba8(SKIN_WIDTH + 1, SKIN_HEIGHT)
.write_to(&mut bytes, image::ImageFormat::Png)
.unwrap();
assert_eq!(
validate(&bytes.into_inner()).unwrap_err(),
"Skin must be 64×64 pixels"
);
}
#[test]
fn accepts_a_64_by_64_png_and_returns_its_sha256_hash() {
let mut bytes = Cursor::new(Vec::new());
image::DynamicImage::new_rgba8(SKIN_WIDTH, SKIN_HEIGHT)
.write_to(&mut bytes, image::ImageFormat::Png)
.unwrap();
let bytes = bytes.into_inner();
assert_eq!(validate(&bytes).unwrap(), hash(&bytes));
}
}
src-tauri/src/user/mod.rs
+1
View File
@@ -11,6 +11,7 @@ use specta::Type;
pub struct User {
pub id: String,
pub display_name: String,
pub skin_hash: Option<String>,
}
pub(crate) fn validate_id(id: &str) -> Result<(), String> {