auth.ccm

Go to the documentation of this file.

// SPDX-FileType: Source
// SPDX-FileCopyrightText: 2026 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0

module;
#include <array>
#include <concepts>
#include <compare>
#include <cstdint>
#include <exception>
#include <span>
#include <type_traits>
#include <utility>
#include <vector>
 
export module auth;
export import auth.error;
import auth.hash;
import auth.serialization;
 
namespace auth {

export struct prover {
  template<class T>
  class sealed {
    T value;
    digest hash{};

    sealed(T value, digest hash) : value(std::move(value)), hash(hash) {}
    friend struct prover;
 
  public:
    bool operator==(const sealed& other) const { return hash == other.hash; }
    auto operator<=>(const sealed& other) const { return hash <=> other.hash; }
 
  private:
    friend struct auth::writer;
    friend struct auth::reader;

    template<class Stream>
    void serialize(Stream& stream) const {
      // Invariant: prover sealed values are only serialized with a writing stream.
      stream(hash);
    }
  };
 
  bytes proof; 

  template<class T>
  sealed<T> seal(T value) const {
    auto hash = sha256(encode(value));
    return {std::move(value), hash};
  }

  template<class T>
  T unseal(sealed<T> p) {
    auto data = encode(p.value);
    proof.insert(proof.end(), data.begin(), data.end());
    return std::move(p.value);
  }
};

export struct verifier {
  template<class T>
  class sealed {
    digest hash{};
    explicit sealed(digest hash) : hash(hash) {}
    friend struct verifier;
 
  public:
    sealed() = default;
    auto operator<=>(const sealed&) const = default;
 
  private:
    friend struct auth::writer;
    friend struct auth::reader;

    template<class Self, class Stream>
    void serialize(this Self& self, Stream& stream) { stream(self.hash); }
  };

  explicit verifier(std::span<const std::uint8_t> proof)
    : position(proof.data()), end(proof.subspan(proof.size()).data()) {}

  verifier(bytes&&) = delete;

  template<class T>
  sealed<T> seal(T value) const {
    return sealed<T>{sha256(encode(value))};
  }

  template<class T>
  T unseal(sealed<T> p) {
    auto [value, next] = decode<T>({position, end});
    if (sha256({position, next}) != p.hash) throw auth_error("sealed hash mismatch");
    if constexpr (std::is_nothrow_move_constructible_v<T>) {
      position = next;
      return std::move(value);
    } else {
      // Return construction precedes local destruction; commit only on success.
      struct advance_on_success {
        const std::uint8_t*& position;
        const std::uint8_t* next;
        int exceptions = std::uncaught_exceptions();
        ~advance_on_success() {
          if (std::uncaught_exceptions() == exceptions) position = next;
        }
      } advance{position, next};
      return std::move(value);
    }
  }

  void finish() const {
    if (position != end) throw auth_error("unused proof bytes");
  }
 
private:
  const std::uint8_t* position;
  const std::uint8_t* const end;
};

export template<class D>
concept db = requires(D& database, std::uint32_t value,
                      typename std::remove_cvref_t<D>::template sealed<std::uint32_t> p) {
  { database.seal(value) } ->
    std::same_as<typename std::remove_cvref_t<D>::template sealed<std::uint32_t>>;
  { database.unseal(std::move(p)) } -> std::same_as<std::uint32_t>;
};

export template<db DB, class T>
using sealed = typename std::remove_cvref_t<DB>::template sealed<T>;
 
} // namespace auth