C++ Primera admisión y confianza histórica

C++ Primera admisión y confianza histórica

El C++ 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 Organization completa de 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::authoritative_absence. 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 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; record_bytes devuelve una vista de los bytes de registro 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

const auto first = AdmissionService{}.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 un registro encontrado 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.

Los fallos de seis etapas siguen siendo SignedDocumentVerificationError. Las fallas de la etapa de admisión son AdmissionError con código de cable AUTH_INVALID_SIGNATURE, etapa admission y un AdmissionReason escrito, según lo requiere MWP-ADM-012. Los adaptadores de implementación arrojan 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.

#include <missionweaveprotocol/admission.hpp>
#include <missionweaveprotocol/bundle.hpp>

#include <cstddef>
#include <cstdint>
#include <iostream>
#include <optional>
#include <ranges>
#include <stdexcept>
#include <string_view>
#include <utility>
#include <vector>

namespace {

constexpr std::string_view service_id = "urn:missionweaveprotocol:service:admission";

class CurrentRegistry final : public missionweaveprotocol::AdmissionCurrentKeyResolver,
                              public missionweaveprotocol::KeyResolver {
public:
  explicit CurrentRegistry(const missionweaveprotocol::AssetBytes registry)
      : registry_(registry.begin(), registry.end()) {}

  [[nodiscard]] missionweaveprotocol::KeyRegistrySnapshot
  resolve_current(const missionweaveprotocol::KeyResolutionRequest&) const override {
    return snapshot();
  }

  [[nodiscard]] missionweaveprotocol::KeyRegistrySnapshot
  resolve(const missionweaveprotocol::KeyResolutionRequest&) const override {
    return snapshot();
  }

private:
  [[nodiscard]] missionweaveprotocol::KeyRegistrySnapshot snapshot() const {
    return missionweaveprotocol::KeyRegistrySnapshot::organization_wide(registry_);
  }

  std::vector<std::uint8_t> registry_;
};

class FixedTrustedContext final : public missionweaveprotocol::TrustedAdmissionContext {
public:
  [[nodiscard]] missionweaveprotocol::AdmissionContextValue issue(std::string_view,
                                                                  std::string_view) const override {
    return {
        .admission_record_id = "urn:missionweaveprotocol:admission-record:website-example",
        .trusted_accepted_at = "2026-07-15T00:05:00Z",
        .accepted_by = {.type = "service", .id = std::string{service_id}},
    };
  }
};

class InMemoryAdmissionLog final : public missionweaveprotocol::AdmissionLog {
public:
  [[nodiscard]] missionweaveprotocol::AdmissionLookup lookup(std::string_view,
                                                             std::string_view) const override {
    return record_ ? missionweaveprotocol::AdmissionLookup::found(*record_)
                   : missionweaveprotocol::AdmissionLookup::authoritative_absence();
  }

  [[nodiscard]] missionweaveprotocol::AuthenticatedAdmissionRecord
  append_or_return_existing(std::string_view, std::string_view,
                            const missionweaveprotocol::AssetBytes candidate_bytes) const override {
    if (record_) {
      return *record_;
    }

    record_.emplace(
        std::vector<std::uint8_t>{candidate_bytes.begin(), candidate_bytes.end()},
        missionweaveprotocol::Principal{.type = "service", .id = std::string{service_id}});
    append_count_ += 1;
    return *record_;
  }

  [[nodiscard]] std::size_t append_count() const noexcept { return append_count_; }

private:
  mutable std::optional<missionweaveprotocol::AuthenticatedAdmissionRecord> record_;
  mutable std::size_t append_count_ = 0;
};

} // namespace

int main() {
  const auto protocol = missionweaveprotocol::ProtocolBundle::verify();
  const auto cryptography = missionweaveprotocol::ProtocolBundle::verify_cryptography();
  const auto admission = missionweaveprotocol::ProtocolBundle::verify_admission();
  if (protocol.schema_files != 22 || cryptography.evaluation_count != 62 ||
      admission.evaluation_count != 30) {
    throw std::runtime_error("embedded bundle identity is inconsistent");
  }

  const auto document = missionweaveprotocol::ProtocolBundle::cryptography(
      "vectors/signed-documents/valid/command.json");
  const auto registry =
      missionweaveprotocol::ProtocolBundle::cryptography("keys/registry-valid.json");
  if (!document || !registry) {
    throw std::runtime_error("packaged Command or Registry is missing");
  }

  const CurrentRegistry current_registry{*registry};
  const InMemoryAdmissionLog admission_log;
  const FixedTrustedContext trusted_context;
  const missionweaveprotocol::AdmissionService service;

  const auto first =
      service.admit_first(missionweaveprotocol::SignedDocumentKind::command, *document,
                          current_registry, admission_log, trusted_context);
  const auto historical =
      service.verify_historical_admission(missionweaveprotocol::SignedDocumentKind::command,
                                          *document, current_registry, admission_log);

  if (first.record().admission_record_id() != historical.record().admission_record_id()) {
    throw std::runtime_error("historical replay returned a different record ID");
  }
  if (first.verified().signing_hash() != historical.verified().signing_hash()) {
    throw std::runtime_error("historical replay returned a different signing hash");
  }
  if (!std::ranges::equal(first.record_bytes(), historical.record_bytes())) {
    throw std::runtime_error("historical replay returned different record bytes");
  }
  if (!(admission_log.append_count() == 1)) {
    throw std::runtime_error("Admission Log did not append exactly once");
  }

  std::cout << "first admission: " << first.record().admission_record_id() << '\n';
  std::cout << "historical replay: " << historical.record().admission_record_id() << '\n';
}

Copie admission.cpp y el siguiente CMakeLists.txt en un directorio de consumidor vacío. La receta de compilación define el ejecutable en sí y agrega el checkout SDK fijado exactamente como una dependencia; no depende de un objetivo que el consumidor no haya declarado.

cmake_minimum_required(VERSION 3.24)

project(missionweaveprotocol_website_admission LANGUAGES CXX)

if(NOT DEFINED MISSIONWEAVEPROTOCOL_SDK_ROOT)
  message(FATAL_ERROR "Set MISSIONWEAVEPROTOCOL_SDK_ROOT to the exact-pinned C++ SDK checkout")
endif()

set(MISSIONWEAVEPROTOCOL_BUILD_TESTS OFF CACHE BOOL "" FORCE)
set(MISSIONWEAVEPROTOCOL_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
add_subdirectory("${MISSIONWEAVEPROTOCOL_SDK_ROOT}"
                 "${CMAKE_BINARY_DIR}/missionweaveprotocol-sdk")

add_executable(missionweaveprotocol_website_admission admission.cpp)
target_link_libraries(missionweaveprotocol_website_admission
                      PRIVATE MissionWeaveProtocol::sdk)
target_compile_features(missionweaveprotocol_website_admission PRIVATE cxx_std_20)

Desde ese directorio de consumidores, ejecute:

cmake -S . -B build \
  -DMISSIONWEAVEPROTOCOL_SDK_ROOT=/absolute/path/to/exact/cpp-sdk \
  -DOPENSSL_ROOT_DIR=/absolute/path/to/openssl-3
cmake --build build --target missionweaveprotocol_website_admission --parallel 2
./build/missionweaveprotocol_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 la duración de los bytes y nunca colapse estos límites de autoridad en un valor booleano de confianza proporcionado por la persona que llama.