Checkpoint the party/runtime stack before share-program and malicious-mode work.

Ship the TLS mesh, composer, Beaver/Yao/leaf MPC, prep/online paths, apps, and docs so the tree is pushable before elevating share_expr, security_mode, and prep resume. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-28 05:59:19 -06:00 · 2026-09-28 05:59:19 -06:00 · 0d22946a0e
commit 0d22946a0e
parent 695f8e84f7
1835 changed files with 170291 additions and 2849 deletions
--- a/include/dpf/blob.hpp
+++ b/include/dpf/blob.hpp
@ -0,0 +1,149 @@
+/// @file dpf/blob.hpp
+/// @brief Fixed-length XOR byte-string leaf (`dpf::blob<N>`).
+/// @details A mailbox row or other byte payload that does not fit in one AES
+///          block. Keygen stretches each final seed with the exterior PRG
+///          (counter mode) into `N` bytes and XORs a correction of that
+///          length, matching Express's `genDPF` leaf. The tree and depth are
+///          unchanged: Boyle packing uses `ceil(8N / λ)` exterior blocks and
+///          `lg(outputs_per_leaf) = 0`.
+/// @copyright Copyright (c) 2019-2026 Ryan Henry and [others](@ref authors)
+/// @license Released under a GNU General Public v2.0 (GPLv2) license.
+
+#ifndef LIBDPF_INCLUDE_DPF_BLOB_HPP__
+#define LIBDPF_INCLUDE_DPF_BLOB_HPP__
+
+#include <array>
+#include <cstddef>
+#include <cstring>
+#include <type_traits>
+
+#include "hedley/hedley.h"
+
+#include "dpf/utils.hpp"
+
+namespace dpf
+{
+
+/// @brief XOR share of an `N`-byte string.
+/// @tparam N byte length (`N >= 1`)
+template <std::size_t N>
+struct blob
+{
+    static_assert(N >= 1, "dpf::blob: N must be at least 1");
+    static constexpr std::size_t size = N;
+    std::array<unsigned char, N> bytes{};
+
+    HEDLEY_NO_THROW
+    constexpr blob() noexcept = default;
+
+    HEDLEY_NO_THROW
+    explicit blob(const unsigned char * src, std::size_t n = N) noexcept
+    {
+        const std::size_t m = n < N ? n : N;
+        if (m != 0)
+            std::memcpy(bytes.data(), src, m);
+    }
+
+    HEDLEY_NO_THROW
+    explicit blob(std::array<unsigned char, N> b) noexcept
+      : bytes{std::move(b)}
+    { }
+
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    unsigned char * data() noexcept { return bytes.data(); }
+
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    const unsigned char * data() const noexcept { return bytes.data(); }
+
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    friend constexpr bool operator==(const blob & a, const blob & b) noexcept
+    {
+        for (std::size_t i = 0; i < N; ++i)
+            if (a.bytes[i] != b.bytes[i])
+                return false;
+        return true;
+    }
+
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    friend constexpr bool operator!=(const blob & a, const blob & b) noexcept
+    {
+        return !(a == b);
+    }
+
+    /// @brief XOR (group addition / subtraction for this leaf).
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    friend blob operator^(const blob & a, const blob & b) noexcept
+    {
+        blob out;
+        for (std::size_t i = 0; i < N; ++i)
+            out.bytes[i] = static_cast<unsigned char>(a.bytes[i] ^ b.bytes[i]);
+        return out;
+    }
+
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    friend blob operator+(const blob & a, const blob & b) noexcept
+    {
+        return a ^ b;
+    }
+
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    friend blob operator-(const blob & a, const blob & b) noexcept
+    {
+        return a ^ b;
+    }
+
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    blob & operator^=(const blob & o) noexcept
+    {
+        *this = *this ^ o;
+        return *this;
+    }
+
+    HEDLEY_NO_THROW
+    HEDLEY_ALWAYS_INLINE
+    blob & operator+=(const blob & o) noexcept
+    {
+        return (*this) ^= o;
+    }
+};
+
+template <typename T>
+struct is_blob : std::false_type {};
+template <std::size_t N>
+struct is_blob<blob<N>> : std::true_type {};
+template <typename T>
+inline constexpr bool is_blob_v = is_blob<std::decay_t<T>>::value;
+
+namespace utils
+{
+
+template <std::size_t N>
+struct bitlength_of<dpf::blob<N>>
+  : public std::integral_constant<std::size_t, N * 8>
+{ };
+
+template <std::size_t N, typename NodeT>
+struct bitlength_of_output<dpf::blob<N>, NodeT>
+  : public std::integral_constant<std::size_t, N * 8>
+{ };
+
+template <std::size_t N>
+struct has_characteristic_two<dpf::blob<N>> : std::true_type
+{ };
+
+template <std::size_t N>
+struct is_xor_wrapper<dpf::blob<N>> : std::true_type
+{ };
+
+}  // namespace utils
+}  // namespace dpf
+
+#endif  // LIBDPF_INCLUDE_DPF_BLOB_HPP__