version 6.1.0 (#15)

Author: anderspkd

CMakeLists.txt

@@ -16,7 +16,7 @@
 
 cmake_minimum_required( VERSION 3.14 )
 
-project( scl VERSION 6.0.0 DESCRIPTION "Secure Computation Library" )
+project( scl VERSION 6.1.0 DESCRIPTION "Secure Computation Library" )
 
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release)

RELEASE.txt

@@ -1,3 +1,7 @@
+6.1.0: Extend serialization functionality
+- Make Write methods return the number of bytes written.
+- Make it possible to serialize vectors with arbitrary content.
+
 6.0.0: Improvements to serialization and Channels.
 - Added a Serializer type that can be specialized in order to specify how
   various objects are converted to bytes.

include/scl/math/ec.h

@@ -23,6 +23,7 @@
 #include "scl/math/ec_ops.h"
 #include "scl/math/ff.h"
 #include "scl/math/number.h"
+#include "scl/math/ops.h"
 
 namespace scl::math {
 
@@ -36,7 +37,7 @@ namespace scl::math {
  * @see Secp256k1
  */
 template <typename Curve>
-class EC {
+class EC final : Add<EC<Curve>>, Eq<EC<Curve>>, Print<EC<Curve>> {
  public:
   /**
    * @brief The field that this curve is defined over.
@@ -121,17 +122,6 @@ class EC {
     return *this;
   }
 
-  /**
-   * @brief Add two points.
-   * @param lhs the left hand point
-   * @param rhs the right hand point
-   * @return the sum of two EC points.
-   */
-  friend EC operator+(const EC& lhs, const EC& rhs) {
-    EC copy(lhs);
-    return copy += rhs;
-  }
-
   /**
    * @brief Double this point.
    * @return this after doubling.
@@ -160,17 +150,6 @@ class EC {
     return *this;
   }
 
-  /**
-   * @brief Subtract two EC points.
-   * @param lhs the left hand point
-   * @param rhs the right hand point
-   * @return the difference of two EC points.
-   */
-  friend EC operator-(const EC& lhs, const EC& rhs) {
-    EC copy(lhs);
-    return copy -= rhs;
-  }
-
   /**
    * @brief Perform a scalar multiplication.
    * @param scalar the scalar
@@ -243,15 +222,6 @@ class EC {
     return *this;
   }
 
-  /**
-   * @brief Compute the negation of this EC point.
-   * @return the negation of this EC point.
-   */
-  EC operator-() {
-    EC copy(*this);
-    return copy.Negate();
-  }
-
   /**
    * @brief Check if this EC point is equal to another EC point.
    * @param other the other EC point
@@ -261,20 +231,6 @@ class EC {
     return CurveEqual<Curve>(m_value, other.m_value);
   }
 
-  /**
-   * @brief Equality operator for EC points.
-   */
-  friend bool operator==(const EC& lhs, const EC& rhs) {
-    return lhs.Equal(rhs);
-  }
-
-  /**
-   * @brief In-equality operator for EC points.
-   */
-  friend bool operator!=(const EC& lhs, const EC& rhs) {
-    return !(lhs == rhs);
-  }
-
   /**
    * @brief Check if this point is equal to the point at inifity.
    * @return true if this point is equal to the point at inifity.
@@ -298,14 +254,6 @@ class EC {
     return CurveToString<Curve>(m_value);
   }
 
-  /**
-   * @brief Write the curve point to a STL output stream.
-   * @see EC::ToString.
-   */
-  friend std::ostream& operator<<(std::ostream& os, const EC& point) {
-    return os << point.ToString();
-  }
-
   /**
    * @brief Write this point to a buffer.
    * @param dest the destination

include/scl/math/ff.h

@@ -23,7 +23,7 @@
 #include <type_traits>
 
 #include "scl/math/ff_ops.h"
-#include "scl/math/ring.h"
+#include "scl/math/ops.h"
 #include "scl/util/prg.h"
 
 namespace scl::math {
@@ -35,7 +35,10 @@ namespace scl::math {
  * @see Mersenne127
  */
 template <typename Field>
-class FF final : Ring<FF<Field>> {
+class FF final : Add<FF<Field>>,
+                 Mul<FF<Field>>,
+                 Eq<FF<Field>>,
+                 Print<FF<Field>> {
  public:
   /**
    * @brief Size in bytes of a field element.

include/scl/math/mat.h

@@ -29,6 +29,7 @@
 
 #include "scl/math/ff.h"
 #include "scl/math/lagrange.h"
+#include "scl/math/ops.h"
 #include "scl/math/vec.h"
 #include "scl/util/prg.h"
 #include "scl/util/traits.h"
@@ -42,7 +43,7 @@ class Vec;
  * @brief Matrix.
  */
 template <typename Elem>
-class Mat {
+class Mat : Print<Mat<Elem>> {
  public:
   /**
    * @brief The type of the matrix elements.
@@ -385,13 +386,6 @@ class Mat {
    */
   std::string ToString() const;
 
-  /**
-   * @brief Write a string representation of this vector to a stream.
-   */
-  friend std::ostream& operator<<(std::ostream& os, const Mat<Elem>& v) {
-    return os << v.ToString();
-  }
-
   /**
    * @brief Test if this matrix is equal to another.
    */

include/scl/math/number.h

@@ -23,14 +23,15 @@
 
 #include <gmp.h>
 
+#include "scl/math/ops.h"
 #include "scl/util/prg.h"
 
 namespace scl::math {
 
 /**
  * @brief Arbitrary precision integer.
  */
-class Number {
+class Number final : Print<Number> {
  public:
   /**
    * @brief Generate a random Number.
@@ -355,13 +356,6 @@ class Number {
    */
   std::string ToString() const;
 
-  /**
-   * @brief << overload for STL ostream objects.
-   */
-  friend std::ostream& operator<<(std::ostream& os, const Number& number) {
-    return os << number.ToString();
-  };
-
   /**
    * @brief STL swap implementation for Number.
    */

include/scl/math/ops.h

@@ -0,0 +1,123 @@
+/* SCL --- Secure Computation Library
+ * Copyright (C) 2023 Anders Dalskov
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef SCL_MATH_OPS_H
+#define SCL_MATH_OPS_H
+
+#include <ostream>
+
+namespace scl::math {
+
+/**
+ * @brief Provides binary <code>+</code> and <code>-</code>, and unary
+ * <code>-</code> operators.
+ *
+ * Requires that the type \p T implements the <code>+=</code> and
+ * <code>-=</code> operators, and a <code>Negate</code> function.
+ */
+template <typename T>
+struct Add {
+  /**
+   * @brief Add two elements and return their sum.
+   */
+  friend T operator+(const T& lhs, const T& rhs) {
+    T temp(lhs);
+    return temp += rhs;
+  }
+
+  /**
+   * @brief Subtract two elements and return their difference.
+   */
+  friend T operator-(const T& lhs, const T& rhs) {
+    T temp(lhs);
+    return temp -= rhs;
+  }
+
+  /**
+   * @brief Return the negation of an element.
+   */
+  friend T operator-(const T& elem) {
+    T temp(elem);
+    return temp.Negate();
+  }
+};
+
+/**
+ * @brief Provides <code>*</code> and <code>/</code> operators.
+ *
+ * Requires that \p T implements the <code>*=</code> and <code>/=</code>
+ * operators.
+ */
+template <typename T>
+struct Mul {
+  /**
+   * @brief Multiply two elements and return their product.
+   */
+  friend T operator*(const T& lhs, const T& rhs) {
+    T temp(lhs);
+    return temp *= rhs;
+  }
+
+  /**
+   * @brief Divide two elements and return their quotient.
+   */
+  friend T operator/(const T& lhs, const T& rhs) {
+    T temp(lhs);
+    return temp /= rhs;
+  }
+};
+
+/**
+ * @brief Provides <code>==</code> and <code>!=</code> operators.
+ *
+ * Requires that \p implements an <code>Equal(T)</code> function.
+ */
+template <typename T>
+struct Eq {
+  /**
+   * @brief Compare two elements for equality.
+   */
+  friend bool operator==(const T& lhs, const T& rhs) {
+    return lhs.Equal(rhs);
+  }
+
+  /**
+   * @brief Compare two elements for inequality.
+   */
+  friend bool operator!=(const T& lhs, const T& rhs) {
+    return !(lhs == rhs);
+  }
+};
+
+/**
+ * @brief Provides <code><<</code> syntax for printing to a string.
+ *
+ * Requires that \p implements a <code>ToString()</code> function.
+ */
+template <typename T>
+struct Print {
+  /**
+   * @brief Write a string representation of an element to a stream.
+   */
+  friend std::ostream& operator<<(std::ostream& os, const T& r) {
+    return os << r.ToString();
+  }
+};
+
+}  // namespace scl::math
+
+#endif  // SCL_MATH_OPS_H

include/scl/math/ring.h

@@ -25,6 +25,7 @@ namespace scl::math {
 
 /**
  * @brief Derives some basic operations on Ring elements via. CRTP.
+ * @deprecated
  */
 template <typename T>
 struct Ring {

include/scl/math/z2k.h

@@ -20,7 +20,7 @@
 
 #include <stdexcept>
 
-#include "scl/math/ring.h"
+#include "scl/math/ops.h"
 #include "scl/math/z2k_ops.h"
 #include "scl/util/prg.h"
 
@@ -36,7 +36,10 @@ namespace scl::math {
  * byte (so Z2k<6> and Z2k<8> take up the same amount of space).
  */
 template <std::size_t Bits>
-class Z2k final : public Ring<Z2k<Bits>> {
+class Z2k final : Add<Z2k<Bits>>,
+                  Mul<Z2k<Bits>>,
+                  Eq<Z2k<Bits>>,
+                  Print<Z2k<Bits>> {
  public:
   /**
    * @brief The raw type of a Z2k element.