mars-server · federation::policy

Package: mars-server · Workspace version: 0.1.0 · Module: federation::policy

This reference follows declared modules and public syntax, including public implementation methods. Function bodies and constant values are omitted. Feature conditions are retained. Private-module re-exports and trait resolution require the compiler; not every declaration is a root import.

federation::policy::VersionTrust

Trust facts established before conflict selection.

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VersionTrust {
/// Publisher Ed25519 signature verified against a controller-bound key.

pub publisher_signature_verified: bool,
/// A matching confirmed anchor receipt was verified in local durable state.

pub confirmed_anchor_verified: bool,
/// Source registry sequence for this version.

pub sequence: u64,
/// SHA-256 of the JCS publisher-authored entry.

pub content_digest: String
}

Source line: 11.

federation::policy::ConflictWinner

Deterministic conflict winner.

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConflictWinner {
    Local,
    Remote,
    Identical,
}

Source line: 24.

federation::policy::ConflictResolutionError

Conflict selection failure.

#[derive(Debug, thiserror::Error)]
pub enum ConflictResolutionError {
    #[error("conflict candidate publisher signature is not verified")]
    UnverifiedPublisherSignature,
    #[error("conflict candidate digest is malformed")]
    InvalidDigest,
}

Source line: 32.

federation::policy::resolve_verified_conflict

Resolve a conflict only after both publisher signatures have been cryptographically verified.

A locally confirmed matching anchor wins first. If anchor evidence is equal, the higher source sequence wins. Equal sequences use the lexically lower canonical SHA-256 digest, yielding the same result on every registry.

pub fn resolve_verified_conflict(
    local: &VersionTrust,
    remote: &VersionTrust,
) -> Result<ConflictWinner, ConflictResolutionError>;

Source line: 45.

federation::policy::PeerNetworkError

URL or DNS safety failure. Messages are deliberately non-sensitive and do not include resolved internal addresses.

#[derive(Debug, thiserror::Error)]
pub enum PeerNetworkError {
    #[error("federation peer URL is invalid")]
    InvalidUrl,
    #[error("federation peer URL must use HTTPS")]
    HttpsRequired,
    #[error("federation peer URL authority is not allowed")]
    InvalidAuthority,
    #[error("federation peer DNS returned no usable addresses")]
    MissingAddress,
    #[error("federation peer address is blocked by SSRF policy")]
    BlockedAddress,
    #[error("federation peer DNS resolution failed")]
    ResolutionFailed,
}

Source line: 189.

federation::policy::validate_peer_url_and_addresses

Parse an HTTPS peer URL and validate every resolved address.

A mixed public/private DNS answer fails closed. Non-public addresses are accepted only when every such address is contained in an explicit CIDR.

pub fn validate_peer_url_and_addresses(
    raw_url: &str,
    addresses: &[IpAddr],
    allow_private_cidrs: &[IpNet],
) -> Result<Url, PeerNetworkError>;

Source line: 208.

federation::policy::resolve_peer_endpoint

Resolve and pin a peer endpoint before constructing an HTTP client.

pub async fn resolve_peer_endpoint(
    raw_url: &str,
    allow_private_cidrs: &[IpNet],
) -> Result<(Url, Vec<SocketAddr>), PeerNetworkError>;

Source line: 253.

Source provenance

Source: mars-server/src/federation/policy.rs · SHA-256 be95f7ddb9def0ec9adfe7e98024136229d2dfc05ecc32a7c793386c908ec2f4. Package overview.

mars-server · federation::policy

On this page