GNUnet  0.17.5
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 
144  int do_create,
146 {
148 
149  if (GNUNET_OK ==
151  pkey,
152  sizeof (*pkey)))
153  {
154  /* file existed, report that we didn't create it... */
155  return (do_create) ? GNUNET_NO : GNUNET_OK;
156  }
157  else if (! do_create)
158  {
159  return GNUNET_SYSERR;
160  }
161 
164  pkey,
165  sizeof (*pkey),
167  if ( (GNUNET_OK == ret) ||
168  (GNUNET_SYSERR == ret) )
169  return ret;
170  /* maybe another process succeeded in the meantime, try reading one more time */
171  if (GNUNET_OK ==
173  pkey,
174  sizeof (*pkey)))
175  {
176  /* file existed, report that *we* didn't create it... */
177  return (do_create) ? GNUNET_NO : GNUNET_OK;
178  }
179  /* give up */
180  return GNUNET_SYSERR;
181 }
182 
183 
201  int do_create,
203 {
204  if (GNUNET_OK ==
206  pkey,
207  sizeof (*pkey)))
208  {
209  /* file existed, report that we didn't create it... */
210  return (do_create) ? GNUNET_NO : GNUNET_OK;
211  }
213  if (GNUNET_OK ==
215  pkey,
216  sizeof (*pkey),
218  return GNUNET_OK;
219  /* maybe another process succeeded in the meantime, try reading one more time */
220  if (GNUNET_OK ==
222  pkey,
223  sizeof (*pkey)))
224  {
225  /* file existed, report that *we* didn't create it... */
226  return (do_create) ? GNUNET_NO : GNUNET_OK;
227  }
228  /* give up */
229  return GNUNET_SYSERR;
230 }
231 
232 
243  const struct GNUNET_CONFIGURATION_Handle *cfg)
244 {
245  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
246  char *fn;
247 
248  if (GNUNET_OK !=
250  "PEER",
251  "PRIVATE_KEY",
252  &fn))
253  return NULL;
256  GNUNET_YES,
257  priv);
258  GNUNET_free (fn);
259  return priv;
260 }
261 
262 
265  struct GNUNET_PeerIdentity *dst)
266 {
267  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
268 
270  {
272  _ ("Could not load peer's private key\n"));
273  return GNUNET_SYSERR;
274  }
276  &dst->public_key);
277  GNUNET_free (priv);
278  return GNUNET_OK;
279 }
280 
281 
290 void
291 GNUNET_CRYPTO_eddsa_setup_key (const char *cfg_name)
292 {
294  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
295 
297  (void) GNUNET_CONFIGURATION_load (cfg, cfg_name);
299  if (NULL != priv)
300  GNUNET_free (priv);
302 }
303 
304 
305 /* end of crypto_ecc_setup.c */
static enum GNUNET_GenericReturnValue read_from_file(const char *filename, void *buf, size_t buf_size)
Read file to buf.
void GNUNET_CRYPTO_eddsa_setup_key(const char *cfg_name)
Setup a key file for a peer given the name of the configuration file (!).
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static char * filename
static char * pkey
Public key of the zone to look in, in ASCII.
static char buf[2048]
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.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
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's key from the file specified in the configuration.
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.
enum GNUNET_GenericReturnValue 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.
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
void GNUNET_CRYPTO_eddsa_key_create(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:461
void GNUNET_CRYPTO_ecdsa_key_create(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:446
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_get_peer_identity(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_PeerIdentity *dst)
Retrieve the identity of the host's peer.
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:725
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
#define GNUNET_log(kind,...)
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:96
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Private ECC key encoded for transmission.
Private ECC key encoded for transmission.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key