Restyle refactor: Use structs for extended public/secret keys.

CMakeLists.txt

@@ -223,6 +223,8 @@ set(toxcore_SOURCES
   toxcore/ccompat.h
   toxcore/crypto_core.c
   toxcore/crypto_core.h
+  toxcore/crypto_core_pack.c
+  toxcore/crypto_core_pack.h
   toxcore/DHT.c
   toxcore/DHT.h
   toxcore/events/conference_connected.c

toxcore/BUILD.bazel

@@ -175,6 +175,20 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "crypto_core_pack",
+    srcs = ["crypto_core_pack.c"],
+    hdrs = ["crypto_core_pack.h"],
+    visibility = ["//c-toxcore:__subpackages__"],
+    deps = [
+        ":attributes",
+        ":bin_pack",
+        ":bin_unpack",
+        ":ccompat",
+        ":crypto_core",
+    ],
+)
+
 cc_library(
     name = "crypto_core_test_util",
     testonly = True,
@@ -920,6 +934,7 @@ cc_library(
         ":bin_unpack",
         ":ccompat",
         ":crypto_core",
+        ":crypto_core_pack",
         ":forwarding",
         ":friend_connection",
         ":friend_requests",

toxcore/Makefile.inc

@@ -67,6 +67,8 @@ libtoxcore_la_SOURCES = ../third_party/cmp/cmp.c \
                         ../toxcore/network.c \
                         ../toxcore/crypto_core.h \
                         ../toxcore/crypto_core.c \
+                        ../toxcore/crypto_core_pack.h \
+                        ../toxcore/crypto_core_pack.c \
                         ../toxcore/timed_auth.h \
                         ../toxcore/timed_auth.c \
                         ../toxcore/ping_array.h \

toxcore/Messenger.c

@@ -404,7 +404,7 @@ bool m_create_group_connection(Messenger *m, GC_Chat *chat)
     const int onion_friend_number = friend_conn_get_onion_friendnum(connection);
     Onion_Friend *onion_friend = onion_get_friend(m->onion_c, (uint16_t)onion_friend_number);
 
-    onion_friend_set_gc_public_key(onion_friend, get_chat_id(chat->chat_public_key));
+    onion_friend_set_gc_public_key(onion_friend, get_chat_id(&chat->chat_public_key));
     onion_friend_set_gc_data(onion_friend, nullptr, 0);
 
     return true;
@@ -2594,8 +2594,8 @@ static bool self_announce_group(const Messenger *m, GC_Chat *chat, Onion_Friend
         memcpy(&announce.base_announce.ip_port, &chat->self_ip_port, sizeof(IP_Port));
     }
 
-    memcpy(announce.base_announce.peer_public_key, chat->self_public_key, ENC_PUBLIC_KEY_SIZE);
-    memcpy(announce.chat_public_key, get_chat_id(chat->chat_public_key), ENC_PUBLIC_KEY_SIZE);
+    memcpy(announce.base_announce.peer_public_key, chat->self_public_key.enc, ENC_PUBLIC_KEY_SIZE);
+    memcpy(announce.chat_public_key, get_chat_id(&chat->chat_public_key), ENC_PUBLIC_KEY_SIZE);
 
     uint8_t gc_data[GCA_MAX_DATA_LENGTH];
     const int length = gca_pack_public_announce(m->log, gc_data, GCA_MAX_DATA_LENGTH, &announce);

toxcore/bin_pack.c

@@ -36,6 +36,8 @@ static bool null_skipper(cmp_ctx_t *ctx, size_t count)
 non_null()
 static size_t buf_writer(cmp_ctx_t *ctx, const void *data, size_t count)
 {
+    const uint8_t *bytes = (const uint8_t *)data;
+
     Bin_Pack *bp = (Bin_Pack *)ctx->buf;
     assert(bp != nullptr);
     const uint32_t new_pos = bp->bytes_pos + count;
@@ -48,7 +50,7 @@ static size_t buf_writer(cmp_ctx_t *ctx, const void *data, size_t count)
             // Buffer too small.
             return 0;
         }
-        memcpy(&bp->bytes[bp->bytes_pos], data, count);
+        memcpy(&bp->bytes[bp->bytes_pos], bytes, count);
     }
     bp->bytes_pos += count;
     return count;

toxcore/bin_unpack.c

@@ -21,12 +21,14 @@ struct Bin_Unpack {
 non_null()
 static bool buf_reader(cmp_ctx_t *ctx, void *data, size_t limit)
 {
+    uint8_t *bytes = (uint8_t *)data;
+
     Bin_Unpack *reader = (Bin_Unpack *)ctx->buf;
     assert(reader != nullptr && reader->bytes != nullptr);
     if (limit > reader->bytes_size) {
         return false;
     }
-    memcpy(data, reader->bytes, limit);
+    memcpy(bytes, reader->bytes, limit);
     reader->bytes += limit;
     reader->bytes_size -= limit;
     return true;

toxcore/crypto_core.c

@@ -45,43 +45,43 @@ static_assert(CRYPTO_SIGN_PUBLIC_KEY_SIZE == crypto_sign_PUBLICKEYBYTES,
 static_assert(CRYPTO_SIGN_SECRET_KEY_SIZE == crypto_sign_SECRETKEYBYTES,
               "CRYPTO_SIGN_SECRET_KEY_SIZE should be equal to crypto_sign_SECRETKEYBYTES");
 
-bool create_extended_keypair(uint8_t pk[EXT_PUBLIC_KEY_SIZE], uint8_t sk[EXT_SECRET_KEY_SIZE])
+bool create_extended_keypair(Extended_Public_Key *pk, Extended_Secret_Key *sk)
 {
     /* create signature key pair */
-    crypto_sign_keypair(pk + ENC_PUBLIC_KEY_SIZE, sk + ENC_SECRET_KEY_SIZE);
+    crypto_sign_keypair(pk->sig, sk->sig);
 
     /* convert public signature key to public encryption key */
-    const int res1 = crypto_sign_ed25519_pk_to_curve25519(pk, pk + ENC_PUBLIC_KEY_SIZE);
+    const int res1 = crypto_sign_ed25519_pk_to_curve25519(pk->enc, pk->sig);
 
     /* convert secret signature key to secret encryption key */
-    const int res2 = crypto_sign_ed25519_sk_to_curve25519(sk, sk + ENC_SECRET_KEY_SIZE);
+    const int res2 = crypto_sign_ed25519_sk_to_curve25519(sk->enc, sk->sig);
 
     return res1 == 0 && res2 == 0;
 }
 
-const uint8_t *get_enc_key(const uint8_t *key)
+const uint8_t *get_enc_key(const Extended_Public_Key *key)
 {
-    return key;
+    return key->enc;
 }
 
-const uint8_t *get_sig_pk(const uint8_t *key)
+const uint8_t *get_sig_pk(const Extended_Public_Key *key)
 {
-    return key + ENC_PUBLIC_KEY_SIZE;
+    return key->sig;
 }
 
-void set_sig_pk(uint8_t *key, const uint8_t *sig_pk)
+void set_sig_pk(Extended_Public_Key *key, const uint8_t *sig_pk)
 {
-    memcpy(key + ENC_PUBLIC_KEY_SIZE, sig_pk, SIG_PUBLIC_KEY_SIZE);
+    memcpy(key->sig, sig_pk, SIG_PUBLIC_KEY_SIZE);
 }
 
-const uint8_t *get_sig_sk(const uint8_t *key)
+const uint8_t *get_sig_sk(const Extended_Secret_Key *key)
 {
-    return key + ENC_SECRET_KEY_SIZE;
+    return key->sig;
 }
 
-const uint8_t *get_chat_id(const uint8_t *key)
+const uint8_t *get_chat_id(const Extended_Public_Key *key)
 {
-    return key + ENC_PUBLIC_KEY_SIZE;
+    return key->sig;
 }
 
 #if !defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)

toxcore/crypto_core.h

@@ -324,6 +324,16 @@ void random_bytes(const Random *rng, uint8_t *bytes, size_t length);
 non_null()
 bool public_key_valid(const uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]);
 
+typedef struct Extended_Public_Key {
+    uint8_t enc[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t sig[CRYPTO_SIGN_PUBLIC_KEY_SIZE];
+} Extended_Public_Key;
+
+typedef struct Extended_Secret_Key {
+    uint8_t enc[CRYPTO_SECRET_KEY_SIZE];
+    uint8_t sig[CRYPTO_SIGN_SECRET_KEY_SIZE];
+} Extended_Secret_Key;
+
 /**
  * @brief Creates an extended keypair: curve25519 and ed25519 for encryption and signing
  *   respectively. The Encryption keys are derived from the signature keys.
@@ -337,14 +347,14 @@ bool public_key_valid(const uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]);
  * @retval true on success.
  */
 non_null()
-bool create_extended_keypair(uint8_t pk[EXT_PUBLIC_KEY_SIZE], uint8_t sk[EXT_SECRET_KEY_SIZE]);
+bool create_extended_keypair(Extended_Public_Key *pk, Extended_Secret_Key *sk);
 
 /** Functions for groupchat extended keys */
-non_null() const uint8_t *get_enc_key(const uint8_t *key);
-non_null() const uint8_t *get_sig_pk(const uint8_t *key);
-non_null() void set_sig_pk(uint8_t *key, const uint8_t *sig_pk);
-non_null() const uint8_t *get_sig_sk(const uint8_t *key);
-non_null() const uint8_t *get_chat_id(const uint8_t *key);
+non_null() const uint8_t *get_enc_key(const Extended_Public_Key *key);
+non_null() const uint8_t *get_sig_pk(const Extended_Public_Key *key);
+non_null() void set_sig_pk(Extended_Public_Key *key, const uint8_t *sig_pk);
+non_null() const uint8_t *get_sig_sk(const Extended_Secret_Key *key);
+non_null() const uint8_t *get_chat_id(const Extended_Public_Key *key);
 
 /**
  * @brief Generate a new random keypair.

toxcore/crypto_core_pack.c

@@ -0,0 +1,70 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later
+ * Copyright © 2016-2024 The TokTok team.
+ * Copyright © 2013 Tox project.
+ */
+
+#include "crypto_core_pack.h"
+
+#include <string.h>
+
+#include "bin_pack.h"
+#include "bin_unpack.h"
+#include "ccompat.h"
+#include "crypto_core.h"
+
+static_assert(EXT_PUBLIC_KEY_SIZE == CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SIGN_PUBLIC_KEY_SIZE,
+              "extended public key size is not the sum of the encryption and sign public key sizes");
+static_assert(EXT_SECRET_KEY_SIZE == CRYPTO_SECRET_KEY_SIZE + CRYPTO_SIGN_SECRET_KEY_SIZE,
+              "extended secret key size is not the sum of the encryption and sign secret key sizes");
+
+bool pack_extended_public_key(const Extended_Public_Key *key, Bin_Pack *bp)
+{
+    uint8_t ext_key[EXT_PUBLIC_KEY_SIZE];
+    memcpy(ext_key, key->enc, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(&ext_key[CRYPTO_PUBLIC_KEY_SIZE], key->sig, CRYPTO_SIGN_PUBLIC_KEY_SIZE);
+
+    const bool result = bin_pack_bin(bp, ext_key, EXT_PUBLIC_KEY_SIZE);
+    crypto_memzero(ext_key, EXT_PUBLIC_KEY_SIZE);
+    return result;
+}
+
+bool pack_extended_secret_key(const Extended_Secret_Key *key, Bin_Pack *bp)
+{
+    uint8_t ext_key[EXT_SECRET_KEY_SIZE];
+    memcpy(ext_key, key->enc, CRYPTO_SECRET_KEY_SIZE);
+    memcpy(&ext_key[CRYPTO_SECRET_KEY_SIZE], key->sig, CRYPTO_SIGN_SECRET_KEY_SIZE);
+
+    const bool result = bin_pack_bin(bp, ext_key, EXT_SECRET_KEY_SIZE);
+    crypto_memzero(ext_key, EXT_SECRET_KEY_SIZE);
+    return result;
+}
+
+bool unpack_extended_public_key(Extended_Public_Key *key, Bin_Unpack *bu)
+{
+    uint8_t ext_key[EXT_PUBLIC_KEY_SIZE];
+
+    if (!bin_unpack_bin_fixed(bu, ext_key, EXT_PUBLIC_KEY_SIZE)) {
+        return false;
+    }
+
+    memcpy(key->enc, ext_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(key->sig, &ext_key[CRYPTO_PUBLIC_KEY_SIZE], CRYPTO_SIGN_PUBLIC_KEY_SIZE);
+    crypto_memzero(ext_key, EXT_PUBLIC_KEY_SIZE);
+
+    return true;
+}
+
+bool unpack_extended_secret_key(Extended_Secret_Key *key, Bin_Unpack *bu)
+{
+    uint8_t ext_key[EXT_SECRET_KEY_SIZE];
+
+    if (!bin_unpack_bin_fixed(bu, ext_key, EXT_SECRET_KEY_SIZE)) {
+        return false;
+    }
+
+    memcpy(key->enc, ext_key, CRYPTO_SECRET_KEY_SIZE);
+    memcpy(key->sig, &ext_key[CRYPTO_SECRET_KEY_SIZE], CRYPTO_SIGN_SECRET_KEY_SIZE);
+    crypto_memzero(ext_key, EXT_SECRET_KEY_SIZE);
+
+    return true;
+}

toxcore/crypto_core_pack.h

@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later
+ * Copyright © 2016-2024 The TokTok team.
+ * Copyright © 2013 Tox project.
+ */
+
+#ifndef C_TOXCORE_TOXCORE_CRYPTO_CORE_PACK_H
+#define C_TOXCORE_TOXCORE_CRYPTO_CORE_PACK_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "attributes.h"
+#include "bin_pack.h"
+#include "bin_unpack.h"
+#include "crypto_core.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+non_null() bool pack_extended_public_key(const Extended_Public_Key *key, Bin_Pack *bp);
+non_null() bool pack_extended_secret_key(const Extended_Secret_Key *key, Bin_Pack *bp);
+non_null() bool unpack_extended_public_key(Extended_Public_Key *key, Bin_Unpack *bu);
+non_null() bool unpack_extended_secret_key(Extended_Secret_Key *key, Bin_Unpack *bu);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* C_TOXCORE_TOXCORE_CRYPTO_CORE_PACK_H */

toxcore/crypto_core_test.cc

@@ -14,8 +14,6 @@ namespace {
 using HmacKey = std::array<uint8_t, CRYPTO_HMAC_KEY_SIZE>;
 using Hmac = std::array<uint8_t, CRYPTO_HMAC_SIZE>;
 using SecretKey = std::array<uint8_t, CRYPTO_SECRET_KEY_SIZE>;
-using ExtPublicKey = std::array<uint8_t, EXT_PUBLIC_KEY_SIZE>;
-using ExtSecretKey = std::array<uint8_t, EXT_SECRET_KEY_SIZE>;
 using Signature = std::array<uint8_t, CRYPTO_SIGNATURE_SIZE>;
 using Nonce = std::array<uint8_t, CRYPTO_NONCE_SIZE>;
 
@@ -72,10 +70,10 @@ TEST(CryptoCore, Signatures)
 {
     Test_Random rng;
 
-    ExtPublicKey pk;
-    ExtSecretKey sk;
+    Extended_Public_Key pk;
+    Extended_Secret_Key sk;
 
-    EXPECT_TRUE(create_extended_keypair(pk.data(), sk.data()));
+    EXPECT_TRUE(create_extended_keypair(&pk, &sk));
 
     std::vector<uint8_t> message{0};
     message.clear();
@@ -84,9 +82,9 @@ TEST(CryptoCore, Signatures)
     for (uint8_t i = 0; i < 100; ++i) {
         Signature signature;
         EXPECT_TRUE(crypto_signature_create(
-            signature.data(), message.data(), message.size(), get_sig_sk(sk.data())));
+            signature.data(), message.data(), message.size(), get_sig_sk(&sk)));
         EXPECT_TRUE(crypto_signature_verify(
-            signature.data(), message.data(), message.size(), get_sig_pk(pk.data())));
+            signature.data(), message.data(), message.size(), get_sig_pk(&pk)));
 
         message.push_back(random_u08(rng));
     }

toxcore/group_announce.c

@@ -78,15 +78,15 @@ int gca_get_announces(const GC_Announces_List *gc_announces_list, GC_Announce *g
     for (size_t i = 0; i < announces->index && i < GCA_MAX_SAVED_ANNOUNCES_PER_GC && added_count < max_nodes; ++i) {
         const size_t index = i % GCA_MAX_SAVED_ANNOUNCES_PER_GC;
 
-        if (memcmp(except_public_key, &announces->peer_announces[index].base_announce.peer_public_key,
+        if (memcmp(except_public_key, announces->peer_announces[index].base_announce.peer_public_key,
                    ENC_PUBLIC_KEY_SIZE) == 0) {
             continue;
         }
 
         bool already_added = false;
 
         for (size_t j = 0; j < added_count; ++j) {
-            if (memcmp(&gc_announces[j].peer_public_key, &announces->peer_announces[index].base_announce.peer_public_key,
+            if (memcmp(gc_announces[j].peer_public_key, announces->peer_announces[index].base_announce.peer_public_key,
                        ENC_PUBLIC_KEY_SIZE) == 0) {
                 already_added = true;
                 break;