Merge pull request #20 from Bilb/add-blinding

chore: bump libsession-util and use oxen fork

Author: Bilb

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "libsession-util"]
 	path = libsession-util
-	url = https://github.com/Bilb/libsession-util.git
+	url = https://github.com/oxen-io/libsession-util.git

index.d.ts

@@ -1,5 +1,6 @@
 /// <reference path="./shared.d.ts" />
 /// <reference path="./user/index.d.ts" />
+/// <reference path="./types/index.d.ts" />
 
 declare module 'libsession_util_nodejs' {
   /**

libsession-util

@@ -2,7 +2,7 @@
   "main": "index.js",
   "name": "libsession_util_nodejs",
   "description": "Wrappers for the Session Util Library",
-  "version": "0.3.20",
+  "version": "0.3.21",
   "license": "GPL-3.0",
   "author": {
     "name": "Oxen Project",

package.json

@@ -1,5 +1,6 @@
 #include <napi.h>
 
+#include "blinding/blinding.hpp"
 #include "constants.hpp"
 #include "contacts_config.hpp"
 #include "convo_info_volatile_config.hpp"
@@ -15,6 +16,9 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
     UserGroupsWrapper::Init(env, exports);
     ConvoInfoVolatileWrapper::Init(env, exports);
 
+    // Fully static wrappers init
+    BlindingWrapper::Init(env, exports);
+
     return exports;
 }
 

src/addon.cpp

@@ -15,8 +15,7 @@ namespace session::nodeapi {
 
 class ConfigBaseImpl;
 template <typename T>
-inline constexpr bool is_derived_napi_wrapper =
-        std::is_base_of_v<ConfigBaseImpl, T> && std::is_base_of_v<Napi::ObjectWrap<T>, T>;
+inline constexpr bool is_derived_napi_wrapper = std::is_base_of_v<Napi::ObjectWrap<T>, T>;
 
 /// Base implementation class for config types; this provides the napi wrappers for the base
 /// methods.  Subclasses should inherit from this (alongside Napi::ObjectWrap<ConfigBaseWrapper>)

src/base_config.hpp

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <napi.h>
+
+#include <algorithm>
+
+#include "../meta/meta_base_wrapper.hpp"
+#include "../utilities.hpp"
+#include "oxenc/hex.h"
+#include "session/blinding.hpp"
+#include "session/config/user_profile.hpp"
+#include "session/platform.hpp"
+#include "session/random.hpp"
+
+namespace session::nodeapi {
+
+class BlindingWrapper : public Napi::ObjectWrap<BlindingWrapper> {
+
+  public:
+    BlindingWrapper(const Napi::CallbackInfo& info) : Napi::ObjectWrap<BlindingWrapper>{info} {
+        throw std::invalid_argument(
+                "BlindingWrapper is all static and don't need to be constructed");
+    }
+
+    static void Init(Napi::Env env, Napi::Object exports) {
+        MetaBaseWrapper::NoBaseClassInitHelper<BlindingWrapper>(
+                env,
+                exports,
+                "BlindingWrapperNode",
+                {
+                        StaticMethod<&BlindingWrapper::blindVersionPubkey>(
+                                "blindVersionPubkey",
+                                static_cast<napi_property_attributes>(
+                                        napi_writable | napi_configurable)),
+                        StaticMethod<&BlindingWrapper::blindVersionSign>(
+                                "blindVersionSign",
+                                static_cast<napi_property_attributes>(
+                                        napi_writable | napi_configurable)),
+
+                });
+    }
+
+  private:
+    static Napi::Value blindVersionPubkey(const Napi::CallbackInfo& info) {
+        return wrapResult(info, [&] {
+            assertInfoLength(info, 1);
+            assertIsObject(info[0]);
+            auto obj = info[0].As<Napi::Object>();
+
+            if (obj.IsEmpty())
+                throw std::invalid_argument("blindVersionPubkey received empty");
+
+            assertIsUInt8Array(obj.Get("ed25519SecretKey"));
+            auto ed25519_secret_key =
+                    toCppBuffer(obj.Get("ed25519SecretKey"), "blindVersionPubkey.ed25519SecretKey");
+
+            auto keypair = session::blind_version_key_pair(ed25519_secret_key);
+            session::uc32 pk_arr = std::get<0>(keypair);
+            ustring blinded_pk = session::ustring(
+                    session::to_unsigned_sv(std::string(pk_arr.begin(), pk_arr.end())));
+            std::string blinded_pk_hex;
+            blinded_pk_hex.reserve(66);
+            blinded_pk_hex += "07";
+            oxenc::to_hex(blinded_pk.begin(), blinded_pk.end(), std::back_inserter(blinded_pk_hex));
+
+            return blinded_pk_hex;
+        });
+    };
+
+    static Napi::Value blindVersionSign(const Napi::CallbackInfo& info) {
+        return wrapResult(info, [&] {
+            assertInfoLength(info, 1);
+            assertIsObject(info[0]);
+            auto obj = info[0].As<Napi::Object>();
+
+            if (obj.IsEmpty())
+                throw std::invalid_argument("blindVersionSign received empty");
+
+            assertIsUInt8Array(obj.Get("ed25519SecretKey"));
+            auto ed25519_secret_key =
+                    toCppBuffer(obj.Get("ed25519SecretKey"), "blindVersionSign.ed25519SecretKey");
+
+            assertIsNumber(obj.Get("sigTimestampSeconds"));
+            auto sig_timestamp = toCppInteger(
+                    obj.Get("sigTimestampSeconds"), "blindVersionSign.sigTimestampSeconds", false);
+
+            return session::blind_version_sign(
+                    ed25519_secret_key, Platform::desktop, sig_timestamp);
+        });
+    };
+};
+
+}  // namespace session::nodeapi

src/blinding/blinding.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <napi.h>
+
+#include "../base_config.hpp"
+
+namespace session::nodeapi {
+
+class MetaBaseWrapper {
+
+  public:
+    explicit MetaBaseWrapper(){};
+
+    virtual ~MetaBaseWrapper() = default;
+
+    template <typename T, std::enable_if_t<is_derived_napi_wrapper<T>, int> = 0>
+    static void NoBaseClassInitHelper(
+            Napi::Env env,
+            Napi::Object exports,
+            const char* class_name,
+            std::vector<typename T::PropertyDescriptor> properties) {
+
+        // not adding the baseMethods here from withBaseMethods()
+        Napi::Function cls = T::DefineClass(env, class_name, std::move(properties));
+
+        auto ref = std::make_unique<Napi::FunctionReference>();
+        *ref = Napi::Persistent(cls);
+        env.SetInstanceData(ref.release());
+
+        exports.Set(class_name, cls);
+    }
+};
+
+}  // namespace session::nodeapi

src/meta/meta_base_wrapper.hpp

@@ -0,0 +1,38 @@
+/// <reference path="../../shared.d.ts" />
+
+declare module 'libsession_util_nodejs' {
+  type BlindingWrapper = {
+    blindVersionPubkey: (opts: {
+      /**
+       * len 64: ed25519 secretKey with pubkey
+       */
+      ed25519SecretKey: Uint8Array;
+    }) => Uint8Array;
+    blindVersionSign: (opts: {
+      /**
+       * len 64: ed25519 secretKey with pubkey
+       */
+      ed25519SecretKey: Uint8Array;
+      sigTimestampSeconds: number;
+    }) => Uint8Array;
+  };
+
+  export type BlindingActionsCalls = MakeWrapperActionCalls<BlindingWrapper>;
+
+  /**
+   * To be used inside the web worker only (calls are synchronous and won't work asynchrously)
+   */
+  export class BlindingWrapperNode {
+    public static blindVersionPubkey: BlindingWrapper['blindVersionPubkey'];
+    public static blindVersionSign: BlindingWrapper['blindVersionSign'];
+  }
+
+  /**
+   * Those actions are used internally for the web worker communication.
+   * You should never need to import them in Session directly
+   * You will need to add an entry here if you add a new function
+   */
+  export type BlindingActionsType =
+    | MakeActionCall<BlindingWrapper, 'blindVersionPubkey'>
+    | MakeActionCall<BlindingWrapper, 'blindVersionSign'>;
+}

types/blinding/blinding.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../shared.d.ts" />
+/// <reference path="./blinding.d.ts" />