Add typed updater handoff and preserving Linux Full renderer
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
Keep release verifier and native drivers unchanged. Independently reviewed as an isolated contract after provisioned-file-key correction; eight local release contracts and format/clippy checks pass. Runtime persistence, approvals, service ownership, apply and rollback remain unimplemented.
This commit is contained in:
@@ -0,0 +1,639 @@
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
use rmm_updater_handoff::*;
|
||||
use serde_json::{Value, json};
|
||||
use uuid::Uuid;
|
||||
|
||||
fn id(n: u128) -> Uuid {
|
||||
Uuid::from_u128(n)
|
||||
}
|
||||
fn h(n: u8) -> String {
|
||||
format!("{n:02x}").repeat(32)
|
||||
}
|
||||
fn process(pid: u32, image: &str) -> Process {
|
||||
Process {
|
||||
pid,
|
||||
birth: u64::from(pid) + 1000,
|
||||
image_sha256: image.into(),
|
||||
}
|
||||
}
|
||||
fn handoff() -> Handoff {
|
||||
Handoff {
|
||||
schema_version: 1,
|
||||
attempt: AttemptBinding {
|
||||
tenant_id: id(1),
|
||||
asset_id: id(2),
|
||||
agent_id: id(3),
|
||||
enrollment_generation: 1,
|
||||
assignment_version: 2,
|
||||
plan_id: id(4),
|
||||
plan_sha256: h(1),
|
||||
job_id: id(5),
|
||||
attempt_id: id(6),
|
||||
job_payload_sha256: h(2),
|
||||
grant_id: id(7),
|
||||
authorization_id: id(8),
|
||||
original_request_sha256: h(3),
|
||||
original_start_witness_sha256: h(4),
|
||||
},
|
||||
agent_journal_id: id(9),
|
||||
helper_journal_id: id(10),
|
||||
helper_checkpoint: 7,
|
||||
previous_decision_id: id(11),
|
||||
boot_id: id(12),
|
||||
connection_generation: 20,
|
||||
owner_nonce: id(13),
|
||||
updater_sha256: h(5),
|
||||
updater_policy_sha256: h(6),
|
||||
predecessor_record_sha256: h(7),
|
||||
retained_state_sha256: h(8),
|
||||
ledger_identity_sha256: h(22),
|
||||
staged_files_sha256: h(9),
|
||||
predecessor: CodePair {
|
||||
manifest_sha256: h(10),
|
||||
agent_sha256: h(11),
|
||||
helper_sha256: h(12),
|
||||
pin_sha256: h(13),
|
||||
},
|
||||
target: CodePair {
|
||||
manifest_sha256: h(14),
|
||||
agent_sha256: h(15),
|
||||
helper_sha256: h(16),
|
||||
pin_sha256: h(17),
|
||||
},
|
||||
pin_transition: PinTransition::LinuxGeneralFullV1,
|
||||
pin_transition_sha256: h(18),
|
||||
files: vec![
|
||||
FileTransition {
|
||||
role: FileRole::AgentBinary,
|
||||
old_sha256: h(11),
|
||||
new_sha256: h(15),
|
||||
},
|
||||
FileTransition {
|
||||
role: FileRole::HelperBinary,
|
||||
old_sha256: h(12),
|
||||
new_sha256: h(16),
|
||||
},
|
||||
FileTransition {
|
||||
role: FileRole::LinuxFullConfig,
|
||||
old_sha256: h(19),
|
||||
new_sha256: h(20),
|
||||
},
|
||||
FileTransition {
|
||||
role: FileRole::LinuxFullPin,
|
||||
old_sha256: h(13),
|
||||
new_sha256: h(17),
|
||||
},
|
||||
],
|
||||
stop_set: vec![
|
||||
Service::LinuxAgent,
|
||||
Service::LinuxGeneralHelper,
|
||||
Service::LinuxFullHelper,
|
||||
],
|
||||
consumed_at: 100,
|
||||
finish_before: 700,
|
||||
}
|
||||
}
|
||||
fn key() -> SigningKey {
|
||||
SigningKey::from_bytes(&[73; 32])
|
||||
}
|
||||
fn open(handoff: &Handoff) -> Journal {
|
||||
Journal::open(&handoff.bytes().unwrap(), key().verifying_key().to_bytes()).unwrap()
|
||||
}
|
||||
fn append(journal: &mut Journal, at: u64, evidence: Evidence) -> Vec<u8> {
|
||||
let bytes = journal.prepare(at, evidence).unwrap();
|
||||
journal.replay(&bytes).unwrap();
|
||||
bytes
|
||||
}
|
||||
fn services(handoff: &Handoff) -> Vec<StartedService> {
|
||||
handoff
|
||||
.stop_set
|
||||
.iter()
|
||||
.filter(|s| **s != Service::LinuxAptHelper)
|
||||
.enumerate()
|
||||
.map(|(i, service)| StartedService {
|
||||
service: *service,
|
||||
process: process(
|
||||
50 + i as u32,
|
||||
if *service == Service::LinuxAgent {
|
||||
&handoff.target.agent_sha256
|
||||
} else {
|
||||
&handoff.target.helper_sha256
|
||||
},
|
||||
),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn until_started(journal: &mut Journal, handoff: &Handoff) -> Vec<Vec<u8>> {
|
||||
let mut events = vec![
|
||||
append(journal, 101, Evidence::StopIntent),
|
||||
append(
|
||||
journal,
|
||||
102,
|
||||
Evidence::AllStopped {
|
||||
observation_sha256: h(21),
|
||||
},
|
||||
),
|
||||
append(
|
||||
journal,
|
||||
103,
|
||||
Evidence::UpdaterOwnsLedger {
|
||||
process: process(40, &handoff.updater_sha256),
|
||||
ledger_identity_sha256: h(22),
|
||||
},
|
||||
),
|
||||
];
|
||||
for file in &handoff.files {
|
||||
events.push(append(
|
||||
journal,
|
||||
104,
|
||||
Evidence::ReplaceIntent { role: file.role },
|
||||
));
|
||||
events.push(append(
|
||||
journal,
|
||||
104,
|
||||
Evidence::Replaced {
|
||||
role: file.role,
|
||||
observed_sha256: file.new_sha256.clone(),
|
||||
},
|
||||
));
|
||||
}
|
||||
events.push(append(
|
||||
journal,
|
||||
105,
|
||||
Evidence::PairVerified {
|
||||
pair: handoff.target.clone(),
|
||||
retained_state_sha256: handoff.retained_state_sha256.clone(),
|
||||
},
|
||||
));
|
||||
events.push(append(journal, 106, Evidence::LedgerReturnIntent));
|
||||
events.push(append(
|
||||
journal,
|
||||
107,
|
||||
Evidence::ServicesStarted {
|
||||
services: services(handoff),
|
||||
ledger_identity_sha256: h(22),
|
||||
observation_sha256: h(23),
|
||||
},
|
||||
));
|
||||
events
|
||||
}
|
||||
fn receipt(journal: &Journal, handoff: &Handoff) -> HealthReceipt {
|
||||
HealthReceipt {
|
||||
schema_version: 1,
|
||||
handoff_sha256: journal.handoff_sha256().into(),
|
||||
owner_nonce: handoff.owner_nonce,
|
||||
boot_id: handoff.boot_id,
|
||||
helper_journal_id: handoff.helper_journal_id,
|
||||
agent_journal_id: handoff.agent_journal_id,
|
||||
connection_generation: 21,
|
||||
service_processes: services(handoff),
|
||||
ledger_identity_sha256: h(22),
|
||||
signed_sync_decision_id: id(14),
|
||||
signed_sync_request_sha256: h(24),
|
||||
signed_sync_response_sha256: h(25),
|
||||
signed_sync_applied_at: 108,
|
||||
ready: false,
|
||||
inventory_message_id: id(15),
|
||||
inventory_received_at: 108,
|
||||
inventory_ack_sha256: h(26),
|
||||
issued_at: 109,
|
||||
valid_until: 200,
|
||||
}
|
||||
}
|
||||
fn signed(receipt: &HealthReceipt, domain: &[u8], key: &SigningKey) -> SignedHealth {
|
||||
let payload = serde_json::to_vec(receipt).unwrap();
|
||||
let mut bytes = domain.to_vec();
|
||||
bytes.extend_from_slice(&payload);
|
||||
SignedHealth {
|
||||
payload,
|
||||
signature: key.sign(&bytes).to_bytes().to_vec(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_linux_three_service_handoff_replays_exactly_sixteen_events() {
|
||||
let handoff = handoff();
|
||||
let mut journal = open(&handoff);
|
||||
let mut events = until_started(&mut journal, &handoff);
|
||||
let receipt = signed(&receipt(&journal, &handoff), HEALTH_DOMAIN, &key());
|
||||
events.push(append(
|
||||
&mut journal,
|
||||
110,
|
||||
Evidence::HealthVerified { receipt },
|
||||
));
|
||||
events.push(append(
|
||||
&mut journal,
|
||||
111,
|
||||
Evidence::OutcomePersisted {
|
||||
outcome_sha256: h(27),
|
||||
},
|
||||
));
|
||||
assert_eq!(events.len(), MAX_EVENTS);
|
||||
assert_eq!(journal.phase(), Phase::OutcomePersisted);
|
||||
let mut reopened = open(&handoff);
|
||||
for event in events {
|
||||
reopened.replay(&event).unwrap();
|
||||
}
|
||||
assert_eq!(journal.head_sha256(), reopened.head_sha256());
|
||||
assert_eq!(reopened.phase(), Phase::OutcomePersisted);
|
||||
assert!(reopened.prepare(112, Evidence::StopIntent).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_ownership_before_stop_no_partial_pair_no_start_before_return() {
|
||||
let handoff = handoff();
|
||||
let mut journal = open(&handoff);
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
101,
|
||||
Evidence::UpdaterOwnsLedger {
|
||||
process: process(40, &handoff.updater_sha256),
|
||||
ledger_identity_sha256: h(22)
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
append(&mut journal, 101, Evidence::StopIntent);
|
||||
append(
|
||||
&mut journal,
|
||||
102,
|
||||
Evidence::AllStopped {
|
||||
observation_sha256: h(21),
|
||||
},
|
||||
);
|
||||
append(
|
||||
&mut journal,
|
||||
103,
|
||||
Evidence::UpdaterOwnsLedger {
|
||||
process: process(40, &handoff.updater_sha256),
|
||||
ledger_identity_sha256: h(22),
|
||||
},
|
||||
);
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
104,
|
||||
Evidence::PairVerified {
|
||||
pair: handoff.target.clone(),
|
||||
retained_state_sha256: handoff.retained_state_sha256.clone()
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
104,
|
||||
Evidence::ReplaceIntent {
|
||||
role: FileRole::HelperBinary
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
for file in &handoff.files {
|
||||
append(
|
||||
&mut journal,
|
||||
104,
|
||||
Evidence::ReplaceIntent { role: file.role },
|
||||
);
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
104,
|
||||
Evidence::Replaced {
|
||||
role: file.role,
|
||||
observed_sha256: h(99)
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
append(
|
||||
&mut journal,
|
||||
104,
|
||||
Evidence::Replaced {
|
||||
role: file.role,
|
||||
observed_sha256: file.new_sha256.clone(),
|
||||
},
|
||||
);
|
||||
}
|
||||
append(
|
||||
&mut journal,
|
||||
105,
|
||||
Evidence::PairVerified {
|
||||
pair: handoff.target.clone(),
|
||||
retained_state_sha256: handoff.retained_state_sha256.clone(),
|
||||
},
|
||||
);
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
106,
|
||||
Evidence::ServicesStarted {
|
||||
services: services(&handoff),
|
||||
ledger_identity_sha256: h(22),
|
||||
observation_sha256: h(23)
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
append(&mut journal, 106, Evidence::LedgerReturnIntent);
|
||||
let mut incomplete = services(&handoff);
|
||||
incomplete.pop();
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
107,
|
||||
Evidence::ServicesStarted {
|
||||
services: incomplete,
|
||||
ledger_identity_sha256: h(22),
|
||||
observation_sha256: h(23)
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn event_chain_clock_limits_and_canonical_bytes_fail_closed() {
|
||||
let handoff = handoff();
|
||||
let mut journal = open(&handoff);
|
||||
let event = journal.prepare(101, Evidence::StopIntent).unwrap();
|
||||
for field in [
|
||||
"handoff_sha256",
|
||||
"previous_sha256",
|
||||
"boot_id",
|
||||
"sequence",
|
||||
"observed_at",
|
||||
] {
|
||||
let mut value: Value = serde_json::from_slice(&event).unwrap();
|
||||
value[field] = match field {
|
||||
"sequence" => json!(2),
|
||||
"observed_at" => json!(99),
|
||||
"boot_id" => json!(id(99)),
|
||||
_ => json!(h(99)),
|
||||
};
|
||||
let parsed: Event = serde_json::from_value(value).unwrap();
|
||||
assert!(
|
||||
journal
|
||||
.replay(&serde_json::to_vec(&parsed).unwrap())
|
||||
.is_err(),
|
||||
"{field}"
|
||||
);
|
||||
}
|
||||
let mut whitespace = event.clone();
|
||||
whitespace.push(b' ');
|
||||
assert!(journal.replay(&whitespace).is_err());
|
||||
assert!(journal.replay(&vec![b' '; MAX_EVENT_BYTES + 1]).is_err());
|
||||
assert!(journal.prepare(700, Evidence::StopIntent).is_err());
|
||||
journal.replay(&event).unwrap();
|
||||
assert!(journal.replay(&event).is_err());
|
||||
assert_eq!(journal.phase(), Phase::StopIntent);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn health_is_domain_bound_fresh_evidence_and_never_opens_ready() {
|
||||
let handoff = handoff();
|
||||
let mut journal = open(&handoff);
|
||||
until_started(&mut journal, &handoff);
|
||||
let baseline = receipt(&journal, &handoff);
|
||||
for change in 0..11 {
|
||||
let mut receipt = baseline.clone();
|
||||
match change {
|
||||
0 => receipt.ready = true,
|
||||
1 => receipt.owner_nonce = id(99),
|
||||
2 => receipt.boot_id = id(99),
|
||||
3 => receipt.helper_journal_id = id(99),
|
||||
4 => receipt.connection_generation = 20,
|
||||
5 => receipt.signed_sync_applied_at = 106,
|
||||
6 => receipt.inventory_received_at = 106,
|
||||
7 => receipt.service_processes[1].process.birth += 1,
|
||||
8 => receipt.valid_until = 110,
|
||||
9 => receipt.handoff_sha256 = h(99),
|
||||
_ => receipt.issued_at = 111,
|
||||
}
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
110,
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed(&receipt, HEALTH_DOMAIN, &key())
|
||||
}
|
||||
)
|
||||
.is_err(),
|
||||
"change {change}"
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
110,
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed(&baseline, b"rmm.execution-permit.v1\0", &key())
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
110,
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed(&baseline, HEALTH_DOMAIN, &SigningKey::from_bytes(&[74; 32]))
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
let mut late = baseline;
|
||||
late.issued_at = 287;
|
||||
late.valid_until = 400;
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
287,
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed(&late, HEALTH_DOMAIN, &key())
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
append(
|
||||
&mut journal,
|
||||
701,
|
||||
Evidence::Unknown {
|
||||
reason: UnknownReason::DeadlineExpired,
|
||||
},
|
||||
);
|
||||
assert_eq!(journal.phase(), Phase::Unknown);
|
||||
assert!(
|
||||
journal
|
||||
.prepare(
|
||||
702,
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed(&late, HEALTH_DOMAIN, &key())
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
assert!(journal.prepare(702, Evidence::StopIntent).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closed_service_sets_reject_omitted_full_and_apt_restart() {
|
||||
let mut handoff = handoff();
|
||||
handoff.stop_set.pop();
|
||||
assert!(handoff.bytes().is_err());
|
||||
handoff.stop_set.push(Service::LinuxFullHelper);
|
||||
handoff.stop_set.push(Service::LinuxAptHelper);
|
||||
let mut journal = open(&handoff);
|
||||
until_started(&mut journal, &handoff);
|
||||
assert_eq!(journal.phase(), Phase::ServicesStarted);
|
||||
handoff.files[3].new_sha256 = h(99);
|
||||
assert!(handoff.bytes().is_err());
|
||||
}
|
||||
|
||||
fn full_files() -> (Vec<u8>, Vec<u8>) {
|
||||
let public_key = hex::encode(key().verifying_key().as_bytes());
|
||||
let identity = json!({"tenant_id":id(1),"asset_id":id(2),"agent_id":id(3),
|
||||
"enrollment_generation":1,"assignment_version":2,"signing_key_id":sha256(&hex::decode(&public_key).unwrap())});
|
||||
// Exact Policy codec order copied from runtime control::Policy schema2.
|
||||
let policy = format!(
|
||||
"{{\"schema_version\":2,\"profile\":\"full_maintenance_v1\",\"identity\":{{\"tenant_id\":\"{}\",\"asset_id\":\"{}\",\"agent_id\":\"{}\",\"enrollment_generation\":1,\"assignment_version\":2,\"signing_key_id\":\"{}\"}},\"allowed_services\":[],\"allow_root_scripts\":true,\"allow_reboot\":false,\"allowed_script_profiles\":[\"full_maintenance_v1\"],\"helper_binary_sha256\":\"{}\"}}",
|
||||
id(1),
|
||||
id(2),
|
||||
id(3),
|
||||
identity["signing_key_id"].as_str().unwrap(),
|
||||
h(12)
|
||||
);
|
||||
let config = json!({"profile":"full_maintenance_v1", "binding":{"tenant_id":id(1),"asset_id":id(2),
|
||||
"agent_id":id(3),"enrollment_generation":1,"assignment_version":2,"public_key_hex":public_key},
|
||||
"signing_key_file":format!("/etc/rmm/{}/public-key.json",h(12)),"agent_uid":993,"socket_gid":984,
|
||||
"socket":"/run/rmm-full-helper/helper.sock","state":"/var/lib/rmm-helper","allowed_services":[],
|
||||
"allow_reboot":false,"allow_root_scripts":true,"allowed_script_profiles":["full_maintenance_v1"],
|
||||
"helper_binary_sha256":h(12)});
|
||||
let pin = json!({"schema_version":2,"profile":"full_maintenance_v1","identity":identity,
|
||||
"policy_sha256":sha256(policy.as_bytes()),"helper_binary_sha256":h(12)});
|
||||
(
|
||||
serde_json::to_vec_pretty(&config).unwrap(),
|
||||
serde_json::to_vec_pretty(&pin).unwrap(),
|
||||
)
|
||||
}
|
||||
|
||||
fn render_linux_full(
|
||||
config: &[u8],
|
||||
pin: &[u8],
|
||||
target: &str,
|
||||
) -> anyhow::Result<LinuxFullTransition> {
|
||||
rmm_updater_handoff::render_linux_full(config, pin, target, &key().verifying_key())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_renderer_binds_provisioned_file_key_without_inserting_it_into_raw_config() {
|
||||
let (inline_config, pin) = full_files();
|
||||
let mut file_config: Value = serde_json::from_slice(&inline_config).unwrap();
|
||||
file_config["binding"]["public_key_hex"] = json!("");
|
||||
let bytes = serde_json::to_vec_pretty(&file_config).unwrap();
|
||||
let transition = render_linux_full(&bytes, &pin, &h(16)).unwrap();
|
||||
let actual: Value = serde_json::from_slice(transition.new_config_bytes()).unwrap();
|
||||
assert_eq!(actual["binding"]["public_key_hex"], "");
|
||||
assert_eq!(actual["signing_key_file"], file_config["signing_key_file"]);
|
||||
assert_eq!(
|
||||
transition.proof().effective_signing_key_id,
|
||||
sha256(key().verifying_key().as_bytes())
|
||||
);
|
||||
let expected = String::from_utf8(bytes.clone()).unwrap().replace(
|
||||
&format!("\"helper_binary_sha256\": \"{}\"", h(12)),
|
||||
&format!("\"helper_binary_sha256\": \"{}\"", h(16)),
|
||||
);
|
||||
assert_eq!(transition.new_config_bytes(), expected.as_bytes());
|
||||
let inline = render_linux_full(&inline_config, &pin, &h(16)).unwrap();
|
||||
assert_eq!(
|
||||
transition.proof().new_policy_sha256,
|
||||
inline.proof().new_policy_sha256
|
||||
);
|
||||
assert_eq!(transition.new_pin_bytes(), inline.new_pin_bytes());
|
||||
let foreign_key = SigningKey::from_bytes(&[74; 32]).verifying_key();
|
||||
assert!(rmm_updater_handoff::render_linux_full(&bytes, &pin, &h(16), &foreign_key).is_err());
|
||||
assert!(
|
||||
rmm_updater_handoff::render_linux_full(&inline_config, &pin, &h(16), &foreign_key).is_err()
|
||||
);
|
||||
file_config
|
||||
.as_object_mut()
|
||||
.unwrap()
|
||||
.remove("signing_key_file");
|
||||
assert!(render_linux_full(&serde_json::to_vec(&file_config).unwrap(), &pin, &h(16)).is_err());
|
||||
file_config["signing_key_file"] = json!("relative-key.json");
|
||||
assert!(render_linux_full(&serde_json::to_vec(&file_config).unwrap(), &pin, &h(16)).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_renderer_changes_only_named_hash_spans_preserving_all_other_raw_bytes() {
|
||||
let (config, pin) = full_files();
|
||||
let transition = render_linux_full(&config, &pin, &h(16)).unwrap();
|
||||
assert_eq!(transition.proof().old_config_sha256, sha256(&config));
|
||||
let before: Value = serde_json::from_slice(&config).unwrap();
|
||||
let after: Value = serde_json::from_slice(transition.new_config_bytes()).unwrap();
|
||||
assert_eq!(before["signing_key_file"], after["signing_key_file"]);
|
||||
assert!(after["signing_key_file"].as_str().unwrap().contains(&h(12)));
|
||||
let needle = format!("\"helper_binary_sha256\": \"{}\"", h(12));
|
||||
let expected = String::from_utf8(config)
|
||||
.unwrap()
|
||||
.replace(&needle, &format!("\"helper_binary_sha256\": \"{}\"", h(16)));
|
||||
assert_eq!(transition.new_config_bytes(), expected.as_bytes());
|
||||
let old_pin = String::from_utf8(pin).unwrap();
|
||||
let expected = old_pin
|
||||
.replace(&needle, &format!("\"helper_binary_sha256\": \"{}\"", h(16)))
|
||||
.replace(
|
||||
&transition.proof().old_policy_sha256,
|
||||
&transition.proof().new_policy_sha256,
|
||||
);
|
||||
assert_eq!(transition.new_pin_bytes(), expected.as_bytes());
|
||||
assert_eq!(transition.sha256().unwrap().len(), 64);
|
||||
assert!(
|
||||
render_linux_full(
|
||||
transition.new_config_bytes(),
|
||||
transition.new_pin_bytes(),
|
||||
&h(17)
|
||||
)
|
||||
.is_ok()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_renderer_rejects_foreign_pins_unknown_duplicate_escaped_and_privilege_changes() {
|
||||
let (config, pin) = full_files();
|
||||
for field in [
|
||||
"allow_reboot",
|
||||
"allowed_services",
|
||||
"allowed_script_profiles",
|
||||
"profile",
|
||||
"apt_provider",
|
||||
] {
|
||||
let mut value: Value = serde_json::from_slice(&config).unwrap();
|
||||
value[field] = match field {
|
||||
"allow_reboot" => json!(true),
|
||||
"allowed_services" => json!(["other.service"]),
|
||||
"allowed_script_profiles" => Value::Null,
|
||||
"profile" => json!("general"),
|
||||
_ => json!({}),
|
||||
};
|
||||
assert!(
|
||||
render_linux_full(&serde_json::to_vec(&value).unwrap(), &pin, &h(16)).is_err(),
|
||||
"{field}"
|
||||
);
|
||||
}
|
||||
let mut foreign: Value = serde_json::from_slice(&pin).unwrap();
|
||||
foreign["identity"]["agent_id"] = json!(id(99));
|
||||
assert!(render_linux_full(&config, &serde_json::to_vec(&foreign).unwrap(), &h(16)).is_err());
|
||||
let mut unknown: Value = serde_json::from_slice(&config).unwrap();
|
||||
unknown["binding"]["new_field"] = json!(true);
|
||||
assert!(render_linux_full(&serde_json::to_vec(&unknown).unwrap(), &pin, &h(16)).is_err());
|
||||
let text = String::from_utf8(config).unwrap();
|
||||
let duplicate = text.replacen("{", "{\"helper_binary_sha256\":\"0000000000000000000000000000000000000000000000000000000000000000\",",1);
|
||||
assert!(render_linux_full(duplicate.as_bytes(), &pin, &h(16)).is_err());
|
||||
let escaped = text.replace(
|
||||
&format!("\"helper_binary_sha256\": \"{}\"", h(12)),
|
||||
&format!("\"helper_binary_sha256\": \"\\u0030{}\"", &h(12)[1..]),
|
||||
);
|
||||
assert!(render_linux_full(escaped.as_bytes(), &pin, &h(16)).is_err());
|
||||
}
|
||||
Reference in New Issue
Block a user