GNUnet  0.11.x
crypto_ecc_setup.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012, 2013, 2015, 2020 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 <gcrypt.h>
28 #include "gnunet_util_lib.h"
29 
30 #define LOG(kind, ...) GNUNET_log_from (kind, "util-crypto-ecc", __VA_ARGS__)
31 
32 #define LOG_STRERROR(kind, syscall) \
33  GNUNET_log_from_strerror (kind, "util-crypto-ecc", syscall)
34 
35 #define LOG_STRERROR_FILE(kind, syscall, filename) \
36  GNUNET_log_from_strerror_file (kind, "util-crypto-ecc", syscall, filename)
37 
43 #define LOG_GCRY(level, cmd, rc) \
44  do \
45  { \
46  LOG (level, \
47  _ ("`%s' failed at %s:%d with error: %s\n"), \
48  cmd, \
49  __FILE__, \
50  __LINE__, \
51  gcry_strerror (rc)); \
52  } while (0)
53 
54 
64 static enum GNUNET_GenericReturnValue
65 read_from_file (const char *filename,
66  void *buf,
67  size_t buf_size)
68 {
69  int fd;
70  struct stat sb;
71 
72  fd = open (filename,
73  O_RDONLY);
74  if (-1 == fd)
75  {
76  memset (buf,
77  0,
78  buf_size);
79  return GNUNET_SYSERR;
80  }
81  if (0 != fstat (fd,
82  &sb))
83  {
85  "stat",
86  filename);
87  GNUNET_assert (0 == close (fd));
88  memset (buf,
89  0,
90  buf_size);
91  return GNUNET_SYSERR;
92  }
93  if (sb.st_size != buf_size)
94  {
96  "File `%s' has wrong size (%llu), expected %llu bytes\n",
97  filename,
98  (unsigned long long) sb.st_size,
99  (unsigned long long) buf_size);
100  GNUNET_assert (0 == close (fd));
101  memset (buf,
102  0,
103  buf_size);
104  return GNUNET_SYSERR;
105  }
106  if (buf_size !=
107  read (fd,
108  buf,
109  buf_size))
110  {
112  "read",
113  filename);
114  GNUNET_assert (0 == close (fd));
115  memset (buf,
116  0,
117  buf_size);
118  return GNUNET_SYSERR;
119  }
120  GNUNET_assert (0 == close (fd));
121  return GNUNET_OK;
122 }
123 
124 
142  int do_create,
144 {
146 
147  if (GNUNET_OK ==
148  read_from_file (filename,
149  pkey,
150  sizeof (*pkey)))
151  {
152  /* file existed, report that we didn't create it... */
153  return (do_create) ? GNUNET_NO : GNUNET_OK;
154  }
156  ret = GNUNET_DISK_fn_write (filename,
157  pkey,
158  sizeof (*pkey),
160  if ( (GNUNET_OK == ret) ||
161  (GNUNET_SYSERR == ret) )
162  return ret;
163  /* maybe another process succeeded in the meantime, try reading one more time */
164  if (GNUNET_OK ==
165  read_from_file (filename,
166  pkey,
167  sizeof (*pkey)))
168  {
169  /* file existed, report that *we* didn't create it... */
170  return (do_create) ? GNUNET_NO : GNUNET_OK;
171  }
172  /* give up */
173  return GNUNET_SYSERR;
174 }
175 
176 
194  int do_create,
196 {
197  if (GNUNET_OK ==
198  read_from_file (filename,
199  pkey,
200  sizeof (*pkey)))
201  {
202  /* file existed, report that we didn't create it... */
203  return (do_create) ? GNUNET_NO : GNUNET_OK;
204  }
206  if (GNUNET_OK ==
207  GNUNET_DISK_fn_write (filename,
208  pkey,
209  sizeof (*pkey),
211  return GNUNET_OK;
212  /* maybe another process succeeded in the meantime, try reading one more time */
213  if (GNUNET_OK ==
214  read_from_file (filename,
215  pkey,
216  sizeof (*pkey)))
217  {
218  /* file existed, report that *we* didn't create it... */
219  return (do_create) ? GNUNET_NO : GNUNET_OK;
220  }
221  /* give up */
222  return GNUNET_SYSERR;
223 }
224 
225 
236  const struct GNUNET_CONFIGURATION_Handle *cfg)
237 {
238  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
239  char *fn;
240 
241  if (GNUNET_OK !=
243  "PEER",
244  "PRIVATE_KEY",
245  &fn))
246  return NULL;
249  GNUNET_YES,
250  priv);
251  GNUNET_free (fn);
252  return priv;
253 }
254 
255 
266  struct GNUNET_PeerIdentity *dst)
267 {
268  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
269 
270  if (NULL == (priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg)))
271  {
273  _ ("Could not load peer's private key\n"));
274  return GNUNET_SYSERR;
275  }
277  &dst->public_key);
278  GNUNET_free (priv);
279  return GNUNET_OK;
280 }
281 
282 
291 void
292 GNUNET_CRYPTO_eddsa_setup_key (const char *cfg_name)
293 {
295  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
296 
298  (void) GNUNET_CONFIGURATION_load (cfg, cfg_name);
300  if (NULL != priv)
301  GNUNET_free (priv);
303 }
304 
305 
306 /* end of crypto_ecc_setup.c */
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static char * pkey
Public key of the zone to look in, in ASCII.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:83
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Private ECC key encoded for transmission.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static char * fn
Filename of the unique file.
static enum GNUNET_GenericReturnValue read_from_file(const char *filename, void *buf, size_t buf_size)
Read file to buf.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
static char buf[2048]
static char * filename
void GNUNET_CRYPTO_eddsa_key_create(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:461
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:197
enum GNUNET_GenericReturnValue GNUNET_DISK_fn_write(const char *fn, const void *buf, size_t buf_size, enum GNUNET_DISK_AccessPermissions mode)
Write a buffer to a file atomically.
Definition: disk.c:705
Private ECC key encoded for transmission.
The identity of the host (wraps the signing key of the peer).
configuration data
Definition: configuration.c:84
void GNUNET_CRYPTO_ecdsa_key_create(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:446
#define GNUNET_log(kind,...)
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_get_peer_identity(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_PeerIdentity *dst)
Retrieve the identity of the host&#39;s peer.
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer&#39;s key from the file specified in the configuration...
int GNUNET_CRYPTO_eddsa_key_from_file(const char *filename, int do_create, struct GNUNET_CRYPTO_EddsaPrivateKey *pkey)
Create a new private key by reading it from a file.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
void GNUNET_CRYPTO_eddsa_setup_key(const char *cfg_name)
Setup a key file for a peer given the name of the configuration file (!).
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_key_from_file(const char *filename, int do_create, struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey)
Create a new private key by reading it from a file.