use crate::registry_core::declaration::{
Admission, ObjectContract, PluginManifest, PluginMode, PluginSource, RegistrationInfo,
RegistrationRule, SourceLocation,
};
use super::FlowContract;
pub(super) fn field(out: &mut Vec<u8>, value: &str) {
out.extend_from_slice(&(value.len() as u64).to_le_bytes());
out.extend_from_slice(value.as_bytes());
}
fn optional(out: &mut Vec<u8>, value: Option<&str>) {
match value {
Some(value) => {
out.push(1);
field(out, value);
}
None => out.push(0),
}
}
fn strings(out: &mut Vec<u8>, values: &[&str]) {
out.extend_from_slice(&(values.len() as u64).to_le_bytes());
for value in values {
field(out, value);
}
}
pub(super) fn manifest(out: &mut Vec<u8>, manifest: PluginManifest) {
field(out, manifest.name);
field(out, manifest.crate_name);
field(out, manifest.version);
field(out, manifest.framework.0);
field(
out,
match manifest.source {
PluginSource::Official => "official",
PluginSource::User => "user",
},
);
field(
out,
match manifest.mode {
PluginMode::Extension => "extension",
PluginMode::Replacement => "replacement",
},
);
field(out, manifest.checksum);
optional(out, manifest.public_key_fingerprint);
optional(out, manifest.revocation_list);
}
fn rule(out: &mut Vec<u8>, rule: RegistrationRule) {
optional(out, rule.required_preset);
strings(out, rule.required_parts);
strings(out, rule.required_exports);
strings(out, rule.required_handle_traits);
strings(out, rule.required_part_traits);
}
fn admission(out: &mut Vec<u8>, admission: Admission) {
strings(out, admission.allowed_paths);
strings(out, admission.denied_paths);
}
fn object_contract(out: &mut Vec<u8>, contract: ObjectContract) {
strings(out, contract.required_parts);
strings(out, contract.provided_parts);
}
fn flow(out: &mut Vec<u8>, flow: FlowContract) {
field(out, flow.id.0);
out.extend_from_slice(&flow.version.to_le_bytes());
field(out, flow.input);
field(out, flow.output);
}
fn source(out: &mut Vec<u8>, source: SourceLocation) {
field(out, source.file);
out.extend_from_slice(&source.line.to_le_bytes());
out.extend_from_slice(&source.column.to_le_bytes());
field(out, source.function);
}
pub(super) fn registration(info: &RegistrationInfo, out: &mut Vec<u8>) {
field(out, info.namespace);
out.extend_from_slice(&info.id.into_bytes());
out.extend_from_slice(&info.parent.into_bytes());
field(out, info.kind);
field(out, info.preset);
field(out, info.parts);
field(out, info.params);
field(out, info.handle);
optional(out, info.stable_name);
field(out, info.name.zh);
field(out, info.name.en);
field(out, info.summary.zh);
field(out, info.summary.en);
strings(out, info.exports);
out.push(u8::from(info.needs_registry));
field(out, info.registry_name);
optional(out, info.getting_from_other_registry);
field(out, info.registry_rule_path);
rule(out, info.registry_rule);
admission(out, info.admission);
out.extend_from_slice(&(info.requires.len() as u64).to_le_bytes());
for requirement in info.requires {
field(out, requirement.capability);
field(out, requirement.provider);
}
strings(out, info.provides);
object_contract(out, info.contract);
flow(out, info.flow);
optional(out, info.flow_provider);
strings(out, info.handle_traits);
strings(out, info.part_traits);
out.extend_from_slice(&(info.runtime_checks.len() as u64).to_le_bytes());
for check in info.runtime_checks {
field(out, &check.expression());
}
match info.plugin {
Some(manifest_of_face) => {
out.push(1);
manifest(out, manifest_of_face);
}
None => out.push(0),
}
source(out, info.source);
}
#[cfg(test)]
mod tests {
use crate::registry_core::declaration::{
Admission, ContractId, LocalizedText, ObjectContract, PluginManifest, PluginMode,
PluginSource, RegistrationInfo, RegistrationRule, SourceLocation,
};
use crate::{FlowContract, FrameworkId, NodeId};
fn full_registration() -> RegistrationInfo {
RegistrationInfo {
namespace: "signing-test",
id: NodeId::from_path("signing.rs", "Signing"),
parent: NodeId::from_path("parent.rs", "Parent"),
kind: "Signing",
preset: "SigningPreset",
parts: "SigningParts",
params: "SigningParams",
handle: "SigningHandle",
stable_name: Some("signing"),
name: LocalizedText {
zh: "签名",
en: "Signing",
},
summary: LocalizedText {
zh: "摘要",
en: "Summary",
},
exports: &["one"],
needs_registry: true,
registry_name: "signing-registry",
getting_from_other_registry: Some("other-registry"),
registry_rule_path: "rule.rs",
registry_rule: RegistrationRule::ANY.require_preset("SigningPreset"),
admission: Admission::allow_paths(&["crate::allowed"]),
requires: &[],
provides: &["capability"],
contract: ObjectContract {
required_parts: &["head"],
provided_parts: &["head", "tail"],
},
flow: FlowContract::new(ContractId::new("signing.v1"), 3, "Input", "Output"),
flow_provider: Some("FlowProvider"),
handle_traits: &["SigningHandleTrait"],
part_traits: &["SigningPartsTrait"],
runtime_checks: &[crate::NON_EMPTY_TEXT],
plugin: Some(PluginManifest {
name: "official.signing",
crate_name: "official_signing",
version: "1.0.0",
framework: FrameworkId::new("xirang.test"),
source: PluginSource::Official,
mode: PluginMode::Extension,
checksum: "sha256:aa",
signature: Some("ignored-by-the-payload"),
public_key_fingerprint: Some("ff"),
revocation_list: Some("official-1"),
}),
source: SourceLocation {
file: "signing.rs",
line: 7,
column: 11,
function: "full_registration",
},
}
}
fn encoded(info: &RegistrationInfo) -> Vec<u8> {
let mut out = Vec::new();
super::registration(info, &mut out);
out
}
#[test]
fn every_compared_field_changes_the_registration_bytes() {
let honest = encoded(&full_registration());
assert!(!honest.is_empty());
type Mutation = (&'static str, fn(&mut RegistrationInfo));
let mutations: [Mutation; 5] = [
("parent", |info| {
info.parent = NodeId::from_path("other.rs", "Other");
}),
("flow", |info| {
info.flow = FlowContract::new(ContractId::new("hijacked.v1"), 1, "A", "B");
}),
("kind", |info| info.kind = "Other"),
("requires", |info| {
info.requires = &[crate::registry_core::declaration::RequirementSpec {
capability: "cap",
provider: "obj",
}];
}),
("plugin", |info| info.plugin = None),
];
for (name, mutate) in mutations {
let mut info = full_registration();
mutate(&mut info);
assert_ne!(
encoded(&info),
honest,
"a change to `{name}` must change the signed registration bytes"
);
}
}
#[test]
fn the_signature_itself_is_not_part_of_the_payload() {
let honest = encoded(&full_registration());
let mut resigned = full_registration();
let mut manifest = resigned.plugin.expect("manifest");
manifest.signature = Some("another-signature");
resigned.plugin = Some(manifest);
assert_eq!(encoded(&resigned), honest);
}
}