C++ Première admission et confiance historique

C++ Première admission et confiance historique

Le C++ AdmissionService superpose la première admission et la confiance historique au-dessus du vérificateur Signed Document en six étapes (MWP-ADM-005). Le flux indépendant de la langue est la page d’exécution de première admission et de confiance historique locale, et les exigences exactes sont les clauses d’admission locales.

## Adaptateurs et résultats publics

Public API	Responsabilité
AdmissionCurrentKeyResolver::resolve_current	Renvoie la preuve complète Organization Registry selon laquelle le déploiement affirme qu’elle est à jour pour cette décision.
TrustedAdmissionContext::issue	Émettez l’ID d’enregistrement, l’acceptation de confiance instantanée et l’acceptation du service uniquement après une absence faisant autorité.
AdmissionLog::lookup	Renvoyez AdmissionLookup::found ou AdmissionLookup::authoritative_absence. Échec d’échec de cache, d’expiration de délai ou d’absence non authentifiée sous MWP-ADM-003.
AdmissionLog::append_or_return_existing	Ajoutez atomiquement des octets candidats ou renvoyez le gagnant faisant autorité simultané via une identité de service authentifiée.
AuthenticatedAdmissionRecord	Bind a renvoyé des octets d’enregistrement à l’identité de service authentifiée par l’adaptateur pour MWP-ADM-009.
AdmissionService::prepare_first_admission	Créer et valider des preuves de candidat à partir d’un SDK produit par VerifiedSignedDocument ; cela n’ajoute ni n’implique l’admission.
AdmissionService::admit_first	Vérifiez les preuves actuelles, recherchez, préparez-vous après une absence, ajoutez ou retournez l’existant et validez l’enregistrement renvoyé sous MWP-ADM-006.
AdmissionService::verify_historical_admission	Réexécutez la vérification avec les preuves historiques Registry et exigez un enregistrement existant sans émettre de contexte ni ajouter sous MWP-ADM-008.
PreparedFirstAdmission, AdmittedSignedDocument	Préserver une vérification immuable et enregistrer des preuves ; record_bytes renvoie une vue sur les octets d’enregistrement validés.

Un booléen de confiance fourni par l’appelant n’est pas un résultat de recherche d’admission et ne doit jamais sélectionner le chemin de réussite.

Ordre d’appel de première admission

Informative example

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

admit_first termine les six étapes de vérification avant l’accès au journal. Un enregistrement trouvé est validé et renvoyé sans émettre de contexte fiable ni ajout. Après une absence faisant autorité, le service émet le contexte, prépare les octets candidats canoniques, appelle append_or_return_existing et valide l’enregistrement effectivement renvoyé. Un gagnant simultané ne réussit que lorsque le schéma, l’authentification, la liaison de document et l’heure de confiance satisfont MWP-ADM-009 et MWP-ADM-010.

Relecture historique et erreurs

verify_historical_admission utilise KeyResolver, réexécute les six étapes, nécessite un enregistrement trouvé et n’appelle jamais TrustedAdmissionContext::issue ou AdmissionLog::append_or_return_existing. Les ID d’enregistrement correspondant récupèrent le même enregistrement faisant autorité mais ne prouvent pas la fraîcheur de Command, l’autorisation du signataire, l’acceptation de la machine d’état ou la vérification de preuve de journal portable sous MWP-ADM-013 et MWP-ADM-014.

Les défauts à six niveaux restent SignedDocumentVerificationError. Les défauts de l’étape d’admission sont AdmissionError avec le code filaire AUTH_INVALID_SIGNATURE, l’étape admission et un AdmissionReason typé, comme l’exige MWP-ADM-012. Les adaptateurs de déploiement lancent AdmissionAdapterError ; le succès ou la disponibilité générique ne constitue pas une preuve authentifiée.

Exemple d’exécution exacte épinglée

Informative example

L’exemple lit les Command et Registry signés à partir du ProtocolBundle intégré vérifié du SDK, puis fournit des adaptateurs d’autorité en mémoire saisis. Il ne lit pas les fichiers du référentiel. Il affirme des ID d’enregistrement, des hachages de signature et des octets d’enregistrement identiques pour la première admission et la relecture historique, avec exactement un ajout.

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

Copiez admission.cpp et le CMakeLists.txt suivant dans un répertoire consommateur vide. La recette de build définit l’exécutable lui-même et ajoute l’extraction SDK exactement épinglée en tant que dépendance ; cela ne dépend pas d’un objectif que le consommateur n’a pas déclaré.

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)

À partir de ce répertoire de consommateurs, exécutez :

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

La sortie attendue contient le même ID d’enregistrement pour first admission et historical replay.

Implementation note

Remplacez CurrentRegistry par des adaptateurs Registry actuels et historiques authentifiés, InMemoryAdmissionLog par un journal durable authentifié dont l’opération d’ajout ou de retour existante est atomique et FixedTrustedContext par Organization contrôlé. temps de confiance et émission de service d’acceptation. Préservez la durée de vie des octets et ne réduisez jamais ces limites d’autorité en un seul booléen de confiance fourni par l’appelant.