GNUnet  0.16.x
delegate_misc.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 #include <inttypes.h>
35 
36 char *
38  const struct GNUNET_ABD_Delegate *cred)
39 {
40  char *cred_str;
41  char *subject_pkey;
42  char *issuer_pkey;
43  char *signature;
44 
47  GNUNET_STRINGS_base64_encode ((char *) &cred->signature,
48  sizeof (struct GNUNET_IDENTITY_Signature),
49  &signature);
50  if (0 == cred->subject_attribute_len)
51  {
52  GNUNET_asprintf (&cred_str,
53  "%s.%s -> %s | %s | %" SCNu64,
55  cred->issuer_attribute,
57  signature,
58  cred->expiration.abs_value_us);
59  }
60  else
61  {
62  GNUNET_asprintf (&cred_str,
63  "%s.%s -> %s.%s | %s | %" SCNu64,
65  cred->issuer_attribute,
67  cred->subject_attribute,
68  signature,
69  cred->expiration.abs_value_us);
70  }
73  GNUNET_free (signature);
74 
75  return cred_str;
76 }
77 
78 
79 struct GNUNET_ABD_Delegate *
81 {
82  struct GNUNET_ABD_Delegate *dele;
83  size_t enclen = (sizeof (struct GNUNET_IDENTITY_PublicKey)) * 8;
84  if (enclen % 5 > 0)
85  enclen += 5 - enclen % 5;
86  enclen /= 5; /* 260/5 = 52 */
87  char subject_pkey[enclen + 1];
88  char issuer_pkey[enclen + 1];
89  char iss_attr[253 + 1];
90  // Needs to be initialized, in case of Type 1 credential (A.a <- B)
91  char sub_attr[253 + 1] = "";
92  char signature[256]; // TODO max payload size
93 
94  struct GNUNET_IDENTITY_Signature *sig;
95  struct GNUNET_TIME_Absolute etime_abs;
96 
97  // If it's A.a <- B.b...
98  if (6 != sscanf (s,
99  "%58s.%253s -> %58s.%253s | %s | %" SCNu64,
100  issuer_pkey,
101  iss_attr,
102  subject_pkey,
103  sub_attr,
104  signature,
105  &etime_abs.abs_value_us))
106  {
107  // Try if it's A.a <- B
108  if (5 != sscanf (s,
109  "%58s.%253s -> %58s | %s | %" SCNu64,
110  issuer_pkey,
111  iss_attr,
112  subject_pkey,
113  signature,
114  &etime_abs.abs_value_us))
115  {
117  "Unable to parse DEL record string `%s'\n",
118  s);
119  return NULL;
120  }
121  }
122 
123  // +1 for \0
124  int attr_len;
125  if (strcmp (sub_attr, "") == 0)
126  {
127  attr_len = strlen (iss_attr) + 1;
128  }
129  else
130  {
131  attr_len = strlen (iss_attr) + strlen (sub_attr) + 2;
132  }
133  dele = GNUNET_malloc (sizeof (struct GNUNET_ABD_Delegate) + attr_len);
134 
135  char tmp_str[attr_len];
136  GNUNET_memcpy (tmp_str, iss_attr, strlen (iss_attr));
137  if (strcmp (sub_attr, "") != 0)
138  {
139  tmp_str[strlen (iss_attr)] = '\0';
140  GNUNET_memcpy (tmp_str + strlen (iss_attr) + 1,
141  sub_attr,
142  strlen (sub_attr));
143  }
144  tmp_str[attr_len - 1] = '\0';
145 
146  if (GNUNET_SYSERR ==
148  &dele->subject_key))
149  {
150  GNUNET_free (dele);
151  return NULL;
152  }
153  if (GNUNET_SYSERR ==
155  &dele->issuer_key))
156  {
157  GNUNET_free (dele);
158  return NULL;
159  }
160  GNUNET_assert (sizeof (struct GNUNET_IDENTITY_Signature) ==
161  GNUNET_STRINGS_base64_decode (signature,
162  strlen (signature),
163  (void **) &sig));
164  dele->signature = *sig;
165  dele->expiration = etime_abs;
166  GNUNET_free (sig);
167 
168  GNUNET_memcpy (&dele[1], tmp_str, attr_len);
169 
170  dele->issuer_attribute = (char *) &dele[1];
171  dele->issuer_attribute_len = strlen (iss_attr);
172  if (strcmp (sub_attr, "") == 0)
173  {
174  dele->subject_attribute = NULL;
175  dele->subject_attribute_len = 0;
176  }
177  else
178  {
179  dele->subject_attribute = (char *) &dele[1] + strlen (iss_attr) + 1;
180  dele->subject_attribute_len = strlen (sub_attr);
181  }
182 
183  return dele;
184 }
185 
186 
196 struct GNUNET_ABD_Delegate *
198  const struct GNUNET_IDENTITY_PrivateKey *issuer,
200  const char *iss_attr,
201  const char *sub_attr,
203 {
204  struct DelegateEntry *del;
205  struct GNUNET_ABD_Delegate *dele;
206  size_t size;
207  int attr_len;
208 
209  if (NULL == sub_attr)
210  {
211  // +1 for \0
212  attr_len = strlen (iss_attr) + 1;
213  }
214  else
215  {
216  // +2 for both strings need to be terminated with \0
217  attr_len = strlen (iss_attr) + strlen (sub_attr) + 2;
218  }
219  size = sizeof (struct DelegateEntry) + attr_len;
220 
221  char tmp_str[attr_len];
222  GNUNET_memcpy (tmp_str, iss_attr, strlen (iss_attr));
223  if (NULL != sub_attr)
224  {
225  tmp_str[strlen (iss_attr)] = '\0';
226  GNUNET_memcpy (tmp_str + strlen (iss_attr) + 1,
227  sub_attr,
228  strlen (sub_attr));
229  }
230  tmp_str[attr_len - 1] = '\0';
231 
232  del = GNUNET_malloc (size);
233  del->purpose.size =
234  htonl (size - sizeof (struct GNUNET_IDENTITY_Signature));
235  del->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DELEGATE);
236  GNUNET_IDENTITY_key_get_public (issuer, &del->issuer_key);
237  del->subject_key = *subject;
238  del->expiration = GNUNET_htonll (expiration->abs_value_us);
239  del->issuer_attribute_len = htonl (strlen (iss_attr) + 1);
240  if (NULL == sub_attr)
241  {
242  del->subject_attribute_len = htonl (0);
243  }
244  else
245  {
246  del->subject_attribute_len = htonl (strlen (sub_attr) + 1);
247  }
248 
249  GNUNET_memcpy (&del[1], tmp_str, attr_len);
250 
251  GNUNET_IDENTITY_sign_ (issuer, &del->purpose, &del->signature);
252 
253  dele = GNUNET_malloc (sizeof (struct GNUNET_ABD_Delegate) + attr_len);
254  dele->signature = del->signature;
255  dele->expiration = *expiration;
257 
258  dele->subject_key = *subject;
259 
260  // Copy the combined string at the part in the memory where the struct ends
261  GNUNET_memcpy (&dele[1], tmp_str, attr_len);
262 
263  dele->issuer_attribute = (char *) &dele[1];
264  dele->issuer_attribute_len = strlen (iss_attr);
265  if (NULL == sub_attr)
266  {
267  dele->subject_attribute = NULL;
268  dele->subject_attribute_len = 0;
269  }
270  else
271  {
272  dele->subject_attribute = (char *) &dele[1] + strlen (iss_attr) + 1;
273  dele->subject_attribute_len = strlen (sub_attr);
274  }
275 
276  GNUNET_free (del);
277  return dele;
278 }
IPC messages between ABD API and ABD service.
char * GNUNET_ABD_delegate_to_string(const struct GNUNET_ABD_Delegate *cred)
Definition: delegate_misc.c:37
struct GNUNET_ABD_Delegate * GNUNET_ABD_delegate_from_string(const char *s)
Definition: delegate_misc.c:80
struct GNUNET_IDENTITY_PublicKey subject_pkey
Subject key.
Definition: gnunet-abd.c:101
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
struct GNUNET_IDENTITY_PublicKey issuer_pkey
Issuer key.
Definition: gnunet-abd.c:106
static char * subject
Subject pubkey string.
Definition: gnunet-abd.c:86
static int del
Desired action is to remove a record.
#define GNUNET_log(kind,...)
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_SIGNATURE_PURPOSE_DELEGATE
Signature for a GNUnet credential (Reclaim)
struct GNUNET_ABD_Delegate * GNUNET_ABD_delegate_issue(const struct GNUNET_IDENTITY_PrivateKey *issuer, struct GNUNET_IDENTITY_PublicKey *subject, const char *iss_attr, const char *sub_attr, struct GNUNET_TIME_Absolute *expiration)
Issue an attribute to a subject.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_sign_(const struct GNUNET_IDENTITY_PrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_IDENTITY_Signature *sig)
Sign a given block.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_public_key_from_string(const char *str, struct GNUNET_IDENTITY_PublicKey *key)
Parses a (Base32) string representation of the public key.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public(const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: identity_api.c:175
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_ERROR
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **output)
Decode from Base64.
Definition: strings.c:1696
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1608
static unsigned int size
Size of the "table".
Definition: peer.c:67
const char * subject_attribute
The subject attribute.
const char * issuer_attribute
The issuer attribute.
struct GNUNET_IDENTITY_Signature signature
Signature of this credential.
uint32_t issuer_attribute_len
Length of the issuer attribute.
uint32_t subject_attribute_len
Length of the subject attribute.
struct GNUNET_IDENTITY_PublicKey subject_key
Public key of the subject this credential was issued to.
struct GNUNET_TIME_Absolute expiration
Expiration of this credential.
struct GNUNET_IDENTITY_PublicKey issuer_key
The issuer of the credential.
A private key for an identity as per LSD0001.
An identity key as per LSD0001.
An identity signature as per LSD0001.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.