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

+9 -1
View File
@@ -356,7 +356,7 @@ dependencies = [
[[package]]
name = "coa-core"
version = "0.6.7"
version = "0.7.3"
dependencies = [
"base64 0.22.1",
"chrono",
@@ -364,6 +364,7 @@ dependencies = [
"coa-registry-proto",
"dunce",
"ed25519-dalek",
"flate2",
"fs4",
"hex",
"if-addrs",
@@ -743,6 +744,7 @@ checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
dependencies = [
"crc32fast",
"miniz_oxide",
"zlib-rs",
]
[[package]]
@@ -3079,6 +3081,12 @@ dependencies = [
"zopfli",
]
[[package]]
name = "zlib-rs"
version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112"
[[package]]
name = "zmij"
version = "1.0.23"
+37 -20
View File
@@ -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,67 +371,85 @@ 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
let outcome = pc.transfer_character(&mut ch, cid, 1, &payload, hash, collections.clone()).unwrap();
let outcome = pc.transfer_character(&mut ch, cid, "coa", 1, &payload, hash, collections.clone()).unwrap();
assert!(outcome.local_guid > 0);
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
let retry_outcome = pc.transfer_character(&mut ch, cid, 1, &payload, hash, collections.clone()).unwrap();
let retry_outcome = pc.transfer_character(&mut ch, cid, "coa", 1, &payload, hash, collections.clone()).unwrap();
assert_eq!(outcome.local_guid, retry_outcome.local_guid);
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();
let update_outcome = pc.transfer_character(&mut ch, cid, 2, &payload2, hash2, collections).unwrap();
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, 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<u32> = (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, 1, &large_payload, large_hash, massive_collections).unwrap();
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());
// 2. Standard request exceeding 4096 bytes is rejected
let bloated_hello = coa_control_proto::app::Request::Hello {
protocol: 1,
protocol: coa_control_proto::CONTROL_PROTOCOL_VERSION,
client: "A".repeat(5000),
};
let encoded = serde_json::to_vec(&bloated_hello).unwrap();
+17 -11
View File
@@ -19,6 +19,14 @@ use coa_registry_proto::*;
use ed25519_dalek::SigningKey;
use uuid::Uuid;
fn transfer_snapshot(id: Uuid, money: u32) -> (Vec<u8>, [u8; 32]) {
let mut model = coa_core::portable::fixtures::geared_level_eighty();
model.character_id = coa_core::portable::CharacterId::from_uuid(id).unwrap();
model.progression.money = money;
let encoded = coa_core::portable::snapshot::encode(&model).unwrap();
(encoded.payload, encoded.content_hash)
}
fn now() -> i64 {
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() as i64
}
@@ -179,7 +187,6 @@ fn gate_phase12_live_vps_control_channel() {
#[ignore]
fn gate_phase12_1_live_vps_remote_transfer() {
use std::collections::BTreeMap;
use sha2::{Digest, Sha256};
let Some(base) = base_url() else { return };
@@ -202,7 +209,7 @@ fn gate_phase12_1_live_vps_remote_transfer() {
while Instant::now() < deadline && !link.status().connected {
std::thread::sleep(Duration::from_millis(200));
}
assert!(link.status().connected, "Host failed to connect to Coordinator via WSS");
assert!(link.status().connected, "Host failed to connect to Coordinator via WSS: {:?}", link.status());
let player_dir = tempfile::tempdir().unwrap();
let pc = PlayerControl::open(player_dir.path(), Arc::new(MemoryStore::default())).unwrap();
@@ -218,33 +225,32 @@ fn gate_phase12_1_live_vps_remote_transfer() {
pc.ensure_account(&mut ch, &realm, Some("VarianWrynn")).expect("ensure_account");
let cid = Uuid::now_v7();
let payload = b"REMOTE_PORTABLE_CHARACTER_VARIAN_PAYLOAD_V1".to_vec();
let hash: [u8; 32] = Sha256::digest(&payload).into();
let (payload, hash) = transfer_snapshot(cid, 1);
let collections = BTreeMap::from([("coa:appearance".to_string(), vec![101, 202])]);
// 1. Remote transfer over Coordinator WSS channel
let outcome = pc.transfer_character(&mut ch, cid, 1, &payload, hash, collections.clone()).expect("transfer_character");
let outcome = pc.transfer_character(&mut ch, cid, "coa", 1, &payload, hash, collections.clone()).expect("transfer_character");
assert!(outcome.local_guid > 0);
assert_ne!(outcome.session_id, Uuid::nil());
println!("GATE 12.1 PASS remote transfer succeeded over WSS: local_guid={}, session_id={}", outcome.local_guid, outcome.session_id);
// 2. Idempotent retry with same payload discovers existing commit
let retry_outcome = pc.transfer_character(&mut ch, cid, 1, &payload, hash, collections.clone()).expect("retry transfer");
let retry_outcome = pc.transfer_character(&mut ch, cid, "coa", 1, &payload, hash, collections.clone()).expect("retry transfer");
assert_eq!(outcome.local_guid, retry_outcome.local_guid, "idempotent retry must return existing guid");
assert_eq!(outcome.session_id, retry_outcome.session_id, "idempotent retry must return existing session");
println!("GATE 12.1 PASS idempotent retry returned existing commit without duplication");
// 3. Update with newer revision 2 updates working copy without duplicating character
let payload2 = b"REMOTE_PORTABLE_CHARACTER_VARIAN_PAYLOAD_V2".to_vec();
let hash2: [u8; 32] = Sha256::digest(&payload2).into();
let update_outcome = pc.transfer_character(&mut ch, cid, 2, &payload2, hash2, collections).expect("update transfer");
let (payload2, hash2) = transfer_snapshot(cid, 2);
let update_outcome = pc.transfer_character(&mut ch, cid, "coa", 2, &payload2, hash2, collections).expect("update transfer");
assert_eq!(outcome.local_guid, update_outcome.local_guid, "revision update must preserve guid");
println!("GATE 12.1 PASS revision 2 update succeeded without character duplication");
// 4. Incompatible realm rejects before mutation
let incomp_id = Uuid::now_v7();
fake.incompatible.lock().unwrap().insert(incomp_id);
let err = pc.transfer_character(&mut ch, incomp_id, 1, b"incomp", [0u8; 32], BTreeMap::new()).expect_err("should reject");
let (incomp_payload, incomp_hash) = transfer_snapshot(incomp_id, 1);
let err = pc.transfer_character(&mut ch, incomp_id, "coa", 1, &incomp_payload, incomp_hash, BTreeMap::new()).expect_err("should reject");
assert_eq!(err.code(), "incompatible");
println!("GATE 12.1 PASS incompatible character rejected cleanly");
@@ -326,7 +332,7 @@ fn gate_phase13_live_vps_relay() {
let host_ws_url = coordinator_url(&base, "/coord/v1/host").expect("coordinator host url");
let relay_ws_url = coordinator_url(&base, "/relay/v1/host").expect("relay host url");
let relay_link = RelayLink::start(relay_ws_url.clone(), realm, host_key.clone());
let relay_link = RelayLink::start_with_ports(relay_ws_url.clone(), realm, host_key.clone(), Some(mock_world_port));
service.set_relay(relay_link.clone());
let mut host_link = HostLink::start(host_ws_url.clone(), realm, host_key.clone(), service, Arc::new(now));