Update README file && support OSX

README.md

@@ -11,7 +11,7 @@ It takes the form of a library (`libcosigner`) containing the algorithms and sup
 This version of the code targets *Ubuntu Linux 20.04 LTS* release.
 The libraries and headers of the following dependencies are required:
 
-* OpenSSL version 1.1.1
+* OpenSSL version 1.1.1 or higher
 * libuuid (for tests)
 * libsecp256k1 (for tests, optional)
 
@@ -24,12 +24,12 @@ apt install build-essential libssl-dev uuid-dev libsecp256k1-dev
 
 Build the library and tests by running:
 ```sh
-make
+mkdir build; cd build; cmake ..; make
 ```
 
-To execute the test suite, run the command:
+To execute the test suite, run the command from the same build folder:
 ```sh
-make run-tests
+make test
 ```
 
 ## Usage

include/crypto/common/byteswap.h

@@ -0,0 +1,9 @@
+#pragma once
+#ifdef __APPLE__
+    #include <libkern/OSByteOrder.h>
+    #define bswap_16(x) OSSwapInt16(x)
+    #define bswap_32(x) OSSwapInt32(x)
+    #define bswap_64(x) OSSwapInt64(x)
+#else
+    #include <byteswap.h>
+#endif

src/common/CMakeLists.txt

@@ -47,11 +47,16 @@ if(NOT EMSCRIPTEN)
     target_compile_options(cosigner PRIVATE -fstack-protector-strong)
 endif()
 
-set(LINKER_VERSION_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/lib.lds)
-target_link_options(cosigner PRIVATE
-    "LINKER:--version-script=${LINKER_VERSION_SCRIPT}"
-    "LINKER:--no-undefined")
-set_target_properties(cosigner PROPERTIES LINK_DEPENDS ${LINKER_VERSION_SCRIPT})
+# Check for macOS platform
+if(NOT APPLE)
+    # For Linux/other systems, use version script and no-undefined
+    set(LINKER_VERSION_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/lib.lds)
+    target_link_options(cosigner PRIVATE
+        "LINKER:--version-script=${LINKER_VERSION_SCRIPT}"
+        "LINKER:--no-undefined")
+    set_target_properties(cosigner PROPERTIES LINK_DEPENDS ${LINKER_VERSION_SCRIPT})
+endif()
 
 target_include_directories(cosigner PUBLIC ${PROJECT_SOURCE_DIR}/include)
-target_link_libraries(cosigner PUBLIC OpenSSL::Crypto)
+target_include_directories(cosigner PUBLIC ${OPENSSL_INCLUDE_DIR})
+target_link_libraries(cosigner PRIVATE OpenSSL::Crypto)

src/common/crypto/GFp_curve_algebra/GFp_curve_algebra.c

@@ -2,7 +2,7 @@
 
 #include <string.h>
 #include <assert.h>
-#include <byteswap.h>
+#include "crypto/common/byteswap.h"
 
 #include <openssl/bn.h>
 #include <openssl/err.h>

src/common/crypto/ed25519_algebra/ed25519_algebra.c

@@ -3,7 +3,7 @@
 #include "crypto/keccak1600/keccak1600.h"
 #include "curve25519.c"
 
-#include <byteswap.h>
+#include "crypto/common/byteswap.h"
 
 #include <openssl/bn.h>
 #include <openssl/sha.h>

src/common/crypto/zero_knowledge_proof/diffie_hellman_log.c

@@ -1,6 +1,6 @@
 #include "crypto/zero_knowledge_proof/diffie_hellman_log.h"
 #include "crypto/drng/drng.h"
-#include <byteswap.h>
+#include "crypto/common/byteswap.h"
 #include <string.h>
 #include <openssl/sha.h>
 

test/cosigner/CMakeLists.txt

@@ -12,6 +12,12 @@ add_executable(cosigner_test
     setup_test.cpp
 )
 
-target_link_libraries(cosigner_test PRIVATE tests_main cosigner Threads::Threads UUID::UUID)
+
+# Link the necessary libraries to the cosigner_test target
+if(APPLE)
+    target_link_libraries(cosigner_test PRIVATE tests_main cosigner Threads::Threads) # No UUID library on macOS
+else()
+    target_link_libraries(cosigner_test PRIVATE tests_main cosigner Threads::Threads UUID::UUID OpenSSL::Crypto)
+endif()
 
 add_test(NAME cosigner_test COMMAND cosigner_test)

test/cosigner/cmake/FindUUID.cmake

@@ -1,12 +1,31 @@
 # FindUUID.cmake
-find_path(UUID_INCLUDE_DIR uuid/uuid.h)
-find_library(UUID_LIBRARY NAMES uuid)
+if(APPLE)
+  # On macOS, uuid is part of the system and doesn't need an external library
+  find_path(UUID_INCLUDE_DIR uuid/uuid.h /usr/include)
+
+  if(UUID_INCLUDE_DIR)
+    set(UUID_FOUND TRUE)
+    set(UUID_LIBRARY "") # No library needed on macOS
+  else()
+    set(UUID_FOUND FALSE)
+  endif()
+else()
+  # For Linux or other UNIX-like systems
+  find_path(UUID_INCLUDE_DIR uuid/uuid.h)
+  find_library(UUID_LIBRARY NAMES uuid)
+endif()
 
 message(STATUS "UUID_LIBRARY=${UUID_LIBRARY}")
 message(STATUS "UUID_INCLUDE_DIR=${UUID_INCLUDE_DIR}")
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(UUID DEFAULT_MSG UUID_LIBRARY UUID_INCLUDE_DIR)
+if(APPLE)
+  # On macOS, only check for the header file, not the library
+  find_package_handle_standard_args(UUID DEFAULT_MSG UUID_INCLUDE_DIR)
+else()
+  # On Linux, check for both the header and the library
+  find_package_handle_standard_args(UUID DEFAULT_MSG UUID_LIBRARY UUID_INCLUDE_DIR)
+endif()
 
 if(UUID_FOUND AND NOT TARGET UUID::UUID)
   add_library(UUID::UUID UNKNOWN IMPORTED)

test/cosigner/ecdsa_offline_test.cpp

@@ -35,8 +35,8 @@ static elliptic_curve256_algebra_ctx_t* create_algebra(cosigner_sign_algorithm t
         case ECDSA_SECP256K1: return elliptic_curve256_new_secp256k1_algebra();
         case ECDSA_SECP256R1: return elliptic_curve256_new_secp256r1_algebra();
         case ECDSA_STARK: return elliptic_curve256_new_stark_algebra();
+        default: return NULL;
     }
-    return NULL;
 }
 
 
@@ -46,21 +46,21 @@ class sign_platform : public platform_service
     sign_platform(uint64_t id) : _id(id), _positive_r(false) {}
     void set_positive_r(bool positive_r) {_positive_r = positive_r;}
 private:
-    void gen_random(size_t len, uint8_t* random_data) const
+    void gen_random(size_t len, uint8_t* random_data) const override
     {
         RAND_bytes(random_data, len);
     }
 
     uint64_t now_msec() const override { return std::chrono::time_point_cast<std::chrono::milliseconds>(Clock::now()).time_since_epoch().count(); }
 
-    const std::string get_current_tenantid() const {return TENANT_ID;}
-    uint64_t get_id_from_keyid(const std::string& key_id) const {return _id;}
-    void derive_initial_share(const share_derivation_args& derive_from, cosigner_sign_algorithm algorithm, elliptic_curve256_scalar_t* key) const {assert(0);}
-    byte_vector_t encrypt_for_player(uint64_t id, const byte_vector_t& data) const {return data;}
-    byte_vector_t decrypt_message(const byte_vector_t& encrypted_data) const {return encrypted_data;}
-    bool backup_key(const std::string& key_id, cosigner_sign_algorithm algorithm, const elliptic_curve256_scalar_t& private_key, const cmp_key_metadata& metadata, const auxiliary_keys& aux) {return true;}
-    void start_signing(const std::string& key_id, const std::string& txid, const signing_data& data, const std::string& metadata_json, const std::set<std::string>& players) {}
-    void fill_signing_info_from_metadata(const std::string& metadata, std::vector<uint32_t>& flags) const
+    const std::string get_current_tenantid() const override {return TENANT_ID;}
+    uint64_t get_id_from_keyid(const std::string& key_id) const override {return _id;}
+    void derive_initial_share(const share_derivation_args& derive_from, cosigner_sign_algorithm algorithm, elliptic_curve256_scalar_t* key) const override {assert(0);}
+    byte_vector_t encrypt_for_player(uint64_t id, const byte_vector_t& data) const override {return data;}
+    byte_vector_t decrypt_message(const byte_vector_t& encrypted_data) const override {return encrypted_data;}
+    bool backup_key(const std::string& key_id, cosigner_sign_algorithm algorithm, const elliptic_curve256_scalar_t& private_key, const cmp_key_metadata& metadata, const auxiliary_keys& aux) override {return true;}
+    void start_signing(const std::string& key_id, const std::string& txid, const signing_data& data, const std::string& metadata_json, const std::set<std::string>& players) override {}
+    void fill_signing_info_from_metadata(const std::string& metadata, std::vector<uint32_t>& flags) const override 
     {
         for (auto i = flags.begin(); i != flags.end(); ++i)
             *i = _positive_r ? POSITIVE_R : 0;
@@ -494,7 +494,7 @@ TEST_CASE("cmp_offline_ecdsa") {
         for (auto i = players.begin(); i != players.end(); ++i)
         {
             auto info = std::make_unique<offline_siging_info>(i->first, i->second);
-            services.emplace(i->first, move(info));
+            services.emplace(i->first, std::move(info));
         }
 
         auto before = Clock::now();
@@ -543,7 +543,7 @@ TEST_CASE("cmp_offline_ecdsa") {
         for (auto i = players.begin(); i != players.end(); ++i)
         {
             auto info = std::make_unique<key_refresh_info>(i->first, i->second, services.at(i->first)->persistency);
-            refresh_info.emplace(i->first, move(info));
+            refresh_info.emplace(i->first, std::move(info));
         }
         key_refresh(refresh_info, keyid, pubkey);
         ecdsa_sign(services, ECDSA_SECP256K1, keyid, 9, 1, pubkey, chaincode, derivation_paths);
@@ -562,7 +562,7 @@ TEST_CASE("cmp_offline_ecdsa") {
         for (auto i = players.begin(); i != players.end(); ++i)
         {
             auto info = std::make_unique<offline_siging_info>(i->first, i->second);
-            services.emplace(i->first, move(info));
+            services.emplace(i->first, std::move(info));
         }
 
         const size_t THREAD_COUNT = 8;
@@ -607,7 +607,7 @@ TEST_CASE("cmp_offline_ecdsa") {
         for (auto i = players.begin(); i != players.end(); ++i)
         {
             auto info = std::make_unique<offline_siging_info>(i->first, i->second);
-            services.emplace(i->first, move(info));
+            services.emplace(i->first, std::move(info));
         }
 
         ecdsa_preprocess(services, keyid, 0, BLOCK_SIZE, BLOCK_SIZE);
@@ -625,7 +625,7 @@ TEST_CASE("cmp_offline_ecdsa") {
         for (auto i = new_players.begin(); i != new_players.end(); ++i)
         {
             auto info = std::make_unique<offline_siging_info>(i->first, i->second);
-            new_services.emplace(i->first, move(info));
+            new_services.emplace(i->first, std::move(info));
         }
         ecdsa_preprocess(new_services, new_keyid, 0, BLOCK_SIZE, BLOCK_SIZE);
         ecdsa_sign(new_services, ECDSA_SECP256R1, new_keyid, 0, 1, pubkey, chaincode, {path});
@@ -644,7 +644,7 @@ TEST_CASE("cmp_offline_ecdsa") {
         for (auto i = players.begin(); i != players.end(); ++i)
         {
             auto info = std::make_unique<offline_siging_info>(i->first, i->second);
-            services.emplace(i->first, move(info));
+            services.emplace(i->first, std::move(info));
         }
 
         ecdsa_preprocess(services, keyid, 0, BLOCK_SIZE, BLOCK_SIZE);

test/cosigner/ecdsa_online_test.cpp

@@ -32,8 +32,8 @@ static elliptic_curve256_algebra_ctx_t* create_algebra(cosigner_sign_algorithm t
         case ECDSA_SECP256K1: return elliptic_curve256_new_secp256k1_algebra();
         case ECDSA_SECP256R1: return elliptic_curve256_new_secp256r1_algebra();
         case ECDSA_STARK: return elliptic_curve256_new_stark_algebra();
+        default: return NULL;
     }
-    return NULL;
 }
 
 
@@ -42,21 +42,21 @@ class sign_platform : public platform_service
 public:
     sign_platform(uint64_t id, bool positive_r) : _id(id), _positive_r(positive_r) {}
 private:
-    void gen_random(size_t len, uint8_t* random_data) const
+    void gen_random(size_t len, uint8_t* random_data) const override
     {
         RAND_bytes(random_data, len);
     }
 
     uint64_t now_msec() const override { return std::chrono::time_point_cast<std::chrono::milliseconds>(Clock::now()).time_since_epoch().count(); }
 
-    const std::string get_current_tenantid() const {return TENANT_ID;}
-    uint64_t get_id_from_keyid(const std::string& key_id) const {return _id;}
-    void derive_initial_share(const share_derivation_args& derive_from, cosigner_sign_algorithm algorithm, elliptic_curve256_scalar_t* key) const {assert(0);}
-    byte_vector_t encrypt_for_player(uint64_t id, const byte_vector_t& data) const {assert(0);}
-    byte_vector_t decrypt_message(const byte_vector_t& encrypted_data) const {assert(0);}
-    bool backup_key(const std::string& key_id, cosigner_sign_algorithm algorithm, const elliptic_curve256_scalar_t& private_key, const cmp_key_metadata& metadata, const auxiliary_keys& aux) {return true;}
-    void start_signing(const std::string& key_id, const std::string& txid, const signing_data& data, const std::string& metadata_json, const std::set<std::string>& players) {}
-    void fill_signing_info_from_metadata(const std::string& metadata, std::vector<uint32_t>& flags) const 
+    const std::string get_current_tenantid() const override {return TENANT_ID;}
+    uint64_t get_id_from_keyid(const std::string& key_id) const override {return _id;}
+    void derive_initial_share(const share_derivation_args& derive_from, cosigner_sign_algorithm algorithm, elliptic_curve256_scalar_t* key) const override {assert(0);}
+    byte_vector_t encrypt_for_player(uint64_t id, const byte_vector_t& data) const override {assert(0);}
+    byte_vector_t decrypt_message(const byte_vector_t& encrypted_data) const override {assert(0);}
+    bool backup_key(const std::string& key_id, cosigner_sign_algorithm algorithm, const elliptic_curve256_scalar_t& private_key, const cmp_key_metadata& metadata, const auxiliary_keys& aux) override {return true;}
+    void start_signing(const std::string& key_id, const std::string& txid, const signing_data& data, const std::string& metadata_json, const std::set<std::string>& players) override {}
+    void fill_signing_info_from_metadata(const std::string& metadata, std::vector<uint32_t>& flags) const override
     {
         for (auto i = flags.begin(); i != flags.end(); ++i)
             *i = _positive_r ? POSITIVE_R : 0;
@@ -133,7 +133,7 @@ static void ecdsa_sign(players_setup_info& players, cosigner_sign_algorithm type
     for (auto i = players.begin(); i != players.end(); ++i)
     {
         auto info = std::make_unique<siging_info>(i->first, i->second, positive_r);
-        services.emplace(i->first, move(info));
+        services.emplace(i->first, std::move(info));
         players_ids.insert(i->first);
         players_str.insert(std::to_string(i->first));
     }

test/cosigner/eddsa_offline_test.cpp

@@ -28,8 +28,8 @@ static elliptic_curve256_algebra_ctx_t* create_algebra(cosigner_sign_algorithm t
         case EDDSA_ED25519: return elliptic_curve256_new_secp256k1_algebra();
         case ECDSA_SECP256R1: return elliptic_curve256_new_secp256r1_algebra();
         case ECDSA_STARK: return elliptic_curve256_new_stark_algebra();
+        default: return NULL;
     }
-    return NULL;
 }
 
 
@@ -39,21 +39,21 @@ class asymmetric_eddsa_platform : public platform_service
     asymmetric_eddsa_platform(uint64_t id) : _id(id), _use_keccak(false) {}
     void set_use_keccak(bool use_keccak) {_use_keccak = use_keccak;}
 private:
-    void gen_random(size_t len, uint8_t* random_data) const
+    void gen_random(size_t len, uint8_t* random_data) const override
     {
         RAND_bytes(random_data, len);
     }
 
     uint64_t now_msec() const override { return std::chrono::time_point_cast<std::chrono::milliseconds>(Clock::now()).time_since_epoch().count(); }
 
-    const std::string get_current_tenantid() const {return TENANT_ID;}
-    uint64_t get_id_from_keyid(const std::string& key_id) const {return _id;}
-    void derive_initial_share(const share_derivation_args& derive_from, cosigner_sign_algorithm algorithm, elliptic_curve256_scalar_t* key) const {assert(0);}
-    byte_vector_t encrypt_for_player(uint64_t id, const byte_vector_t& data) const {assert(0);}
-    byte_vector_t decrypt_message(const byte_vector_t& encrypted_data) const {assert(0);}
-    bool backup_key(const std::string& key_id, cosigner_sign_algorithm algorithm, const elliptic_curve256_scalar_t& private_key, const cmp_key_metadata& metadata, const auxiliary_keys& aux) {return true;}
-    void start_signing(const std::string& key_id, const std::string& txid, const signing_data& data, const std::string& metadata_json, const std::set<std::string>& players) {}
-    void fill_signing_info_from_metadata(const std::string& metadata, std::vector<uint32_t>& flags) const 
+    const std::string get_current_tenantid() const override {return TENANT_ID;}
+    uint64_t get_id_from_keyid(const std::string& key_id) const override {return _id;}
+    void derive_initial_share(const share_derivation_args& derive_from, cosigner_sign_algorithm algorithm, elliptic_curve256_scalar_t* key) const override { assert(0);}
+    byte_vector_t encrypt_for_player(uint64_t id, const byte_vector_t& data) const override {assert(0);}
+    byte_vector_t decrypt_message(const byte_vector_t& encrypted_data) const override {assert(0);}
+    bool backup_key(const std::string& key_id, cosigner_sign_algorithm algorithm, const elliptic_curve256_scalar_t& private_key, const cmp_key_metadata& metadata, const auxiliary_keys& aux) override {return true;}
+    void start_signing(const std::string& key_id, const std::string& txid, const signing_data& data, const std::string& metadata_json, const std::set<std::string>& players) override {}
+    void fill_signing_info_from_metadata(const std::string& metadata, std::vector<uint32_t>& flags) const override
     {
         for (auto i = flags.begin(); i != flags.end(); ++i)
             *i = _use_keccak ? EDDSA_KECCAK : 0;
@@ -71,7 +71,7 @@ class client_persistency : public asymmetric_eddsa_cosigner_client::preprocessin
         std::lock_guard<std::mutex> lock(_mutex);
         if (_preprocessed_data.find(key_id) != _preprocessed_data.end())
             throw cosigner_exception(cosigner_exception::INVALID_TRANSACTION);
-        _preprocessed_data.emplace(key_id, std::move(std::vector<ed25519_scalar_t>(size)));
+        _preprocessed_data.emplace(key_id, std::move(std::vector<std::array<uint8_t, sizeof(ed25519_scalar_t)>>(size)));
     }
 
     void store_preprocessed_data(const std::string& key_id, uint64_t index, const ed25519_scalar_t& k) override
@@ -82,7 +82,7 @@ class client_persistency : public asymmetric_eddsa_cosigner_client::preprocessin
             throw cosigner_exception(cosigner_exception::INVALID_TRANSACTION);
         if (index >= it->second.size())
             throw cosigner_exception(cosigner_exception::INVALID_PRESIGNING_INDEX);
-        memcpy(it->second[index], k, sizeof(ed25519_scalar_t));
+        memcpy(&((it->second[index])[0]), k, sizeof(ed25519_scalar_t));
     }
 
     void load_preprocessed_data(const std::string& key_id, uint64_t index, ed25519_scalar_t& k) override
@@ -92,10 +92,10 @@ class client_persistency : public asymmetric_eddsa_cosigner_client::preprocessin
         auto it = _preprocessed_data.find(key_id);
         if (it == _preprocessed_data.end())
             throw cosigner_exception(cosigner_exception::INVALID_TRANSACTION);
-        if (index >= it->second.size() || memcmp(it->second[index], ZERO, sizeof(ed25519_scalar_t)) == 0)
+        if (index >= it->second.size() || memcmp(&((it->second[index])[0]), ZERO, sizeof(ed25519_scalar_t)) == 0)
             throw cosigner_exception(cosigner_exception::INVALID_PRESIGNING_INDEX);
-        memcpy(k, it->second[index], sizeof(ed25519_scalar_t));
-        memset(it->second[index], 0, sizeof(ed25519_scalar_t));
+        memcpy(k, &((it->second[index])[0]), sizeof(ed25519_scalar_t));
+        memset(&((it->second[index])[0]), 0, sizeof(ed25519_scalar_t));
     }
 
     void delete_preprocessed_data(const std::string& key_id) override
@@ -105,7 +105,7 @@ class client_persistency : public asymmetric_eddsa_cosigner_client::preprocessin
     }
 
     mutable std::mutex _mutex;
-    std::map<std::string, std::vector<ed25519_scalar_t>> _preprocessed_data;
+    std::map<std::string, std::vector<std::array<uint8_t, sizeof(ed25519_scalar_t)>>> _preprocessed_data;
 };
 
 class server_persistency : public asymmetric_eddsa_cosigner_server::signing_persistency