GNUnet  0.11.x
abd_serialization.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009-2013, 2016 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 
28 #include "platform.h"
29 #include "gnunet_util_lib.h"
30 #include "gnunet_constants.h"
31 #include "gnunet_abd_service.h"
32 #include "gnunet_signatures.h"
33 #include "abd.h"
34 
43 size_t
45  unsigned int ds_count,
46  const struct GNUNET_ABD_DelegationSet *dsr)
47 {
48  unsigned int i;
49  size_t ret;
50 
51  ret = sizeof (struct DelegationRecordData) * (ds_count);
52 
53  for (i = 0; i < ds_count; i++)
54  {
55  GNUNET_assert ((ret + dsr[i].subject_attribute_len) >= ret);
56  ret += dsr[i].subject_attribute_len;
57  }
58  return ret;
59 }
60 
61 
71 ssize_t
73  unsigned int d_count,
74  const struct GNUNET_ABD_DelegationSet *dsr,
75  size_t dest_size,
76  char *dest)
77 {
78  struct DelegationRecordData rec;
79  unsigned int i;
80  size_t off;
81 
82  off = 0;
83  for (i = 0; i < d_count; i++)
84  {
85  rec.subject_attribute_len = htonl ((uint32_t) dsr[i].subject_attribute_len);
86  rec.subject_key = dsr[i].subject_key;
87  if (off + sizeof (rec) > dest_size)
88  return -1;
89  GNUNET_memcpy (&dest[off], &rec, sizeof (rec));
90  off += sizeof (rec);
91  if (0 == dsr[i].subject_attribute_len)
92  continue;
93  if (off + dsr[i].subject_attribute_len > dest_size)
94  return -1;
95  GNUNET_memcpy (&dest[off],
96  dsr[i].subject_attribute,
97  dsr[i].subject_attribute_len);
98  off += dsr[i].subject_attribute_len;
99  }
100  return off;
101 }
102 
103 
113 int
115  size_t len,
116  const char *src,
117  unsigned int d_count,
118  struct GNUNET_ABD_DelegationSet *dsr)
119 {
120  struct DelegationRecordData rec;
121  unsigned int i;
122  size_t off;
123 
124  off = 0;
125  for (i = 0; i < d_count; i++)
126  {
127  if (off + sizeof (rec) > len)
128  return GNUNET_SYSERR;
129  GNUNET_memcpy (&rec, &src[off], sizeof (rec));
130  dsr[i].subject_key = rec.subject_key;
131  off += sizeof (rec);
132  dsr[i].subject_attribute_len = ntohl ((uint32_t) rec.subject_attribute_len);
133  if (off + dsr[i].subject_attribute_len > len)
134  return GNUNET_SYSERR;
135  dsr[i].subject_attribute = (char *) &src[off];
136  off += dsr[i].subject_attribute_len;
137  }
138  return GNUNET_OK;
139 }
140 
141 
150 size_t
152  unsigned int c_count,
153  const struct GNUNET_ABD_Delegate *cd)
154 {
155  unsigned int i;
156  size_t ret;
157 
158  ret = sizeof (struct DelegateEntry) * (c_count);
159 
160  for (i = 0; i < c_count; i++)
161  {
162  GNUNET_assert ((ret + cd[i].issuer_attribute_len
163  + cd[i].subject_attribute_len) >= ret);
164  // subject_attribute_len should be 0
165  ret += cd[i].issuer_attribute_len + cd[i].subject_attribute_len;
166  }
167  return ret;
168 }
169 
170 
180 ssize_t
182  unsigned int c_count,
183  const struct GNUNET_ABD_Delegate *cd,
184  size_t dest_size,
185  char *dest)
186 {
187  struct DelegateEntry c_rec;
188  unsigned int i;
189  size_t off;
190 
191  off = 0;
192  for (i = 0; i < c_count; i++)
193  {
194  // c_rec.subject_attribute_len = htonl ((uint32_t) cd[i].subject_attribute_len);
195  c_rec.issuer_attribute_len = htonl ((uint32_t) cd[i].issuer_attribute_len);
196  c_rec.issuer_key = cd[i].issuer_key;
197  c_rec.subject_key = cd[i].subject_key;
198  c_rec.signature = cd[i].signature;
200  c_rec.purpose.size =
201  htonl ((sizeof (struct DelegateEntry) + cd[i].issuer_attribute_len)
202  - sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
203  c_rec.expiration = GNUNET_htonll (cd[i].expiration.abs_value_us);
204  if (off + sizeof (c_rec) > dest_size)
205  return -1;
206  GNUNET_memcpy (&dest[off], &c_rec, sizeof (c_rec));
207  off += sizeof (c_rec);
208  if (off + cd[i].issuer_attribute_len > dest_size)
209  return -1;
210  GNUNET_memcpy (&dest[off],
211  cd[i].issuer_attribute,
212  cd[i].issuer_attribute_len);
213  off += cd[i].issuer_attribute_len;
214  }
215 
216  return off;
217 }
218 
219 
229 int
231  const char *src,
232  unsigned int c_count,
233  struct GNUNET_ABD_Delegate *cd)
234 {
235  struct DelegateEntry c_rec;
236  unsigned int i;
237  size_t off;
238 
239  off = 0;
240  for (i = 0; i < c_count; i++)
241  {
242  if (off + sizeof (c_rec) > len)
243  return GNUNET_SYSERR;
244  GNUNET_memcpy (&c_rec, &src[off], sizeof (c_rec));
245  cd[i].issuer_attribute_len = ntohl ((uint32_t) c_rec.issuer_attribute_len);
246  cd[i].issuer_key = c_rec.issuer_key;
247  cd[i].subject_key = c_rec.subject_key;
248  cd[i].signature = c_rec.signature;
250  off += sizeof (c_rec);
251  if (off + cd[i].issuer_attribute_len > len)
252  return GNUNET_SYSERR;
253  cd[i].issuer_attribute = &src[off];
254  off += cd[i].issuer_attribute_len;
255  cd[i].subject_attribute_len = 0;
256  }
257  return GNUNET_OK;
258 }
259 
260 
271 size_t
273  unsigned int d_count,
274  const struct GNUNET_ABD_Delegation *dd,
275  unsigned int c_count,
276  const struct GNUNET_ABD_Delegate *cd)
277 {
278  unsigned int i;
279  size_t ret;
280 
281  ret = sizeof (struct ChainEntry) * (d_count);
282 
283  for (i = 0; i < d_count; i++)
284  {
285  GNUNET_assert (
286  (ret + dd[i].issuer_attribute_len + dd[i].subject_attribute_len) >= ret);
287  ret += dd[i].issuer_attribute_len + dd[i].subject_attribute_len;
288  }
289  return ret + GNUNET_ABD_delegates_get_size (c_count, cd);
290 }
291 
292 
304 ssize_t
306  unsigned int d_count,
307  const struct GNUNET_ABD_Delegation *dd,
308  unsigned int c_count,
309  const struct GNUNET_ABD_Delegate *cd,
310  size_t dest_size,
311  char *dest)
312 {
313  struct ChainEntry rec;
314  unsigned int i;
315  size_t off;
316 
317  off = 0;
318  for (i = 0; i < d_count; i++)
319  {
320  rec.issuer_attribute_len = htonl ((uint32_t) dd[i].issuer_attribute_len);
321  rec.subject_attribute_len = htonl ((uint32_t) dd[i].subject_attribute_len);
322  rec.issuer_key = dd[i].issuer_key;
323  rec.subject_key = dd[i].subject_key;
324  if (off + sizeof (rec) > dest_size)
325  return -1;
326  GNUNET_memcpy (&dest[off], &rec, sizeof (rec));
327  off += sizeof (rec);
328  if (off + dd[i].issuer_attribute_len > dest_size)
329  return -1;
330  GNUNET_memcpy (&dest[off],
331  dd[i].issuer_attribute,
332  dd[i].issuer_attribute_len);
333  off += dd[i].issuer_attribute_len;
334  if (0 == dd[i].subject_attribute_len)
335  continue;
336  if (off + dd[i].subject_attribute_len > dest_size)
337  return -1;
338  GNUNET_memcpy (&dest[off],
339  dd[i].subject_attribute,
340  dd[i].subject_attribute_len);
341  off += dd[i].subject_attribute_len;
342  }
343  return off + GNUNET_ABD_delegates_serialize (c_count,
344  cd,
345  dest_size - off,
346  &dest[off]);
347 }
348 
349 
361 int
363  size_t len,
364  const char *src,
365  unsigned int d_count,
366  struct GNUNET_ABD_Delegation *dd,
367  unsigned int c_count,
368  struct GNUNET_ABD_Delegate *cd)
369 {
370  struct ChainEntry rec;
371  unsigned int i;
372  size_t off;
373 
374  off = 0;
375  for (i = 0; i < d_count; i++)
376  {
377  if (off + sizeof (rec) > len)
378  return GNUNET_SYSERR;
379  GNUNET_memcpy (&rec, &src[off], sizeof (rec));
380  dd[i].issuer_attribute_len = ntohl ((uint32_t) rec.issuer_attribute_len);
381  dd[i].issuer_key = rec.issuer_key;
382  dd[i].subject_key = rec.subject_key;
383  off += sizeof (rec);
384  if (off + dd[i].issuer_attribute_len > len)
385  return GNUNET_SYSERR;
386  dd[i].issuer_attribute = &src[off];
387  off += dd[i].issuer_attribute_len;
388  dd[i].subject_attribute_len = ntohl ((uint32_t) rec.subject_attribute_len);
389  if (off + dd[i].subject_attribute_len > len)
390  return GNUNET_SYSERR;
391  dd[i].subject_attribute = &src[off];
392  off += dd[i].subject_attribute_len;
393  }
394  return GNUNET_ABD_delegates_deserialize (len - off,
395  &src[off],
396  c_count,
397  cd);
398 }
399 
400 
401 int
403  char **data)
404 {
405  size_t size;
406  struct DelegateEntry *cdata;
407  int attr_len;
408 
409  // +1 for \0
410  if (0 == dele->subject_attribute_len)
411  {
412  attr_len = dele->issuer_attribute_len + 1;
413  }
414  else
415  {
416  attr_len = dele->issuer_attribute_len + dele->subject_attribute_len + 2;
417  }
418  size = sizeof (struct DelegateEntry) + attr_len;
419 
420  char tmp_str[attr_len];
421  GNUNET_memcpy (tmp_str, dele->issuer_attribute, dele->issuer_attribute_len);
422  if (0 != dele->subject_attribute_len)
423  {
424  tmp_str[dele->issuer_attribute_len] = '\0';
425  GNUNET_memcpy (tmp_str + dele->issuer_attribute_len + 1,
426  dele->subject_attribute,
427  dele->subject_attribute_len);
428  }
429  tmp_str[attr_len - 1] = '\0';
430 
431  *data = GNUNET_malloc (size);
432  cdata = (struct DelegateEntry *) *data;
433  cdata->subject_key = dele->subject_key;
434  cdata->issuer_key = dele->issuer_key;
436  cdata->signature = dele->signature;
437  cdata->issuer_attribute_len = htonl (dele->issuer_attribute_len + 1);
438  if (0 == dele->subject_attribute_len)
439  {
440  cdata->subject_attribute_len = htonl (0);
441  }
442  else
443  {
444  cdata->subject_attribute_len = htonl (dele->subject_attribute_len + 1);
445  }
447  cdata->purpose.size =
448  htonl (size - sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
449 
450  GNUNET_memcpy (&cdata[1], tmp_str, attr_len);
451 
452  if (GNUNET_OK !=
454  &cdata->purpose,
455  &cdata->signature,
456  &cdata->issuer_key))
457  {
458  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Serialize: Invalid delegate\n");
459  return 0;
460  }
461  return size;
462 }
463 
464 
465 struct GNUNET_ABD_Delegate *
467 {
468  struct GNUNET_ABD_Delegate *dele;
469  struct DelegateEntry *cdata;
470  char *attr_combo_str;
471 
472  if (data_size < sizeof (struct DelegateEntry))
473  return NULL;
474  cdata = (struct DelegateEntry *) data;
475  if (GNUNET_OK !=
477  &cdata->purpose,
478  &cdata->signature,
479  &cdata->issuer_key))
480  {
481  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deserialize: Invalid delegate\n");
482  return NULL;
483  }
484  attr_combo_str = (char *) &cdata[1];
485  int iss_len = ntohl (cdata->issuer_attribute_len);
486  int sub_len = ntohl (cdata->subject_attribute_len);
487  int attr_combo_len = iss_len + sub_len;
488 
489  dele =
490  GNUNET_malloc (sizeof (struct GNUNET_ABD_Delegate) + attr_combo_len);
491 
492  dele->issuer_key = cdata->issuer_key;
493  dele->subject_key = cdata->subject_key;
494  GNUNET_memcpy (&dele[1], attr_combo_str, attr_combo_len);
495  dele->signature = cdata->signature;
496 
497  // Set the pointers for the attributes
498  dele->issuer_attribute = (char *) &dele[1];
499  dele->issuer_attribute_len = iss_len;
500  dele->subject_attribute_len = sub_len;
501  if (0 == sub_len)
502  {
503  dele->subject_attribute = NULL;
504  }
505  else
506  {
507  dele->subject_attribute = (char *) &dele[1] + iss_len;
508  }
509 
511 
512  return dele;
513 }
514 
515 
516 /* end of abd_serialization.c */
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Subject key.
Definition: abd.h:192
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this credential was issued to.
IPC messages between ABD API and ABD service.
int GNUNET_CRYPTO_ecdsa_verify(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EcdsaSignature *sig, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Verify ECDSA signature.
Definition: crypto_ecc.c:790
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Subject key.
Definition: abd.h:173
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this attribute was delegated to.
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
uint32_t issuer_attribute_len
Length of the attribute.
int GNUNET_ABD_delegates_deserialize(size_t len, const char *src, unsigned int c_count, struct GNUNET_ABD_Delegate *cd)
Deserialize the given destination.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
Public key of the issuer.
Definition: abd.h:260
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t issuer_attribute_len
Issuer attributes.
Definition: abd.h:197
The attribute delegation record.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
uint64_t expiration
Expiration time of this credential.
Definition: abd.h:270
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature of this credential.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The issuer of the credential.
uint64_t abs_value_us
The actual value.
ssize_t GNUNET_ABD_delegation_chain_serialize(unsigned int d_count, const struct GNUNET_ABD_Delegation *dd, unsigned int c_count, const struct GNUNET_ABD_Delegate *cd, size_t dest_size, char *dest)
Serizalize the given delegation chain entries and abd.
int GNUNET_ABD_delegate_serialize(struct GNUNET_ABD_Delegate *dele, char **data)
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this credential was issued to.
Definition: abd.h:265
struct GNUNET_ABD_Delegate * GNUNET_ABD_delegate_deserialize(const char *data, size_t data_size)
ssize_t GNUNET_ABD_delegates_serialize(unsigned int c_count, const struct GNUNET_ABD_Delegate *cd, size_t dest_size, char *dest)
Serizalize the given abds.
uint32_t subject_attribute_len
Subject attributes.
Definition: abd.h:202
uint32_t subject_attribute_len
Length of the subject attribute.
ssize_t GNUNET_ABD_delegation_set_serialize(unsigned int d_count, const struct GNUNET_ABD_DelegationSet *dsr, size_t dest_size, char *dest)
Serizalize the given delegation chain entries and abd.
an ECC signature using ECDSA
int GNUNET_ABD_delegation_chain_deserialize(size_t len, const char *src, unsigned int d_count, struct GNUNET_ABD_Delegation *dd, unsigned int c_count, struct GNUNET_ABD_Delegate *cd)
Deserialize the given destination.
const char * subject_attribute
The subject attribute.
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!)...
struct GNUNET_CRYPTO_EcdsaSignature signature
The signature for this credential by the issuer.
Definition: abd.h:250
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The issuer of the delegation.
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
uint32_t subject_attribute_len
Subject attributes.
Definition: abd.h:178
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
uint32_t issuer_attribute_len
Length of the issuer attribute.
size_t GNUNET_ABD_delegation_chain_get_size(unsigned int d_count, const struct GNUNET_ABD_Delegation *dd, unsigned int c_count, const struct GNUNET_ABD_Delegate *cd)
Calculate how many bytes we will need to serialize the given delegation chain and abd...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
const char * subject_attribute
The attribute.
const char * subject_attribute
The subject attribute.
int GNUNET_ABD_delegation_set_deserialize(size_t len, const char *src, unsigned int d_count, struct GNUNET_ABD_DelegationSet *dsr)
Deserialize the given destination.
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this attribute was delegated to.
uint32_t subject_attribute_len
Issuer attribute length.
Definition: abd.h:280
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Signature meta.
Definition: abd.h:255
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Absolute expiration
Expiration of this credential.
size_t GNUNET_ABD_delegates_get_size(unsigned int c_count, const struct GNUNET_ABD_Delegate *cd)
Calculate how many bytes we will need to serialize the abds.
uint32_t issuer_attribute_len
Issuer subject attribute length.
Definition: abd.h:275
const char * issuer_attribute
The attribute.
const char * issuer_attribute
The issuer attribute.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
Issuer key.
Definition: abd.h:187
size_t GNUNET_ABD_delegation_set_get_size(unsigned int ds_count, const struct GNUNET_ABD_DelegationSet *dsr)
Calculate how many bytes we will need to serialize the given delegation chain.
uint32_t data
The data value.
uint32_t subject_attribute_len
Length of the attribute.
#define GNUNET_malloc(size)
Wrapper around malloc.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
#define GNUNET_SIGNATURE_PURPOSE_DELEGATE
Signature for a GNUnet credential.