GNUnet  0.10.x
hello-ng.c
Go to the documentation of this file.
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 
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 
36 struct SignedAddress {
41 
46 
51 };
52 
53 
64 void
66  const char *address,
69  const struct GNUNET_CRYPTO_EddsaPrivateKey *private_key,
70  void **result,
71  size_t *result_size)
72 {
73  struct SignedAddress sa;
75  char *sig_str;
76 
78  sa.purpose.size = htonl(sizeof(sa));
79  sa.mono_time = GNUNET_TIME_absolute_hton(mono_time);
80  GNUNET_CRYPTO_hash(address, strlen(address), &sa.h_addr);
82  GNUNET_CRYPTO_eddsa_sign(private_key, &sa.purpose, &sig));
83  sig_str = NULL;
84  (void)GNUNET_STRINGS_base64_encode(&sig, sizeof(sig), &sig_str);
85  *result_size =
86  1 + GNUNET_asprintf((char **)result,
87  "%s;%llu;%u;%s",
88  sig_str,
89  (unsigned long long)mono_time.abs_value_us,
90  (unsigned int)nt,
91  address);
92  GNUNET_free(sig_str);
93 }
94 
95 
106 char *
108  size_t raw_size,
109  const struct GNUNET_PeerIdentity *pid,
110  enum GNUNET_NetworkType *nt,
112 {
113  const struct GNUNET_CRYPTO_EddsaPublicKey *public_key = &pid->public_key;
114  const char *raws = raw;
115  unsigned long long raw_us;
116  unsigned int raw_nt;
117  const char *sc;
118  const char *sc2;
119  const char *sc3;
120  const char *raw_addr;
121  struct GNUNET_TIME_Absolute raw_mono_time;
122  struct SignedAddress sa;
123  struct GNUNET_CRYPTO_EddsaSignature *sig;
124 
125  if ('\0' != raws[raw_size])
126  {
127  GNUNET_break_op(0);
128  return NULL;
129  }
130  if (NULL == (sc = strchr(raws, ';')))
131  {
132  GNUNET_break_op(0);
133  return NULL;
134  }
135  if (NULL == (sc2 = strchr(sc + 1, ';')))
136  {
137  GNUNET_break_op(0);
138  return NULL;
139  }
140  if (NULL == (sc3 = strchr(sc2 + 1, ';')))
141  {
142  GNUNET_break_op(0);
143  return NULL;
144  }
145  if (1 != sscanf(sc + 1, "%llu;%u;", &raw_us, &raw_nt))
146  {
147  GNUNET_break_op(0);
148  return NULL;
149  }
150  raw_mono_time.abs_value_us = raw_us;
151  sig = NULL;
152  if (sizeof(struct GNUNET_CRYPTO_EddsaSignature) !=
153  GNUNET_STRINGS_base64_decode(raws, sc - raws, (void **)&sig))
154  {
155  GNUNET_break_op(0);
157  return NULL;
158  }
159  raw_addr = sc3 + 1;
160 
162  sa.purpose.size = htonl(sizeof(sa));
163  sa.mono_time = GNUNET_TIME_absolute_hton(raw_mono_time);
164  GNUNET_CRYPTO_hash(raw_addr, strlen(raw_addr), &sa.h_addr);
165  if (GNUNET_YES !=
167  &sa.purpose,
168  sig,
169  public_key))
170  {
171  GNUNET_break_op(0);
172  GNUNET_free(sig);
173  return NULL;
174  }
175  GNUNET_free(sig);
176  *mono_time = raw_mono_time;
177  *nt = (enum GNUNET_NetworkType)raw_nt;
178  return GNUNET_strdup(raw_addr);
179 }
180 
181 
189 char *
191 {
192  const char *dash;
193 
194  dash = strchr(address, '-');
195  if (NULL == dash)
196  return NULL;
197  return GNUNET_strndup(address, dash - address);
198 }
static int raw
raw output
Definition: gnunet-gns.c:55
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_CRYPTO_eddsa_sign(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
EdDSA sign a given block.
Definition: crypto_ecc.c:989
struct GNUNET_HashCode h_addr
Hash of the address.
Definition: hello-ng.c:50
struct GNUNET_TIME_AbsoluteNBO mono_time
When was the address generated.
Definition: hello-ng.c:45
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS.
Definition: hello-ng.c:40
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Time for absolute time used by GNUnet, in microseconds and in network byte order. ...
uint64_t abs_value_us
The actual value.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
int GNUNET_CRYPTO_eddsa_verify(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EddsaSignature *sig, const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Verify EdDSA signature.
Definition: crypto_ecc.c:1116
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
void GNUNET_HELLO_sign_address(const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Absolute mono_time, const struct GNUNET_CRYPTO_EddsaPrivateKey *private_key, void **result, size_t *result_size)
Build address record by signing raw information with private key.
Definition: hello-ng.c:65
static int result
Global testing status.
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!)...
A 512-bit hashcode.
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **output)
Decode from Base64.
Definition: strings.c:1920
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1856
Binary block we sign when we sign an address.
Definition: hello-ng.c:36
char * GNUNET_HELLO_address_to_prefix(const char *address)
Given an address as a string, extract the prefix that identifies the communicator offering transmissi...
Definition: hello-ng.c:190
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
#define GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS
Signature by a peer affirming that this is one of its addresses (for the given time period)...
an ECC signature using EdDSA.
Private ECC key encoded for transmission.
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
The identity of the host (wraps the signing key of the peer).
Automatic transport selection and outbound bandwidth determination.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
char * GNUNET_HELLO_extract_address(const void *raw, size_t raw_size, const struct GNUNET_PeerIdentity *pid, enum GNUNET_NetworkType *nt, struct GNUNET_TIME_Absolute *mono_time)
Check signature and extract address record.
Definition: hello-ng.c:107
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:655
static char * address
GNS address for this phone.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...