Merge pull request #26 from mpretty-cyro/feature/updated-libquic

Updated to the latest stable libQuic, Retyped the networking code

Author: mpretty-cyro

.drone.jsonnet

@@ -319,7 +319,7 @@ local static_build(name,
         'echo "Building on ${DRONE_STAGE_MACHINE}"',
         apt_get_quiet + ' update',
         apt_get_quiet + ' install -y eatmydata',
-        'eatmydata ' + apt_get_quiet + ' install --no-install-recommends -y git clang-format-15 jsonnet',
+        'eatmydata ' + apt_get_quiet + ' install --no-install-recommends -y git clang-format-19 jsonnet',
         './utils/ci/drone-format-verify.sh',
       ],
     }],

CMakeLists.txt

@@ -17,7 +17,7 @@ if(CCACHE_PROGRAM)
 endif()
 
 project(libsession-util
-    VERSION 1.2.1
+    VERSION 1.3.0
     DESCRIPTION "Session client utility library"
     LANGUAGES ${LANGS})
 

external/CMakeLists.txt

@@ -102,14 +102,14 @@ endif()
 
 set(LIBQUIC_BUILD_TESTS OFF CACHE BOOL "")
 if(ENABLE_ONIONREQ)
-  libsession_system_or_submodule(OXENQUIC quic liboxenquic>=1.1.0 oxen-libquic)
+  libsession_system_or_submodule(OXENQUIC quic liboxenquic>=1.2.0 oxen-libquic)
 endif()
 
 if(NOT TARGET oxenc::oxenc)
     # The oxenc target will already exist if we load libquic above via submodule
     set(OXENC_BUILD_TESTS OFF CACHE BOOL "")
     set(OXENC_BUILD_DOCS OFF CACHE BOOL "")
-    libsession_system_or_submodule(OXENC oxenc liboxenc>=1.1.0 oxen-libquic/external/oxen-encoding)
+    libsession_system_or_submodule(OXENC oxenc liboxenc>=1.3.0 oxen-libquic/external/oxen-encoding)
 endif()
 
 if(NOT TARGET oxen::logging)

external/oxen-libquic

@@ -59,12 +59,13 @@ namespace session {
 
 /// Returns the blinding factor for 15 blinding.  Typically this isn't used directly, but is
 /// exposed for debugging/testing.  Takes server pk in bytes, not hex.
-uc32 blind15_factor(ustring_view server_pk);
+std::array<unsigned char, 32> blind15_factor(std::span<const unsigned char> server_pk);
 
 /// Returns the blinding factor for 25 blinding.  Typically this isn't used directly, but is
 /// exposed for debugging/testing.  Takes session id and server pk in bytes, not hex.  session
 /// id can be 05-prefixed (33 bytes) or unprefixed (32 bytes).
-uc32 blind25_factor(ustring_view session_id, ustring_view server_pk);
+std::array<unsigned char, 32> blind25_factor(
+        std::span<const unsigned char> session_id, std::span<const unsigned char> server_pk);
 
 /// Computes the two possible 15-blinded ids from a session id and server pubkey.  Values accepted
 /// and returned are hex-encoded.
@@ -75,7 +76,8 @@ std::array<std::string, 2> blind15_id(std::string_view session_id, std::string_v
 /// session_id here may be passed unprefixed (i.e. 32 bytes instead of 33 with the 05 prefix).  Only
 /// the *positive* possible ID is returned: the alternative can be computed by flipping the highest
 /// bit of byte 32, i.e.: `result[32] ^= 0x80`.
-ustring blind15_id(ustring_view session_id, ustring_view server_pk);
+std::vector<unsigned char> blind15_id(
+        std::span<const unsigned char> session_id, std::span<const unsigned char> server_pk);
 
 /// Computes the 25-blinded id from a session id and server pubkey.  Values accepted and
 /// returned are hex-encoded.
@@ -84,7 +86,8 @@ std::string blind25_id(std::string_view session_id, std::string_view server_pk);
 /// Same as above, but takes the session id and pubkey as byte values instead of hex, and returns a
 /// 33-byte value (instead of a 66-digit hex value).  Unlike the string version, session_id here may
 /// be passed unprefixed (i.e. 32 bytes instead of 33 with the 05 prefix).
-ustring blind25_id(ustring_view session_id, ustring_view server_pk);
+std::vector<unsigned char> blind25_id(
+        std::span<const unsigned char> session_id, std::span<const unsigned char> server_pk);
 
 /// Computes the 15-blinded id from a 32-byte Ed25519 pubkey, i.e. from the known underlying Ed25519
 /// pubkey behind a (X25519) Session ID.  Unlike blind15_id, knowing the true Ed25519 pubkey allows
@@ -96,8 +99,10 @@ ustring blind25_id(ustring_view session_id, ustring_view server_pk);
 /// `blinded25_id_from_ed`, but unlike the 25 version, this value is not read if non-empty, and is
 /// not an optimization (that is: it is purely for convenience and is no more efficient to use this
 /// than it is to compute it yourself).
-ustring blinded15_id_from_ed(
-        ustring_view ed_pubkey, ustring_view server_pk, ustring* session_id = nullptr);
+std::vector<unsigned char> blinded15_id_from_ed(
+        std::span<const unsigned char> ed_pubkey,
+        std::span<const unsigned char> server_pk,
+        std::vector<unsigned char>* session_id = nullptr);
 
 /// Computes the 25-blinded id from a 32-byte Ed25519 pubkey, i.e. from the known underlying Ed25519
 /// pubkey behind a (X25519) Session ID.  This will be the same as blind25_id (if given the X25519
@@ -109,8 +114,10 @@ ustring blinded15_id_from_ed(
 /// containing the precomputed value (to avoid needing to compute it again).  If unknown but needed
 /// then a pointer to an empty string can be given to computed and stored the value here.  Otherwise
 /// (if omitted or nullptr) then the value will temporarily computed within the function.
-ustring blinded25_id_from_ed(
-        ustring_view ed_pubkey, ustring_view server_pk, ustring* session_id = nullptr);
+std::vector<unsigned char> blinded25_id_from_ed(
+        std::span<const unsigned char> ed_pubkey,
+        std::span<const unsigned char> server_pk,
+        std::vector<unsigned char>* session_id = nullptr);
 
 /// Computes a 15-blinded key pair.
 ///
@@ -122,8 +129,10 @@ ustring blinded25_id_from_ed(
 ///
 /// It is recommended to pass the full 64-byte libsodium-style secret key for `ed25519_sk` (i.e.
 /// seed + appended pubkey) as with just the 32-byte seed the public key has to be recomputed.
-std::pair<uc32, cleared_uc32> blind15_key_pair(
-        ustring_view ed25519_sk, ustring_view server_pk, uc32* k = nullptr);
+std::pair<std::array<unsigned char, 32>, cleared_uc32> blind15_key_pair(
+        std::span<const unsigned char> ed25519_sk,
+        std::span<const unsigned char> server_pk,
+        std::array<unsigned char, 32>* k = nullptr);
 
 /// Computes a 25-blinded key pair.
 ///
@@ -137,8 +146,10 @@ std::pair<uc32, cleared_uc32> blind15_key_pair(
 ///
 /// It is recommended to pass the full 64-byte libsodium-style secret key for `ed25519_sk` (i.e.
 /// seed + appended pubkey) as with just the 32-byte seed the public key has to be recomputed.
-std::pair<uc32, cleared_uc32> blind25_key_pair(
-        ustring_view ed25519_sk, ustring_view server_pk, uc32* k_prime = nullptr);
+std::pair<std::array<unsigned char, 32>, cleared_uc32> blind25_key_pair(
+        std::span<const unsigned char> ed25519_sk,
+        std::span<const unsigned char> server_pk,
+        std::array<unsigned char, 32>* k_prime = nullptr);
 
 /// Computes a version-blinded key pair.
 ///
@@ -147,7 +158,8 @@ std::pair<uc32, cleared_uc32> blind25_key_pair(
 ///
 /// It is recommended to pass the full 64-byte libsodium-style secret key for `ed25519_sk` (i.e.
 /// seed + appended pubkey) as with just the 32-byte seed the public key has to be recomputed.
-std::pair<uc32, cleared_uc64> blind_version_key_pair(ustring_view ed25519_sk);
+std::pair<std::array<unsigned char, 32>, cleared_uc64> blind_version_key_pair(
+        std::span<const unsigned char> ed25519_sk);
 
 /// Computes a verifiable 15-blinded signature that validates with the blinded pubkey that would
 /// be returned from blind15_key_pair().
@@ -157,7 +169,10 @@ std::pair<uc32, cleared_uc64> blind_version_key_pair(ustring_view ed25519_sk);
 ///
 /// It is recommended to pass the full 64-byte libsodium-style secret key for `ed25519_sk` (i.e.
 /// seed + appended pubkey) as with just the 32-byte seed the public key has to be recomputed.
-ustring blind15_sign(ustring_view ed25519_sk, std::string_view server_pk_in, ustring_view message);
+std::vector<unsigned char> blind15_sign(
+        std::span<const unsigned char> ed25519_sk,
+        std::string_view server_pk_in,
+        std::span<const unsigned char> message);
 
 /// Computes a verifiable 25-blinded signature that validates with the blinded pubkey that would
 /// be returned from blind25_id().
@@ -167,27 +182,31 @@ ustring blind15_sign(ustring_view ed25519_sk, std::string_view server_pk_in, ust
 ///
 /// It is recommended to pass the full 64-byte libsodium-style secret key for `ed25519_sk` (i.e.
 /// seed + appended pubkey) as with just the 32-byte seed the public key has to be recomputed.
-ustring blind25_sign(ustring_view ed25519_sk, std::string_view server_pk, ustring_view message);
+std::vector<unsigned char> blind25_sign(
+        std::span<const unsigned char> ed25519_sk,
+        std::string_view server_pk,
+        std::span<const unsigned char> message);
 
 /// Computes a verifiable version-blinded signature that validates with the version-blinded pubkey
 /// that would be returned from blind_version_key_pair.
 ///
 /// Takes the Ed25519 secret key (64 bytes, or 32-byte seed), unix timestamp, method, path, and
 /// optional body.
 /// Returns the version-blinded signature.
-ustring blind_version_sign_request(
-        ustring_view ed25519_sk,
+std::vector<unsigned char> blind_version_sign_request(
+        std::span<const unsigned char> ed25519_sk,
         uint64_t timestamp,
         std::string_view method,
         std::string_view path,
-        std::optional<ustring_view> body);
+        std::optional<std::span<const unsigned char>> body);
 
 /// Computes a verifiable version-blinded signature that validates with the version-blinded pubkey
 /// that would be returned from blind_version_key_pair.
 ///
 /// Takes the Ed25519 secret key (64 bytes, or 32-byte seed), current platform and unix timestamp.
 /// Returns the version-blinded signature.
-ustring blind_version_sign(ustring_view ed25519_sk, Platform platform, uint64_t timestamp);
+std::vector<unsigned char> blind_version_sign(
+        std::span<const unsigned char> ed25519_sk, Platform platform, uint64_t timestamp);
 
 /// Takes in a standard session_id and returns a flag indicating whether it matches the given
 /// blinded_id for a given server_pk.

include/session/blinding.hpp

@@ -108,10 +108,12 @@ class ConfigMessage {
     /// message.  It can also throw to abort message construction (that is: returning false skips
     /// the message when loading multiple messages, but can still continue with other messages;
     /// throwing aborts the entire construction).
-    using verify_callable = std::function<bool(ustring_view data, ustring_view signature)>;
+    using verify_callable = std::function<bool(
+            std::span<const unsigned char> data, std::span<const unsigned char> signature)>;
 
     /// Signing function: this is passed the data to be signed and returns the 64-byte signature.
-    using sign_callable = std::function<ustring(ustring_view data)>;
+    using sign_callable =
+            std::function<std::vector<unsigned char>(std::span<const unsigned char> data)>;
 
     ConfigMessage();
     ConfigMessage(const ConfigMessage&) = default;
@@ -124,7 +126,7 @@ class ConfigMessage {
     /// Initializes a config message by parsing a serialized message.  Throws on any error.  See the
     /// vector version below for argument descriptions.
     explicit ConfigMessage(
-            ustring_view serialized,
+            std::span<const unsigned char> serialized,
             verify_callable verifier = nullptr,
             sign_callable signer = nullptr,
             int lag = DEFAULT_DIFF_LAGS,
@@ -160,7 +162,7 @@ class ConfigMessage {
     /// `[](size_t, const auto& e) { throw e; }` can be used to make any parse error of any message
     /// fatal.
     explicit ConfigMessage(
-            const std::vector<ustring_view>& configs,
+            const std::vector<std::span<const unsigned char>>& configs,
             verify_callable verifier = nullptr,
             sign_callable signer = nullptr,
             int lag = DEFAULT_DIFF_LAGS,
@@ -231,10 +233,11 @@ class ConfigMessage {
     /// typically for a local serialization value that isn't being pushed to the server).  Note that
     /// signing is always disabled if there is no signing callback set, regardless of the value of
     /// this argument.
-    virtual ustring serialize(bool enable_signing = true);
+    virtual std::vector<unsigned char> serialize(bool enable_signing = true);
 
   protected:
-    ustring serialize_impl(const oxenc::bt_dict& diff, bool enable_signing = true);
+    std::vector<unsigned char> serialize_impl(
+            const oxenc::bt_dict& diff, bool enable_signing = true);
 };
 
 // Constructor tag
@@ -282,7 +285,7 @@ class MutableConfigMessage : public ConfigMessage {
     /// constructor only increments seqno once while the indirect version would increment twice in
     /// the case of a required merge conflict resolution.
     explicit MutableConfigMessage(
-            const std::vector<ustring_view>& configs,
+            const std::vector<std::span<const unsigned char>>& configs,
             verify_callable verifier = nullptr,
             sign_callable signer = nullptr,
             int lag = DEFAULT_DIFF_LAGS,
@@ -292,7 +295,7 @@ class MutableConfigMessage : public ConfigMessage {
     /// take an error handler and instead always throws on parse errors (the above also throws for
     /// an erroneous single message, but with a less specific "no valid config messages" error).
     explicit MutableConfigMessage(
-            ustring_view config,
+            std::span<const unsigned char> config,
             verify_callable verifier = nullptr,
             sign_callable signer = nullptr,
             int lag = DEFAULT_DIFF_LAGS);
@@ -339,7 +342,7 @@ class MutableConfigMessage : public ConfigMessage {
     const hash_t& hash() override;
 
   protected:
-    const hash_t& hash(ustring_view serialized);
+    const hash_t& hash(std::span<const unsigned char> serialized);
     void increment_impl();
 };
 

include/session/config.hpp

@@ -274,11 +274,7 @@ LIBSESSION_EXPORT config_string_list* config_current_hashes(const config_object*
 ///
 /// Outputs:
 /// - `config_string_list*` -- pointer to the list of hashes; the pointer belongs to the caller
-LIBSESSION_EXPORT config_string_list* config_old_hashes(config_object* conf)
-#ifdef __GNUC__
-        __attribute__((warn_unused_result))
-#endif
-        ;
+LIBSESSION_EXPORT config_string_list* config_old_hashes(config_object* conf) LIBSESSION_WARN_UNUSED;
 
 /// API: base/config_get_keys
 ///