repo-sync-2023-11-17T12:01:22+0800 (#164)

CHANGELOG.md

@@ -8,36 +8,42 @@ All notable changes to this project will be documented in this file.
 > - Add `[Bugfix]` prefix for bug fixes
 > - Add `[API]` prefix for API changes
 
+## 2023-11-16
+- [YACL] 0.4.1.1
+- [Feature] Init Global Security Parameters for Yacl [WIP: apply security parameter to all algorithms]
+- [Feature] Add Softspoken OTe (semi-honest version)
+- [Feature] Add Silent Vole [WIP: optimize MpVole and DualEncode]
+
 ## 2023-10-20
-- [YACL] 0.4.1 release
+- [YACL] 0.4.1
 - [Feature] Add Sigma-type ZKP Protocols (An unified implementation)
 - [Feature] Add ECC Pairing SPI and support to libmcl(ecc, pairing)
 - [Feature] Add Multiplication for GF(2^64) and GF(2^128)
 - [Bugfix] fix KOS OTe security flaws
 - [Feature] Add AVX2 Matrix Transpose
 
 ## 2023-05-25
-- [YACL] 0.3.3 release
+- [YACL] 0.3.3
 - [Feature] Add Ferret OTe
 - [Feature] Add Gywz OTe (Correlated GGM Tree)
 - [Feature] Add KOS OTe (warning: KOS still has potential security flaws)
 
 ## 2023-02-02
-- [YACL] 0.3.1 release
+- [YACL] 0.3.1
 - [Feature] Add `dynamic_bitset` for manipulating bit vectors
 - [API] RO now can accept multiple inputs
 - [API] Add iknp cot api, improve iknp performance
 - [Bugfix] Fix Several m1 related bugs
 
 ## 2022-12-08
-- [YACL] 0.3.0 release
+- [YACL] 0.3.0
 - [Feature] Add random permutation and correlation-robust hash function
 - [Feature] Add OT/OTe benchmark
 - [API] Fix randomness implementation
 - [API] Re-organize repo layout
 - [Bugfix] Fix Random Oralce Usage
 
 ## 2022-12-01
-- [YACL] 0.2.0 release
+- [YACL] 0.2.0
 - [API] Rename YASL to YACL
 - [API] Re-organize repo layout

bazel/repositories.bzl

@@ -18,7 +18,7 @@ load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
 
 SECRETFLOW_GIT = "https://github.com/secretflow"
 
-IC_COMMIT_ID = "dfa3281d641f33c85266b4e04e8c0214f9401cf7"
+IC_COMMIT_ID = "b4a657d5ac39fe584dbccb7808fcbc8897ed2077"
 
 SIMPLEST_OT_COMMIT_ID = "4e39b7c35721c7fd968da6e047f59c0ac92e8088"
 

yacl/base/exception.h

@@ -86,7 +86,8 @@ class Exception : public std::exception {
   Exception() = default;
   explicit Exception(std::string msg) : msg_(std::move(msg)) {}
   explicit Exception(const char* msg) : msg_(msg) {}
-  explicit Exception(const std::string& msg, void** stacks, int dep) {
+  explicit Exception(std::string msg, void** stacks, int dep)
+      : msg_(std::move(msg)) {
     for (int i = 0; i < dep; ++i) {
       std::array<char, 2048> tmp;
       const char* symbol = "(unknown)";
@@ -95,8 +96,6 @@ class Exception : public std::exception {
       }
       stack_trace_.append(fmt::format("#{} {}+{}\n", i, symbol, stacks[i]));
     }
-
-    msg_ = fmt::format("{}\nStacktrace:\n{}", msg, stack_trace_);
   }
   const char* what() const noexcept override { return msg_.c_str(); }
 
@@ -166,65 +165,67 @@ using stacktrace_t = std::array<void*, ::yacl::internal::kMaxStackTraceDep>;
 //   ...
 // }
 //
-#define YACL_THROW(...)                                                    \
-  do {                                                                     \
-    ::yacl::stacktrace_t stacks;                                           \
-    int dep = absl::GetStackTrace(stacks.data(),                           \
-                                  ::yacl::internal::kMaxStackTraceDep, 0); \
-    throw ::yacl::RuntimeError(YACL_ERROR_MSG(__VA_ARGS__), stacks.data(), \
-                               dep);                                       \
+#define YACL_THROW(...)                                                        \
+  do {                                                                         \
+    ::yacl::stacktrace_t __stacks__;                                           \
+    int __dep__ = absl::GetStackTrace(__stacks__.data(),                       \
+                                      ::yacl::internal::kMaxStackTraceDep, 0); \
+    throw ::yacl::RuntimeError(YACL_ERROR_MSG(__VA_ARGS__), __stacks__.data(), \
+                               __dep__);                                       \
   } while (false)
 
 #define YACL_THROW_LOGIC_ERROR(...)                                            \
   do {                                                                         \
-    ::yacl::stacktrace_t stacks;                                               \
-    int dep = absl::GetStackTrace(stacks.data(),                               \
-                                  ::yacl::internal::kMaxStackTraceDep, 0);     \
-    throw ::yacl::LogicError(YACL_ERROR_MSG(__VA_ARGS__), stacks.data(), dep); \
+    ::yacl::stacktrace_t __stacks__;                                           \
+    int __dep__ = absl::GetStackTrace(__stacks__.data(),                       \
+                                      ::yacl::internal::kMaxStackTraceDep, 0); \
+    throw ::yacl::LogicError(YACL_ERROR_MSG(__VA_ARGS__), __stacks__.data(),   \
+                             __dep__);                                         \
   } while (false)
 
-#define YACL_THROW_IO_ERROR(...)                                            \
-  do {                                                                      \
-    ::yacl::stacktrace_t stacks;                                            \
-    int dep = absl::GetStackTrace(stacks.data(),                            \
-                                  ::yacl::internal::kMaxStackTraceDep, 0);  \
-    throw ::yacl::IoError(YACL_ERROR_MSG(__VA_ARGS__), stacks.data(), dep); \
+#define YACL_THROW_IO_ERROR(...)                                               \
+  do {                                                                         \
+    ::yacl::stacktrace_t __stacks__;                                           \
+    int __dep__ = absl::GetStackTrace(__stacks__.data(),                       \
+                                      ::yacl::internal::kMaxStackTraceDep, 0); \
+    throw ::yacl::IoError(YACL_ERROR_MSG(__VA_ARGS__), __stacks__.data(),      \
+                          __dep__);                                            \
   } while (false)
 
-#define YACL_THROW_NETWORK_ERROR(...)                                      \
-  do {                                                                     \
-    ::yacl::stacktrace_t stacks;                                           \
-    int dep = absl::GetStackTrace(stacks.data(),                           \
-                                  ::yacl::internal::kMaxStackTraceDep, 0); \
-    throw ::yacl::NetworkError(YACL_ERROR_MSG(__VA_ARGS__), stacks.data(), \
-                               dep);                                       \
+#define YACL_THROW_NETWORK_ERROR(...)                                          \
+  do {                                                                         \
+    ::yacl::stacktrace_t __stacks__;                                           \
+    int __dep__ = absl::GetStackTrace(__stacks__.data(),                       \
+                                      ::yacl::internal::kMaxStackTraceDep, 0); \
+    throw ::yacl::NetworkError(YACL_ERROR_MSG(__VA_ARGS__), __stacks__.data(), \
+                               __dep__);                                       \
   } while (false)
 
-#define YACL_THROW_LINK_ERROR(code, http_code, ...)                          \
-  do {                                                                       \
-    ::yacl::stacktrace_t stacks;                                             \
-    int dep = absl::GetStackTrace(stacks.data(),                             \
-                                  ::yacl::internal::kMaxStackTraceDep, 0);   \
-    throw ::yacl::LinkError(YACL_ERROR_MSG(__VA_ARGS__), stacks.data(), dep, \
-                            code, http_code);                                \
+#define YACL_THROW_LINK_ERROR(code, http_code, ...)                            \
+  do {                                                                         \
+    ::yacl::stacktrace_t __stacks__;                                           \
+    int __dep__ = absl::GetStackTrace(__stacks__.data(),                       \
+                                      ::yacl::internal::kMaxStackTraceDep, 0); \
+    throw ::yacl::LinkError(YACL_ERROR_MSG(__VA_ARGS__), __stacks__.data(),    \
+                            __dep__, code, http_code);                         \
   } while (false)
 
-#define YACL_THROW_INVALID_FORMAT(...)                                      \
-  do {                                                                      \
-    ::yacl::stacktrace_t stacks;                                            \
-    int dep = absl::GetStackTrace(stacks.data(),                            \
-                                  ::yacl::internal::kMaxStackTraceDep, 0);  \
-    throw ::yacl::InvalidFormat(YACL_ERROR_MSG(__VA_ARGS__), stacks.data(), \
-                                dep);                                       \
+#define YACL_THROW_INVALID_FORMAT(...)                                         \
+  do {                                                                         \
+    ::yacl::stacktrace_t __stacks__;                                           \
+    int __dep__ = absl::GetStackTrace(__stacks__.data(),                       \
+                                      ::yacl::internal::kMaxStackTraceDep, 0); \
+    throw ::yacl::InvalidFormat(YACL_ERROR_MSG(__VA_ARGS__),                   \
+                                __stacks__.data(), __dep__);                   \
   } while (false)
 
-#define YACL_THROW_ARGUMENT_ERROR(...)                                      \
-  do {                                                                      \
-    ::yacl::stacktrace_t stacks;                                            \
-    int dep = absl::GetStackTrace(stacks.data(),                            \
-                                  ::yacl::internal::kMaxStackTraceDep, 0);  \
-    throw ::yacl::ArgumentError(YACL_ERROR_MSG(__VA_ARGS__), stacks.data(), \
-                                dep);                                       \
+#define YACL_THROW_ARGUMENT_ERROR(...)                                         \
+  do {                                                                         \
+    ::yacl::stacktrace_t __stacks__;                                           \
+    int __dep__ = absl::GetStackTrace(__stacks__.data(),                       \
+                                      ::yacl::internal::kMaxStackTraceDep, 0); \
+    throw ::yacl::ArgumentError(YACL_ERROR_MSG(__VA_ARGS__),                   \
+                                __stacks__.data(), __dep__);                   \
   } while (false)
 
 // For Status.
@@ -278,16 +279,16 @@ class EnforceNotMet : public Exception {
 
 // If you don't want to print stacktrace in error message, use
 // "YACL_ENFORCE_THAT" instead.
-#define YACL_ENFORCE(condition, ...)                                         \
-  do {                                                                       \
-    if (!(condition)) {                                                      \
-      ::yacl::stacktrace_t stacks;                                           \
-      int dep = absl::GetStackTrace(stacks.data(),                           \
-                                    ::yacl::internal::kMaxStackTraceDep, 0); \
-      throw ::yacl::EnforceNotMet(__FILE__, __LINE__, #condition,            \
-                                  ::yacl::internal::Format(__VA_ARGS__),     \
-                                  stacks.data(), dep);                       \
-    }                                                                        \
+#define YACL_ENFORCE(condition, ...)                                     \
+  do {                                                                   \
+    if (!(condition)) {                                                  \
+      ::yacl::stacktrace_t __stacks__;                                   \
+      int __dep__ = absl::GetStackTrace(                                 \
+          __stacks__.data(), ::yacl::internal::kMaxStackTraceDep, 0);    \
+      throw ::yacl::EnforceNotMet(__FILE__, __LINE__, #condition,        \
+                                  ::yacl::internal::Format(__VA_ARGS__), \
+                                  __stacks__.data(), __dep__);           \
+    }                                                                    \
   } while (false)
 
 /**

yacl/crypto/primitives/ot/BUILD.bazel

@@ -70,6 +70,7 @@ yacl_cc_library(
         "//yacl/base:exception",
         "//yacl/crypto/tools:random_oracle",
         "//yacl/link",
+        "//yacl/math:gadget",
         "@simplest_ot//:simplest_ot_x86_asm",
     ],
 )
@@ -81,6 +82,7 @@ yacl_cc_library(
     deps = [
         "//yacl/base:exception",
         "//yacl/crypto/primitives/ot:ot_store",
+        "//yacl/crypto/utils:secparam",
         "//yacl/link",
         "@com_google_absl//absl/types:span",
     ] + select({
@@ -109,10 +111,9 @@ yacl_cc_library(
     hdrs = ["iknp_ote.h"],
     deps = [
         ":ot_store",
-        "//yacl/base:exception",
-        "//yacl/base:int128",
         "//yacl/crypto/tools:prg",
         "//yacl/crypto/tools:random_permutation",
+        "//yacl/crypto/utils:secparam",
         "//yacl/link",
         "//yacl/utils:matrix_utils",
     ],
@@ -143,6 +144,7 @@ yacl_cc_library(
         "//yacl/crypto/tools:random_oracle",
         "//yacl/crypto/tools:random_permutation",
         "//yacl/crypto/utils:rand",
+        "//yacl/crypto/utils:secparam",
         "//yacl/link",
         "//yacl/utils:matrix_utils",
     ],
@@ -169,6 +171,7 @@ yacl_cc_library(
         "//yacl/crypto/tools:prg",
         "//yacl/crypto/tools:random_permutation",
         "//yacl/crypto/utils:rand",
+        "//yacl/crypto/utils:secparam",
         "//yacl/link",
         "//yacl/math:gadget",
         "@com_google_absl//absl/numeric:bits",
@@ -197,6 +200,7 @@ yacl_cc_library(
         "//yacl/crypto/tools:prg",
         "//yacl/crypto/tools:random_permutation",
         "//yacl/crypto/utils:rand",
+        "//yacl/crypto/utils:secparam",
         "//yacl/link",
         "//yacl/math:gadget",
         "@com_google_absl//absl/numeric:bits",
@@ -230,6 +234,7 @@ yacl_cc_library(
         "//yacl/crypto/tools:prg",
         "//yacl/crypto/tools:random_permutation",
         "//yacl/crypto/utils:rand",
+        "//yacl/crypto/utils:secparam",
         "//yacl/link",
         "//yacl/math:gadget",
         "//yacl/utils:cuckoo_index",
@@ -259,6 +264,7 @@ yacl_cc_library(
         "//yacl/crypto/tools:prg",
         "//yacl/crypto/tools:random_permutation",
         "//yacl/crypto/utils:rand",
+        "//yacl/crypto/utils:secparam",
         "//yacl/link",
         "//yacl/math/f2k",
         "//yacl/utils:matrix_utils",
@@ -275,6 +281,39 @@ yacl_cc_test(
     ],
 )
 
+yacl_cc_library(
+    name = "softspoken_ote",
+    srcs = ["softspoken_ote.cc"],
+    hdrs = ["softspoken_ote.h"],
+    copts = AES_COPT_FLAGS,
+    deps = [
+        ":base_ot",
+        ":ot_store",
+        ":sgrr_ote",
+        "//yacl/base:exception",
+        "//yacl/base:int128",
+        "//yacl/crypto/tools:prg",
+        "//yacl/crypto/tools:random_permutation",
+        "//yacl/link",
+        "//yacl/utils:matrix_utils",
+    ] + select({
+        "@platforms//cpu:aarch64": [
+            "@com_github_dltcollab_sse2neon//:sse2neon",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+yacl_cc_test(
+    name = "softspoken_ote_test",
+    srcs = ["softspoken_ote_test.cc"],
+    deps = [
+        ":softspoken_ote",
+        "//yacl/crypto/utils:rand",
+        "//yacl/link:test_util",
+    ],
+)
+
 yacl_cc_binary(
     name = "benchmark",
     srcs = [
@@ -289,6 +328,7 @@ yacl_cc_binary(
         ":kkrt_ote",
         ":kos_ote",
         ":sgrr_ote",
+        ":softspoken_ote",
         "//yacl/crypto/utils:rand",
         "//yacl/link:test_util",
         "@com_github_google_benchmark//:benchmark_main",

yacl/crypto/primitives/ot/base_ot.h

@@ -22,10 +22,13 @@
 #include "yacl/base/dynamic_bitset.h"
 #include "yacl/base/int128.h"
 #include "yacl/crypto/primitives/ot/ot_store.h"
+#include "yacl/crypto/utils/secparam.h"
 #include "yacl/link/link.h"
 
 namespace yacl::crypto {
 
+YACL_MODULE_DECLARE("base_ot", SecParam::C::k128, SecParam::S::INF);
+
 using Block = uint128_t;
 
 void BaseOtRecv(const std::shared_ptr<link::Context>& ctx,

yacl/crypto/primitives/ot/benchmark.cc

@@ -29,7 +29,7 @@ void BM_DefaultArguments(benchmark::internal::Benchmark* b) {
 }
 
 void BM_PerfArguments(benchmark::internal::Benchmark* b) {
-  b->Arg(1 << 20)  // 1048576
+  b->Arg(1 << 20)  // 1048576, one million
       ->Arg(1 << 21)
       ->Arg(1 << 22)
       ->Arg(1 << 23)
@@ -39,7 +39,7 @@ void BM_PerfArguments(benchmark::internal::Benchmark* b) {
       ->Iterations(10);
 }
 
-BM_REGISTER_ALL_OT(BM_DefaultArguments);
+// BM_REGISTER_ALL_OT(BM_DefaultArguments);
 
 // Equivalent to the following
 // BM_REGISTER_SIMPLEST_OT(BM_DefaultArguments);
@@ -48,7 +48,7 @@ BM_REGISTER_ALL_OT(BM_DefaultArguments);
 // BM_REGISTER_KKRT_OTE(BM_DefaultArguments);
 // BM_REGISTER_SGRR_OTE(BM_DefaultArguments);
 // BM_REGISTER_GYWZ_OTE(BM_PerfArguments);
-// BM_REGISTER_FERRET_OTE(BM_PerfArguments);
-// BM_REGISTER_FERRET_OTE(BM_PerfArguments);
+// BM_REGISTER_SOFTSPOKEN_OTE(BM_PerfArguments);
+BM_REGISTER_FERRET_OTE(BM_PerfArguments);
 
 }  // namespace yacl::crypto