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 
37 {
42 
47 
52 };
53 
54 
65 void
67  const char *address,
70  const struct GNUNET_CRYPTO_EddsaPrivateKey *private_key,
71  void **result,
72  size_t *result_size)
73 {
74  struct SignedAddress sa;
76  char *sig_str;
77 
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);
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 
107 char *
109  size_t raw_size,
110  const struct GNUNET_PeerIdentity *pid,
111  enum GNUNET_NetworkType *nt,
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 
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 !=
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 
190 char *
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 }
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:51
struct GNUNET_TIME_AbsoluteNBO mono_time
When was the address generated.
Definition: hello-ng.c:46
#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:41
#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:66
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:2067
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:2004
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:191
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:80
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:108
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:654
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...