use super::*;
use crate::declaration::{LocalizedText, ObjectContract, SourceLocation};
use crate::plugin::{PluginChannel, validate_artifact};
use crate::{
Admission, ContractId, FlowContract, FrameworkId, NodeId, PluginManifest, PluginMode,
PluginSource, RegistrationInfo, RegistrationRule,
};
const KEY: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
const BYTES: &[u8] = b"abc";
const CHECKSUM: &str = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad";
struct AcceptingVerifier;
impl PluginSignatureVerifier for AcceptingVerifier {
fn verify(&self, manifest: PluginManifest, payload: &[u8], key_fingerprint: &str) -> bool {
manifest.signature == Some("adapter-verified-signature")
&& !payload.is_empty()
&& key_fingerprint.len() == 64
}
}
struct PayloadDigestVerifier;
impl PluginSignatureVerifier for PayloadDigestVerifier {
fn verify(&self, manifest: PluginManifest, payload: &[u8], key_fingerprint: &str) -> bool {
manifest
.signature
.is_some_and(|signature| signature == crate::sha256_hex(payload))
&& key_fingerprint.len() == 64
}
}
fn payload_digest(artifact: &PluginArtifact) -> &'static str {
let manifest = artifact.registration.plugin.expect("manifest");
let digest =
crate::sha256_hex(&manifest.signing_payload(&artifact.registration, &artifact.bytes));
Box::leak(digest.into_boxed_str())
}
fn signed_artifact() -> PluginArtifact {
let mut artifact = official_artifact();
let digest = payload_digest(&artifact);
let mut manifest = artifact.registration.plugin.expect("manifest");
manifest.signature = Some(digest);
artifact.registration.plugin = Some(manifest);
artifact
}
struct RejectingVerifier;
impl PluginSignatureVerifier for RejectingVerifier {
fn verify(&self, _: PluginManifest, _: &[u8], _: &str) -> bool {
false
}
}
fn official_artifact() -> PluginArtifact {
PluginArtifact {
registration: RegistrationInfo {
namespace: "plugin-test",
id: NodeId::from_path("plugin.rs", "Plugin"),
parent: crate::ROOT_NODE_ID,
kind: "Plugin",
preset: "",
parts: "",
params: "",
handle: "PluginHandle",
stable_name: None,
name: LocalizedText {
zh: "插件",
en: "Plugin",
},
summary: LocalizedText { zh: "", en: "" },
exports: &[],
needs_registry: false,
registry_name: "plugin",
getting_from_other_registry: None,
registry_rule_path: "<test>",
registry_rule: RegistrationRule::ANY,
admission: Admission::ANY,
requires: &[],
provides: &[],
contract: ObjectContract {
required_parts: &[],
provided_parts: &[],
},
flow: FlowContract::NONE,
flow_provider: None,
handle_traits: &[],
part_traits: &[],
runtime_checks: &[],
plugin: Some(PluginManifest {
name: "official.canvas",
crate_name: "official_canvas",
version: "1.0.0",
framework: FrameworkId::new("xirang.test"),
source: PluginSource::Official,
mode: PluginMode::Extension,
checksum: CHECKSUM,
signature: Some("adapter-verified-signature"),
public_key_fingerprint: Some(KEY),
revocation_list: Some("official-2026"),
}),
source: SourceLocation {
file: "plugin.rs",
line: 1,
column: 1,
function: "plugin",
},
},
bytes: BYTES.to_vec(),
key_fingerprint: Some(KEY.to_owned()),
}
}
fn official_channel(artifact: &VerifiedPluginArtifact) -> Result<(), SlotValidationError> {
validate_artifact(
"canvas",
FrameworkId::new("xirang.test"),
PluginMode::Extension,
FlowContract::NONE,
&[PluginChannel::Official],
PluginChannel::Official,
artifact,
)
}
#[test]
fn a_signed_artifact_is_the_only_way_into_the_official_channel() {
let policy = PluginTrustPolicy::official(&[KEY], &[]);
let signed = official_artifact()
.verify_signed(policy, &AcceptingVerifier)
.expect("a trusted signature verifies");
assert_eq!(signed.assurance(), PluginAssurance::Signature);
let digest_only = official_artifact()
.verify_artifact(policy)
.expect("the checksum path still works");
assert_eq!(digest_only.assurance(), PluginAssurance::Digest);
assert!(
official_channel(&signed).is_ok(),
"a verified signature must open the official lane"
);
assert!(
official_channel(&digest_only).is_err(),
"a checksum alone must not"
);
}
#[test]
fn a_revoked_version_is_refused_even_with_a_good_signature() {
let policy = PluginTrustPolicy::official(
&[KEY],
&[PluginRevocation {
package: "official.canvas",
version: "1.0.0",
}],
);
assert!(matches!(
official_artifact().verify_signed(policy, &AcceptingVerifier),
Err(PluginTrustError::Revoked)
));
}
#[test]
fn signature_assurance_is_refused_for_a_user_artifact() {
let mut artifact = official_artifact();
let mut manifest = artifact.registration.plugin.expect("manifest");
manifest.source = PluginSource::User;
manifest.signature = None;
manifest.public_key_fingerprint = None;
artifact.registration.plugin = Some(manifest);
artifact.key_fingerprint = None;
assert!(
matches!(
artifact
.clone()
.verify_signed(PluginTrustPolicy::open(), &AcceptingVerifier),
Err(PluginTrustError::SignatureLaneRequired)
),
"a lane that never calls a verifier cannot record a verified signature"
);
let digest = artifact
.verify_artifact(PluginTrustPolicy::open())
.expect("the checksum path accepts a user artifact");
assert_eq!(digest.assurance(), PluginAssurance::Digest);
}
#[test]
fn a_refused_signature_never_earns_the_stronger_assurance() {
assert!(matches!(
official_artifact()
.verify_signed(PluginTrustPolicy::official(&[KEY], &[]), &RejectingVerifier),
Err(PluginTrustError::SignatureNotVerified)
));
}
#[test]
fn a_tampered_registration_no_longer_earns_a_signature() {
let policy = PluginTrustPolicy::official(&[KEY], &[]);
assert_eq!(
signed_artifact()
.verify_signed(policy, &PayloadDigestVerifier)
.expect("the honest artifact verifies")
.assurance(),
PluginAssurance::Signature
);
let mut moved = signed_artifact();
moved.registration.parent = NodeId::from_path("other.rs", "Other");
assert!(
matches!(
moved.verify_signed(policy, &PayloadDigestVerifier),
Err(PluginTrustError::SignatureNotVerified)
),
"a moved parent must not keep the signature"
);
let mut rewired = signed_artifact();
rewired.registration.flow = FlowContract::new(ContractId::new("hijacked.v1"), 1, "A", "B");
assert!(
matches!(
rewired.verify_signed(policy, &PayloadDigestVerifier),
Err(PluginTrustError::SignatureNotVerified)
),
"a rewired flow contract must not keep the signature"
);
}