updates

Author: anderspkd

include/scl/argparser.h

@@ -38,6 +38,8 @@ namespace scl {
  *
  * The interface of ProgramOptions is pretty intuitive
  * @code
+ * #include <scl/argparser.h>
+ *
  * ProgramOptions opts = ...  //
  *
  * // check if "-foo 123" was passed in argv
@@ -58,6 +60,8 @@ namespace scl {
  * strings. Specialization is, of course, allowed.
  *
  * @code
+ * #include <scl/argparser.h>
+ *
  * struct FooStruct {
  *   int x;
  *   int y;
@@ -226,7 +230,7 @@ struct ProgramFlag {
  *
  * @code
  * // example.cc
- * #include <scl/cmdline.h>
+ * #include <scl/argparser.h>
  * #include <iostream>
  *
  * using namespace scl;

include/scl/protocol.h

@@ -18,6 +18,8 @@
 #pragma once
 
 #include <any>
+#include <stdexcept>
+#include <type_traits>
 
 #include "scl/coro/task.h"
 #include "scl/net/network.h"
@@ -63,18 +65,22 @@ struct Result;
  *
  * The following simple example illustrates this idea.
  * @code
+ * #include <scl/protocol.h>
+ *
  * class CountdownProtocol final : public Protocol {
  *  public:
  *   CountdownProtocol(int current) : m_current(current) {}
+
  *   Task<Result> run(Env& ignored) const override {
- *     std::cout << "countdown: " << m_current << "\n";
  *     if (m_current == 0) {
  *       co_return Result::done();
  *     } else {
- *       co_return Result::next(
- *           std::make_unique<CountdownProtocol>(m_current - 1));
+ *       co_return Result::nextStep(
+ *           std::make_unique<CountdownProtocol>(m_current - 1),
+ *            m_current);
  *     }
  *   }
+
  *  private:
  *   int m_current;
  * };
@@ -138,21 +144,41 @@ struct Result {
   std::any output;
 };
 
+/**
+ * @brief Run a protocol.
+ */
 template <typename CALLBACK>
 Task<void> runProtocol(std::unique_ptr<Protocol> protocol,
                        Env& env,
                        CALLBACK output_cb) {
   while (protocol) {
     Result result = co_await protocol->run(env);
 
-    if (result.next) {
-      protocol = std::move(result.next);
-    }
+    protocol = std::move(result.next);
 
     if (result.output.has_value()) {
       output_cb(result.output);
     }
   }
 }
 
+template <typename R>
+Task<R> runProtocol(std::unique_ptr<Protocol> protocol, Env& env) {
+  Result result;
+
+  while (protocol) {
+    result = co_await protocol->run(env);
+
+    protocol = std::move(result.next);
+  }
+
+  if constexpr (!std::is_void_v<R>) {
+    if (result.output.has_value()) {
+      co_return std::any_cast<R>(result.output);
+    } else {
+      throw std::runtime_error("protocol never gave output");
+    }
+  }
+}
+
 }  // namespace scl

include/scl/ss/feldman.h

@@ -124,24 +124,4 @@ bool feldmanVerify(const FeldmanShare<GROUP>& share, std::size_t share_index) {
   return v == GROUP::generator() * share.share;
 }
 
-/**
- * @brief Verify a share given a set of commitments.
- * @ingroup ss
- * @param share the share to verify.
- * @param commitments the commitments to verify against.
- * @param share_index the index (e.g., party ID) of the share.
- * @return true if the provided share is valid for that index, and false
- * otherwise.
- *
- * This function checks if a provided share is consistent with a set of
- * commitments.
- */
-template <typename GROUP>
-bool feldmanVerify(
-    const typename FeldmanShare<GROUP>::Field& share,
-    const Vector<typename FeldmanShare<GROUP>::Group>& commitments,
-    std::size_t share_index) {
-  return feldmanVerify<GROUP>({share, commitments}, share_index);
-}
-
 }  // namespace scl

include/scl/time.h

@@ -61,12 +61,24 @@ inline long double timeToMillis(Time::Duration time) {
  * time wouldn't be accurate.
  */
 struct Clock {
-  virtual ~Clock();
+  virtual ~Clock() {}
 
   /**
    * @brief Read the value of the clock.
    */
   virtual Time::Duration read() const = 0;
 };
 
+class RealtimeClock final : public Clock {
+ public:
+  RealtimeClock() : m_start(Time::now()) {}
+
+  Time::Duration read() const override {
+    return Time::now() - m_start;
+  }
+
+ private:
+  Time::TimePoint m_start;
+};
+
 }  // namespace scl

src/scl/hex.cc

@@ -18,22 +18,25 @@
 #include "scl/hex.h"
 
 #include <cstdint>
+#include <iomanip>
 
 template <>
 std::string scl::details::toHexString(const __uint128_t& v) {
-  std::string str;
-  if (v == 0) {
-    str = "0";
+  auto top = static_cast<std::uint64_t>(v >> 64);
+  auto bot = static_cast<std::uint64_t>(v);
+
+  std::stringstream ss;
+  ss << std::hex << std::setfill('0');
+  if (top) {
+    ss << top;
+    // have to add appropriate padding to the bottom word here
+    ss << std::setw(16);
+    ss << bot;
   } else {
-    std::stringstream ss;
-    auto top = static_cast<std::uint64_t>(v >> 64);
-    auto bot = static_cast<std::uint64_t>(v);
-    ss << std::hex;
-    if (top > 0) {
-      ss << top;
-    }
     ss << bot;
-    str = ss.str();
   }
-  return str;
+
+  auto str = ss.str();
+  // make sure the output has an even length
+  return str.length() % 2 ? '0' + str : str;
 }

test/CMakeLists.txt

@@ -55,7 +55,7 @@ set(SCL_SOURCE_FILES_TEST
   scl/net/tcp/test_config.cc
   scl/net/tcp/test_network.cc
 
-  # scl/protocol/test_protocol.cc
+  scl/test_protocol.cc
 
   scl/simulation/test_event.cc
   # scl/simulation/test_context.cc

test/scl/math/test_mersenne127.cc

@@ -33,8 +33,8 @@ TEST_CASE("Mersenne127 defs", "[math][ff]") {
 }
 
 TEST_CASE("Mersenne127 to string", "[math][ff]") {
-  REQUIRE(Field::zero().toString() == "0");
-  REQUIRE(Field::one().toString() == "1");
+  REQUIRE(Field::zero().toString() == "00");
+  REQUIRE(Field::one().toString() == "01");
 
   Field x(0x7b);
   REQUIRE(x.toString() == "7b");
@@ -50,6 +50,14 @@ TEST_CASE("Mersenne127 to string", "[math][ff]") {
   REQUIRE(ss.str() == "7b");
 }
 
+TEST_CASE("Mersenne127 hex") {
+  Field x = Field::fromString("1a0000000000000001");
+  REQUIRE(x.toString() == "1a0000000000000001");
+
+  Field y = Field::fromString("0123");
+  REQUIRE(y.toString() == "0123");
+}
+
 TEST_CASE("Mersenne127 from string", "[math][ff]") {
   auto y = Field::fromString("7b");
   REQUIRE(y == Field(0x7b));

test/scl/math/test_poly.cc

@@ -69,7 +69,7 @@ TEMPLATE_TEST_CASE("Polynomial evaluate", "[math][ss]", FIELD_DEFS) {
   REQUIRE(x5 == FF(54));
 }
 
-TEMPLATE_TEST_CASE("Polynomial to string", "[math][ss]", FIELD_DEFS) {
+TEMPLATE_TEST_CASE("Polynomial to string", "[math][ss]", scl::test::Mersenne61) {
   using FF = TestType;
 
   Vector coeff = {FF(4), FF(5), FF(1)};

test/scl/ss/test_feldman.cc

@@ -33,13 +33,12 @@ TEST_CASE("Feldman", "[ss]") {
   std::size_t t = 4;
 
   auto secret = Field(123);
-  auto sb = feldmanSecretShare<Curve>(secret, 4, 24, prg);
+  auto sb = createFeldmanVerifiableSharing<Curve>(secret, 4, 24, prg);
   REQUIRE(sb.commitments[0] == secret * Curve::generator());
   REQUIRE(sb.shares.size() == 24);
   REQUIRE(sb.commitments.size() == t + 1);
   REQUIRE(feldmanVerify<Curve>({secret, sb.commitments}, 0));
-  REQUIRE(feldmanVerify<Curve>(secret, sb.commitments, 0));
-  REQUIRE(feldmanVerify(sb.getShare(22), 23));
+  REQUIRE(feldmanVerify<Curve>({sb.shares[22], sb.commitments}, 23));
   REQUIRE(shamirRecoverP(sb.shares.subVector(5)) == secret);
 }
 
@@ -50,8 +49,8 @@ TEST_CASE("Feldman hom", "[ss]") {
   auto s0 = Field(123);
   auto s1 = Field(44);
 
-  auto ss0 = feldmanSecretShare<Curve>(s0, t, 10, prg);
-  auto ss1 = feldmanSecretShare<Curve>(s1, t, 10, prg);
+  auto ss0 = createFeldmanVerifiableSharing<Curve>(s0, t, 10, prg);
+  auto ss1 = createFeldmanVerifiableSharing<Curve>(s1, t, 10, prg);
 
   auto ss2 = ss0.shares.add(ss1.shares);
   auto com2 = ss0.commitments.add(ss1.commitments);