commit 19cf074f4d8e209af35c1829626738b3b924cb65
Author: J. Ryan Stinnett <jryans(a)gmail.com>
Date: Sun Dec 4 20:30:26 2016 -0600
hs: Remove private keys from hs_desc_plaintext_data_t.
Since both the client and service will use that data structure to store the
descriptor decoded data, only the public keys are common to both.
Fixes #20572.
Signed-off-by: David Goulet <dgoulet(a)torproject.org>
---
src/or/hs_cache.c | 2 +-
src/or/hs_descriptor.c | 64 +++++++++++++++--------------
src/or/hs_descriptor.h | 11 ++---
src/test/test_hs_cache.c | 93 ++++++++++++++++++++++++++-----------------
src/test/test_hs_descriptor.c | 79 +++++++++++++++++++++---------------
5 files changed, 146 insertions(+), 103 deletions(-)
diff --git a/src/or/hs_cache.c b/src/or/hs_cache.c
index b7ff979..e5bd0e4 100644
--- a/src/or/hs_cache.c
+++ b/src/or/hs_cache.c
@@ -86,7 +86,7 @@ cache_dir_desc_new(const char *desc)
}
/* The blinded pubkey is the indexed key. */
- dir_desc->key = dir_desc->plaintext_data->blinded_kp.pubkey.pubkey;
+ dir_desc->key = dir_desc->plaintext_data->blinded_pubkey.pubkey;
dir_desc->created_ts = time(NULL);
return dir_desc;
diff --git a/src/or/hs_descriptor.c b/src/or/hs_descriptor.c
index 37aa1d7..00d1075 100644
--- a/src/or/hs_descriptor.c
+++ b/src/or/hs_descriptor.c
@@ -219,7 +219,7 @@ encode_link_specifiers(const smartlist_t *specs)
/* Encode an introduction point encryption key and return a newly allocated
* string with it. On failure, return NULL. */
static char *
-encode_enc_key(const ed25519_keypair_t *sig_key,
+encode_enc_key(const ed25519_public_key_t *sig_key,
const hs_desc_intro_point_t *ip)
{
char *encoded = NULL;
@@ -237,8 +237,7 @@ encode_enc_key(const ed25519_keypair_t *sig_key,
uint8_t *cert_data = NULL;
/* Create cross certification cert. */
- cert_len = tor_make_rsa_ed25519_crosscert(&sig_key->pubkey,
- ip->enc_key.legacy,
+ cert_len = tor_make_rsa_ed25519_crosscert(sig_key, ip->enc_key.legacy,
now + HS_DESC_CERT_LIFETIME,
&cert_data);
if (cert_len < 0) {
@@ -282,7 +281,7 @@ encode_enc_key(const ed25519_keypair_t *sig_key,
}
tor_cert_t *cross_cert = tor_cert_create(&curve_kp,
CERT_TYPE_CROSS_HS_IP_KEYS,
- &sig_key->pubkey, now,
+ sig_key, now,
HS_DESC_CERT_LIFETIME,
CERT_FLAG_INCLUDE_SIGNING_KEY);
memwipe(&curve_kp, 0, sizeof(curve_kp));
@@ -318,7 +317,7 @@ encode_enc_key(const ed25519_keypair_t *sig_key,
/* Encode an introduction point object and return a newly allocated string
* with it. On failure, return NULL. */
static char *
-encode_intro_point(const ed25519_keypair_t *sig_key,
+encode_intro_point(const ed25519_public_key_t *sig_key,
const hs_desc_intro_point_t *ip)
{
char *encoded_ip = NULL;
@@ -377,9 +376,9 @@ build_secret_input(const hs_descriptor_t *desc, uint8_t *dst, size_t dstlen)
/* XXX use the destination length as the memcpy length */
/* Copy blinded public key. */
- memcpy(dst, desc->plaintext_data.blinded_kp.pubkey.pubkey,
- sizeof(desc->plaintext_data.blinded_kp.pubkey.pubkey));
- offset += sizeof(desc->plaintext_data.blinded_kp.pubkey.pubkey);
+ memcpy(dst, desc->plaintext_data.blinded_pubkey.pubkey,
+ sizeof(desc->plaintext_data.blinded_pubkey.pubkey));
+ offset += sizeof(desc->plaintext_data.blinded_pubkey.pubkey);
/* Copy subcredential. */
memcpy(dst + offset, desc->subcredential, sizeof(desc->subcredential));
offset += sizeof(desc->subcredential);
@@ -665,7 +664,7 @@ encode_encrypted_data(const hs_descriptor_t *desc,
/* Build the introduction point(s) section. */
SMARTLIST_FOREACH_BEGIN(desc->encrypted_data.intro_points,
const hs_desc_intro_point_t *, ip) {
- char *encoded_ip = encode_intro_point(&desc->plaintext_data.signing_kp,
+ char *encoded_ip = encode_intro_point(&desc->plaintext_data.signing_pubkey,
ip);
if (encoded_ip == NULL) {
log_err(LD_BUG, "HS desc intro point is malformed.");
@@ -710,7 +709,8 @@ encode_encrypted_data(const hs_descriptor_t *desc,
* newly allocated string of the encoded descriptor. On error, -1 is returned
* and encoded_out is untouched. */
static int
-desc_encode_v3(const hs_descriptor_t *desc, char **encoded_out)
+desc_encode_v3(const hs_descriptor_t *desc,
+ const ed25519_keypair_t *signing_kp, char **encoded_out)
{
int ret = -1;
char *encoded_str = NULL;
@@ -718,6 +718,7 @@ desc_encode_v3(const hs_descriptor_t *desc, char **encoded_out)
smartlist_t *lines = smartlist_new();
tor_assert(desc);
+ tor_assert(signing_kp);
tor_assert(encoded_out);
tor_assert(desc->plaintext_data.version == 3);
@@ -732,7 +733,7 @@ desc_encode_v3(const hs_descriptor_t *desc, char **encoded_out)
goto err;
}
if (tor_cert_encode_ed22519(desc->plaintext_data.signing_key_cert,
- &encoded_cert) < 0) {
+ &encoded_cert) < 0) {
/* The function will print error logs. */
goto err;
}
@@ -775,8 +776,7 @@ desc_encode_v3(const hs_descriptor_t *desc, char **encoded_out)
char ed_sig_b64[ED25519_SIG_BASE64_LEN + 1];
if (ed25519_sign_prefixed(&sig,
(const uint8_t *) encoded_str, encoded_len,
- str_desc_sig_prefix,
- &desc->plaintext_data.signing_kp) < 0) {
+ str_desc_sig_prefix, signing_kp) < 0) {
log_warn(LD_BUG, "Can't sign encoded HS descriptor!");
tor_free(encoded_str);
goto err;
@@ -1365,7 +1365,8 @@ decode_intro_points(const hs_descriptor_t *desc,
/* Return 1 iff the given base64 encoded signature in b64_sig from the encoded
* descriptor in encoded_desc validates the descriptor content. */
STATIC int
-desc_sig_is_valid(const char *b64_sig, const ed25519_keypair_t *signing_kp,
+desc_sig_is_valid(const char *b64_sig,
+ const ed25519_public_key_t *signing_pubkey,
const char *encoded_desc, size_t encoded_len)
{
int ret = 0;
@@ -1373,7 +1374,7 @@ desc_sig_is_valid(const char *b64_sig, const ed25519_keypair_t *signing_kp,
const char *sig_start;
tor_assert(b64_sig);
- tor_assert(signing_kp);
+ tor_assert(signing_pubkey);
tor_assert(encoded_desc);
/* Verifying nothing won't end well :). */
tor_assert(encoded_len > 0);
@@ -1408,7 +1409,7 @@ desc_sig_is_valid(const char *b64_sig, const ed25519_keypair_t *signing_kp,
(const uint8_t *) encoded_desc,
sig_start - encoded_desc,
str_desc_sig_prefix,
- &signing_kp->pubkey) != 0) {
+ signing_pubkey) != 0) {
log_warn(LD_REND, "Invalid signature on service descriptor");
goto err;
}
@@ -1474,10 +1475,10 @@ desc_decode_plaintext_v3(smartlist_t *tokens,
goto err;
}
- /* Copy the public keys into signing_kp and blinded_kp */
- memcpy(&desc->signing_kp.pubkey, &desc->signing_key_cert->signed_key,
+ /* Copy the public keys into signing_pubkey and blinded_pubkey */
+ memcpy(&desc->signing_pubkey, &desc->signing_key_cert->signed_key,
sizeof(ed25519_public_key_t));
- memcpy(&desc->blinded_kp.pubkey, &desc->signing_key_cert->signing_key,
+ memcpy(&desc->blinded_pubkey, &desc->signing_key_cert->signing_key,
sizeof(ed25519_public_key_t));
/* Extract revision counter value. */
@@ -1511,7 +1512,7 @@ desc_decode_plaintext_v3(smartlist_t *tokens,
tok = find_by_keyword(tokens, R3_SIGNATURE);
tor_assert(tok->n_args == 1);
/* First arg here is the actual encoded signature. */
- if (!desc_sig_is_valid(tok->args[0], &desc->signing_kp,
+ if (!desc_sig_is_valid(tok->args[0], &desc->signing_pubkey,
encoded_desc, encoded_len)) {
goto err;
}
@@ -1806,41 +1807,46 @@ hs_desc_decode_descriptor(const char *encoded,
return ret;
}
-/* Table of encode function version specific. The function are indexed by the
+/* Table of encode function version specific. The functions are indexed by the
* version number so v3 callback is at index 3 in the array. */
static int
(*encode_handlers[])(
const hs_descriptor_t *desc,
+ const ed25519_keypair_t *signing_kp,
char **encoded_out) =
{
/* v0 */ NULL, /* v1 */ NULL, /* v2 */ NULL,
desc_encode_v3,
};
-/* Encode the given descriptor desc. On success, encoded_out points to a newly
- * allocated NUL terminated string that contains the encoded descriptor as a
- * string.
+/* Encode the given descriptor desc including signing with the given key pair
+ * signing_kp. On success, encoded_out points to a newly allocated NUL
+ * terminated string that contains the encoded descriptor as a string.
*
* Return 0 on success and encoded_out is a valid pointer. On error, -1 is
* returned and encoded_out is set to NULL. */
int
-hs_desc_encode_descriptor(const hs_descriptor_t *desc, char **encoded_out)
+hs_desc_encode_descriptor(const hs_descriptor_t *desc,
+ const ed25519_keypair_t *signing_kp,
+ char **encoded_out)
{
int ret = -1;
+ uint32_t version;
tor_assert(desc);
tor_assert(encoded_out);
/* Make sure we support the version of the descriptor format. */
- if (!hs_desc_is_supported_version(desc->plaintext_data.version)) {
+ version = desc->plaintext_data.version;
+ if (!hs_desc_is_supported_version(version)) {
goto err;
}
/* Extra precaution. Having no handler for the supported version should
* never happened else we forgot to add it but we bumped the version. */
- tor_assert(ARRAY_LENGTH(encode_handlers) >= desc->plaintext_data.version);
- tor_assert(encode_handlers[desc->plaintext_data.version]);
+ tor_assert(ARRAY_LENGTH(encode_handlers) >= version);
+ tor_assert(encode_handlers[version]);
- ret = encode_handlers[desc->plaintext_data.version](desc, encoded_out);
+ ret = encode_handlers[version](desc, signing_kp, encoded_out);
if (ret < 0) {
goto err;
}
diff --git a/src/or/hs_descriptor.h b/src/or/hs_descriptor.h
index 083d353..a6fe96a 100644
--- a/src/or/hs_descriptor.h
+++ b/src/or/hs_descriptor.h
@@ -148,13 +148,13 @@ typedef struct hs_desc_plaintext_data_t {
* replica which is signed by the blinded public key for that replica. */
tor_cert_t *signing_key_cert;
- /* Signing keypair which is used to sign the descriptor. Same public key
+ /* Signing public key which is used to sign the descriptor. Same public key
* as in the signing key certificate. */
- ed25519_keypair_t signing_kp;
+ ed25519_public_key_t signing_pubkey;
- /* Blinded keypair used for this descriptor derived from the master
+ /* Blinded public key used for this descriptor derived from the master
* identity key and generated for a specific replica number. */
- ed25519_keypair_t blinded_kp;
+ ed25519_public_key_t blinded_pubkey;
/* Revision counter is incremented at each upload, regardless of whether
* the descriptor has changed. This avoids leaking whether the descriptor
@@ -201,6 +201,7 @@ void hs_desc_plaintext_data_free(hs_desc_plaintext_data_t *desc);
void hs_desc_encrypted_data_free(hs_desc_encrypted_data_t *desc);
int hs_desc_encode_descriptor(const hs_descriptor_t *desc,
+ const ed25519_keypair_t *signing_kp,
char **encoded_out);
int hs_desc_decode_descriptor(const char *encoded,
@@ -232,7 +233,7 @@ STATIC int encrypted_data_length_is_valid(size_t len);
STATIC int cert_is_valid(tor_cert_t *cert, uint8_t type,
const char *log_obj_type);
STATIC int desc_sig_is_valid(const char *b64_sig,
- const ed25519_keypair_t *signing_kp,
+ const ed25519_public_key_t *signing_pubkey,
const char *encoded_desc, size_t encoded_len);
STATIC void desc_intro_point_free(hs_desc_intro_point_t *ip);
#endif /* HS_DESCRIPTOR_PRIVATE */
diff --git a/src/test/test_hs_cache.c b/src/test/test_hs_cache.c
index e7deec2..64391a7 100644
--- a/src/test/test_hs_cache.c
+++ b/src/test/test_hs_cache.c
@@ -66,27 +66,27 @@ helper_build_intro_point(const ed25519_keypair_t *blinded_kp,
/* Return a valid hs_descriptor_t object. */
static hs_descriptor_t *
helper_build_hs_desc(uint64_t revision_counter, uint32_t lifetime,
- ed25519_keypair_t *blinded_kp)
+ ed25519_public_key_t *signing_pubkey)
{
int ret;
+ ed25519_keypair_t blinded_kp;
hs_descriptor_t *descp = NULL, *desc = tor_malloc_zero(sizeof(*desc));
desc->plaintext_data.version = HS_DESC_SUPPORTED_FORMAT_VERSION_MAX;
- ret = ed25519_keypair_generate(&desc->plaintext_data.signing_kp, 0);
+
+ /* Copy only the public key into the descriptor. */
+ memcpy(&desc->plaintext_data.signing_pubkey, signing_pubkey,
+ sizeof(ed25519_public_key_t));
+
+ ret = ed25519_keypair_generate(&blinded_kp, 0);
tt_int_op(ret, ==, 0);
- if (blinded_kp) {
- memcpy(&desc->plaintext_data.blinded_kp, blinded_kp,
- sizeof(ed25519_keypair_t));
- } else {
- ret = ed25519_keypair_generate(&desc->plaintext_data.blinded_kp, 0);
- tt_int_op(ret, ==, 0);
- }
+ /* Copy only the public key into the descriptor. */
+ memcpy(&desc->plaintext_data.blinded_pubkey, &blinded_kp.pubkey,
+ sizeof(ed25519_public_key_t));
desc->plaintext_data.signing_key_cert =
- tor_cert_create(&desc->plaintext_data.blinded_kp,
- CERT_TYPE_SIGNING_HS_DESC,
- &desc->plaintext_data.signing_kp.pubkey, time(NULL),
- 3600, CERT_FLAG_INCLUDE_SIGNING_KEY);
+ tor_cert_create(&blinded_kp, CERT_TYPE_SIGNING_HS_DESC, signing_pubkey,
+ time(NULL), 3600, CERT_FLAG_INCLUDE_SIGNING_KEY);
tt_assert(desc->plaintext_data.signing_key_cert);
desc->plaintext_data.revision_counter = revision_counter;
desc->plaintext_data.lifetime_sec = lifetime;
@@ -98,8 +98,7 @@ helper_build_hs_desc(uint64_t revision_counter, uint32_t lifetime,
desc->encrypted_data.intro_points = smartlist_new();
/* Add an intro point. */
smartlist_add(desc->encrypted_data.intro_points,
- helper_build_intro_point(&desc->plaintext_data.blinded_kp,
- "1.2.3.4"));
+ helper_build_intro_point(&blinded_kp, "1.2.3.4"));
descp = desc;
done:
@@ -109,12 +108,11 @@ helper_build_hs_desc(uint64_t revision_counter, uint32_t lifetime,
/* Static variable used to encoded the HSDir query. */
static char query_b64[256];
-/* Build an HSDir query using a ed25519 keypair. */
+/* Build an HSDir query using a ed25519 public key. */
static const char *
helper_get_hsdir_query(const hs_descriptor_t *desc)
{
- ed25519_public_to_base64(query_b64,
- &desc->plaintext_data.blinded_kp.pubkey);
+ ed25519_public_to_base64(query_b64, &desc->plaintext_data.blinded_pubkey);
return query_b64;
}
@@ -132,17 +130,20 @@ test_directory(void *arg)
{
int ret;
size_t oom_size;
- char *desc1_str=NULL;
+ char *desc1_str = NULL;
const char *desc_out;
- hs_descriptor_t *desc1;
+ ed25519_keypair_t signing_kp1;
+ hs_descriptor_t *desc1 = NULL;
(void) arg;
init_test();
/* Generate a valid descriptor with normal values. */
- desc1 = helper_build_hs_desc(42, 3 * 60 * 60, NULL);
+ ret = ed25519_keypair_generate(&signing_kp1, 0);
+ tt_int_op(ret, ==, 0);
+ desc1 = helper_build_hs_desc(42, 3 * 60 * 60, &signing_kp1.pubkey);
tt_assert(desc1);
- ret = hs_desc_encode_descriptor(desc1, &desc1_str);
+ ret = hs_desc_encode_descriptor(desc1, &signing_kp1, &desc1_str);
tt_int_op(ret, OP_EQ, 0);
/* Very first basic test, should be able to be stored, survive a
@@ -170,10 +171,14 @@ test_directory(void *arg)
/* Store two descriptors and remove the expiring one only. */
{
- hs_descriptor_t *desc_zero_lifetime = helper_build_hs_desc(1, 0, NULL);
+ ed25519_keypair_t signing_kp_zero;
+ ret = ed25519_keypair_generate(&signing_kp_zero, 0);
+ tt_int_op(ret, ==, 0);
+ hs_descriptor_t *desc_zero_lifetime;
+ desc_zero_lifetime = helper_build_hs_desc(1, 0, &signing_kp_zero.pubkey);
tt_assert(desc_zero_lifetime);
char *desc_zero_lifetime_str;
- ret = hs_desc_encode_descriptor(desc_zero_lifetime,
+ ret = hs_desc_encode_descriptor(desc_zero_lifetime, &signing_kp_zero,
&desc_zero_lifetime_str);
tt_int_op(ret, OP_EQ, 0);
@@ -225,7 +230,7 @@ test_directory(void *arg)
tt_int_op(ret, OP_EQ, 1);
/* Bump revision counter. */
desc1->plaintext_data.revision_counter++;
- ret = hs_desc_encode_descriptor(desc1, &new_desc_str);
+ ret = hs_desc_encode_descriptor(desc1, &signing_kp1, &new_desc_str);
tt_int_op(ret, OP_EQ, 0);
ret = hs_cache_store_as_dir(new_desc_str);
tt_int_op(ret, OP_EQ, 0);
@@ -248,15 +253,18 @@ test_clean_as_dir(void *arg)
char *desc1_str = NULL;
time_t now = time(NULL);
hs_descriptor_t *desc1 = NULL;
+ ed25519_keypair_t signing_kp1;
(void) arg;
init_test();
/* Generate a valid descriptor with values. */
- desc1 = helper_build_hs_desc(42, 3 * 60 * 60, NULL);
+ ret = ed25519_keypair_generate(&signing_kp1, 0);
+ tt_int_op(ret, ==, 0);
+ desc1 = helper_build_hs_desc(42, 3 * 60 * 60, &signing_kp1.pubkey);
tt_assert(desc1);
- ret = hs_desc_encode_descriptor(desc1, &desc1_str);
+ ret = hs_desc_encode_descriptor(desc1, &signing_kp1, &desc1_str);
tt_int_op(ret, OP_EQ, 0);
ret = hs_cache_store_as_dir(desc1_str);
tt_int_op(ret, OP_EQ, 0);
@@ -343,7 +351,7 @@ static void
test_upload_and_download_hs_desc(void *arg)
{
int retval;
- hs_descriptor_t *published_desc;
+ hs_descriptor_t *published_desc = NULL;
char *published_desc_str = NULL;
char *received_desc_str = NULL;
@@ -355,9 +363,13 @@ test_upload_and_download_hs_desc(void *arg)
/* Generate a valid descriptor with normal values. */
{
- published_desc = helper_build_hs_desc(42, 3 * 60 * 60, NULL);
+ ed25519_keypair_t signing_kp;
+ retval = ed25519_keypair_generate(&signing_kp, 0);
+ tt_int_op(retval, ==, 0);
+ published_desc = helper_build_hs_desc(42, 3 * 60 * 60, &signing_kp.pubkey);
tt_assert(published_desc);
- retval = hs_desc_encode_descriptor(published_desc, &published_desc_str);
+ retval = hs_desc_encode_descriptor(published_desc, &signing_kp,
+ &published_desc_str);
tt_int_op(retval, OP_EQ, 0);
}
@@ -370,7 +382,7 @@ test_upload_and_download_hs_desc(void *arg)
/* Simulate a fetch of the previously published descriptor */
{
const ed25519_public_key_t *blinded_key;
- blinded_key = &published_desc->plaintext_data.blinded_kp.pubkey;
+ blinded_key = &published_desc->plaintext_data.blinded_pubkey;
received_desc_str = helper_fetch_desc_from_hsdir(blinded_key);
}
@@ -391,7 +403,9 @@ test_hsdir_revision_counter_check(void *arg)
{
int retval;
- hs_descriptor_t *published_desc;
+ ed25519_keypair_t signing_kp;
+
+ hs_descriptor_t *published_desc = NULL;
char *published_desc_str = NULL;
char *received_desc_str = NULL;
@@ -404,9 +418,13 @@ test_hsdir_revision_counter_check(void *arg)
/* Generate a valid descriptor with normal values. */
{
- published_desc = helper_build_hs_desc(1312, 3 * 60 * 60, NULL);
+ retval = ed25519_keypair_generate(&signing_kp, 0);
+ tt_int_op(retval, ==, 0);
+ published_desc = helper_build_hs_desc(1312, 3 * 60 * 60,
+ &signing_kp.pubkey);
tt_assert(published_desc);
- retval = hs_desc_encode_descriptor(published_desc, &published_desc_str);
+ retval = hs_desc_encode_descriptor(published_desc, &signing_kp,
+ &published_desc_str);
tt_int_op(retval, OP_EQ, 0);
}
@@ -426,7 +444,7 @@ test_hsdir_revision_counter_check(void *arg)
{
const ed25519_public_key_t *blinded_key;
- blinded_key = &published_desc->plaintext_data.blinded_kp.pubkey;
+ blinded_key = &published_desc->plaintext_data.blinded_pubkey;
received_desc_str = helper_fetch_desc_from_hsdir(blinded_key);
retval = hs_desc_decode_descriptor(received_desc_str,NULL, &received_desc);
@@ -445,7 +463,8 @@ test_hsdir_revision_counter_check(void *arg)
{
published_desc->plaintext_data.revision_counter = 1313;
tor_free(published_desc_str);
- retval = hs_desc_encode_descriptor(published_desc, &published_desc_str);
+ retval = hs_desc_encode_descriptor(published_desc, &signing_kp,
+ &published_desc_str);
tt_int_op(retval, OP_EQ, 0);
retval = handle_post_hs_descriptor("/tor/hs/3/publish",published_desc_str);
@@ -457,7 +476,7 @@ test_hsdir_revision_counter_check(void *arg)
{
const ed25519_public_key_t *blinded_key;
- blinded_key = &published_desc->plaintext_data.blinded_kp.pubkey;
+ blinded_key = &published_desc->plaintext_data.blinded_pubkey;
received_desc_str = helper_fetch_desc_from_hsdir(blinded_key);
retval = hs_desc_decode_descriptor(received_desc_str,NULL, &received_desc);
diff --git a/src/test/test_hs_descriptor.c b/src/test/test_hs_descriptor.c
index 3f588df..3603342 100644
--- a/src/test/test_hs_descriptor.c
+++ b/src/test/test_hs_descriptor.c
@@ -77,24 +77,28 @@ helper_build_intro_point(const ed25519_keypair_t *blinded_kp, time_t now,
/* Return a valid hs_descriptor_t object. If no_ip is set, no introduction
* points are added. */
static hs_descriptor_t *
-helper_build_hs_desc(unsigned int no_ip)
+helper_build_hs_desc(unsigned int no_ip, ed25519_public_key_t *signing_pubkey)
{
int ret;
time_t now = time(NULL);
+ ed25519_keypair_t blinded_kp;
hs_descriptor_t *descp = NULL, *desc = tor_malloc_zero(sizeof(*desc));
desc->plaintext_data.version = HS_DESC_SUPPORTED_FORMAT_VERSION_MAX;
- ret = ed25519_keypair_generate(&desc->plaintext_data.signing_kp, 0);
- tt_int_op(ret, ==, 0);
- ret = ed25519_keypair_generate(&desc->plaintext_data.blinded_kp, 0);
+
+ /* Copy only the public key into the descriptor. */
+ memcpy(&desc->plaintext_data.signing_pubkey, signing_pubkey,
+ sizeof(ed25519_public_key_t));
+
+ ret = ed25519_keypair_generate(&blinded_kp, 0);
tt_int_op(ret, ==, 0);
+ /* Copy only the public key into the descriptor. */
+ memcpy(&desc->plaintext_data.blinded_pubkey, &blinded_kp.pubkey,
+ sizeof(ed25519_public_key_t));
desc->plaintext_data.signing_key_cert =
- tor_cert_create(&desc->plaintext_data.blinded_kp,
- CERT_TYPE_SIGNING_HS_DESC,
- &desc->plaintext_data.signing_kp.pubkey, now,
- 3600,
- CERT_FLAG_INCLUDE_SIGNING_KEY);
+ tor_cert_create(&blinded_kp, CERT_TYPE_SIGNING_HS_DESC, signing_pubkey,
+ now, 3600, CERT_FLAG_INCLUDE_SIGNING_KEY);
tt_assert(desc->plaintext_data.signing_key_cert);
desc->plaintext_data.revision_counter = 42;
desc->plaintext_data.lifetime_sec = 3 * 60 * 60;
@@ -108,17 +112,13 @@ helper_build_hs_desc(unsigned int no_ip)
if (!no_ip) {
/* Add four intro points. */
smartlist_add(desc->encrypted_data.intro_points,
- helper_build_intro_point(&desc->plaintext_data.blinded_kp, now,
- "1.2.3.4", 0));
+ helper_build_intro_point(&blinded_kp, now, "1.2.3.4", 0));
smartlist_add(desc->encrypted_data.intro_points,
- helper_build_intro_point(&desc->plaintext_data.blinded_kp, now,
- "[2600::1]", 0));
+ helper_build_intro_point(&blinded_kp, now, "[2600::1]", 0));
smartlist_add(desc->encrypted_data.intro_points,
- helper_build_intro_point(&desc->plaintext_data.blinded_kp, now,
- "3.2.1.4", 1));
+ helper_build_intro_point(&blinded_kp, now, "3.2.1.4", 1));
smartlist_add(desc->encrypted_data.intro_points,
- helper_build_intro_point(&desc->plaintext_data.blinded_kp, now,
- "", 1));
+ helper_build_intro_point(&blinded_kp, now, "", 1));
}
descp = desc;
@@ -138,11 +138,11 @@ helper_compare_hs_desc(const hs_descriptor_t *desc1,
desc2->plaintext_data.lifetime_sec);
tt_assert(tor_cert_eq(desc1->plaintext_data.signing_key_cert,
desc2->plaintext_data.signing_key_cert));
- tt_mem_op(desc1->plaintext_data.signing_kp.pubkey.pubkey, OP_EQ,
- desc2->plaintext_data.signing_kp.pubkey.pubkey,
+ tt_mem_op(desc1->plaintext_data.signing_pubkey.pubkey, OP_EQ,
+ desc2->plaintext_data.signing_pubkey.pubkey,
ED25519_PUBKEY_LEN);
- tt_mem_op(desc1->plaintext_data.blinded_kp.pubkey.pubkey, OP_EQ,
- desc2->plaintext_data.blinded_kp.pubkey.pubkey,
+ tt_mem_op(desc1->plaintext_data.blinded_pubkey.pubkey, OP_EQ,
+ desc2->plaintext_data.blinded_pubkey.pubkey,
ED25519_PUBKEY_LEN);
tt_u64_op(desc1->plaintext_data.revision_counter, ==,
desc2->plaintext_data.revision_counter);
@@ -481,11 +481,15 @@ test_encode_descriptor(void *arg)
{
int ret;
char *encoded = NULL;
- hs_descriptor_t *desc = helper_build_hs_desc(0);
+ ed25519_keypair_t signing_kp;
+ hs_descriptor_t *desc = NULL;
(void) arg;
- ret = hs_desc_encode_descriptor(desc, &encoded);
+ ret = ed25519_keypair_generate(&signing_kp, 0);
+ tt_int_op(ret, ==, 0);
+ desc = helper_build_hs_desc(0, &signing_kp.pubkey);
+ ret = hs_desc_encode_descriptor(desc, &signing_kp, &encoded);
tt_int_op(ret, ==, 0);
tt_assert(encoded);
@@ -499,17 +503,22 @@ test_decode_descriptor(void *arg)
{
int ret;
char *encoded = NULL;
- hs_descriptor_t *desc = helper_build_hs_desc(0);
+ ed25519_keypair_t signing_kp;
+ hs_descriptor_t *desc = NULL;
hs_descriptor_t *decoded = NULL;
hs_descriptor_t *desc_no_ip = NULL;
(void) arg;
+ ret = ed25519_keypair_generate(&signing_kp, 0);
+ tt_int_op(ret, ==, 0);
+ desc = helper_build_hs_desc(0, &signing_kp.pubkey);
+
/* Give some bad stuff to the decoding function. */
ret = hs_desc_decode_descriptor("hladfjlkjadf", NULL, &decoded);
tt_int_op(ret, OP_EQ, -1);
- ret = hs_desc_encode_descriptor(desc, &encoded);
+ ret = hs_desc_encode_descriptor(desc, &signing_kp, &encoded);
tt_int_op(ret, ==, 0);
tt_assert(encoded);
@@ -521,10 +530,13 @@ test_decode_descriptor(void *arg)
/* Decode a descriptor with _no_ introduction points. */
{
- desc_no_ip = helper_build_hs_desc(1);
+ ed25519_keypair_t signing_kp_no_ip;
+ ret = ed25519_keypair_generate(&signing_kp_no_ip, 0);
+ tt_int_op(ret, ==, 0);
+ desc_no_ip = helper_build_hs_desc(1, &signing_kp_no_ip.pubkey);
tt_assert(desc_no_ip);
tor_free(encoded);
- ret = hs_desc_encode_descriptor(desc_no_ip, &encoded);
+ ret = hs_desc_encode_descriptor(desc_no_ip, &signing_kp_no_ip, &encoded);
tt_int_op(ret, ==, 0);
tt_assert(encoded);
hs_descriptor_free(decoded);
@@ -599,6 +611,7 @@ test_decode_intro_point(void *arg)
char *encoded_ip = NULL;
size_t len_out;
hs_desc_intro_point_t *ip = NULL;
+ ed25519_keypair_t signing_kp;
hs_descriptor_t *desc = NULL;
(void) arg;
@@ -647,7 +660,9 @@ test_decode_intro_point(void *arg)
/* Start by testing the "decode all intro points" function. */
{
char *line;
- desc = helper_build_hs_desc(0);
+ ret = ed25519_keypair_generate(&signing_kp, 0);
+ tt_int_op(ret, ==, 0);
+ desc = helper_build_hs_desc(0, &signing_kp.pubkey);
tt_assert(desc);
/* Only try to decode an incomplete introduction point section. */
tor_asprintf(&line, "\n%s", intro_point);
@@ -674,7 +689,9 @@ test_decode_intro_point(void *arg)
/* Try to decode a junk string. */
{
hs_descriptor_free(desc);
- desc = helper_build_hs_desc(0);
+ ret = ed25519_keypair_generate(&signing_kp, 0);
+ tt_int_op(ret, ==, 0);
+ desc = helper_build_hs_desc(0, &signing_kp.pubkey);
const char *junk = "this is not a descriptor";
ip = decode_introduction_point(desc, junk);
tt_assert(!ip);
@@ -977,10 +994,10 @@ test_desc_signature(void *arg)
tt_int_op(ret, ==, 0);
/* Build the descriptor that should be valid. */
tor_asprintf(&desc, "%ssignature %s\n", data, sig_b64);
- ret = desc_sig_is_valid(sig_b64, &kp, desc, strlen(desc));
+ ret = desc_sig_is_valid(sig_b64, &kp.pubkey, desc, strlen(desc));
tt_int_op(ret, ==, 1);
/* Junk signature. */
- ret = desc_sig_is_valid("JUNK", &kp, desc, strlen(desc));
+ ret = desc_sig_is_valid("JUNK", &kp.pubkey, desc, strlen(desc));
tt_int_op(ret, ==, 0);
done:
