use crate::registry_core::declaration::{FrameworkId, PluginManifest, PluginSource};
use super::*;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PluginAdapter {
Native,
Wasm,
Process,
}
pub trait PluginRuntime {
type Instance;
type Error: std::error::Error;
fn adapter(&self) -> PluginAdapter;
fn load_plugin_policy(
&self,
manifest: PluginManifest,
bytes: &[u8],
) -> Result<Self::Instance, Self::Error>;
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PluginPolicy {
pub framework: FrameworkId,
pub allow_official: bool,
pub allow_user: bool,
pub require_digest: bool,
}
impl PluginPolicy {
pub const fn local(framework: FrameworkId) -> Self {
Self {
framework,
allow_official: false,
allow_user: false,
require_digest: true,
}
}
pub const fn open(framework: FrameworkId) -> Self {
Self {
framework,
allow_official: true,
allow_user: true,
require_digest: false,
}
}
pub const fn strict(framework: FrameworkId) -> Self {
Self {
framework,
allow_official: true,
allow_user: true,
require_digest: true,
}
}
pub fn accepts(self, plugin: PluginManifest, catalog: Option<&PluginCatalog>) -> bool {
matches!(self.decision(plugin, catalog), PluginDecision::Accepted)
}
pub fn decision(
self,
plugin: PluginManifest,
catalog: Option<&PluginCatalog>,
) -> PluginDecision {
if !plugin.targets_framework(self.framework) {
return PluginDecision::Rejected(PluginRejectReason::FrameworkMismatch);
}
let source_allowed = match plugin.source {
PluginSource::Official => self.allow_official,
PluginSource::User => self.allow_user,
};
if !source_allowed {
return PluginDecision::Rejected(PluginRejectReason::SourceDisabled);
}
if self.require_digest && !artifact::is_sha256(plugin.checksum) {
return PluginDecision::Rejected(PluginRejectReason::InvalidDigest);
}
if self.require_digest
&& plugin.source == PluginSource::Official
&& plugin
.signature
.is_none_or(|signature| signature.trim().is_empty())
{
return PluginDecision::Rejected(PluginRejectReason::MissingSignature);
}
if plugin.source == PluginSource::Official
&& catalog.is_some_and(|catalog| !catalog.contains_manifest(plugin))
{
return PluginDecision::Rejected(PluginRejectReason::LockMismatch);
}
PluginDecision::Accepted
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::registry_core::declaration::{ContractId, FlowContract, PluginMode};
#[test]
fn flow_contracts_compare_without_runtime_hashing() {
let expected = FlowContract::new(
ContractId::new("render.canvas2d.v1"),
1,
"CanvasInput",
"CanvasFrame",
);
assert!(expected.compatible_with(expected));
assert!(!expected.compatible_with(FlowContract::new(
ContractId::new("render.canvas2d.v1"),
1,
"AbsoluteInput",
"CanvasFrame",
)));
}
#[test]
fn plugin_policy_keeps_frameworks_and_sources_separate() {
let framework = FrameworkId::new("com.nichui.editor");
let official = PluginManifest {
name: "official.canvas",
crate_name: "official_canvas",
version: "1.0.0",
framework,
source: PluginSource::Official,
mode: PluginMode::Replacement,
checksum: "sha256:official",
signature: None,
public_key_fingerprint: None,
revocation_list: None,
};
let user = PluginManifest {
source: PluginSource::User,
..official
};
assert!(PluginPolicy::open(framework).accepts(official, None));
assert!(!PluginPolicy::local(framework).accepts(official, None));
assert!(PluginPolicy::open(framework).accepts(user, None));
assert!(!PluginPolicy::open(FrameworkId::new("com.other.app")).accepts(official, None));
}
#[test]
fn the_official_lock_check_is_reachable_through_accepts() {
let framework = FrameworkId::new("com.nichui.editor");
let manifest = PluginManifest {
name: "official.canvas",
crate_name: "official_canvas",
version: "1.0.0",
framework,
source: PluginSource::Official,
mode: PluginMode::Replacement,
checksum: "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
signature: Some("adapter-verified-signature"),
public_key_fingerprint: None,
revocation_list: None,
};
let elsewhere = PluginCatalog::parse_plugin_catalog(
"official|com.nichui.editor|official.other|1.0.0|official_other|sha256:aa|replacement",
)
.expect("a lock with another package parses");
assert!(PluginPolicy::open(framework).accepts(manifest, None));
assert_eq!(
PluginPolicy::open(framework).decision(manifest, Some(&elsewhere)),
PluginDecision::Rejected(PluginRejectReason::LockMismatch)
);
assert!(!PluginPolicy::open(framework).accepts(manifest, Some(&elsewhere)));
}
#[test]
fn strict_policy_explains_digest_rejection() {
let manifest = PluginManifest {
name: "local",
crate_name: "local",
version: "1.0.0",
framework: FrameworkId::new("xirang.default"),
source: PluginSource::User,
mode: PluginMode::Extension,
checksum: "fixture-development",
signature: None,
public_key_fingerprint: None,
revocation_list: None,
};
assert_eq!(
PluginPolicy::strict(manifest.framework).decision(manifest, None),
PluginDecision::Rejected(PluginRejectReason::InvalidDigest)
);
let digest = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad";
assert!(
PluginManifest {
checksum: digest,
..manifest
}
.verify_bytes(b"abc")
);
}
#[test]
fn strict_policy_accepts_prefixed_sha256_checksums() {
let framework = FrameworkId::new("xirang.default");
let manifest = PluginManifest {
name: "local",
crate_name: "local",
version: "1.0.0",
framework,
source: PluginSource::User,
mode: PluginMode::Extension,
checksum: "sha256:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
signature: None,
public_key_fingerprint: None,
revocation_list: None,
};
assert_eq!(
PluginPolicy::strict(framework).decision(manifest, None),
PluginDecision::Accepted
);
}
#[test]
fn strict_policy_rejects_an_unsigned_official_face() {
let framework = FrameworkId::new("xirang.default");
let manifest = PluginManifest {
name: "official",
crate_name: "official",
version: "1.0.0",
framework,
source: PluginSource::Official,
mode: PluginMode::Extension,
checksum: "sha256:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
signature: None,
public_key_fingerprint: None,
revocation_list: None,
};
assert_eq!(
PluginPolicy::strict(framework).decision(manifest, None),
PluginDecision::Rejected(PluginRejectReason::MissingSignature)
);
}
}