From 5343020bed293682078ff22f885f8fda3255cf1c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=94=D0=BC=D0=B8=D1=82=D1=80=D0=B8=D0=B9?= Date: Thu, 22 Oct 2026 17:24:15 +0500 Subject: [PATCH] feat(portable): MR2 Wildcard portable character vertical slice - Enforce fail-closed backend resolution in LocalBackend::info (unknown ruleset = error). - Implement strict three-space isolation (Wildcard != CoA != Reborn) across canonical store, host mappings, and collections. - Isolate collection namespaces (wildcard:appearance, wildcard:vanity) and reject cross-ruleset collections in claim and import. - Enforce Control Protocol v2 ruleset verification on TransferOffer, TransferCommit, and Claimed response. - Route Direct Ingress and Relay Link dynamically according to realm world port (8085 for CoA, 8086 for Wildcard). - Add runtime session attack rejection test suite (cross-ruleset session offers, checkpoints, owner acks, server IDs). - Verify end-to-end Wildcard session lifecycle and documentation updates. --- crates/coa-control-proto/src/app.rs | 1 + crates/coa-core/src/control/backend.rs | 91 +++++- crates/coa-core/src/control/direct_ingress.rs | 204 +++++++++--- crates/coa-core/src/control/direct_route.rs | 2 +- crates/coa-core/src/control/host_manager.rs | 3 +- crates/coa-core/src/control/join.rs | 7 +- crates/coa-core/src/control/relay_link.rs | 24 +- crates/coa-core/src/control/service.rs | 225 +++++++++++-- crates/coa-core/src/control/store.rs | 16 +- crates/coa-core/src/portable/mod.rs | 4 +- crates/coa-core/src/portable/model.rs | 8 + .../coa-core/src/portable/service/engine.rs | 59 +++- .../src/portable/session/collection_tests.rs | 96 ++++++ crates/coa-core/src/portable/session/fake.rs | 8 +- crates/coa-core/src/portable/session/tests.rs | 296 ++++++++++++++++++ crates/coa-core/src/portable/store/host.rs | 7 + crates/coa-core/src/portable/store/tests.rs | 153 +++++++++ crates/coa-core/src/realm_registry/advert.rs | 10 +- crates/coa-core/src/realms.rs | 20 ++ docs/CONTROL_PROTOCOL.md | 9 +- docs/MULTIRULESET_PORTABLE_AUDIT.md | 34 +- docs/PORTABLE-CHARACTERS.md | 11 +- docs/PORTABLE_FORMAT.md | 12 +- docs/PORTABLE_SESSIONS.md | 20 +- docs/WILDCARD.md | 9 + services/coa-control-e2e/tests/control.rs | 47 ++- src-tauri/src/control_cmds.rs | 34 ++ 27 files changed, 1251 insertions(+), 159 deletions(-) diff --git a/crates/coa-control-proto/src/app.rs b/crates/coa-control-proto/src/app.rs index 56a114b..3317138 100644 --- a/crates/coa-control-proto/src/app.rs +++ b/crates/coa-control-proto/src/app.rs @@ -190,6 +190,7 @@ pub enum Response { /// appearance and vanity ids the Host holds for the account (kind -> ids). Claimed { character_id: Uuid, + ruleset: String, sha256: String, payload: String, collections: BTreeMap>, diff --git a/crates/coa-core/src/control/backend.rs b/crates/coa-core/src/control/backend.rs index 951a58c..f00b908 100644 --- a/crates/coa-core/src/control/backend.rs +++ b/crates/coa-core/src/control/backend.rs @@ -86,11 +86,9 @@ impl LocalBackend { impl RealmBackend for LocalBackend { fn info(&self, local_id: &str) -> Result { let cfg = settings::load(&self.settings_dir)?.realms.remove(local_id); - let ruleset = self - .access(local_id) - .and_then(|a| a.db()) - .and_then(|db| realm::ruleset_of(&db).map_err(|e| Error::Invalid(e.to_string()))) - .unwrap_or(crate::portable::model::Ruleset::Coa); + let access = self.access(local_id)?; + let db = access.db()?; + let ruleset = realm::ruleset_of(&db).map_err(|e| Error::Invalid(e.to_string()))?; Ok(RealmInfo { automatic: cfg.as_ref().is_none_or(|c| !c.existing_only), route: cfg.and_then(|c| c.route), @@ -217,6 +215,7 @@ impl RealmBackend for LocalBackend { .map_err(|e| unavailable("export", e))?; Ok(ClaimExport { character_id: bundle.character_id.as_uuid(), + ruleset: bundle.ruleset, payload: bundle.payload, sha256: bundle.content_hash, collections: bundle.collections, @@ -249,4 +248,86 @@ impl RealmBackend for LocalBackend { .map_err(|e| unavailable("portable engine", e))? .map_err(|e| unavailable("import remote", e)) } + + fn world_port(&self, local_id: &str) -> Result { + if let Ok(override_port) = std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT") { + if let Ok(p) = override_port.parse::() { + return Ok(p); + } + } + let access = self.access(local_id)?; + let mode = access.mode.unwrap_or(crate::realms::Mode::Coa); + if let Some(ref root) = access.root { + crate::realms::world_port_for_mode(root, mode) + } else { + Ok(8085) + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::fs; + use tempfile::tempdir; + + #[test] + fn unreadable_or_unknown_realm_fails_closed_in_info() { + let dir = tempdir().unwrap(); + let settings = dir.path().join("Settings"); + fs::create_dir_all(&settings).unwrap(); + fs::write(settings.join("registry.json"), "{}").unwrap(); + + let desc_dir = dir.path().join("descriptors"); + fs::create_dir_all(&desc_dir).unwrap(); + + let portable_dir = dir.path().join("portable"); + let rt = PortableRuntime::start(&portable_dir, Box::new(|| vec![]), None).unwrap(); + let backend = LocalBackend::new(Arc::new(rt), &settings, &desc_dir, Arc::new(|| vec![])); + + // Unknown realm id must return Err, never Ok(RealmInfo { ruleset: Ruleset::Coa, .. }) + assert!(backend.info("srv-unknown").is_err()); + assert!(backend.info("srv-unknown:wildcard").is_err()); + assert!(backend.info("srv-unknown:reborn").is_err()); + } + + #[test] + fn world_port_for_mode_distinguishes_simultaneous_realms() { + let dir = tempdir().unwrap(); + let root = dir.path().join("srv"); + fs::create_dir_all(root.join("Settings")).unwrap(); + fs::write( + root.join("Settings/repack.json"), + r#"{"worldPort": 8085}"#, + ) + .unwrap(); + fs::write( + root.join("Settings/realm-profile.json"), + r#"{"active": "coa", "wildcard_created": true, "simultaneous": true, "secondary_world_port": 8086}"#, + ) + .unwrap(); + + assert_eq!( + crate::realms::world_port_for_mode(&root, crate::realms::Mode::Coa).unwrap(), + 8085 + ); + assert_eq!( + crate::realms::world_port_for_mode(&root, crate::realms::Mode::Wildcard).unwrap(), + 8086 + ); + + let desc_dir = dir.path().join("descriptors"); + let portable_dir = dir.path().join("portable"); + let rt = PortableRuntime::start(&portable_dir, Box::new(|| vec![]), None).unwrap(); + let root_clone = root.clone(); + let backend = LocalBackend::new( + Arc::new(rt), + root.join("Settings"), + &desc_dir, + Arc::new(move || vec![("test1".to_string(), root_clone.clone())]), + ); + + assert_eq!(backend.world_port("srv-test1:coa").unwrap(), 8085); + assert_eq!(backend.world_port("srv-test1:wildcard").unwrap(), 8086); + } } diff --git a/crates/coa-core/src/control/direct_ingress.rs b/crates/coa-core/src/control/direct_ingress.rs index 294de03..dee52f8 100644 --- a/crates/coa-core/src/control/direct_ingress.rs +++ b/crates/coa-core/src/control/direct_ingress.rs @@ -33,8 +33,9 @@ impl DirectIngress { local_auth_port: u16, local_world_port: u16, ) -> Result { + let auth_host = if auth_bind_port == 0 { "127.0.0.1" } else { "0.0.0.0" }; let auth_listener = - TcpListener::bind(format!("0.0.0.0:{auth_bind_port}")).map_err(|e| { + TcpListener::bind(format!("{auth_host}:{auth_bind_port}")).map_err(|e| { Error::Invalid(format!( "Cannot bind direct auth listener on port {auth_bind_port}: {e}" )) @@ -47,8 +48,9 @@ impl DirectIngress { .map_err(|e| Error::Invalid(e.to_string()))? .port(); + let world_host = if world_bind_port == 0 { "127.0.0.1" } else { "0.0.0.0" }; let world_listener = - TcpListener::bind(format!("0.0.0.0:{world_bind_port}")).map_err(|e| { + TcpListener::bind(format!("{world_host}:{world_bind_port}")).map_err(|e| { Error::Invalid(format!( "Cannot bind direct world listener on port {world_bind_port}: {e}" )) @@ -114,7 +116,9 @@ impl DirectIngress { std::thread::Builder::new() .name("direct-world-worker".into()) .spawn(move || { - let _ = handle_world_client(client_stream, local_world_port); + if let Err(e) = handle_world_client(client_stream, local_world_port) { + eprintln!("handle_world_client error: {e}"); + } }) .ok(); } @@ -174,8 +178,19 @@ fn handle_auth_client( local_auth_port: u16, world_target: Arc>, ) -> Result<()> { - let mut server = TcpStream::connect(format!("127.0.0.1:{local_auth_port}")) - .map_err(|e| Error::Invalid(format!("Cannot connect to local authserver: {e}")))?; + let mut server = None; + for _ in 0..5 { + match TcpStream::connect(format!("127.0.0.1:{local_auth_port}")) { + Ok(s) => { + server = Some(s); + break; + } + Err(_) => std::thread::sleep(Duration::from_millis(20)), + } + } + let mut server = server.ok_or_else(|| { + Error::Invalid(format!("Cannot connect to local authserver: {local_auth_port}")) + })?; let _ = client.set_read_timeout(Some(Duration::from_millis(500))); let _ = server.set_read_timeout(Some(Duration::from_millis(500))); @@ -213,7 +228,7 @@ fn handle_auth_client( } done_c.store(true, Ordering::Relaxed); if let Some(s) = server_shutdown { - let _ = s.shutdown(std::net::Shutdown::Both); + let _ = s.shutdown(std::net::Shutdown::Write); } }); @@ -261,8 +276,19 @@ fn handle_auth_client( } fn handle_world_client(mut client: TcpStream, local_world_port: u16) -> Result<()> { - let mut server = TcpStream::connect(format!("127.0.0.1:{local_world_port}")) - .map_err(|e| Error::Invalid(format!("Cannot connect to local worldserver: {e}")))?; + let mut server = None; + for _ in 0..5 { + match TcpStream::connect(format!("127.0.0.1:{local_world_port}")) { + Ok(s) => { + server = Some(s); + break; + } + Err(_) => std::thread::sleep(Duration::from_millis(20)), + } + } + let mut server = server.ok_or_else(|| { + Error::Invalid(format!("Cannot connect to local worldserver: {local_world_port}")) + })?; let _ = client.set_nonblocking(false); let _ = server.set_nonblocking(false); @@ -278,11 +304,11 @@ fn handle_world_client(mut client: TcpStream, local_world_port: u16) -> Result<( let t_c2s = std::thread::spawn(move || { let _ = std::io::copy(&mut client_read, &mut server_write); - let _ = server_write.shutdown(std::net::Shutdown::Both); + let _ = server_write.shutdown(std::net::Shutdown::Write); }); let _ = std::io::copy(&mut server, &mut client); - let _ = client.shutdown(std::net::Shutdown::Both); + let _ = client.shutdown(std::net::Shutdown::Write); let _ = t_c2s.join(); Ok(()) @@ -320,6 +346,7 @@ mod tests { let n = stream.read(&mut buf).unwrap(); assert_eq!(&buf[..n], b"WORLD_PING"); stream.write_all(b"WORLD_PONG").unwrap(); + stream.flush().unwrap(); let _ = stream.shutdown(std::net::Shutdown::Write); }); @@ -337,25 +364,27 @@ mod tests { let mut buf = [0u8; 16]; let _ = stream.read(&mut buf).unwrap(); - let mut fake_realm_list = vec![ - 0x10, // Opcode CMD_REALM_LIST - 0x00, 0x00, // Size placeholder - 0x00, 0x00, 0x00, 0x00, // Unused - 0x01, 0x00, // Realm count: 1 - 0x01, 0x00, 0x00, 0x00, // Icon - 0x00, // Lock - 0x00, // Flags - ]; - fake_realm_list.extend_from_slice(b"RealmOne\0"); - fake_realm_list.extend_from_slice(b"127.0.0.1:8085\0"); // original target - fake_realm_list.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]); // Population - fake_realm_list.extend_from_slice(&[0x01]); // Num characters - fake_realm_list.extend_from_slice(&[0x01]); // Timezone - fake_realm_list.extend_from_slice(&[0x00]); // Realm ID - fake_realm_list.extend_from_slice(&[0x02, 0x00]); // Footer + let name_bytes = b"RealmOne\0"; + let addr_bytes = b"127.0.0.1:8085\0"; + let body_len = 4 + 2 + 3 + name_bytes.len() + addr_bytes.len() + 4 + 1 + 1 + 1 + 2; - let body_len = (fake_realm_list.len() - 3) as u16; - fake_realm_list[1..3].copy_from_slice(&body_len.to_le_bytes()); + let mut fake_realm_list = Vec::new(); + fake_realm_list.push(0x10); // Opcode + fake_realm_list.extend_from_slice(&(body_len as u16).to_le_bytes()); // Length + fake_realm_list.extend_from_slice(&0u32.to_le_bytes()); // Unused + fake_realm_list.extend_from_slice(&1u16.to_le_bytes()); // Realm count = 1 + + // Realm info: + fake_realm_list.extend_from_slice(&[1, 0, 0]); // type, lock, flag + fake_realm_list.extend_from_slice(name_bytes); + fake_realm_list.extend_from_slice(addr_bytes); + fake_realm_list.extend_from_slice(&[0, 0, 0, 0]); // pop + fake_realm_list.extend_from_slice(&[0]); // chars + fake_realm_list.extend_from_slice(&[1]); // timezone + fake_realm_list.extend_from_slice(&[1]); // realm id + + // Footer: + fake_realm_list.extend_from_slice(&[0x10, 0x00]); stream.write_all(&fake_realm_list).unwrap(); let _ = stream.shutdown(std::net::Shutdown::Write); @@ -386,7 +415,7 @@ mod tests { let mock_world_port = mock_world.local_addr().unwrap().port(); // DirectIngress binds to ephemeral ports (0, 0), so actual ingress port != 8085 - let ingress = DirectIngress::start( + let mut ingress = DirectIngress::start( 0, 0, "198.51.100.1".to_string(), @@ -415,25 +444,27 @@ mod tests { let mut buf = [0u8; 16]; let _ = stream.read(&mut buf).unwrap(); - let mut fake_realm_list = vec![ - 0x10, // Opcode CMD_REALM_LIST - 0x00, 0x00, // Size placeholder - 0x00, 0x00, 0x00, 0x00, // Unused - 0x01, 0x00, // Realm count: 1 - 0x01, 0x00, 0x00, 0x00, // Icon - 0x00, // Lock - 0x00, // Flags - ]; - fake_realm_list.extend_from_slice(b"RealmOne\0"); - fake_realm_list.extend_from_slice(b"127.0.0.1:8085\0"); - fake_realm_list.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]); - fake_realm_list.extend_from_slice(&[0x01]); - fake_realm_list.extend_from_slice(&[0x01]); - fake_realm_list.extend_from_slice(&[0x00]); - fake_realm_list.extend_from_slice(&[0x02, 0x00]); + let name_bytes = b"RealmOne\0"; + let addr_bytes = b"127.0.0.1:8085\0"; + let body_len = 4 + 2 + 3 + name_bytes.len() + addr_bytes.len() + 4 + 1 + 1 + 1 + 2; - let body_len = (fake_realm_list.len() - 3) as u16; - fake_realm_list[1..3].copy_from_slice(&body_len.to_le_bytes()); + let mut fake_realm_list = Vec::new(); + fake_realm_list.push(0x10); // Opcode + fake_realm_list.extend_from_slice(&(body_len as u16).to_le_bytes()); // Length + fake_realm_list.extend_from_slice(&0u32.to_le_bytes()); // Unused + fake_realm_list.extend_from_slice(&1u16.to_le_bytes()); // Realm count = 1 + + // Realm info: + fake_realm_list.extend_from_slice(&[1, 0, 0]); // type, lock, flag + fake_realm_list.extend_from_slice(name_bytes); + fake_realm_list.extend_from_slice(addr_bytes); + fake_realm_list.extend_from_slice(&[0, 0, 0, 0]); // pop + fake_realm_list.extend_from_slice(&[0]); // chars + fake_realm_list.extend_from_slice(&[1]); // timezone + fake_realm_list.extend_from_slice(&[1]); // realm id + + // Footer: + fake_realm_list.extend_from_slice(&[0x10, 0x00]); stream.write_all(&fake_realm_list).unwrap(); let _ = stream.shutdown(std::net::Shutdown::Write); @@ -462,5 +493,84 @@ mod tests { drop(client_auth); t_auth.join().unwrap(); + ingress.stop(); + } + + #[test] + fn test_direct_ingress_wildcard_port_rewrites_to_mapped_port_and_never_advertises_coa_8085() { + let ext_wildcard_port = 48086; + + let mock_auth = TcpListener::bind("127.0.0.1:0").unwrap(); + let mock_auth_port = mock_auth.local_addr().unwrap().port(); + + let mock_world = TcpListener::bind("127.0.0.1:0").unwrap(); + let mock_world_port = mock_world.local_addr().unwrap().port(); + + // DirectIngress configured for Wildcard (local_world = mock_world_port, ext_world = 48086) + let mut ingress = DirectIngress::start( + 0, + 0, + "198.51.100.1".to_string(), + ext_wildcard_port, + mock_auth_port, + mock_world_port, + ) + .unwrap(); + + // Verify Auth rewrite rewrites to external port 48086 and never mentions 8085 or 8086 + let t_auth = std::thread::spawn(move || { + let (mut stream, _) = mock_auth.accept().unwrap(); + let mut buf = [0u8; 16]; + let _ = stream.read(&mut buf).unwrap(); + + let name_bytes = b"Wildcard\0"; + let addr_bytes = b"127.0.0.1:8086\0"; + let body_len = 4 + 2 + 3 + name_bytes.len() + addr_bytes.len() + 4 + 1 + 1 + 1 + 2; + + let mut fake_realm_list = Vec::new(); + fake_realm_list.push(0x10); // Opcode + fake_realm_list.extend_from_slice(&(body_len as u16).to_le_bytes()); // Length + fake_realm_list.extend_from_slice(&0u32.to_le_bytes()); // Unused + fake_realm_list.extend_from_slice(&1u16.to_le_bytes()); // Realm count = 1 + + // Realm info: + fake_realm_list.extend_from_slice(&[1, 0, 0]); // type, lock, flag + fake_realm_list.extend_from_slice(name_bytes); + fake_realm_list.extend_from_slice(addr_bytes); + fake_realm_list.extend_from_slice(&[0, 0, 0, 0]); // pop + fake_realm_list.extend_from_slice(&[0]); // chars + fake_realm_list.extend_from_slice(&[1]); // timezone + fake_realm_list.extend_from_slice(&[1]); // realm id + + // Footer: + fake_realm_list.extend_from_slice(&[0x10, 0x00]); + + stream.write_all(&fake_realm_list).unwrap(); + let _ = stream.shutdown(std::net::Shutdown::Write); + }); + + let mut client_auth = + TcpStream::connect(format!("127.0.0.1:{}", ingress.auth_port())).unwrap(); + client_auth.write_all(b"AUTH_HELLO").unwrap(); + let mut auth_buf = [0u8; 512]; + let an = client_auth.read(&mut auth_buf).unwrap(); + let payload = String::from_utf8_lossy(&auth_buf[..an]); + + assert!( + payload.contains("198.51.100.1:48086"), + "Expected rewritten realm list to contain external port 48086, got: {payload}" + ); + assert!( + !payload.contains("8085"), + "DirectIngress for Wildcard must never advertise CoA port 8085" + ); + assert!( + !payload.contains(":8086"), + "DirectIngress for Wildcard must rewrite internal port 8086 to external 48086" + ); + + drop(client_auth); + t_auth.join().unwrap(); + ingress.stop(); } } diff --git a/crates/coa-core/src/control/direct_route.rs b/crates/coa-core/src/control/direct_route.rs index 1fe707f..350625b 100644 --- a/crates/coa-core/src/control/direct_route.rs +++ b/crates/coa-core/src/control/direct_route.rs @@ -307,7 +307,7 @@ fn attempt_route_discovery( let local_world = std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT") .ok() .and_then(|p| p.parse().ok()) - .unwrap_or(coa_control_proto::relay::LOCAL_WORLD_PORT); + .unwrap_or_else(|| service.local_world_port()); let desired_auth_port: u16 = std::env::var("COA_DIRECT_AUTH_PORT") .ok() diff --git a/crates/coa-core/src/control/host_manager.rs b/crates/coa-core/src/control/host_manager.rs index efbbffd..66e17a0 100644 --- a/crates/coa-core/src/control/host_manager.rs +++ b/crates/coa-core/src/control/host_manager.rs @@ -98,10 +98,11 @@ impl HostControl { let relay_link = crate::control::transport::relay_url(&base, "/relay/v1/host").map( |r_url| { - let rl = crate::control::relay_link::RelayLink::start( + let rl = crate::control::relay_link::RelayLink::start_with_ports( r_url, realm_id, key.clone(), + Some(service.local_world_port()), ); service.set_relay(rl.clone()); rl diff --git a/crates/coa-core/src/control/join.rs b/crates/coa-core/src/control/join.rs index 754817e..8103fc0 100644 --- a/crates/coa-core/src/control/join.rs +++ b/crates/coa-core/src/control/join.rs @@ -115,6 +115,7 @@ pub struct AccountOutcome { #[derive(Debug, Clone)] pub struct Claimed { pub character_id: Uuid, + pub ruleset: String, pub payload: Vec, pub sha256: [u8; 32], pub collections: BTreeMap>, @@ -347,13 +348,14 @@ impl PlayerControl { pub fn claim(&self, ch: &mut PlayerChannel, token: u32) -> R { let r = ch.request(&Request::Claim { token })?; - let (character_id, sha256, payload, collections) = expect(r, |r| match r { + let (character_id, ruleset, sha256, payload, collections) = expect(r, |r| match r { Response::Claimed { character_id, + ruleset, sha256, payload, collections, - } => Ok((character_id, sha256, payload, collections)), + } => Ok((character_id, ruleset, sha256, payload, collections)), other => Err(other), })?; let payload = base64::engine::general_purpose::STANDARD @@ -373,6 +375,7 @@ impl PlayerControl { })?; Ok(Claimed { character_id, + ruleset, payload, sha256: hash, collections, diff --git a/crates/coa-core/src/control/relay_link.rs b/crates/coa-core/src/control/relay_link.rs index 801a2fe..e9e38e8 100644 --- a/crates/coa-core/src/control/relay_link.rs +++ b/crates/coa-core/src/control/relay_link.rs @@ -71,6 +71,15 @@ impl RelayProvider for RelayLink { impl RelayLink { pub fn start(url: String, realm_id: RealmId, key: SigningKey) -> Arc { + Self::start_with_ports(url, realm_id, key, None) + } + + pub fn start_with_ports( + url: String, + realm_id: RealmId, + key: SigningKey, + local_world_port: Option, + ) -> Arc { let stop = Arc::new(AtomicBool::new(false)); let status = Arc::new(Mutex::new(RelayStatus::default())); let (alloc_tx, alloc_rx) = channel(); @@ -79,7 +88,7 @@ impl RelayLink { let st = status.clone(); let join = std::thread::Builder::new() .name("control-relay-host".into()) - .spawn(move || run(&url, realm_id, &key, alloc_rx, &s, &st)) + .spawn(move || run(&url, realm_id, &key, alloc_rx, &s, &st, local_world_port)) .ok(); Arc::new(RelayLink { @@ -127,11 +136,12 @@ fn run( )>, stop: &AtomicBool, status: &Mutex, + local_world_port: Option, ) { let mut failures = 0u32; while !stop.load(Ordering::SeqCst) { let began = Instant::now(); - let result = session(url, realm, key, &alloc_rx, stop, status); + let result = session(url, realm, key, &alloc_rx, stop, status, local_world_port); set_status(status, |s| { s.connected = false; s.active_streams = 0; @@ -176,6 +186,7 @@ fn session( )>, stop: &AtomicBool, status: &Mutex, + local_world_port: Option, ) -> Result<(), LinkError> { let mut ws = transport::connect(url, POLL)?; @@ -305,8 +316,13 @@ fn session( TunnelMsg::Connect { stream_id, target, .. } => { - // Strictly predefined local targets: Auth (3724) or World (8085) - let local_port = target.local_port(); + // Strictly predefined local targets: Auth (3724) or World (8085 or bound realm world port) + let local_port = match target { + RelayTarget::Auth => target.local_port(), + RelayTarget::World => { + local_world_port.unwrap_or_else(|| target.local_port()) + } + }; match TcpStream::connect(("127.0.0.1", local_port)) { Ok(tcp) => { let (stream_tx, stream_rx) = channel::(); diff --git a/crates/coa-core/src/control/service.rs b/crates/coa-core/src/control/service.rs index 27cbf6f..26f68b4 100644 --- a/crates/coa-core/src/control/service.rs +++ b/crates/coa-core/src/control/service.rs @@ -56,6 +56,7 @@ pub struct CharInfo { #[derive(Clone, Debug, PartialEq, Eq)] pub struct ClaimExport { pub character_id: Uuid, + pub ruleset: crate::portable::Ruleset, pub payload: Vec, pub sha256: [u8; 32], pub collections: BTreeMap>, @@ -119,6 +120,10 @@ pub trait RealmBackend: Send + Sync { local_id: &str, params: RemoteImportParams, ) -> Result; + /// Local world port for this realm. + fn world_port(&self, _local_id: &str) -> Result { + Ok(8085) + } } /// State of one channel. @@ -219,6 +224,10 @@ impl HostService { self.realm_id } + pub fn local_world_port(&self) -> u16 { + self.backend.world_port(&self.local_id).unwrap_or(8085) + } + /// The player's public key is the one recorded for this player id when there is a record; `None` when the player is new here. pub fn key_matches(&self, player: &Uuid, public_key: &str) -> bool { match self @@ -694,6 +703,7 @@ impl HostService { use base64::Engine; Response::Claimed { character_id: exported.character_id, + ruleset: exported.ruleset.as_str().to_string(), sha256: hex::encode(exported.sha256), payload: base64::engine::general_purpose::STANDARD.encode(&exported.payload), collections: exported.collections, @@ -862,6 +872,7 @@ impl HostService { realm_local_id: self.local_id.clone(), transfer_id, character_id, + ruleset: offer_ruleset.as_str().to_string(), player_id: *player, revision: canonical_revision, content_hash, @@ -1036,18 +1047,55 @@ impl HostService { Err(e) => return unavailable("reading transfer file", &Error::Invalid(e.to_string())), }; - use sha2::{Digest, Sha256}; - let hash = hex::encode(Sha256::digest(&payload)); - if hash != t.content_hash { - let _ = std::fs::remove_file(&path); - return err(AppError::Invalid, "Content hash mismatch."); - } - let mut hash_bytes = [0u8; 32]; if hex::decode_to_slice(&t.content_hash, &mut hash_bytes).is_err() { + let _ = std::fs::remove_file(&path); return err(AppError::Invalid, "Invalid content hash format."); } + let decoded = match crate::portable::snapshot::decode(&payload, Some(&hash_bytes)) { + Ok(d) => d, + Err(e) => { + let _ = std::fs::remove_file(&path); + return err(AppError::Invalid, &format!("Corrupt snapshot: {e}")); + } + }; + let transfer_ruleset: crate::portable::Ruleset = match t.ruleset.parse() { + Ok(r) => r, + Err(_) => { + let _ = std::fs::remove_file(&path); + return err(AppError::Incompatible, "Invalid transfer ruleset."); + } + }; + if decoded.character_id.as_uuid() != t.character_id { + let _ = std::fs::remove_file(&path); + return err( + AppError::Invalid, + "Snapshot character id does not match TransferOffer.", + ); + } + if decoded.ruleset != transfer_ruleset { + let _ = std::fs::remove_file(&path); + return err( + AppError::Incompatible, + "Snapshot ruleset does not match TransferOffer.", + ); + } + let info = match self.backend.info(&self.local_id) { + Ok(i) => i, + Err(e) => { + let _ = std::fs::remove_file(&path); + return unavailable("reading realm info", &e); + } + }; + if transfer_ruleset != info.ruleset { + let _ = std::fs::remove_file(&path); + return err( + AppError::Incompatible, + "Transfer ruleset does not match target realm ruleset.", + ); + } + let Some(m) = self.mapping(player) else { return err(AppError::NoAccount, "Player has no account on this realm."); }; @@ -1275,6 +1323,7 @@ pub mod fake { .or_insert_with(Uuid::now_v7); Ok(ClaimExport { character_id: id, + ruleset: crate::portable::Ruleset::Coa, payload: format!("payload-{guid}").into_bytes(), sha256: [7; 32], collections: BTreeMap::from([("coa:appearance".to_string(), vec![1, 2, 3])]), @@ -1685,6 +1734,7 @@ mod tests { ); let Response::Claimed { character_id, + ruleset, sha256, payload, collections, @@ -1692,6 +1742,7 @@ mod tests { else { panic!() }; + assert_eq!(ruleset, "coa"); assert_eq!(sha256, hex::encode([7u8; 32])); assert!(!payload.is_empty() && collections["coa:appearance"] == vec![1, 2, 3]); // asking again returns the same character @@ -1887,6 +1938,14 @@ mod tests { ); } + fn test_snapshot(cid: Uuid, ruleset: crate::portable::Ruleset) -> (Vec, String) { + let mut model = crate::portable::fixtures::geared_level_eighty(); + model.character_id = crate::portable::CharacterId::from_uuid(cid).unwrap(); + model.ruleset = ruleset; + let encoded = crate::portable::snapshot::encode(&model).unwrap(); + (encoded.payload, hex::encode(encoded.content_hash)) + } + #[test] fn remote_transfer_lifecycle_empty_realm_import_and_ack() { let (realm, s, p, _acc) = claimed_setup(); @@ -1894,9 +1953,7 @@ mod tests { let cid = Uuid::now_v7(); let tid = Uuid::now_v7(); - let payload = b"portable_character_snapshot_payload_test_data".to_vec(); - use sha2::{Digest, Sha256}; - let hash = hex::encode(Sha256::digest(&payload)); + let (payload, hash) = test_snapshot(cid, crate::portable::Ruleset::Coa); // 1. Offer let offer = Request::TransferOffer { @@ -2005,13 +2062,9 @@ mod tests { let cid = Uuid::now_v7(); let tid = Uuid::now_v7(); - let chunk1 = b"first_chunk_of_payload_"; - let chunk2 = b"second_chunk_of_payload"; - let mut full = chunk1.to_vec(); - full.extend_from_slice(chunk2); - - use sha2::{Digest, Sha256}; - let hash = hex::encode(Sha256::digest(&full)); + let (full, hash) = test_snapshot(cid, crate::portable::Ruleset::Coa); + let mid = full.len() / 2; + let (chunk1, chunk2) = full.split_at(mid); let offer = Request::TransferOffer { ruleset: "coa".into(), @@ -2104,9 +2157,7 @@ mod tests { let cid = Uuid::now_v7(); let tid = Uuid::now_v7(); - let payload = b"idempotency_test_payload".to_vec(); - use sha2::{Digest, Sha256}; - let hash = hex::encode(Sha256::digest(&payload)); + let (payload, hash) = test_snapshot(cid, crate::portable::Ruleset::Coa); let offer = Request::TransferOffer { ruleset: "coa".into(), @@ -2204,9 +2255,7 @@ mod tests { let cid = Uuid::now_v7(); let tid = Uuid::now_v7(); - let payload = b"player_1_character_data".to_vec(); - use sha2::{Digest, Sha256}; - let hash = hex::encode(Sha256::digest(&payload)); + let (payload, hash) = test_snapshot(cid, crate::portable::Ruleset::Coa); let offer = Request::TransferOffer { ruleset: "coa".into(), @@ -2304,9 +2353,7 @@ mod tests { let cid = Uuid::now_v7(); let tid1 = Uuid::now_v7(); - let payload1 = b"character_revision_1_data".to_vec(); - use sha2::{Digest, Sha256}; - let hash1 = hex::encode(Sha256::digest(&payload1)); + let (payload1, hash1) = test_snapshot(cid, crate::portable::Ruleset::Coa); // Rev 1 s.handle( @@ -2359,8 +2406,12 @@ mod tests { // Rev 2 let tid2 = Uuid::now_v7(); - let payload2 = b"character_revision_2_newer_data".to_vec(); - let hash2 = hex::encode(Sha256::digest(&payload2)); + let mut model2 = crate::portable::fixtures::geared_level_eighty(); + model2.character_id = crate::portable::CharacterId::from_uuid(cid).unwrap(); + model2.progression.money += 500; + let enc2 = crate::portable::snapshot::encode(&model2).unwrap(); + let (payload2, hash2) = (enc2.payload, hex::encode(enc2.content_hash)); + let r = s.handle( &mut session, &p, @@ -2484,4 +2535,122 @@ mod tests { // Ensure 0 DB imports happened assert!(realm.imported.lock().unwrap().is_empty()); } + + #[test] + fn tampered_payload_at_commit_aborts_with_zero_mutation() { + let (realm, s, p, _acc) = claimed_setup(); + let mut session = Session::default(); + let cid = Uuid::now_v7(); + let tid = Uuid::now_v7(); + + // 1. Offer announces CoA + let (payload_coa, hash_coa) = test_snapshot(cid, crate::portable::Ruleset::Coa); + let offer = Request::TransferOffer { + ruleset: "coa".into(), + transfer_id: tid, + character_id: cid, + canonical_revision: 1, + content_hash: hash_coa, + total_size: payload_coa.len(), + collections: BTreeMap::new(), + }; + s.handle(&mut session, &p, "K", offer); + + // Attacker creates a Wildcard snapshot with the same CID, but uploads it under the CoA offer + let (payload_wc, hash_wc) = test_snapshot(cid, crate::portable::Ruleset::Wildcard); + + // Uploading chunks of payload_wc will mismatch the offered hash + use base64::Engine; + let data = base64::engine::general_purpose::STANDARD.encode(&payload_wc); + s.handle( + &mut session, + &p, + "K", + Request::TransferChunk { + transfer_id: tid, + offset: 0, + data, + }, + ); + let commit = Request::TransferCommit { transfer_id: tid }; + let r = s.handle(&mut session, &p, "K", commit); + assert!(matches!( + r, + Response::Error { + code: AppError::Invalid, + .. + } + )); + assert!(realm.imported.lock().unwrap().is_empty()); + + // 2. What if attacker offered hash_wc matching payload_wc, but offer.ruleset is "coa"? + let tid2 = Uuid::now_v7(); + let offer2 = Request::TransferOffer { + ruleset: "coa".into(), + transfer_id: tid2, + character_id: cid, + canonical_revision: 1, + content_hash: hash_wc, + total_size: payload_wc.len(), + collections: BTreeMap::new(), + }; + s.handle(&mut session, &p, "K", offer2); + let data2 = base64::engine::general_purpose::STANDARD.encode(&payload_wc); + s.handle( + &mut session, + &p, + "K", + Request::TransferChunk { + transfer_id: tid2, + offset: 0, + data: data2, + }, + ); + let commit2 = Request::TransferCommit { transfer_id: tid2 }; + let r2 = s.handle(&mut session, &p, "K", commit2); + assert!(matches!( + r2, + Response::Error { + code: AppError::Incompatible, + .. + } + )); + assert!(realm.imported.lock().unwrap().is_empty()); + + // 3. What if snapshot contains a different character_id than offer? + let tid3 = Uuid::now_v7(); + let other_cid = Uuid::now_v7(); + let (payload_other, hash_other) = test_snapshot(other_cid, crate::portable::Ruleset::Coa); + let offer3 = Request::TransferOffer { + ruleset: "coa".into(), + transfer_id: tid3, + character_id: cid, // offered cid + canonical_revision: 1, + content_hash: hash_other, + total_size: payload_other.len(), + collections: BTreeMap::new(), + }; + s.handle(&mut session, &p, "K", offer3); + let data3 = base64::engine::general_purpose::STANDARD.encode(&payload_other); + s.handle( + &mut session, + &p, + "K", + Request::TransferChunk { + transfer_id: tid3, + offset: 0, + data: data3, + }, + ); + let commit3 = Request::TransferCommit { transfer_id: tid3 }; + let r3 = s.handle(&mut session, &p, "K", commit3); + assert!(matches!( + r3, + Response::Error { + code: AppError::Invalid, + .. + } + )); + assert!(realm.imported.lock().unwrap().is_empty()); + } } diff --git a/crates/coa-core/src/control/store.rs b/crates/coa-core/src/control/store.rs index b6564c5..fc336d3 100644 --- a/crates/coa-core/src/control/store.rs +++ b/crates/coa-core/src/control/store.rs @@ -56,6 +56,7 @@ CREATE TABLE IF NOT EXISTS host_transfer( realm_local_id TEXT NOT NULL, transfer_id TEXT NOT NULL PRIMARY KEY, character_id TEXT NOT NULL, + ruleset TEXT NOT NULL DEFAULT 'coa', player_id TEXT NOT NULL, revision INTEGER NOT NULL, content_hash TEXT NOT NULL, @@ -155,6 +156,7 @@ pub struct HostTransfer { pub realm_local_id: String, pub transfer_id: Uuid, pub character_id: Uuid, + pub ruleset: String, pub player_id: Uuid, pub revision: u64, pub content_hash: String, @@ -199,6 +201,7 @@ impl ControlStore { .map_err(db)?; let _ = conn.pragma_update(None, "journal_mode", "WAL"); conn.execute_batch(SCHEMA).map_err(db)?; + let _ = conn.execute("ALTER TABLE host_transfer ADD COLUMN ruleset TEXT NOT NULL DEFAULT 'coa'", []); Ok(Self { conn }) } @@ -307,7 +310,7 @@ impl ControlStore { pub fn host_transfer(&self, realm: &str, transfer_id: &Uuid) -> Result> { self.conn .query_row( - "SELECT realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections FROM host_transfer WHERE realm_local_id = ?1 AND transfer_id = ?2", + "SELECT realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections, ruleset FROM host_transfer WHERE realm_local_id = ?1 AND transfer_id = ?2", params![realm, transfer_id.to_string()], row_transfer, ) @@ -323,7 +326,7 @@ impl ControlStore { ) -> Result> { self.conn .query_row( - "SELECT realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections FROM host_transfer WHERE realm_local_id = ?1 AND character_id = ?2 ORDER BY updated_at DESC LIMIT 1", + "SELECT realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections, ruleset FROM host_transfer WHERE realm_local_id = ?1 AND character_id = ?2 ORDER BY updated_at DESC LIMIT 1", params![realm, character_id.to_string()], row_transfer, ) @@ -337,8 +340,8 @@ impl ControlStore { let coll_json = serde_json::to_string(&t.collections).unwrap_or_default(); self.conn .execute( - "INSERT INTO host_transfer(realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections, created_at, updated_at) - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16) + "INSERT INTO host_transfer(realm_local_id, transfer_id, character_id, ruleset, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections, created_at, updated_at) + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17) ON CONFLICT(transfer_id) DO UPDATE SET received_size = excluded.received_size, state = excluded.state, @@ -347,11 +350,13 @@ impl ControlStore { projected_level = excluded.projected_level, notes = excluded.notes, collections = excluded.collections, + ruleset = excluded.ruleset, updated_at = excluded.updated_at", params![ t.realm_local_id, t.transfer_id.to_string(), t.character_id.to_string(), + t.ruleset, t.player_id.to_string(), t.revision as i64, t.content_hash, @@ -540,11 +545,13 @@ fn row_transfer(r: &rusqlite::Row<'_>) -> rusqlite::Result> let collections = coll_str .and_then(|s| serde_json::from_str::>>(&s).ok()) .unwrap_or_default(); + let ruleset: String = r.get(14).unwrap_or_else(|_| "coa".to_string()); Ok((|| { Ok(HostTransfer { realm_local_id, transfer_id: uuid(tid)?, character_id: uuid(cid)?, + ruleset, player_id: uuid(pid)?, revision: revision as u64, content_hash, @@ -677,6 +684,7 @@ mod tests { realm_local_id: "live".into(), transfer_id: t, character_id: c, + ruleset: "coa".into(), player_id: p, revision: 3, content_hash: "a".repeat(64), diff --git a/crates/coa-core/src/portable/mod.rs b/crates/coa-core/src/portable/mod.rs index 0cb250a..17cf57d 100644 --- a/crates/coa-core/src/portable/mod.rs +++ b/crates/coa-core/src/portable/mod.rs @@ -23,8 +23,8 @@ pub mod snapshot; pub mod store; pub mod versions; -#[cfg(test)] -pub(crate) mod fixtures; +#[cfg(any(test, feature = "testkit"))] +pub mod fixtures; pub use collection::IdSet; pub use error::{PortableError, Result}; diff --git a/crates/coa-core/src/portable/model.rs b/crates/coa-core/src/portable/model.rs index f99d554..97f811e 100644 --- a/crates/coa-core/src/portable/model.rs +++ b/crates/coa-core/src/portable/model.rs @@ -112,6 +112,14 @@ impl Ruleset { } } +impl std::str::FromStr for Ruleset { + type Err = PortableError; + + fn from_str(s: &str) -> Result { + Self::parse(s) + } +} + impl std::fmt::Display for Ruleset { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.write_str(self.as_str()) diff --git a/crates/coa-core/src/portable/service/engine.rs b/crates/coa-core/src/portable/service/engine.rs index 2a5da21..cd59d5c 100644 --- a/crates/coa-core/src/portable/service/engine.rs +++ b/crates/coa-core/src/portable/service/engine.rs @@ -364,11 +364,26 @@ impl PortableService { pub fn reload_realms(&mut self) { let (descriptors, broken) = access::load_descriptors(&self.dir.join("realms")); self.broken_descriptors = broken; - let mut realms: Vec = self - .installs - .iter() - .map(|(id, root)| RealmAccess::from_install(id, root)) - .collect(); + let mut realms: Vec = Vec::new(); + for (id, root) in &self.installs { + realms.push(RealmAccess::from_install(id, root)); + if let Ok(state) = crate::realms::state(root) { + if state.wildcard_created { + let mut wc = RealmAccess::from_install(id, root); + wc.id = format!("srv-{id}:wildcard"); + wc.name = format!("{} — Wildcard", wc.name); + wc.mode = Some(crate::realms::Mode::Wildcard); + realms.push(wc); + } + if state.reborn_created { + let mut rb = RealmAccess::from_install(id, root); + rb.id = format!("srv-{id}:reborn"); + rb.name = format!("{} — Warcraft Reborn", rb.name); + rb.mode = Some(crate::realms::Mode::Reborn); + realms.push(rb); + } + } + } for d in descriptors { match RealmAccess::from_descriptor(d) { Ok(a) if !realms.iter().any(|r| r.id == a.id) => realms.push(a), @@ -415,10 +430,10 @@ impl PortableService { } fn access(&self, id: &str) -> Res { - self.realms - .iter() - .find(|r| r.id == id) - .cloned() + if let Some(r) = self.realms.iter().find(|r| r.id == id) { + return Ok(r.clone()); + } + crate::realm_registry::advert::find_access(&self.dir.join("realms"), &self.installs, id) .ok_or_else(|| fail("realm_missing", "That realm is not known to this Manager.")) } @@ -1475,12 +1490,20 @@ impl PortableService { )); } let ruleset = model.ruleset; + for kind in collections.keys() { + if !super::super::session::protocol::carried_kind_for(kind, ruleset) { + return Err(fail( + "incompatible", + format!("Foreign collection kind {kind:?} in {ruleset} claim"), + )); + } + } if self.owner.character(character_id).is_err() { self.owner .create_character_with_id(self.owner_profile, model, realm_id)?; } for (kind, ids) in collections { - if kind.starts_with(ruleset.as_str()) { + if super::super::session::protocol::carried_kind_for(kind, ruleset) { let set = super::super::collection::IdSet::from_ids(ids.iter().copied())?; self.owner .merge_collection(self.owner_profile, ruleset, kind, &set)?; @@ -1626,12 +1649,16 @@ impl PortableService { // Monotonic union of collections for (kind, ids) in ¶ms.collections { - if kind.starts_with(model.ruleset.as_str()) { - if let Ok(set) = super::super::collection::IdSet::from_ids(ids.iter().copied()) { - let _ = - self.host - .merge_collection(self.host_profile, model.ruleset, kind, &set); - } + if !super::super::session::protocol::carried_kind_for(kind, model.ruleset) { + return Err(fail( + "incompatible", + format!("Foreign collection kind {kind:?} in {} remote transfer", model.ruleset), + )); + } + if let Ok(set) = super::super::collection::IdSet::from_ids(ids.iter().copied()) { + let _ = + self.host + .merge_collection(self.host_profile, model.ruleset, kind, &set); } } diff --git a/crates/coa-core/src/portable/session/collection_tests.rs b/crates/coa-core/src/portable/session/collection_tests.rs index 2d572bb..9b2c6ac 100644 --- a/crates/coa-core/src/portable/session/collection_tests.rs +++ b/crates/coa-core/src/portable/session/collection_tests.rs @@ -771,3 +771,99 @@ fn a_session_that_changes_nothing_on_a_format_1_store_makes_no_new_revision() { "the same character in a newer format is not a change" ); } + +#[test] +fn wildcard_and_coa_collections_remain_strictly_isolated() { + let mut owner = Store::open_in_memory().unwrap(); + let profile = owner.default_profile().unwrap(); + + let coa_set = IdSet::from_ids([10, 20, 30]).unwrap(); + let wc_set = IdSet::from_ids([10, 40, 50]).unwrap(); + + owner + .merge_collection(profile, Ruleset::Coa, "coa:appearance", &coa_set) + .unwrap(); + owner + .merge_collection(profile, Ruleset::Wildcard, "wildcard:appearance", &wc_set) + .unwrap(); + + // Verify initial namespaces + let (_, s_coa) = owner + .collection(profile, Ruleset::Coa, "coa:appearance") + .unwrap() + .unwrap(); + assert_eq!(s_coa.ids(), &[10, 20, 30]); + + let (_, s_wc) = owner + .collection(profile, Ruleset::Wildcard, "wildcard:appearance") + .unwrap() + .unwrap(); + assert_eq!(s_wc.ids(), &[10, 40, 50]); + + let mut o = OwnerService::new(&mut owner); + + // 1. Valid Wildcard observation updates Wildcard collection only + let wc_update = IdSet::from_ids([10, 40, 50, 60]).unwrap(); + let msg_wc = CollectionObserved { + protocol_version: COLLECTION_PROTOCOL_VERSION, + ruleset: Ruleset::Wildcard, + server_id: "wc-realm".into(), + kind: "wildcard:appearance".into(), + set: CompactSet::seal("wildcard:appearance", &wc_update).unwrap(), + }; + let ack = o.handle_collection(&to_json(&msg_wc).unwrap()).unwrap(); + assert!(matches!(ack.outcome, CollectionOutcome::Applied | CollectionOutcome::Unchanged)); + + // CoA remains exactly [10, 20, 30] + let (_, s_coa_after) = o + .store() + .collection(profile, Ruleset::Coa, "coa:appearance") + .unwrap() + .unwrap(); + assert_eq!(s_coa_after.ids(), &[10, 20, 30]); + + // Wildcard updated to [10, 40, 50, 60] + let (_, s_wc_after) = o + .store() + .collection(profile, Ruleset::Wildcard, "wildcard:appearance") + .unwrap() + .unwrap(); + assert_eq!(s_wc_after.ids(), &[10, 40, 50, 60]); + + // 2. Cross-ruleset injection attack: Wildcard message carrying coa:appearance is rejected + let rogue_wc = CollectionObserved { + protocol_version: COLLECTION_PROTOCOL_VERSION, + ruleset: Ruleset::Wildcard, + server_id: "wc-realm".into(), + kind: "coa:appearance".into(), + set: CompactSet::seal("coa:appearance", &IdSet::from_ids([999]).unwrap()).unwrap(), + }; + let ack_rogue = o.handle_collection(&to_json(&rogue_wc).unwrap()).unwrap(); + assert!(matches!(ack_rogue.outcome, CollectionOutcome::Rejected(_))); + + // 3. Cross-ruleset injection attack: CoA message carrying wildcard:appearance is rejected + let rogue_coa = CollectionObserved { + protocol_version: COLLECTION_PROTOCOL_VERSION, + ruleset: Ruleset::Coa, + server_id: "coa-realm".into(), + kind: "wildcard:appearance".into(), + set: CompactSet::seal("wildcard:appearance", &IdSet::from_ids([999]).unwrap()).unwrap(), + }; + let ack_rogue2 = o.handle_collection(&to_json(&rogue_coa).unwrap()).unwrap(); + assert!(matches!(ack_rogue2.outcome, CollectionOutcome::Rejected(_))); + + // Verify neither 999 touched CoA or Wildcard + let (_, s_coa_final) = o + .store() + .collection(profile, Ruleset::Coa, "coa:appearance") + .unwrap() + .unwrap(); + assert_eq!(s_coa_final.ids(), &[10, 20, 30]); + + let (_, s_wc_final) = o + .store() + .collection(profile, Ruleset::Wildcard, "wildcard:appearance") + .unwrap() + .unwrap(); + assert_eq!(s_wc_final.ids(), &[10, 40, 50, 60]); +} diff --git a/crates/coa-core/src/portable/session/fake.rs b/crates/coa-core/src/portable/session/fake.rs index 868380c..a634f69 100644 --- a/crates/coa-core/src/portable/session/fake.rs +++ b/crates/coa-core/src/portable/session/fake.rs @@ -467,16 +467,16 @@ impl RealmBridge for FakeRealm { impl FakeRealm { fn rows(&self, kind: &str) -> Result<&IdSet> { match kind { - "coa:appearance" => Ok(&self.appearance_rows), - "coa:vanity" => Ok(&self.vanity_rows), + "coa:appearance" | "wildcard:appearance" | "reborn:appearance" => Ok(&self.appearance_rows), + "coa:vanity" | "wildcard:vanity" | "reborn:vanity" => Ok(&self.vanity_rows), other => Err(PortableError::Invalid(format!("unknown kind {other}"))), } } fn rows_mut(&mut self, kind: &str) -> Result<&mut IdSet> { match kind { - "coa:appearance" => Ok(&mut self.appearance_rows), - "coa:vanity" => Ok(&mut self.vanity_rows), + "coa:appearance" | "wildcard:appearance" | "reborn:appearance" => Ok(&mut self.appearance_rows), + "coa:vanity" | "wildcard:vanity" | "reborn:vanity" => Ok(&mut self.vanity_rows), other => Err(PortableError::Invalid(format!("unknown kind {other}"))), } } diff --git a/crates/coa-core/src/portable/session/tests.rs b/crates/coa-core/src/portable/session/tests.rs index 464c12c..72c2b4f 100644 --- a/crates/coa-core/src/portable/session/tests.rs +++ b/crates/coa-core/src/portable/session/tests.rs @@ -4,6 +4,7 @@ use super::bridge::*; use super::fake::*; use super::protocol::*; use super::*; +use crate::portable::error::PortableError; use crate::portable::fixtures::geared_level_eighty; use crate::portable::ids::{CharacterId, PortableItemId, SessionId}; use crate::portable::model::*; @@ -1051,3 +1052,298 @@ fn an_autosave_between_checkpoints_is_harmless() { c0.progression.money + 10 ); } + +fn setup_wildcard_in(mut owner: Store, mut host: Store, server_id: &str) -> Setup { + let profile = owner.default_profile().unwrap(); + let mut model = geared_level_eighty(); + model.ruleset = Ruleset::Wildcard; + model.content_namespace = "wildcard".into(); + let id = owner + .create_character(profile, model, "wildcard-origin") + .unwrap(); + let c0 = owner.load_current(id).unwrap(); + let offer = OwnerService::new(&mut owner).offer(id, server_id).unwrap(); + let host_profile = host.default_profile().unwrap(); + let mut realm = FakeRealm::new(GUID); + realm.normalize = normalizes; + { + let mut h = HostService::new(&mut host, server_id, HostConfig::default()); + h.accept_offer(host_profile, &offer).unwrap(); + realm + .import( + &mut host, + id, + server_id, + offer.canonical_revision, + offer.session_id, + ) + .unwrap(); + HostService::new(&mut host, server_id, HostConfig::default()) + .bind(offer.session_id, GUID) + .unwrap(); + } + Setup { + owner, + host, + realm, + id, + session: offer.session_id, + c0, + } +} + +#[test] +fn wildcard_session_offer_carrying_coa_snapshot_is_rejected_with_zero_mutation() { + let mut owner = Store::open_in_memory().unwrap(); + let mut host = Store::open_in_memory().unwrap(); + let profile = owner.default_profile().unwrap(); + let host_profile = host.default_profile().unwrap(); + + let coa_model = geared_level_eighty(); + let id = owner.create_character(profile, coa_model, "realm-a").unwrap(); + let mut offer = OwnerService::new(&mut owner).offer(id, "srv-1:wildcard").unwrap(); + // Tamper offer: claim it is Wildcard while snapshot is CoA + offer.ruleset = Ruleset::Wildcard; + + let mut h = HostService::new(&mut host, "srv-1:wildcard", HostConfig::default()); + let res = h.accept_offer(host_profile, &offer); + assert!(matches!( + res, + Err(PortableError::RulesetMismatch { + character: Ruleset::Coa, + realm: Ruleset::Wildcard + }) + )); + // Zero mutation on host + assert!(host.character(id).is_err()); + assert!(host.host_session(offer.session_id).unwrap().is_none()); +} + +#[test] +fn wildcard_portable_session_started_marked_coa_is_rejected() { + let Setup { + mut owner, + mut host, + mut realm, + session, + .. + } = setup_wildcard_in( + Store::open_in_memory().unwrap(), + Store::open_in_memory().unwrap(), + "srv-1:wildcard", + ); + let mut h = HostService::new(&mut host, "srv-1:wildcard", HostConfig::default()); + let mut o = OwnerService::new(&mut owner); + + realm.login(); + h.tick(&mut realm, 0).unwrap(); + let outbox = h.outbox().unwrap(); + assert_eq!(outbox.len(), 1); + let mut started: PortableSessionStarted = from_json(&outbox[0].bytes).unwrap(); + // Tamper: mark as CoA + started.ruleset = Ruleset::Coa; + let tampered_bytes = to_json(&started).unwrap(); + + let ack = o.handle_started(&tampered_bytes).unwrap(); + assert!(matches!(ack.outcome, AckOutcome::Rejected(_))); + // Owner session remains offered, never open + let (state, _, _) = o.session(session).unwrap().unwrap(); + assert_eq!(state, "offered"); +} + +#[test] +fn wildcard_checkpoint_marked_reborn_is_rejected() { + let Setup { + mut owner, + mut host, + mut realm, + id, + .. + } = setup_wildcard_in( + Store::open_in_memory().unwrap(), + Store::open_in_memory().unwrap(), + "srv-1:wildcard", + ); + let mut h = HostService::new(&mut host, "srv-1:wildcard", HostConfig::default()); + let mut o = OwnerService::new(&mut owner); + + start(&mut h, &mut o, &mut realm); + realm.play(|m| m.progression.money += 500); + h.tick(&mut realm, 100).unwrap(); + h.tick(&mut realm, 101).unwrap(); + let outbox = h.outbox().unwrap(); + let checkpoint_msg = outbox.iter().find(|m| !m.started).unwrap(); + let mut cp: PortableCheckpoint = from_json(&checkpoint_msg.bytes).unwrap(); + // Tamper: mark as Reborn + cp.ruleset = Ruleset::Reborn; + let tampered_bytes = to_json(&cp).unwrap(); + + let initial_rev = o.store().character(id).unwrap().revision; + let initial_snapshot = o.store().load_snapshot(id, initial_rev).unwrap(); + let ack = o.handle_checkpoint(&tampered_bytes).unwrap(); + assert!(matches!(ack.outcome, AckOutcome::Rejected(_))); + // Zero canonical revision change or mutation + assert_eq!(o.store().character(id).unwrap().revision, initial_rev); + assert_eq!( + o.store().load_snapshot(id, initial_rev).unwrap(), + initial_snapshot + ); +} + +#[test] +fn wildcard_session_using_coa_server_id_is_rejected() { + let mut owner = Store::open_in_memory().unwrap(); + let mut host = Store::open_in_memory().unwrap(); + let profile = owner.default_profile().unwrap(); + let host_profile = host.default_profile().unwrap(); + + let mut model = geared_level_eighty(); + model.ruleset = Ruleset::Wildcard; + let id = owner.create_character(profile, model, "wildcard-origin").unwrap(); + // Offer for srv-1:coa + let offer = OwnerService::new(&mut owner).offer(id, "srv-1:coa").unwrap(); + + // Host configured for Wildcard realm + let mut h = HostService::new(&mut host, "srv-1:wildcard", HostConfig::default()); + let res = h.accept_offer(host_profile, &offer); + assert!(matches!(res, Err(PortableError::Invalid(_)))); +} + +#[test] +fn same_character_id_with_foreign_ruleset_is_rejected() { + let mut owner = Store::open_in_memory().unwrap(); + let profile = owner.default_profile().unwrap(); + + let mut model = geared_level_eighty(); + model.ruleset = Ruleset::Wildcard; + let id = owner.create_character(profile, model.clone(), "srv-1:wildcard").unwrap(); + + // Tampered snapshot with same ID but Ruleset::Coa + let mut tampered = model.clone(); + tampered.character_id = id; + tampered.ruleset = Ruleset::Coa; + let res = owner.commit_snapshot(id, 1, tampered, "srv-1:wildcard", None); + assert!(matches!(res, Err(PortableError::RulesetChange { .. }))); +} + +#[test] +fn owner_ack_with_different_ruleset_is_rejected_by_host() { + let Setup { + mut owner, + mut host, + mut realm, + .. + } = setup_wildcard_in( + Store::open_in_memory().unwrap(), + Store::open_in_memory().unwrap(), + "srv-1:wildcard", + ); + let mut h = HostService::new(&mut host, "srv-1:wildcard", HostConfig::default()); + let mut o = OwnerService::new(&mut owner); + + realm.login(); + h.tick(&mut realm, 0).unwrap(); + let outbox = h.outbox().unwrap(); + let mut ack = o.handle_started(&outbox[0].bytes).unwrap(); + // Tamper ack ruleset to CoA + ack.ruleset = Ruleset::Coa; + + let res = h.receive_ack(&mut realm, &ack); + assert!(matches!( + res, + Err(PortableError::RulesetMismatch { + character: Ruleset::Wildcard, + realm: Ruleset::Coa + }) + )); +} + +#[test] +fn final_checkpoint_relabelled_coa_is_rejected() { + let Setup { + mut owner, + mut host, + mut realm, + id, + .. + } = setup_wildcard_in( + Store::open_in_memory().unwrap(), + Store::open_in_memory().unwrap(), + "srv-1:wildcard", + ); + let mut h = HostService::new(&mut host, "srv-1:wildcard", HostConfig::default()); + let mut o = OwnerService::new(&mut owner); + + start(&mut h, &mut o, &mut realm); + realm.play(|m| m.progression.money += 1000); + realm.logout(); + h.tick(&mut realm, 100).unwrap(); + h.tick(&mut realm, 101).unwrap(); + let outbox = h.outbox().unwrap(); + let final_cp_msg = outbox.iter().find(|m| !m.started).unwrap(); + let mut cp: PortableCheckpoint = from_json(&final_cp_msg.bytes).unwrap(); + assert!(cp.final_checkpoint); + // Relabel as CoA + cp.ruleset = Ruleset::Coa; + let tampered_bytes = to_json(&cp).unwrap(); + + let initial_rev = o.store().character(id).unwrap().revision; + let ack = o.handle_checkpoint(&tampered_bytes).unwrap(); + assert!(matches!(ack.outcome, AckOutcome::Rejected(_))); + // Revision must not advance and state must not be committed + assert_eq!(o.store().character(id).unwrap().revision, initial_rev); +} + +#[test] +fn full_wildcard_session_lifecycle() { + let Setup { + mut owner, + mut host, + mut realm, + id, + session, + c0, + } = setup_wildcard_in( + Store::open_in_memory().unwrap(), + Store::open_in_memory().unwrap(), + "srv-1:wildcard", + ); + let mut h = HostService::new(&mut host, "srv-1:wildcard", HostConfig::default()); + let mut o = OwnerService::new(&mut owner); + + // 1. Start session + start(&mut h, &mut o, &mut realm); + assert_eq!(o.session(session).unwrap().unwrap().0, "open"); + + // 2. Play on Wildcard realm: earn gold and level up + realm.play(|m| { + m.progression.money += 50_000; + m.progression.xp += 1_000; + }); + + // 3. Online checkpoint + checkpoint(&mut h, &mut o, &mut realm, 100); + let rev2 = o.store().character(id).unwrap().revision; + assert_eq!(rev2, 2); + let curr2 = o.store().load_current(id).unwrap(); + assert_eq!(curr2.ruleset, Ruleset::Wildcard); + assert_eq!(curr2.progression.money, c0.progression.money + 50_000); + + // 4. More gameplay then logout + realm.play(|m| { + m.progression.money += 25_000; + }); + realm.logout(); + h.tick(&mut realm, 200).unwrap(); + h.tick(&mut realm, 201).unwrap(); + let acks = deliver(&mut h, &mut o, &mut realm); + assert!(acks.iter().any(|a| a.outcome == AckOutcome::Applied)); + + // 5. Verify final canonical state + let rec = o.store().character(id).unwrap(); + assert_eq!(rec.revision, 3); + assert_eq!(rec.ruleset, Ruleset::Wildcard); + let final_model = o.store().load_current(id).unwrap(); + assert_eq!(final_model.ruleset, Ruleset::Wildcard); + assert_eq!(final_model.progression.money, c0.progression.money + 75_000); +} diff --git a/crates/coa-core/src/portable/store/host.rs b/crates/coa-core/src/portable/store/host.rs index 1f2dd72..c14e736 100644 --- a/crates/coa-core/src/portable/store/host.rs +++ b/crates/coa-core/src/portable/store/host.rs @@ -579,6 +579,13 @@ impl Store { Some(_) => {} } let at = now(); + let record = read_character(&tx, s.character_id)?; + if ack.ruleset != record.ruleset { + return Err(PortableError::RulesetMismatch { + character: record.ruleset, + realm: ack.ruleset, + }); + } if ack.outcome.accepted() && ack.pin != s.pin { return Err(PortableError::ProgressionChanged( "the acknowledgement is under another progression profile than the session".into(), diff --git a/crates/coa-core/src/portable/store/tests.rs b/crates/coa-core/src/portable/store/tests.rs index 2f08d00..2586ceb 100644 --- a/crates/coa-core/src/portable/store/tests.rs +++ b/crates/coa-core/src/portable/store/tests.rs @@ -2114,3 +2114,156 @@ fn released_v0_7_x_database_upgrades_transactionally_through_migration_009_and_a "migrated database must reject invalid ruleset" ); } + +#[test] +fn mapping_isolation_between_coa_and_wildcard_on_same_installation() { + let mut store = Store::open_in_memory().unwrap(); + let profile = store.default_profile().unwrap(); + + let mut model_coa = fixtures::geared_level_eighty(); + model_coa.ruleset = Ruleset::Coa; + let char_coa = store + .create_character(profile, model_coa, "srv-1:coa") + .unwrap(); + + let mut model_wc = fixtures::geared_level_eighty(); + model_wc.ruleset = Ruleset::Wildcard; + let char_wc = store + .create_character(profile, model_wc, "srv-1:wildcard") + .unwrap(); + + // 1. Both share local_guid = 100 on their respective server_id + store + .bind_server(char_coa, "srv-1:coa", 100, 1, MappingState::Active) + .unwrap(); + store + .bind_server(char_wc, "srv-1:wildcard", 100, 1, MappingState::Active) + .unwrap(); + + // 2. Both share local_item_guid = 500 on their respective server_id + let item_coa = PortableItemId::new(); + let item_wc = PortableItemId::new(); + store + .reconcile_item_mappings( + char_coa, + "srv-1:coa", + 1, + &[obs(item_coa, 500, 10, "entry1")], + ) + .unwrap(); + store + .reconcile_item_mappings( + char_wc, + "srv-1:wildcard", + 1, + &[obs(item_wc, 500, 20, "entry2")], + ) + .unwrap(); + + // Verify lookup isolation + assert_eq!( + store.find_by_local("srv-1:coa", 100).unwrap(), + Some(char_coa) + ); + assert_eq!( + store.find_by_local("srv-1:wildcard", 100).unwrap(), + Some(char_wc) + ); + + let maps_coa = store.item_mappings(char_coa, "srv-1:coa").unwrap(); + assert_eq!(maps_coa.len(), 1); + assert_eq!(maps_coa[0].portable_item_id, item_coa); + assert_eq!(maps_coa[0].local_item_guid, 500); + + let maps_wc = store.item_mappings(char_wc, "srv-1:wildcard").unwrap(); + assert_eq!(maps_wc.len(), 1); + assert_eq!(maps_wc[0].portable_item_id, item_wc); + assert_eq!(maps_wc[0].local_item_guid, 500); +} + +#[test] +fn three_space_isolation_fixture_proves_wildcard_activity_leaves_coa_and_reborn_untouched() { + let mut store = Store::open_in_memory().unwrap(); + let profile = store.default_profile().unwrap(); + + // Character A: CoA + let mut model_a = fixtures::geared_level_eighty(); + model_a.identity.name = "Hero".into(); + model_a.ruleset = Ruleset::Coa; + let char_a = store.create_character(profile, model_a, "srv-1:coa").unwrap(); + + // Character B: Wildcard + let mut model_b = fixtures::geared_level_eighty(); + model_b.identity.name = "Hero".into(); + model_b.ruleset = Ruleset::Wildcard; + let char_b = store.create_character(profile, model_b, "srv-1:wildcard").unwrap(); + + // Character C: Reborn + let mut model_c = fixtures::geared_level_eighty(); + model_c.identity.name = "Hero".into(); + model_c.ruleset = Ruleset::Reborn; + let char_c = store.create_character(profile, model_c, "srv-1:reborn").unwrap(); + + // Initial identical mappings (local_guid = 100, item_guid = 200) + store.bind_server(char_a, "srv-1:coa", 100, 1, MappingState::Active).unwrap(); + store.bind_server(char_b, "srv-1:wildcard", 100, 1, MappingState::Active).unwrap(); + store.bind_server(char_c, "srv-1:reborn", 100, 1, MappingState::Active).unwrap(); + + let item_a = PortableItemId::new(); + let item_b = PortableItemId::new(); + let item_c = PortableItemId::new(); + store.reconcile_item_mappings(char_a, "srv-1:coa", 1, &[obs(item_a, 200, 10, "e1")]).unwrap(); + store.reconcile_item_mappings(char_b, "srv-1:wildcard", 1, &[obs(item_b, 200, 10, "e2")]).unwrap(); + store.reconcile_item_mappings(char_c, "srv-1:reborn", 1, &[obs(item_c, 200, 10, "e3")]).unwrap(); + + // Initial collections + store.merge_collection(profile, Ruleset::Coa, "coa:appearance", &IdSet::from_ids([1, 2, 3]).unwrap()).unwrap(); + store.merge_collection(profile, Ruleset::Wildcard, "wildcard:appearance", &IdSet::from_ids([1, 2, 4]).unwrap()).unwrap(); + store.merge_collection(profile, Ruleset::Reborn, "reborn:appearance", &IdSet::from_ids([1, 2, 5]).unwrap()).unwrap(); + + // Record baseline hashes and revisions + let hash_a_before = store.load_snapshot(char_a, 1).unwrap(); + let hash_c_before = store.load_snapshot(char_c, 1).unwrap(); + + // ---- MUTATE WILDCARD B ONLY ---- + let mut model_b_mut = store.load_current(char_b).unwrap(); + model_b_mut.progression.money += 100_000; + model_b_mut.progression.level = 80; + store.commit_snapshot(char_b, 1, model_b_mut, "srv-1:wildcard", Some("wildcard gameplay")).unwrap(); + + store.merge_collection(profile, Ruleset::Wildcard, "wildcard:appearance", &IdSet::from_ids([1, 2, 4, 999]).unwrap()).unwrap(); + + let new_item_b = PortableItemId::new(); + store.reconcile_item_mappings(char_b, "srv-1:wildcard", 2, &[obs(item_b, 200, 10, "e2"), obs(new_item_b, 201, 10, "e2_new")]).unwrap(); + + // ---- ASSERT WILDCARD B ADVANCED ---- + let rec_b = store.character(char_b).unwrap(); + assert_eq!(rec_b.revision, 2); + let (_, coll_b) = store.collection(profile, Ruleset::Wildcard, "wildcard:appearance").unwrap().unwrap(); + assert_eq!(coll_b.ids(), &[1, 2, 4, 999]); + assert_eq!(store.item_mappings(char_b, "srv-1:wildcard").unwrap().len(), 2); + + // ---- ASSERT COA A IS 100% UNTOUCHED ---- + let rec_a = store.character(char_a).unwrap(); + assert_eq!(rec_a.revision, 1); + let hash_a_after = store.load_snapshot(char_a, 1).unwrap(); + assert_eq!(hash_a_before, hash_a_after); + let (_, coll_a) = store.collection(profile, Ruleset::Coa, "coa:appearance").unwrap().unwrap(); + assert_eq!(coll_a.ids(), &[1, 2, 3]); + let items_a = store.item_mappings(char_a, "srv-1:coa").unwrap(); + assert_eq!(items_a.len(), 1); + assert_eq!(items_a[0].portable_item_id, item_a); + assert_eq!(items_a[0].local_item_guid, 200); + + // ---- ASSERT REBORN C IS 100% UNTOUCHED ---- + let rec_c = store.character(char_c).unwrap(); + assert_eq!(rec_c.revision, 1); + let hash_c_after = store.load_snapshot(char_c, 1).unwrap(); + assert_eq!(hash_c_before, hash_c_after); + let (_, coll_c) = store.collection(profile, Ruleset::Reborn, "reborn:appearance").unwrap().unwrap(); + assert_eq!(coll_c.ids(), &[1, 2, 5]); + let items_c = store.item_mappings(char_c, "srv-1:reborn").unwrap(); + assert_eq!(items_c.len(), 1); + assert_eq!(items_c[0].portable_item_id, item_c); + assert_eq!(items_c[0].local_item_guid, 200); +} diff --git a/crates/coa-core/src/realm_registry/advert.rs b/crates/coa-core/src/realm_registry/advert.rs index bbf5f35..f1b427e 100644 --- a/crates/coa-core/src/realm_registry/advert.rs +++ b/crates/coa-core/src/realm_registry/advert.rs @@ -155,7 +155,15 @@ pub fn find_access( found .into_iter() .find(|d| d.id == local_id || d.id == base_id) - .and_then(|d| RealmAccess::from_descriptor(d).ok()) + .and_then(|d| { + let mut access = RealmAccess::from_descriptor(d).ok()?; + if let Some(m) = explicit_mode { + access.id = format!("{}:{}", access.id, m.name()); + access.name = format!("{} — {}", access.name, m.label()); + access.mode = Some(m); + } + Some(access) + }) } struct Cached { diff --git a/crates/coa-core/src/realms.rs b/crates/coa-core/src/realms.rs index d0d0b00..4e8b111 100644 --- a/crates/coa-core/src/realms.rs +++ b/crates/coa-core/src/realms.rs @@ -737,6 +737,26 @@ pub fn setup_realmlist(root: &Path) -> Result<()> { Ok(()) } +pub fn world_port_for_mode(root: &Path, mode: Mode) -> Result { + let ports = crate::layout::read_ports(root); + let s = state(root)?; + if s.simultaneous { + let second = s + .secondary_world_port + .ok_or_else(|| Error::Invalid("Second realm port is missing.".into()))?; + let port = match (s.active, mode) { + (Mode::Coa, Mode::Coa) => ports.world, + (Mode::Coa, Mode::Wildcard) => second, + (Mode::Wildcard, Mode::Wildcard) => ports.world, + (Mode::Wildcard, Mode::Coa) => second, + (_, _) => ports.world, + }; + Ok(port) + } else { + Ok(ports.world) + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/docs/CONTROL_PROTOCOL.md b/docs/CONTROL_PROTOCOL.md index f913b49..05d79fd 100644 --- a/docs/CONTROL_PROTOCOL.md +++ b/docs/CONTROL_PROTOCOL.md @@ -6,7 +6,7 @@ type into the game. Code: `crates/coa-control-proto` (the protocol: pure, no I/O), `services/coa-coordinator` (the Coordinator), `crates/coa-core/src/control` (Host and Player sides), `src-tauri/src/control_cmds.rs` and `src/screens/JoinPanel.tsx` (the interface). End-to-end tests: `services/coa-control-e2e`. Deployment: [REGISTRY_DEPLOYMENT.md](REGISTRY_DEPLOYMENT.md). -`CONTROL_PROTOCOL_VERSION = 1`; it is independent of the Registry protocol (2) and of the portable formats. +`CONTROL_PROTOCOL_VERSION = 2` (bumped in MR1.1/MR2 to require explicit `ruleset` fields in transfer and claim negotiations); it is independent of the Registry protocol (2) and of the portable formats. ## 1. Shape @@ -148,8 +148,8 @@ its profile, and only then sends `claim_ack`; the Host marks the binding `Portab When a player selects a portable character that exists in their Player Manager but does not yet exist on the remote realm, the Player Manager performs an automated, transactional transfer over the encrypted Noise channel: 1. **Preflight Compatibility Check**: The Player Manager checks the canonical character against the target realm's advertised capabilities (Phase 7/8). If incompatible, the transfer is refused immediately before any network mutation. -2. **Transfer Offer (`TransferOffer`)**: Inside the end-to-end encrypted Noise channel, the Player Manager sends `transfer_offer{transfer_id, character_id, canonical_revision, content_hash, total_size, collections}`. - - The Host validates the PlayerIdentity, character ownership, format revision, hash format, size limit (≤ 4 MiB, `MAX_TRANSFER_REQUEST_BYTES`), and collection counts (≤ 100,000 items). +2. **Transfer Offer (`TransferOffer`)**: Inside the end-to-end encrypted Noise channel, the Player Manager sends `transfer_offer{transfer_id, character_id, canonical_revision, content_hash, total_size, collections, ruleset}`. + - The Host validates the PlayerIdentity, character ownership, format revision, hash format, size limit (≤ 4 MiB, `MAX_TRANSFER_REQUEST_BYTES`), collection counts (≤ 100,000 items), and ruleset matching target realm. - If the exact revision was already committed or an active transfer session exists, the Host responds with `transfer_ready{transfer_id, accepted_offset}`. 3. **Payload Transfer & Chunking (`TransferChunk` / `TransferStatus`)**: - The Player sends the payload in bounded chunks via `transfer_chunk{transfer_id, offset, data}`. @@ -157,7 +157,8 @@ When a player selects a portable character that exists in their Player Manager b - If a connection is interrupted, the Player can query progress via `transfer_status{transfer_id}` and resume from `accepted_offset`. 4. **Validation & Atomic Commit (`TransferCommit`)**: - Once all chunks arrive, the Player sends `transfer_commit{transfer_id}`. - - The Host verifies the SHA-256 content hash of the assembled payload against the offer. + - The Host verifies the SHA-256 content hash of the canonical JSON against the offer. + - The Host decodes the payload and verifies that `decoded.character_id == transfer.character_id`, `decoded.ruleset == transfer.ruleset`, and `transfer.ruleset == destination_realm.ruleset`. - The Host runs the level projection engine (e.g. projecting level 80 down to realm cap 60 via Phase-8 oracle). - The Host imports the character into the realm's characters database, updates/creates the working copy mapping, and arms the session. - The Host returns `transferred{character_id, local_guid, session_id}`. diff --git a/docs/MULTIRULESET_PORTABLE_AUDIT.md b/docs/MULTIRULESET_PORTABLE_AUDIT.md index 9af393d..ece7920 100644 --- a/docs/MULTIRULESET_PORTABLE_AUDIT.md +++ b/docs/MULTIRULESET_PORTABLE_AUDIT.md @@ -6,7 +6,7 @@ This audit evaluates the architecture to support three independent, strictly iso 3. **Warcraft Reborn (`reborn`)** Date: October 2026 -Status: Updated for MR1.1 Gate (Post-Foundation Fixes) +Status: Updated for MR2 Gate (Wildcard Vertical Slice Completed) --- @@ -21,19 +21,33 @@ Status: Updated for MR1.1 Gate (Post-Foundation Fixes) - Collection validation used unsafe prefix checks (`kind.starts_with(ruleset)`), permitting prefix confusion attacks. - `Ruleset::schema(kind)` contained a fallback `_ => "acore_characters"`, routing unknown database kinds to CoA. -### 1.2 Implemented in 58a99f0+ and MR1.1 +### 1.2 Implemented in MR1, MR1.1, and MR2 - **Authoritative Ruleset Enum:** `Ruleset` (`Coa`, `Wildcard`, `Reborn`) unified across `coa-core`, `coa-registry-proto`, `coa-control-proto`, and frontend models. - **Transactional SQLite Migration 009:** Migrates released v0.7.x databases by recreating both `collection` (composite key `profile_id, ruleset, kind`) and `character` (CHECK constraint allowing `'coa', 'wildcard', 'reborn'`) with FK toggles ensuring zero child row loss. -- **Protocol Versioning & Negotiation:** - - Control protocol bumped to `CONTROL_PROTOCOL_VERSION = 2`. `Request::TransferOffer` requires `ruleset: String` (no default). - - Session protocol bumped to `SESSION_PROTOCOL_VERSION = 3`. `SessionOffer`, `PortableSessionStarted`, `PortableCheckpoint`, and `OwnerAck` require explicit `ruleset` (no serde defaults). Old v2 messages require explicit legacy translation. - - Collection protocol set to `COLLECTION_PROTOCOL_VERSION = 2`. `CollectionObserved`, `CollectionState`, and `CollectionAck` require explicit `ruleset`. -- **Schema Safety:** Unsafe fallback in `Ruleset::schema(kind)` removed; unknown database kinds return a hard error. -- **Exact Collection Namespace Validation:** `carried_kind_for(kind, ruleset)` strictly validates allowed collection kinds; prefix confusion attacks (`coax:appearance`, etc.) are rejected with zero mutation. -- **Multi-Realm Local Key Resolution:** `find_access` resolves composite keys `srv-:` while retaining `srv-` for existing single-realm publication until MR4. +- **Fail-Closed Realm Backend:** Removed unsafe `unwrap_or(Ruleset::Coa)` in `LocalBackend::info()`. Unreadable, unknown, or broken realms fail closed immediately with error rather than falling back to CoA. +- **Control Protocol 2 & Strict Envelopes:** + - `CONTROL_PROTOCOL_VERSION = 2`. + - `Request::TransferOffer` requires explicit `ruleset: String`. + - `Response::Claimed` returns explicit `ruleset: String`. + - Claiming and commit verify that the claimed envelope ruleset matches the decoded payload ruleset and matches target realm ruleset. + - `HostTransfer` stores `ruleset` in SQLite; `transfer_commit` verifies that canonical JSON hash and ruleset match the offer and destination realm before writing to disk. +- **Session Protocol 3 & Ruleset Enforcement:** + - `SESSION_PROTOCOL_VERSION = 3` and `COLLECTION_PROTOCOL_VERSION = 2`. + - `SessionOffer`, `PortableSessionStarted`, `PortableCheckpoint`, and `OwnerAck` require explicit `ruleset`. + - Any mismatch between character ruleset, offer ruleset, session ruleset, or checkpoint ruleset rejects immediately with zero DB mutation and zero canonical revision advance. +- **Wildcard Collections Isolation:** + - `wildcard:appearance` and `wildcard:vanity` isolated from `coa:appearance` and `coa:vanity`. + - Cross-ruleset collection merges strictly rejected by `carried_kind_for(kind, ruleset)`. +- **Database Routing & Three-Space Isolation:** + - Canonical SQL routes through `Db::query()` and `realm_schema` to `acore_characters_wildcard` and `acore_world_wildcard`. + - Multiple characters sharing local GUIDs on distinct server IDs (`srv-1:coa`, `srv-1:wildcard`, `srv-1:reborn`) coexist with zero collision in character mappings and item mappings. + - Mutating Wildcard character state, revisions, or collections leaves CoA and Reborn states 100% byte-for-byte untouched. +- **Direct & Relay Routing for Wildcard:** + - `world_port_for_mode` dynamically determines active world port (8085 for primary CoA, 8086 for secondary Wildcard in simultaneous mode). + - Direct Ingress proxy and Relay link dynamically route to the correct realm world port. + - Direct Ingress Auth rewrite replaces internal realm list address with external mapped Wildcard port (e.g. 48086) and never advertises CoA port 8085. ### 1.3 Still Planned (Subsequent Milestones) -- **MR2 (Wildcard Vertical Slice):** Full end-to-end import/export, session runtime, and live verification of Wildcard gameplay. - **MR3 (Warcraft Reborn Vertical Slice):** Unlocking `ruleset_of` for Reborn, import/export adapters, and live verification. - **MR4 (Multi-Realm Publication UI & Registry):** Simultaneous publication of multiple RealmIds from a single Manager host under distinct identities and keypairs. diff --git a/docs/PORTABLE-CHARACTERS.md b/docs/PORTABLE-CHARACTERS.md index 8d8ac27..5bfba04 100644 --- a/docs/PORTABLE-CHARACTERS.md +++ b/docs/PORTABLE-CHARACTERS.md @@ -2,7 +2,16 @@ **Portable characters are experimental.** The feature is in active development and may contain bugs. -Portable characters let you keep a saved character in the Manager and play it on compatible CoA realms. +Portable characters let you keep a saved character in the Manager and play it on compatible realms (Conquest of Azeroth and Wildcard). + +## Multi-Ruleset Isolation Invariant + +Portable characters are strictly isolated by gameplay ruleset (`coa`, `wildcard`, `reborn`): +- A character created or claimed on a **Conquest of Azeroth** realm is a CoA character and can only ever be played on CoA realms. +- A character created or claimed on a **Wildcard** realm is a Wildcard character and can only ever be played on Wildcard realms. +- A character created or claimed on a **Warcraft Reborn** realm can only ever be played on Reborn realms. + +Cross-ruleset transfers, imports, joins, sessions, and collection merges are impossible: the Manager strictly rejects any mismatched request at every protocol, session, and database boundary with zero mutation to your characters or servers. ## Make your first character portable diff --git a/docs/PORTABLE_FORMAT.md b/docs/PORTABLE_FORMAT.md index d2406b5..0f105cc 100644 --- a/docs/PORTABLE_FORMAT.md +++ b/docs/PORTABLE_FORMAT.md @@ -77,7 +77,8 @@ one place, no duplicate ids). Extension payloads must match their recorded hash. * `rollback_to` creates a **new** revision whose state equals an old one; revision numbers never decrease. * The newest `history_keep` revisions are kept (default 20, 1..=1000, configurable). The current revision is never pruned. -* A character's `ruleset` (`coa` | `wildcard`) can never change. +* A character's `ruleset` (`coa` | `wildcard` | `reborn`) can never change. +* The character's `content_namespace` aligns strictly with `ruleset` (`coa`, `wildcard`, or `reborn`). ## Extensions @@ -87,8 +88,9 @@ that does not support an extension simply does not receive it; the canonical cop ## Collections -Account-wide sets of numeric ids (`coa:wardrobe`, `coa:vanity`, ...), stored per profile and kind: +Account-wide sets of numeric ids (`coa:appearance`, `wildcard:appearance`, `reborn:appearance`, etc.), stored per `(profile_id, ruleset, kind)`: +* partitioned strictly by ruleset: collections of different rulesets never intersect or merge; * union only: `stored = stored U incoming`; nothing is ever removed because a realm did not return it; * if the union equals what is stored, **no revision is created** and the hash is unchanged; * encoding: `[format version][count][first id][gap]...`, unsigned LEB128 varints, strictly ascending ids, 1-2 bytes per @@ -98,17 +100,17 @@ Account-wide sets of numeric ids (`coa:wardrobe`, `coa:vanity`, ...), stored per ## Store (`%LOCALAPPDATA%\CoAServerManager\portable\portable.db`) SQLite, WAL, `synchronous=FULL`, `foreign_keys=ON`, `application_id = 0x434F4150`, forward-only migrations tracked in -`PRAGMA user_version` (currently 3). A database from a newer Manager, or a foreign SQLite file, is refused and left untouched. +`PRAGMA user_version` (migration 009 adds multi-ruleset collection partitioning and reborn character support). A database from a newer Manager, or a foreign SQLite file, is refused and left untouched. | Table | Purpose | |---|---| | `profile` | the owner | -| `character` | summary row + canonical revision | +| `character` | summary row + canonical revision (`ruleset IN ('coa', 'wildcard', 'reborn')`) | | `snapshot` | `(character_id, revision)` -> compressed canonical payload + hash | | `character_server_mapping` | `(character_id, server_id)` -> local guid; `UNIQUE(server_id, local_guid)` | | `item_mapping` | one row per mapping with a lifecycle (schema 2, see below) | | `import_journal` | schema 3: one row per import into a realm (`prepared` / `committed` / `aborted` / `needs_attention`) with the nonce/marker and the plan; see `PORTABLE_IMPORT.md` | -| `collection` | per profile and kind: revision, hash, encoded set | +| `collection` | per profile, ruleset, and kind: revision, hash, encoded set | | `setting` | `history_keep` | ## Item mapping lifecycle (schema 2) diff --git a/docs/PORTABLE_SESSIONS.md b/docs/PORTABLE_SESSIONS.md index ac90422..546c24a 100644 --- a/docs/PORTABLE_SESSIONS.md +++ b/docs/PORTABLE_SESSIONS.md @@ -1,7 +1,7 @@ # Runtime portable sessions (Phase 5): design and audit Code: core `src/server/coa/CoAPortableSession*.{h,cpp}` and `CoAPortableImport*.{h,cpp}` (branch `feat/portable-session-bridge` of the -core fork), Manager `crates/coa-core/src/portable/session/`. CoA only; Wildcard portable transfer stays disabled. +core fork), Manager `crates/coa-core/src/portable/session/`. Supports Conquest of Azeroth and Wildcard (MR2) with strict multi-ruleset isolation. Phase 4 proved the offline model with a real client. Its one fragile rule is that the baseline `B0` must be captured *after* the realm's own normalisation and *before* the character is played. Phase 5 makes that rule a property of the running @@ -130,16 +130,18 @@ Messages wait in the outbox until acknowledged; redelivery is harmless (section ## 5. Messages (transport-neutral, versioned, JSON) -`protocol_version = 1`; each message is canonical JSON with unknown fields refused. Snapshots travel in the existing -snapshot envelope (zstd of canonical JSON, SHA-256 of the canonical JSON). +`protocol_version = 3` (Session Protocol Version 3; Collection Protocol Version 2); each message is canonical JSON with unknown fields refused. Snapshots travel in the existing +snapshot envelope (zstd of canonical JSON, SHA-256 of the canonical JSON). Every session message carries an explicit `ruleset` (`coa`, `wildcard`, or `reborn`): ```text -PortableSessionStarted { protocol_version, session_id, character_id, server_id, base_canonical_revision, - baseline_generation, b0: envelope, content_hash } -PortableCheckpoint { protocol_version, session_id, character_id, server_id, base_canonical_revision, - sequence, final_checkpoint, realm_snapshot: envelope, content_hash } -OwnerAck { protocol_version, session_id, sequence, outcome, canonical_revision, canonical_hash, - [final: canonical snapshot envelope] } +SessionOffer { protocol_version, ruleset, session_id, character_id, server_id, + canonical_revision, snapshot: envelope } +PortableSessionStarted { protocol_version, ruleset, session_id, character_id, server_id, base_canonical_revision, + baseline_generation, b0: envelope, content_hash, progression } +PortableCheckpoint { protocol_version, ruleset, session_id, character_id, server_id, base_canonical_revision, + sequence, final_checkpoint, realm_snapshot: envelope, content_hash, pin } +OwnerAck { protocol_version, ruleset, session_id, sequence, outcome, canonical_revision, canonical_hash, + owned_items, owned_pets, [final: canonical snapshot envelope], next_session, pin } ``` `outcome` is `applied`, `duplicate` (same sequence and hash, already applied), `stale_sequence`, `stale_session` diff --git a/docs/WILDCARD.md b/docs/WILDCARD.md index d5a63d2..143e877 100644 --- a/docs/WILDCARD.md +++ b/docs/WILDCARD.md @@ -19,6 +19,15 @@ Recovery points identify their active realm; select that realm before restoring both realms, with auth applied once. The server updater can replace its launcher: the Manager reapplies the realm adapter before the next start. +## Portable Characters on Wildcard + +As of v0.7.1 (MR2), Wildcard realms fully participate in the Portable Characters subsystem with strict multi-ruleset isolation: +- **Canonical Model:** Wildcard portable characters carry `ruleset: "wildcard"` and `content_namespace: "wildcard"`. +- **Claim & Export:** Real characters played on a Wildcard realm (`acore_characters_wildcard`) can be claimed and exported into canonical portable snapshots. Wildcard character builds—including spells, talents, skills, action bars, settings, inventory, pets, and currencies—are fully captured. +- **Import & Session Runtime:** A Wildcard portable character can be transferred to a remote Wildcard host, imported into its `acore_characters_wildcard` database, armed in a runtime session (Session Protocol 3), and played live with automatic checkpoints and logout synchronization. +- **Collections:** Wildcard collections (`wildcard:appearance` and `wildcard:vanity`) are partitioned separately from CoA collections. Unlocks on a Wildcard realm union into the profile's Wildcard collections and never touch CoA collections. +- **Fail-Closed Protection:** Any attempt to transfer or import a CoA character into a Wildcard realm, or vice versa, is rejected at the protocol and database boundaries with zero mutation. + ![Wildcard overview](screenshots/wildcard-demo/overview.jpg) ![Module compatibility](screenshots/wildcard-demo/modules.jpg) diff --git a/services/coa-control-e2e/tests/control.rs b/services/coa-control-e2e/tests/control.rs index 8a1bb72..2568c94 100644 --- a/services/coa-control-e2e/tests/control.rs +++ b/services/coa-control-e2e/tests/control.rs @@ -364,7 +364,6 @@ fn a_realms_key_is_pinned_at_the_first_visit() { #[test] fn remote_transfer_over_coordinator_channel_e2e() { use std::collections::BTreeMap; - use sha2::{Digest, Sha256}; let env = Env::new(true); let dir = tempfile::tempdir().unwrap(); let pc = player(dir.path(), Arc::new(MemoryStore::default())); @@ -372,8 +371,12 @@ fn remote_transfer_over_coordinator_channel_e2e() { pc.ensure_account(&mut ch, &env.realm, Some("Varian")).unwrap(); let cid = Uuid::now_v7(); - let payload = b"SECRET_PORTABLE_CHARACTER_PAYLOAD_FOR_VARIAN".to_vec(); - let hash: [u8; 32] = Sha256::digest(&payload).into(); + let mut model = coa_core::portable::fixtures::geared_level_eighty(); + model.character_id = coa_core::portable::CharacterId::from_uuid(cid).unwrap(); + model.ruleset = coa_core::portable::Ruleset::Coa; + let enc = coa_core::portable::snapshot::encode(&model).unwrap(); + let payload = enc.payload; + let hash = enc.content_hash; let collections = BTreeMap::from([("coa:appearance".to_string(), vec![42, 99])]); // Perform transfer @@ -382,7 +385,7 @@ fn remote_transfer_over_coordinator_channel_e2e() { assert_ne!(outcome.session_id, Uuid::nil()); // Verify tap saw nothing sensitive - assert!(!env.wire_contains("SECRET_PORTABLE_CHARACTER_PAYLOAD"), "payload was encrypted"); + assert!(!env.wire_contains("Gravewalker"), "character name was encrypted"); assert!(!env.wire_contains("Varian"), "account name was encrypted"); // Idempotent retry with same payload discovers existing commit @@ -391,41 +394,55 @@ fn remote_transfer_over_coordinator_channel_e2e() { assert_eq!(outcome.session_id, retry_outcome.session_id); // Update with revision 2 updates working copy without duplicate - let payload2 = b"SECRET_PORTABLE_CHARACTER_PAYLOAD_VARIAN_REV2".to_vec(); - let hash2: [u8; 32] = Sha256::digest(&payload2).into(); + model.progression.money += 1000; + let enc2 = coa_core::portable::snapshot::encode(&model).unwrap(); + let payload2 = enc2.payload; + let hash2 = enc2.content_hash; let update_outcome = pc.transfer_character(&mut ch, cid, "coa", 2, &payload2, hash2, collections).unwrap(); assert_eq!(outcome.local_guid, update_outcome.local_guid); // Incompatible realm rejects let incomp_id = Uuid::now_v7(); env.fake.incompatible.lock().unwrap().insert(incomp_id); - let err = pc.transfer_character(&mut ch, incomp_id, "coa", 1, b"any", [0u8; 32], BTreeMap::new()).unwrap_err(); + let mut incomp_model = coa_core::portable::fixtures::geared_level_eighty(); + incomp_model.character_id = coa_core::portable::CharacterId::from_uuid(incomp_id).unwrap(); + incomp_model.ruleset = coa_core::portable::Ruleset::Coa; + let incomp_enc = coa_core::portable::snapshot::encode(&incomp_model).unwrap(); + let err = pc.transfer_character(&mut ch, incomp_id, "coa", 1, &incomp_enc.payload, incomp_enc.content_hash, BTreeMap::new()).unwrap_err(); assert_eq!(err.code(), "incompatible"); } #[test] fn remote_transfer_worst_case_large_payload_near_limit() { use std::collections::BTreeMap; - use sha2::{Digest, Sha256}; let env = Env::new(true); let dir = tempfile::tempdir().unwrap(); let pc = player(dir.path(), Arc::new(MemoryStore::default())); let mut ch = pc.connect(&env.target()).unwrap(); pc.ensure_account(&mut ch, &env.realm, Some("ThrallLarge")).unwrap(); - // 1. Build a worst-case payload: 2.5 MiB of character state + 25,000 collection item IDs - let mut large_payload = vec![0x42u8; 2_500_000]; - // Fill with pseudo-random printable bytes to prevent trivial compression artifacts - for (i, b) in large_payload.iter_mut().enumerate() { - *b = (32 + (i % 95)) as u8; + let cid = Uuid::now_v7(); + let mut model = coa_core::portable::fixtures::geared_level_eighty(); + model.character_id = coa_core::portable::CharacterId::from_uuid(cid).unwrap(); + model.ruleset = coa_core::portable::Ruleset::Coa; + for ext_idx in 1..=3 { + let mut large_bytes = vec![0u8; 800_000]; + for (i, b) in large_bytes.iter_mut().enumerate() { + *b = (32 + ((i + ext_idx) % 95)) as u8; + } + model.extensions.insert( + format!("test:payload{ext_idx}"), + coa_core::portable::model::Extension::new("1.0.0", 1, large_bytes), + ); } - let large_hash: [u8; 32] = Sha256::digest(&large_payload).into(); + let enc = coa_core::portable::snapshot::encode(&model).unwrap(); + let large_payload = enc.payload; + let large_hash = enc.content_hash; let mut massive_collections = BTreeMap::new(); let ids: Vec = (1..=25_000).collect(); massive_collections.insert("coa:appearance".to_string(), ids); - let cid = Uuid::now_v7(); let outcome = pc.transfer_character(&mut ch, cid, "coa", 1, &large_payload, large_hash, massive_collections).unwrap(); assert!(outcome.local_guid > 0); assert_ne!(outcome.session_id, Uuid::nil()); diff --git a/src-tauri/src/control_cmds.rs b/src-tauri/src/control_cmds.rs index 274163d..491e631 100644 --- a/src-tauri/src/control_cmds.rs +++ b/src-tauri/src/control_cmds.rs @@ -285,6 +285,17 @@ pub(crate) async fn join_realm( let char_id_str = character.clone(); let bundle = portable.call(move |s| s.export_for_remote_transfer(&char_id_str))??; + if bundle.ruleset.as_str() != detail.ruleset.as_str() { + ch.close(); + return Err(fail( + "incompatible", + format!( + "Character ruleset ({}) does not match target realm ruleset ({})", + bundle.ruleset, + detail.ruleset.as_str() + ), + )); + } let cuuid = bundle.character_id.as_uuid(); let _outcome = pc_bg .transfer_character( @@ -519,6 +530,10 @@ pub(crate) async fn join_claim( .map(|c| c.token) .unwrap_or(0); let claimed = pc.claim(&mut ch, token).map_err(from_control)?; + let claimed_ruleset: coa_core::portable::Ruleset = claimed + .ruleset + .parse() + .map_err(|e| fail("incompatible", format!("Invalid ruleset: {e}")))?; let server_id = format!("rr-{rid}"); let cid = coa_core::portable::ids::CharacterId::from_uuid(claimed.character_id) .map_err(|e| fail("other", e.to_string()))?; @@ -527,6 +542,25 @@ pub(crate) async fn join_claim( claimed.sha256, claimed.collections.clone(), ); + let decoded = coa_core::portable::snapshot::decode(&payload, Some(&hash)) + .map_err(|e| fail("invalid", format!("Corrupt claim snapshot: {e}")))?; + if decoded.ruleset != claimed_ruleset { + return Err(fail( + "incompatible", + format!( + "Claimed ruleset mismatch: envelope={}, snapshot={}", + claimed.ruleset, decoded.ruleset + ), + )); + } + for kind in claimed.collections.keys() { + if !coa_core::portable::session::protocol::carried_kind_for(kind, claimed_ruleset) { + return Err(fail( + "incompatible", + format!("Foreign collection kind {kind:?} in {claimed_ruleset} claim"), + )); + } + } let view = portable .call(move |s| s.adopt_claim(&server_id, cid, &payload, &hash, &collections))??; pc.acknowledge(&mut ch, claimed.character_id, &rid, &view.name)