C++ Erstzulassung und historischer Trust

C++ Erstzulassung und historischer Trust

Der C++ AdmissionService legt Erstzulassung und historisches Vertrauen über den sechsstufigen Verifizierer Signed Document (MWP-ADM-005). Der sprachunabhängige Ablauf ist die lokale Laufzeitseite für Erstzulassung und historisches Vertrauen, und die genauen Anforderungen sind die lokalen Admission-Klauseln.

Öffentliche Adapter und Ergebnisse

Öffentlich API	Verantwortung
AdmissionCurrentKeyResolver::resolve_current	Geben Sie den vollständigen Organization-weiten Registry-Beweis zurück, dass die Bereitstellung für diese Entscheidung aktuell ist.
TrustedAdmissionContext::issue	Vergeben Sie die Akten-ID, die vertrauenswürdige Annahmestelle und die Annahmezustellung erst nach behördlicher Abwesenheit.
AdmissionLog::lookup	Geben Sie AdmissionLookup::found oder AdmissionLookup::authoritative_absence zurück. Cache-Fehler, Zeitüberschreitung oder nicht authentifizierte Abwesenheit schlagen unter MWP-ADM-003 fehl.
AdmissionLog::append_or_return_existing	Hängen Sie Kandidatenbytes atomar an oder geben Sie den gleichzeitigen maßgeblichen Gewinner über eine authentifizierte Dienstidentität zurück.
AuthenticatedAdmissionRecord	Binden Sie zurückgegebene Datensatzbytes an die vom Adapter authentifizierte Dienstidentität für MWP-ADM-009.
AdmissionService::prepare_first_admission	Erstellen und validieren Sie Kandidatennachweise aus einem von SDK erstellten VerifiedSignedDocument; es stellt keine Zulassung dar oder impliziert diese.
AdmissionService::admit_first	Überprüfen Sie aktuelle Beweise, suchen Sie nach, bereiten Sie sie nach Abwesenheit vor, hängen Sie vorhandene an oder geben Sie sie zurück und validieren Sie den zurückgegebenen Datensatz unter MWP-ADM-006.
AdmissionService::verify_historical_admission	Führen Sie die Überprüfung mit historischen Registry-Beweisen erneut durch und fordern Sie einen vorhandenen Datensatz an, ohne Kontext auszugeben oder unter MWP-ADM-008 anzuhängen.
PreparedFirstAdmission, AdmittedSignedDocument	Bewahren Sie unveränderliche Überprüfungen auf und dokumentieren Sie Beweise; record_bytes gibt eine Ansicht über die validierten Datensatzbytes zurück.

Ein vom Anrufer bereitgestellter boolescher Vertrauensstellungswert ist kein Ergebnis der Zulassungssuche und darf niemals den Erfolgspfad auswählen.

Reihenfolge der Erstzulassung

Informative example

const auto first = AdmissionService{}.admit_first(
    SignedDocumentKind::command,
    document,
    current_registry,
    admission_log,
    trusted_context);

admit_first schließt alle sechs Überprüfungsphasen ab, bevor auf das Protokoll zugegriffen wird. Ein gefundener Datensatz wird validiert und zurückgegeben, ohne dass ein vertrauenswürdiger Kontext ausgegeben oder ein Anhang hinzugefügt wird. Nach maßgeblicher Abwesenheit gibt der Dienst Kontext aus, bereitet kanonische Kandidatenbytes vor und ruft auf append_or_return_existingund validiert den tatsächlich zurückgegebenen Datensatz. Ein gleichzeitiger Gewinner ist nur dann erfolgreich, wenn Schema, Authentifizierung, Dokumentbindung und vertrauenswürdige Zeit die Anforderungen erfüllen MWP-ADM-009 und MWP-ADM-010.

Historische Wiedergabe und Fehler

verify_historical_admission verwendet KeyResolver, führt alle sechs Phasen erneut aus, erfordert einen gefundenen Datensatz und ruft niemals auf TrustedAdmissionContext::issue oder AdmissionLog::append_or_return_existing. Übereinstimmende Datensatz-IDs stellen denselben maßgeblichen Datensatz wieder her, beweisen ihn jedoch nicht Command Aktualität, Autorisierung des Unterzeichners, Akzeptanz der Zustandsmaschine oder tragbare protokollsichere Überprüfung gemäß MWP-ADM-013 und MWP-ADM-014.

Es bleiben sechsstufige Fehler bestehen SignedDocumentVerificationError. Fehler in der Zulassungsphase sind AdmissionError mit Leitungscode AUTH_INVALID_SIGNATURE, Bühne admission, und eine getippte AdmissionReason, wie in MWP-ADM-012. Bereitstellungsadapter lösen aus AdmissionAdapterError; Der allgemeine Erfolg oder die Verfügbarkeit ist kein authentifizierter Beweis.

Ausführbares, exakt angeheftetes Beispiel

Informative example

Das Beispiel liest das signierte Command Und Registry aus dem SDKist verifiziert eingebettet ProtocolBundle, stellt dann typisierte In-Memory-Autoritätsadapter bereit. Es liest keine Repository-Dateien. Es bestätigt identische Datensatz-IDs, Signatur-Hashes und Datensatzbytes für die Erstzulassung und die historische Wiedergabe mit genau einem Anhang.

#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';
}

Kopie admission.cpp und das Folgende CMakeLists.txt in ein leeres Verbraucherverzeichnis. Das Build-Rezept definiert die ausführbare Datei selbst und fügt die genau angeheftete Datei hinzu SDK Kasse als Abhängigkeit; es hängt nicht von einem Ziel ab, das der Verbraucher nicht deklariert hat.

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)

Führen Sie in diesem Verbraucherverzeichnis Folgendes aus:

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

Die erwartete Ausgabe enthält dieselbe Datensatz-ID für first admission und historical replay.

Implementation note

Ersetzen Sie CurrentRegistry durch authentifizierte aktuelle und historische Registry-Adapter, InMemoryAdmissionLog durch ein authentifiziertes dauerhaftes Protokoll, dessen Append-or-Return-Existing-Vorgang atomar ist, und FixedTrustedContext durch Organization-gesteuerte vertrauenswürdige Zeit und Annahmedienstausgabe. Behalten Sie die Byte-Lebensdauer bei und reduzieren Sie diese Autoritätsgrenzen niemals auf einen vom Aufrufer bereitgestellten booleschen Vertrauenswert.