Rust Primera admisión y confianza histórica

Rust Primera admisión y confianza histórica

El Rust AdmissionService coloca la primera admisión y la confianza histórica por encima del verificador Signed Document de seis etapas (MWP-ADM-005). El flujo independiente del idioma es la página de tiempo de ejecución de confianza histórica y de primera admisión local , y los requisitos exactos son las cláusulas de admisión locales.

Adaptadores públicos y resultados.

Público API	Responsabilidad
AdmissionCurrentKeyResolver::resolve_current	Devuelva evidencia completa de Organization en todo el Registry que la implementación afirma que está actualizada para esta decisión.
TrustedAdmissionContext::issue	Emita la identificación del registro, el instante de aceptación confiable y el servicio de aceptación solo después de una constatación autoritativa de ausencia.
AdmissionLog::lookup	Devuelve AdmissionLookup::Found o AdmissionLookup::AuthoritativeAbsence. Fallos de pérdida de caché, tiempo de espera o ausencia no autenticada cerrados en MWP-ADM-003.
AdmissionLog::append_or_return_existing	Agregue atómicamente bytes candidatos o devuelva el registro autoritativo ganador de una carrera concurrente a través de una identidad de servicio autenticada.
AuthenticatedAdmissionRecord	Vincule los bytes de registro devueltos a la identidad del servicio autenticada por el adaptador de registro para MWP-ADM-009.
AdmissionService::prepare_first_admission	Crear y validar evidencia candidata a partir de un VerifiedSignedDocument producido por SDK; no anexa ni implica admisión.
AdmissionService::admit_first	Verifique la evidencia actual, busque, prepárese después de la ausencia, agregue o devuelva lo existente y valide el registro devuelto en MWP-ADM-006.
AdmissionService::verify_historical_admission	Vuelva a ejecutar la verificación con evidencia histórica autoritativa del Registry y exija un registro existente sin emitir contexto ni añadirlo según MWP-ADM-008.
PreparedFirstAdmission, AdmittedSignedDocument	Preservar la verificación inmutable y registrar la evidencia; FirstAdmissionRecord::bytes devuelve los bytes validados.

Un valor booleano de confianza proporcionado por la persona que llama no es un resultado de búsqueda de admisión y nunca debe seleccionar la ruta exitosa.

Orden de llamada de primera admisión

Informative example

let first = AdmissionService::new()?.admit_first(
    SignedDocumentKind::Command,
    document,
    &current_registry,
    &admission_log,
    &trusted_context,
)?;

admit_first completa las seis etapas de verificación antes del acceso al registro. Un registro encontrado se valida y se devuelve sin emitir un contexto confiable ni agregarlo. Después de una constatación autoritativa de ausencia, el servicio emite el contexto, prepara bytes candidatos canónicos, llama a append_or_return_existing y valida el registro realmente devuelto. Un ganador simultáneo tiene éxito solo cuando el esquema, la autenticación, el enlace de documentos y el tiempo de confianza satisfacen MWP-ADM-009 y MWP-ADM-010.

Repetición histórica y errores

verify_historical_admission usa KeyResolver, vuelve a ejecutar las seis etapas, requiere AdmissionLookup::Found y nunca llama a TrustedAdmissionContext::issue o AdmissionLog::append_or_return_existing. Los ID de registros coincidentes recuperan el mismo registro autoritativo, pero no prueban la actualidad de Command, la autorización del firmante, la aceptación de la máquina de estado ni la verificación portátil de prueba de registros según MWP-ADM-013 y MWP-ADM-014.

AdmissionOperationError conserva el error de verificación de seis etapas original o un AdmissionError. Los errores de admisión exponen el código de cable AUTH_INVALID_SIGNATURE, la etapa protegida admission y un AdmissionReason escrito, según lo requiere MWP-ADM-012. Los adaptadores devuelven AdmissionAdapterError; El éxito o la disponibilidad genéricos no son pruebas autenticadas.

Ejemplo ejecutable con fijación exacta

Informative example

El ejemplo lee los Command y Registry firmados del ProtocolBundle integrado verificado de SDK y luego proporciona adaptadores de autoridad en memoria escritos. No lee archivos del repositorio. Afirma ID de registro, hashes de firma y bytes de registro idénticos para la primera admisión y la reproducción histórica, con exactamente un anexo.

use std::cell::{Cell, RefCell};

use missionweaveprotocol::{
    AdapterError, AdmissionAdapterError, AdmissionContextValue, AdmissionCurrentKeyResolver,
    AdmissionLog, AdmissionLookup, AdmissionService, AuthenticatedAdmissionRecord,
    KeyRegistrySnapshot, KeyResolutionRequest, KeyResolver, ProtocolBundle, SignedDocumentKind,
    TrustedAdmissionContext,
};

const SERVICE_ID: &str = "urn:missionweaveprotocol:service:admission";

struct CurrentRegistry(Vec<u8>);

impl CurrentRegistry {
    fn snapshot(&self) -> KeyRegistrySnapshot {
        KeyRegistrySnapshot::organization_wide(self.0.clone())
    }
}

impl AdmissionCurrentKeyResolver for CurrentRegistry {
    fn resolve_current(
        &self,
        _request: &KeyResolutionRequest,
    ) -> Result<KeyRegistrySnapshot, AdapterError> {
        Ok(self.snapshot())
    }
}

impl KeyResolver for CurrentRegistry {
    fn resolve(
        &self,
        _request: &KeyResolutionRequest,
    ) -> Result<KeyRegistrySnapshot, AdapterError> {
        Ok(self.snapshot())
    }
}

struct FixedTrustedContext;

impl TrustedAdmissionContext for FixedTrustedContext {
    fn issue(
        &self,
        _organization_id: &str,
        _signing_hash: &str,
    ) -> Result<AdmissionContextValue, AdmissionAdapterError> {
        Ok(AdmissionContextValue::new(
            "urn:missionweaveprotocol:admission-record:website-example",
            "2026-07-15T00:05:00Z",
            SERVICE_ID,
        ))
    }
}

struct InMemoryAdmissionLog {
    record: RefCell<Option<AuthenticatedAdmissionRecord>>,
    append_count: Cell<usize>,
}

impl InMemoryAdmissionLog {
    fn new() -> Self {
        Self {
            record: RefCell::new(None),
            append_count: Cell::new(0),
        }
    }

    fn append_count(&self) -> usize {
        self.append_count.get()
    }
}

impl AdmissionLog for InMemoryAdmissionLog {
    fn lookup(
        &self,
        _organization_id: &str,
        _signing_hash: &str,
    ) -> Result<AdmissionLookup, AdmissionAdapterError> {
        Ok(match self.record.borrow().as_ref() {
            Some(record) => AdmissionLookup::Found(record.clone()),
            None => AdmissionLookup::AuthoritativeAbsence,
        })
    }

    fn append_or_return_existing(
        &self,
        _organization_id: &str,
        _signing_hash: &str,
        candidate_bytes: &[u8],
    ) -> Result<AuthenticatedAdmissionRecord, AdmissionAdapterError> {
        if let Some(record) = self.record.borrow().as_ref() {
            return Ok(record.clone());
        }

        let committed = AuthenticatedAdmissionRecord::new(candidate_bytes.to_vec(), SERVICE_ID);
        *self.record.borrow_mut() = Some(committed.clone());
        self.append_count.set(self.append_count.get() + 1);
        Ok(committed)
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    ProtocolBundle::verify()?;
    ProtocolBundle::verify_cryptography()?;
    ProtocolBundle::verify_admission()?;

    let document = ProtocolBundle::cryptography("vectors/signed-documents/valid/command.json")
        .ok_or("packaged Command is missing")?;
    let registry = ProtocolBundle::cryptography("keys/registry-valid.json")
        .ok_or("packaged Registry is missing")?;

    let current_registry = CurrentRegistry(registry.to_vec());
    let admission_log = InMemoryAdmissionLog::new();
    let service = AdmissionService::new()?;

    let first = service.admit_first(
        SignedDocumentKind::Command,
        document,
        &current_registry,
        &admission_log,
        &FixedTrustedContext,
    )?;
    let historical = service.verify_historical_admission(
        SignedDocumentKind::Command,
        document,
        &current_registry,
        &admission_log,
    )?;

    assert!(first.record().admission_record_id() == historical.record().admission_record_id());
    assert!(first.verified().signing_hash() == historical.verified().signing_hash());
    assert!(first.record().bytes() == historical.record().bytes());
    assert!(admission_log.append_count() == 1);

    println!("first admission: {}", first.record().admission_record_id());
    println!(
        "historical replay: {}",
        historical.record().admission_record_id()
    );
    Ok(())
}

Cópielo en un crate exacto y ejecute:

cp /absolute/path/to/examples/sdk/rust/admission.rs examples/website_admission.rs
cargo test --locked --all-features
cargo run --locked --example website_admission

El resultado esperado contiene el mismo ID de registro para first admission y historical replay.

Implementation note

Reemplace CurrentRegistry con adaptadores Registry actuales e históricos autenticados, InMemoryAdmissionLog con un registro duradero autenticado cuya operación de agregar o devolver existente es atómica y FixedTrustedContext con Tiempo de confianza controlado por Organization y emisión de servicio de aceptación. Conserve copias defensivas y nunca colapse estos límites de autoridad en un valor booleano de confianza proporcionado por la persona que llama.