src/hello/hello-ng.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2018 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file hello/hello-ng.c
  23  * @brief helper library for handling HELLOs
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_signatures.h"
  28 #include "gnunet_hello_lib.h"
  29 #include "gnunet_protocols.h"
  30 #include "gnunet_util_lib.h"
  31 #include "gnunet_ats_service.h"
  32
  33 /**
  34  * Binary block we sign when we sign an address.
  35  */
  36 struct SignedAddress
  37 {
  38   /**
  39    * Purpose must be #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS
  40    */
  41   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
  42
  43   /**
  44    * When was the address generated.
  45    */
  46   struct GNUNET_TIME_AbsoluteNBO mono_time;
  47
  48   /**
  49    * Hash of the address.
  50    */
  51   struct GNUNET_HashCode h_addr;
  52 };
  53
  54
  55 /**
  56  * Build address record by signing raw information with private key.
  57  *
  58  * @param address text address at @a communicator to sign
  59  * @param nt network type of @a address
  60  * @param mono_time monotonic time at which @a address was valid
  61  * @param private_key signing key to use
  62  * @param result[out] where to write address record (allocated)
  63  * @param result_size[out] set to size of @a result
  64  */
  65 void
  66 GNUNET_HELLO_sign_address (
  67   const char *address,
  68   enum GNUNET_NetworkType nt,
  69   struct GNUNET_TIME_Absolute mono_time,
  70   const struct GNUNET_CRYPTO_EddsaPrivateKey *private_key,
  71   void **result,
  72   size_t *result_size)
  73 {
  74   struct SignedAddress sa;
  75   struct GNUNET_CRYPTO_EddsaSignature sig;
  76   char *sig_str;
  77
  78   sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS);
  79   sa.purpose.size = htonl (sizeof(sa));
  80   sa.mono_time = GNUNET_TIME_absolute_hton (mono_time);
  81   GNUNET_CRYPTO_hash (address, strlen (address), &sa.h_addr);
  82   GNUNET_assert (GNUNET_YES ==
  83                  GNUNET_CRYPTO_eddsa_sign (private_key, &sa.purpose, &sig));
  84   sig_str = NULL;
  85   (void) GNUNET_STRINGS_base64_encode (&sig, sizeof(sig), &sig_str);
  86   *result_size =
  87     1 + GNUNET_asprintf ((char **) result,
  88                          "%s;%llu;%u;%s",
  89                          sig_str,
  90                          (unsigned long long) mono_time.abs_value_us,
  91                          (unsigned int) nt,
  92                          address);
  93   GNUNET_free (sig_str);
  94 }
  95
  96
  97 /**
  98  * Check signature and extract address record.
  99  *
 100  * @param raw raw signed address
 101  * @param raw_size size of @a raw
 102  * @param pid public key to use for signature verification
 103  * @param nt[out] set to network type
 104  * @param mono_time[out] when was the address generated
 105  * @return NULL on error, otherwise the address
 106  */
 107 char *
 108 GNUNET_HELLO_extract_address (const void *raw,
 109                               size_t raw_size,
 110                               const struct GNUNET_PeerIdentity *pid,
 111                               enum GNUNET_NetworkType *nt,
 112                               struct GNUNET_TIME_Absolute *mono_time)
 113 {
 114   const struct GNUNET_CRYPTO_EddsaPublicKey *public_key = &pid->public_key;
 115   const char *raws = raw;
 116   unsigned long long raw_us;
 117   unsigned int raw_nt;
 118   const char *sc;
 119   const char *sc2;
 120   const char *sc3;
 121   const char *raw_addr;
 122   struct GNUNET_TIME_Absolute raw_mono_time;
 123   struct SignedAddress sa;
 124   struct GNUNET_CRYPTO_EddsaSignature *sig;
 125
 126   if ('\0' != raws[raw_size])
 127   {
 128     GNUNET_break_op (0);
 129     return NULL;
 130   }
 131   if (NULL == (sc = strchr (raws, ';')))
 132   {
 133     GNUNET_break_op (0);
 134     return NULL;
 135   }
 136   if (NULL == (sc2 = strchr (sc + 1, ';')))
 137   {
 138     GNUNET_break_op (0);
 139     return NULL;
 140   }
 141   if (NULL == (sc3 = strchr (sc2 + 1, ';')))
 142   {
 143     GNUNET_break_op (0);
 144     return NULL;
 145   }
 146   if (1 != sscanf (sc + 1, "%llu;%u;", &raw_us, &raw_nt))
 147   {
 148     GNUNET_break_op (0);
 149     return NULL;
 150   }
 151   raw_mono_time.abs_value_us = raw_us;
 152   sig = NULL;
 153   if (sizeof(struct GNUNET_CRYPTO_EddsaSignature) !=
 154       GNUNET_STRINGS_base64_decode (raws, sc - raws, (void **) &sig))
 155   {
 156     GNUNET_break_op (0);
 157     GNUNET_free_non_null (sig);
 158     return NULL;
 159   }
 160   raw_addr = sc3 + 1;
 161
 162   sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS);
 163   sa.purpose.size = htonl (sizeof(sa));
 164   sa.mono_time = GNUNET_TIME_absolute_hton (raw_mono_time);
 165   GNUNET_CRYPTO_hash (raw_addr, strlen (raw_addr), &sa.h_addr);
 166   if (GNUNET_YES !=
 167       GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS,
 168                                   &sa.purpose,
 169                                   sig,
 170                                   public_key))
 171   {
 172     GNUNET_break_op (0);
 173     GNUNET_free (sig);
 174     return NULL;
 175   }
 176   GNUNET_free (sig);
 177   *mono_time = raw_mono_time;
 178   *nt = (enum GNUNET_NetworkType) raw_nt;
 179   return GNUNET_strdup (raw_addr);
 180 }
 181
 182
 183 /**
 184  * Given an address as a string, extract the prefix that identifies
 185  * the communicator offering transmissions to that address.
 186  *
 187  * @param address a peer's address
 188  * @return NULL if the address is mal-formed, otherwise the prefix
 189  */
 190 char *
 191 GNUNET_HELLO_address_to_prefix (const char *address)
 192 {
 193   const char *dash;
 194
 195   dash = strchr (address, '-');
 196   if (NULL == dash)
 197     return NULL;
 198   return GNUNET_strndup (address, dash - address);
 199 }