Integrate isolated rulesets, portable admission, and compatible relay authentication

This commit is contained in:
Дмитрий committed 2026-10-24 06:04:26 +05:00
commit d5f1e9cc83
112 files changed
+5892 -965

No files matched your search

+287 -2
View File
@@ -63,9 +63,41 @@ impl LocalBackend {
}
}
fn require_portable(&self, local_id: &str) -> Result<()> {
let settings = settings::load(&self.settings_dir)?;
if settings.realms.get(local_id).is_some_and(|cfg| cfg.allow_portable) {
Ok(())
} else {
Err(Error::Invalid("The realm owner has disabled portable characters.".into()))
}
}
fn access(&self, local_id: &str) -> Result<RealmAccess> {
find_access(&self.descriptors, &(self.installs)(), local_id)
.ok_or_else(|| Error::Invalid("That realm is not known to this Manager.".into()))
let access =
find_access(&self.descriptors, &(self.installs)(), local_id).ok_or_else(|| {
Error::Invalid(format!(
"That realm is not known to this Manager: {local_id}"
))
})?;
if let Some((_base, rs)) = local_id.split_once(':') {
let expected_mode = match rs {
"coa" => crate::realms::Mode::Coa,
"wildcard" => crate::realms::Mode::Wildcard,
"reborn" => crate::realms::Mode::Reborn,
_ => {
return Err(Error::Invalid(format!(
"Malformed or unknown ruleset suffix in local_id: {rs}"
)))
}
};
if access.mode != Some(expected_mode) {
return Err(Error::Invalid(format!(
"Realm access mode {:?} does not match expected ruleset in local_id {local_id}",
access.mode
)));
}
}
Ok(access)
}
fn account(&self, local_id: &str, filter: &str) -> Result<Option<AccountRow>> {
@@ -86,9 +118,39 @@ impl LocalBackend {
impl RealmBackend for LocalBackend {
fn info(&self, local_id: &str) -> Result<RealmInfo> {
let cfg = settings::load(&self.settings_dir)?.realms.remove(local_id);
let access = self.access(local_id)?;
let db = access.db()?;
let ruleset = realm::ruleset_of(&db).map_err(|e| Error::Invalid(e.to_string()))?;
// Explicit local-id -> ruleset invariant:
// local_id ruleset == RealmAccess.mode == Db.realm() == RealmInfo.ruleset
if let Some((_base, rs)) = local_id.split_once(':') {
let expected_ruleset: crate::portable::Ruleset = rs
.parse()
.map_err(|_| Error::Invalid(format!("Unknown ruleset in local_id: {rs}")))?;
if ruleset != expected_ruleset {
return Err(Error::Invalid(format!(
"Ruleset of realm DB ({ruleset:?}) does not match local_id {local_id}"
)));
}
if access.mode.map(|m| m.name()) != Some(expected_ruleset.as_str()) {
return Err(Error::Invalid(format!(
"RealmAccess mode ({:?}) does not match local_id {local_id}",
access.mode
)));
}
if db.realm().name() != expected_ruleset.as_str() {
return Err(Error::Invalid(format!(
"Db realm ({:?}) does not match local_id {local_id}",
db.realm()
)));
}
}
Ok(RealmInfo {
automatic: cfg.as_ref().is_none_or(|c| !c.existing_only),
route: cfg.and_then(|c| c.route),
ruleset,
})
}
@@ -203,6 +265,7 @@ impl RealmBackend for LocalBackend {
}
fn export(&self, local_id: &str, _account_id: u32, guid: u32) -> Result<ClaimExport> {
self.require_portable(local_id)?;
let id = local_id.to_string();
let bundle = self
.portable
@@ -211,6 +274,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,
@@ -223,6 +287,7 @@ impl RealmBackend for LocalBackend {
character_id: Uuid,
revision: u64,
) -> Result<PreflightVerdict> {
self.require_portable(local_id)?;
let id = local_id.to_string();
let cid = crate::portable::CharacterId::from_uuid(character_id)
.map_err(|e| unavailable("character id", e))?;
@@ -237,10 +302,230 @@ impl RealmBackend for LocalBackend {
local_id: &str,
params: RemoteImportParams,
) -> Result<RemoteImportOutcome> {
self.require_portable(local_id)?;
let id = local_id.to_string();
self.portable
.call(move |s| s.import_remote_character(&id, params))
.map_err(|e| unavailable("portable engine", e))?
.map_err(|e| unavailable("import remote", e))
}
fn world_port(&self, local_id: &str) -> Result<u16> {
if let Ok(override_port) = std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT") {
if let Ok(p) = override_port.parse::<u16>() {
return Ok(p);
}
}
let access = self.access(local_id)?;
let mode = if let Some(m) = access.mode {
m
} else if let Some((_base, _rs)) = local_id.split_once(':') {
return Err(Error::Invalid(format!(
"Unresolved mode for ruleset suffix in {local_id}"
)));
} else {
// Legacy unsuffixed CoA realm ONLY
crate::realms::Mode::Coa
};
if let Some(ref root) = access.root {
crate::realms::world_port_for_mode(root, mode)
} else {
Err(Error::Invalid(format!(
"No server installation root for {local_id} to resolve world port"
)))
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile::tempdir;
#[test]
fn portable_access_requires_owner_opt_in_and_revokes_immediately() {
let dir = tempdir().unwrap();
let rt = PortableRuntime::start(&dir.path().join("portable"), Box::new(Vec::new), None).unwrap();
let backend = LocalBackend::new(Arc::new(rt), dir.path(), dir.path(), Arc::new(Vec::new));
assert!(backend.require_portable("srv-test").is_err());
let mut cfg = settings::RegistrySettings::default();
cfg.realms.insert("srv-test".into(), settings::PublishConfig {
realm_id: None, enabled: true, display_name: "Test".into(), description: String::new(),
language: "en".into(), region: None, existing_only: false, allow_portable: true, route: None,
});
settings::save(dir.path(), &cfg).unwrap();
assert!(backend.require_portable("srv-test").is_ok());
cfg.realms.get_mut("srv-test").unwrap().allow_portable = false;
settings::save(dir.path(), &cfg).unwrap();
assert!(backend.export("srv-test", 1, 1).unwrap_err().to_string().contains("disabled portable"));
assert!(backend.check_transfer("srv-test", Uuid::new_v4(), 1).unwrap_err().to_string().contains("disabled portable"));
}
#[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::new), None).unwrap();
let backend = LocalBackend::new(Arc::new(rt), &settings, &desc_dir, Arc::new(Vec::new));
// 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::new), 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);
// When simultaneous is false and active is CoA:
fs::write(
root.join("Settings/realm-profile.json"),
r#"{"active": "coa", "wildcard_created": true, "simultaneous": false}"#,
)
.unwrap();
// CoA succeeds with 8085
assert_eq!(backend.world_port("srv-test1:coa").unwrap(), 8085);
// Wildcard must FAIL CLOSED, never return 8085
let err_wc_mode =
crate::realms::world_port_for_mode(&root, crate::realms::Mode::Wildcard).unwrap_err();
assert!(
err_wc_mode.to_string().contains("not active"),
"Expected not active error, got: {err_wc_mode}"
);
assert!(backend.world_port("srv-test1:wildcard").is_err());
// Reborn must FAIL CLOSED
let err_reb_mode =
crate::realms::world_port_for_mode(&root, crate::realms::Mode::Reborn).unwrap_err();
assert!(
err_reb_mode.to_string().contains("not active"),
"Expected not active error, got: {err_reb_mode}"
);
assert!(backend.world_port("srv-test1:reborn").is_err());
// When active is Reborn:
fs::write(
root.join("Settings/realm-profile.json"),
r#"{"active": "reborn", "wildcard_created": true, "reborn_created": true, "simultaneous": false}"#,
)
.unwrap();
// Reborn succeeds with primary world port 8085
assert_eq!(backend.world_port("srv-test1:reborn").unwrap(), 8085);
// CoA must FAIL CLOSED when Reborn is active
assert!(backend.world_port("srv-test1:coa").is_err());
// Wildcard must FAIL CLOSED when Reborn is active
assert!(backend.world_port("srv-test1:wildcard").is_err());
// Malformed and unknown suffixes must fail closed
assert!(backend.access("srv-test1:unknown").is_err());
assert!(backend.access("srv-test1:garbage").is_err());
assert!(backend.access("srv-test1:coa:extra").is_err());
assert!(backend.world_port("srv-test1:unknown").is_err());
assert!(backend.world_port("srv-test1:garbage").is_err());
}
#[test]
fn world_port_lookup_failure_causes_direct_and_relay_to_fail_closed() {
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();
// Server only has active CoA, simultaneous is off
fs::write(
root.join("Settings/realm-profile.json"),
r#"{"active": "coa", "wildcard_created": false, "simultaneous": false}"#,
)
.unwrap();
let desc_dir = dir.path().join("descriptors");
let portable_dir = dir.path().join("portable");
let rt = PortableRuntime::start(&portable_dir, Box::new(Vec::new), None).unwrap();
let root_clone = root.clone();
let backend = Arc::new(LocalBackend::new(
Arc::new(rt),
root.join("Settings"),
&desc_dir,
Arc::new(move || vec![("test1".to_string(), root_clone.clone())]),
));
let store = Arc::new(std::sync::Mutex::new(
crate::control::store::ControlStore::open_in_memory().unwrap(),
));
let service = Arc::new(crate::control::service::HostService::new(
"srv-test1:wildcard",
coa_registry_proto::sign::RealmId::new(),
store,
backend,
));
// 1. HostService::local_world_port fails closed
assert!(service.local_world_port().is_err());
// 2. Direct route manager cannot find a direct route because world port resolution failed
let mut direct_mgr =
crate::control::direct_route::DirectRouteManager::start(None, service.clone());
assert!(!direct_mgr.is_direct_ready());
assert!(service.direct_route().is_none());
direct_mgr.shutdown();
// 3. When relay link has no world port resolved, AllocateRelay refuses
let mut session = crate::control::service::Session::default();
let player = uuid::Uuid::now_v7();
let resp = service.handle(
&mut session,
&player,
"KEY",
coa_control_proto::app::Request::AllocateRelay { player_id: player },
);
assert!(matches!(
resp,
coa_control_proto::app::Response::Error {
code: coa_control_proto::app::AppError::NoAccount
| coa_control_proto::app::AppError::RelayUnavailable,
..
}
));
}
}
+171 -47
View File
@@ -33,8 +33,13 @@ impl DirectIngress {
local_auth_port: u16,
local_world_port: u16,
) -> Result<Self> {
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 +52,13 @@ 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 +124,11 @@ 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 +188,21 @@ fn handle_auth_client(
local_auth_port: u16,
world_target: Arc<std::sync::RwLock<String>>,
) -> 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 +240,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 +288,21 @@ 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 +318,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 +360,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 +378,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 +429,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 +458,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 +507,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();
}
}
+18 -3
View File
@@ -304,10 +304,25 @@ fn attempt_route_discovery(
.ok()
.and_then(|p| p.parse().ok())
.unwrap_or(coa_control_proto::relay::LOCAL_AUTH_PORT);
let local_world = std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT")
let local_world = match std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT")
.ok()
.and_then(|p| p.parse().ok())
.unwrap_or(coa_control_proto::relay::LOCAL_WORLD_PORT);
{
Some(p) => p,
None => match service.local_world_port() {
Ok(p) => p,
Err(e) => {
set_status(
status,
RouteStatus::RelayOnly {
reason: format!("Cannot resolve local world port: {e}"),
},
);
service.set_direct_route(None);
return;
}
},
};
let desired_auth_port: u16 = std::env::var("COA_DIRECT_AUTH_PORT")
.ok()
@@ -316,7 +331,7 @@ fn attempt_route_discovery(
let desired_world_port: u16 = std::env::var("COA_DIRECT_WORLD_PORT")
.ok()
.and_then(|p| p.parse().ok())
.unwrap_or(8085);
.unwrap_or(local_world);
let ingress = match DirectIngress::start(
desired_auth_port,
+1 -1
View File
@@ -159,7 +159,7 @@ fn session(
) -> Result<(), LinkError> {
let mut ws = transport::connect(url, POLL)?;
let nonce = match transport::next_frame(&mut ws, Duration::from_secs(15))? {
Frame::Challenge { nonce, .. } => nonce,
Frame::Challenge { protocol, nonce } if protocol == coord::COORDINATOR_PROTOCOL_VERSION => nonce,
_ => return Err(LinkError::Protocol("a challenge was expected".into())),
};
transport::send_text(
+23 -12
View File
@@ -24,6 +24,7 @@ pub struct HostControlRealm {
pub local_id: String,
pub realm_id: String,
pub link: LinkStatus,
pub relay: Option<crate::control::relay_link::RelayStatus>,
}
pub struct HostControl {
@@ -95,18 +96,27 @@ impl HostControl {
store.clone(),
backend.clone(),
));
let relay_link =
crate::control::transport::relay_url(&base, "/relay/v1/host").map(
|r_url| {
let rl = crate::control::relay_link::RelayLink::start(
r_url,
realm_id,
key.clone(),
);
service.set_relay(rl.clone());
rl
},
);
let relay_link = match service.local_world_port() {
Ok(world_port) => {
crate::control::transport::relay_url(&base, "/relay/v1/host").map(
|r_url| {
let rl =
crate::control::relay_link::RelayLink::start_with_ports(
r_url,
realm_id,
key.clone(),
Some(world_port),
);
service.set_relay(rl.clone());
rl
},
)
}
Err(e) => {
eprintln!("Relay link unavailable for {local_id}: cannot resolve world port: {e}");
None
}
};
let direct_route =
Some(crate::control::direct_route::DirectRouteManager::start(
Some(base.clone()),
@@ -135,6 +145,7 @@ impl HostControl {
local_id: id.clone(),
realm_id: r.realm_id.to_string(),
link: r.link.status(),
relay: r.relay_link.as_ref().map(|relay| relay.status()),
},
)
})
+7 -2
View File
@@ -115,6 +115,7 @@ pub struct AccountOutcome {
#[derive(Debug, Clone)]
pub struct Claimed {
pub character_id: Uuid,
pub ruleset: String,
pub payload: Vec<u8>,
pub sha256: [u8; 32],
pub collections: BTreeMap<String, Vec<u32>>,
@@ -347,13 +348,14 @@ impl PlayerControl {
pub fn claim(&self, ch: &mut PlayerChannel, token: u32) -> R<Claimed> {
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,
@@ -413,6 +416,7 @@ impl PlayerControl {
&self,
ch: &mut PlayerChannel,
character_id: Uuid,
ruleset: &str,
canonical_revision: u64,
payload: &[u8],
content_hash: [u8; 32],
@@ -423,6 +427,7 @@ impl PlayerControl {
let offer = Request::TransferOffer {
transfer_id,
character_id,
ruleset: ruleset.to_string(),
canonical_revision,
content_hash: content_hash_str.clone(),
total_size: payload.len(),
+1 -1
View File
@@ -35,7 +35,7 @@ impl PlayerChannel {
Duration::from_millis(500),
)?;
let nonce = match transport::next_frame(&mut ws, STEP)? {
Frame::Challenge { nonce, .. } => nonce,
Frame::Challenge { protocol, nonce } if protocol == coord::COORDINATOR_PROTOCOL_VERSION => nonce,
_ => return Err(LinkError::Protocol("a challenge was expected".into())),
};
transport::send_text(
+31 -4
View File
@@ -71,6 +71,15 @@ impl RelayProvider for RelayLink {
impl RelayLink {
pub fn start(url: String, realm_id: RealmId, key: SigningKey) -> Arc<Self> {
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<u16>,
) -> Arc<Self> {
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,15 @@ fn run(
)>,
stop: &AtomicBool,
status: &Mutex<RelayStatus>,
local_world_port: Option<u16>,
) {
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);
if let Err(error) = &result {
tracing::warn!(%realm, %error, "game relay connection lost; retrying");
}
set_status(status, |s| {
s.connected = false;
s.active_streams = 0;
@@ -176,6 +189,7 @@ fn session(
)>,
stop: &AtomicBool,
status: &Mutex<RelayStatus>,
local_world_port: Option<u16>,
) -> Result<(), LinkError> {
let mut ws = transport::connect(url, POLL)?;
@@ -305,8 +319,21 @@ 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 => match local_world_port {
Some(p) => p,
None => {
eprintln!("RelayLink cannot connect to World: local_world_port was not provided (fail-closed)");
let _ = ws_out_tx.send(TunnelMsg::ConnectErr {
stream_id,
error: "World port unresolved".into(),
});
continue;
}
},
};
match TcpStream::connect(("127.0.0.1", local_port)) {
Ok(tcp) => {
let (stream_tx, stream_rx) = channel::<TunnelMsg>();
+314 -29
View File
@@ -26,6 +26,7 @@ pub struct RealmInfo {
pub automatic: bool,
/// An address a player's game client can reach right now, when the owner has stated one. Not a relay and not discovery.
pub route: Option<String>,
pub ruleset: crate::portable::model::Ruleset,
}
#[derive(Clone, Debug, PartialEq, Eq)]
@@ -55,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<u8>,
pub sha256: [u8; 32],
pub collections: BTreeMap<String, Vec<u32>>,
@@ -118,6 +120,8 @@ pub trait RealmBackend: Send + Sync {
local_id: &str,
params: RemoteImportParams,
) -> Result<RemoteImportOutcome>;
/// Local world port for this realm. Must fail closed if the realm port cannot be resolved.
fn world_port(&self, local_id: &str) -> Result<u16>;
}
/// State of one channel.
@@ -218,6 +222,10 @@ impl HostService {
self.realm_id
}
pub fn local_world_port(&self) -> Result<u16> {
self.backend.world_port(&self.local_id)
}
/// 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
@@ -303,6 +311,7 @@ impl HostService {
Request::TransferOffer {
transfer_id,
character_id,
ruleset,
canonical_revision,
content_hash,
total_size,
@@ -311,6 +320,7 @@ impl HostService {
player,
transfer_id,
character_id,
ruleset,
canonical_revision,
content_hash,
total_size,
@@ -691,6 +701,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,
@@ -726,6 +737,7 @@ impl HostService {
player: &Uuid,
transfer_id: Uuid,
character_id: Uuid,
ruleset: String,
canonical_revision: u64,
content_hash: String,
total_size: usize,
@@ -741,6 +753,30 @@ impl HostService {
);
};
// 0. Strict ruleset isolation: target realm ruleset must match offer ruleset
let info = match self.backend.info(&self.local_id) {
Ok(i) => i,
Err(e) => return unavailable("reading realm info", &e),
};
let offer_ruleset = match crate::portable::model::Ruleset::parse(&ruleset) {
Ok(r) => r,
Err(_) => return err(AppError::Incompatible, "Invalid ruleset in transfer offer."),
};
if offer_ruleset != info.ruleset {
return err(
AppError::Incompatible,
"Character ruleset does not match this realm.",
);
}
for kind in collections.keys() {
if !crate::portable::session::protocol::carried_kind_for(kind, offer_ruleset) {
return err(
AppError::Incompatible,
"Collection kind does not belong to this ruleset.",
);
}
}
// 1. Ownership check: another player cannot overwrite a character claimed here
if let Ok(Some(claim)) = self
.store
@@ -834,6 +870,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,
@@ -1008,18 +1045,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.");
};
@@ -1083,6 +1157,7 @@ impl HostService {
#[cfg(any(test, feature = "testkit"))]
pub mod fake {
use super::*;
use crate::portable::Ruleset;
#[derive(Default)]
pub struct FakeRealm {
@@ -1095,6 +1170,7 @@ pub mod fake {
pub seen_passwords: Mutex<Vec<String>>,
pub imported: Mutex<HashMap<Uuid, (u32, Uuid)>>,
pub incompatible: Mutex<std::collections::HashSet<Uuid>>,
pub world_port: Mutex<Option<Result<u16>>>,
}
impl FakeRealm {
@@ -1141,6 +1217,7 @@ pub mod fake {
impl RealmBackend for FakeRealm {
fn info(&self, _: &str) -> Result<RealmInfo> {
Ok(RealmInfo {
ruleset: Ruleset::Coa,
automatic: *self.automatic.lock().unwrap(),
route: self.route.lock().unwrap().clone(),
})
@@ -1245,6 +1322,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])]),
@@ -1284,6 +1362,16 @@ pub mod fake {
notes: vec![],
})
}
fn world_port(&self, _: &str) -> Result<u16> {
if let Some(res) = self.world_port.lock().unwrap().as_ref() {
match res {
Ok(p) => Ok(*p),
Err(e) => Err(Error::Invalid(e.to_string())),
}
} else {
Ok(8085)
}
}
}
}
@@ -1424,7 +1512,7 @@ mod tests {
&Uuid::now_v7(),
"K",
Request::Hello {
protocol: 1,
protocol: coa_control_proto::CONTROL_PROTOCOL_VERSION,
client: "t".into(),
},
)
@@ -1655,6 +1743,7 @@ mod tests {
);
let Response::Claimed {
character_id,
ruleset,
sha256,
payload,
collections,
@@ -1662,6 +1751,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
@@ -1857,6 +1947,14 @@ mod tests {
);
}
fn test_snapshot(cid: Uuid, ruleset: crate::portable::Ruleset) -> (Vec<u8>, 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();
@@ -1864,12 +1962,11 @@ 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 {
ruleset: "coa".into(),
transfer_id: tid,
character_id: cid,
canonical_revision: 1,
@@ -1943,6 +2040,7 @@ mod tests {
realm.incompatible.lock().unwrap().insert(cid);
let offer = Request::TransferOffer {
ruleset: "coa".into(),
transfer_id: tid,
character_id: cid,
canonical_revision: 1,
@@ -1973,15 +2071,12 @@ 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(),
transfer_id: tid,
character_id: cid,
canonical_revision: 1,
@@ -2071,11 +2166,10 @@ 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(),
transfer_id: tid,
character_id: cid,
canonical_revision: 1,
@@ -2138,6 +2232,7 @@ mod tests {
// Client starts a new transfer for the exact same committed revision: discovers committed state
let tid2 = Uuid::now_v7();
let offer2 = Request::TransferOffer {
ruleset: "coa".into(),
transfer_id: tid2,
character_id: cid,
canonical_revision: 1,
@@ -2169,11 +2264,10 @@ 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(),
transfer_id: tid,
character_id: cid,
canonical_revision: 1,
@@ -2240,6 +2334,7 @@ mod tests {
let tid_impostor = Uuid::now_v7();
let impostor_offer = Request::TransferOffer {
ruleset: "coa".into(),
transfer_id: tid_impostor,
character_id: cid,
canonical_revision: 2,
@@ -2267,9 +2362,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(
@@ -2277,6 +2370,7 @@ mod tests {
&p,
"K",
Request::TransferOffer {
ruleset: "coa".into(),
transfer_id: tid1,
character_id: cid,
canonical_revision: 1,
@@ -2321,13 +2415,18 @@ 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,
"K",
Request::TransferOffer {
ruleset: "coa".into(),
transfer_id: tid2,
character_id: cid,
canonical_revision: 2,
@@ -2377,4 +2476,190 @@ mod tests {
"update, not duplicate import"
);
}
#[test]
fn cross_ruleset_transfer_offers_are_rejected_before_mutation() {
let (realm, s, p, _acc) = claimed_setup();
let mut session = Session::default();
let cid = Uuid::now_v7();
let tid = Uuid::now_v7();
// 1. Host is CoA, offer is Wildcard -> Rejected
let wc_offer = Request::TransferOffer {
ruleset: "wildcard".into(),
transfer_id: tid,
character_id: cid,
canonical_revision: 1,
content_hash: "a".repeat(64),
total_size: 100,
collections: BTreeMap::new(),
};
let r = s.handle(&mut session, &p, "K", wc_offer);
assert!(matches!(
r,
Response::Error {
code: AppError::Incompatible,
..
}
));
// 2. Host is CoA, offer is Reborn -> Rejected
let rb_offer = Request::TransferOffer {
ruleset: "reborn".into(),
transfer_id: tid,
character_id: cid,
canonical_revision: 1,
content_hash: "a".repeat(64),
total_size: 100,
collections: BTreeMap::new(),
};
let r = s.handle(&mut session, &p, "K", rb_offer);
assert!(matches!(
r,
Response::Error {
code: AppError::Incompatible,
..
}
));
// 3. Collection kinds for another ruleset -> Rejected
let foreign_coll_offer = Request::TransferOffer {
ruleset: "coa".into(),
transfer_id: tid,
character_id: cid,
canonical_revision: 1,
content_hash: "a".repeat(64),
total_size: 100,
collections: BTreeMap::from([("wildcard:appearance".into(), vec![1, 2, 3])]),
};
let r = s.handle(&mut session, &p, "K", foreign_coll_offer);
assert!(matches!(
r,
Response::Error {
code: AppError::Incompatible,
..
}
));
// 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());
}
}
+15 -4
View File
@@ -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,10 @@ 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 +313,7 @@ impl ControlStore {
pub fn host_transfer(&self, realm: &str, transfer_id: &Uuid) -> Result<Option<HostTransfer>> {
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 +329,7 @@ impl ControlStore {
) -> Result<Option<HostTransfer>> {
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 +343,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 +353,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 +548,13 @@ fn row_transfer(r: &rusqlite::Row<'_>) -> rusqlite::Result<Result<HostTransfer>>
let collections = coll_str
.and_then(|s| serde_json::from_str::<BTreeMap<String, Vec<u32>>>(&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 +687,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),