src/util/crypto_ecc_setup.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012, 2013, 2015 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 /**
  22  * @file util/crypto_ecc_setup.c
  23  * @brief helper function for easy EdDSA key setup
  24  * @author Christian Grothoff
  25  */
  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) GNUNET_log_from_strerror (kind, "util-crypto-ecc", syscall)
  33
  34 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-crypto-ecc", syscall, filename)
  35
  36 /**
  37  * Log an error message at log-level 'level' that indicates
  38  * a failure of the command 'cmd' with the message given
  39  * by gcry_strerror(rc).
  40  */
  41 #define LOG_GCRY(level, cmd, rc) do { LOG(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while(0)
  42
  43
  44 /**
  45  * Wait for a short time (we're trying to lock a file or want
  46  * to give another process a shot at finishing a disk write, etc.).
  47  * Sleeps for 100ms (as that should be long enough for virtually all
  48  * modern systems to context switch and allow another process to do
  49  * some 'real' work).
  50  */
  51 static void
  52 short_wait ()
  53 {
  54   struct GNUNET_TIME_Relative timeout;
  55
  56   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100);
  57   (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
  58 }
  59
  60
  61 /**
  62  * Create a new private key by reading it from a file.  If the
  63  * files does not exist, create a new key and write it to the
  64  * file.  Caller must free return value.  Note that this function
  65  * can not guarantee that another process might not be trying
  66  * the same operation on the same file at the same time.
  67  * If the contents of the file
  68  * are invalid the old file is deleted and a fresh key is
  69  * created.
  70  *
  71  * @param filename name of file to use to store the key
  72  * @return new private key, NULL on error (for example,
  73  *   permission denied)
  74  */
  75 struct GNUNET_CRYPTO_EddsaPrivateKey *
  76 GNUNET_CRYPTO_eddsa_key_create_from_file (const char *filename)
  77 {
  78   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
  79   struct GNUNET_DISK_FileHandle *fd;
  80   unsigned int cnt;
  81   int ec;
  82   uint64_t fs;
  83   ssize_t sret;
  84
  85   if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
  86     return NULL;
  87   while (GNUNET_YES != GNUNET_DISK_file_test (filename))
  88   {
  89     fd = GNUNET_DISK_file_open (filename,
  90                                 GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
  91                                 | GNUNET_DISK_OPEN_FAILIFEXISTS,
  92                                 GNUNET_DISK_PERM_USER_READ |
  93                                 GNUNET_DISK_PERM_USER_WRITE);
  94     if (NULL == fd)
  95     {
  96       if (EEXIST == errno)
  97       {
  98         if (GNUNET_YES != GNUNET_DISK_file_test (filename))
  99         {
 100           /* must exist but not be accessible, fail for good! */
 101           if (0 != ACCESS (filename, R_OK))
 102             LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
 103           else
 104             GNUNET_break (0);   /* what is going on!? */
 105           return NULL;
 106         }
 107         continue;
 108       }
 109       LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
 110       return NULL;
 111     }
 112     cnt = 0;
 113     while (GNUNET_YES !=
 114            GNUNET_DISK_file_lock (fd, 0,
 115                                   sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
 116                                   GNUNET_YES))
 117     {
 118       short_wait ();
 119       if (0 == ++cnt % 10)
 120       {
 121         ec = errno;
 122         LOG (GNUNET_ERROR_TYPE_ERROR,
 123              _("Could not acquire lock on file `%s': %s...\n"),
 124              filename,
 125              STRERROR (ec));
 126       }
 127     }
 128     LOG (GNUNET_ERROR_TYPE_INFO,
 129          _("Creating a new private key.  This may take a while.\n"));
 130     priv = GNUNET_CRYPTO_eddsa_key_create ();
 131     GNUNET_assert (NULL != priv);
 132     GNUNET_assert (sizeof (*priv) ==
 133                    GNUNET_DISK_file_write (fd, priv, sizeof (*priv)));
 134     GNUNET_DISK_file_sync (fd);
 135     if (GNUNET_YES !=
 136         GNUNET_DISK_file_unlock (fd, 0,
 137                                  sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
 138       LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
 139     GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
 140     return priv;
 141   }
 142   /* key file exists already, read it! */
 143   fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
 144                               GNUNET_DISK_PERM_NONE);
 145   if (NULL == fd)
 146   {
 147     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
 148     return NULL;
 149   }
 150   cnt = 0;
 151   while (1)
 152   {
 153     if (GNUNET_YES !=
 154         GNUNET_DISK_file_lock (fd, 0,
 155                                sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
 156                                GNUNET_NO))
 157     {
 158       if (0 == ++cnt % 60)
 159       {
 160         ec = errno;
 161         LOG (GNUNET_ERROR_TYPE_ERROR,
 162              _("Could not acquire lock on file `%s': %s...\n"), filename,
 163              STRERROR (ec));
 164         LOG (GNUNET_ERROR_TYPE_ERROR,
 165              _
 166              ("This may be ok if someone is currently generating a private key.\n"));
 167       }
 168       short_wait ();
 169       continue;
 170     }
 171     if (GNUNET_YES != GNUNET_DISK_file_test (filename))
 172     {
 173       /* eh, what!? File we opened is now gone!? */
 174       LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
 175       if (GNUNET_YES !=
 176           GNUNET_DISK_file_unlock (fd, 0,
 177                                    sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
 178         LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
 179       GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
 180
 181       return NULL;
 182     }
 183     if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
 184       fs = 0;
 185     if (fs < sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey))
 186     {
 187       /* maybe we got the read lock before the key generating
 188        * process had a chance to get the write lock; give it up! */
 189       if (GNUNET_YES !=
 190           GNUNET_DISK_file_unlock (fd, 0,
 191                                    sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
 192         LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
 193       if (0 == ++cnt % 10)
 194       {
 195         LOG (GNUNET_ERROR_TYPE_ERROR,
 196              _("When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
 197              filename,
 198              (unsigned int) fs,
 199              (unsigned int) sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
 200         LOG (GNUNET_ERROR_TYPE_ERROR,
 201              _("This may be ok if someone is currently generating a key.\n"));
 202       }
 203       short_wait ();                /* wait a bit longer! */
 204       continue;
 205     }
 206     break;
 207   }
 208   fs = sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey);
 209   priv = GNUNET_malloc (fs);
 210   sret = GNUNET_DISK_file_read (fd,
 211                                 priv,
 212                                 fs);
 213   GNUNET_assert ( (sret >= 0) &&
 214                   (fs == (size_t) sret) );
 215   if (GNUNET_YES !=
 216       GNUNET_DISK_file_unlock (fd,
 217                                0,
 218                                sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
 219     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
 220                        "fcntl",
 221                        filename);
 222   GNUNET_assert (GNUNET_YES ==
 223                  GNUNET_DISK_file_close (fd));
 224 #if CRYPTO_BUG
 225   if (GNUNET_OK !=
 226       check_eddsa_key (priv))
 227   {
 228     GNUNET_break (0);
 229     GNUNET_free (priv);
 230     return NULL;
 231   }
 232 #endif
 233   return priv;
 234 }
 235
 236
 237 /**
 238  * Create a new private key by reading it from a file.  If the
 239  * files does not exist, create a new key and write it to the
 240  * file.  Caller must free return value.  Note that this function
 241  * can not guarantee that another process might not be trying
 242  * the same operation on the same file at the same time.
 243  * If the contents of the file
 244  * are invalid the old file is deleted and a fresh key is
 245  * created.
 246  *
 247  * @param filename name of file to use to store the key
 248  * @return new private key, NULL on error (for example,
 249  *   permission denied)
 250  */
 251 struct GNUNET_CRYPTO_EcdsaPrivateKey *
 252 GNUNET_CRYPTO_ecdsa_key_create_from_file (const char *filename)
 253 {
 254   struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
 255   struct GNUNET_DISK_FileHandle *fd;
 256   unsigned int cnt;
 257   int ec;
 258   uint64_t fs;
 259   ssize_t sret;
 260
 261   if (GNUNET_SYSERR ==
 262       GNUNET_DISK_directory_create_for_file (filename))
 263     return NULL;
 264   while (GNUNET_YES != GNUNET_DISK_file_test (filename))
 265   {
 266     fd = GNUNET_DISK_file_open (filename,
 267                                 GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
 268                                 | GNUNET_DISK_OPEN_FAILIFEXISTS,
 269                                 GNUNET_DISK_PERM_USER_READ |
 270                                 GNUNET_DISK_PERM_USER_WRITE);
 271     if (NULL == fd)
 272     {
 273       if (EEXIST == errno)
 274       {
 275         if (GNUNET_YES != GNUNET_DISK_file_test (filename))
 276         {
 277           /* must exist but not be accessible, fail for good! */
 278           if (0 != ACCESS (filename, R_OK))
 279             LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR,
 280                                "access",
 281                                filename);
 282           else
 283             GNUNET_break (0);   /* what is going on!? */
 284           return NULL;
 285         }
 286         continue;
 287       }
 288       LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR,
 289                          "open",
 290                          filename);
 291       return NULL;
 292     }
 293     cnt = 0;
 294     while (GNUNET_YES !=
 295            GNUNET_DISK_file_lock (fd,
 296                                   0,
 297                                   sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
 298                                   GNUNET_YES))
 299     {
 300       short_wait ();
 301       if (0 == ++cnt % 10)
 302       {
 303         ec = errno;
 304         LOG (GNUNET_ERROR_TYPE_ERROR,
 305              _("Could not acquire lock on file `%s': %s...\n"),
 306              filename,
 307              STRERROR (ec));
 308       }
 309     }
 310     LOG (GNUNET_ERROR_TYPE_INFO,
 311          _("Creating a new private key.  This may take a while.\n"));
 312     priv = GNUNET_CRYPTO_ecdsa_key_create ();
 313     GNUNET_assert (NULL != priv);
 314     GNUNET_assert (sizeof (*priv) ==
 315                    GNUNET_DISK_file_write (fd,
 316                                            priv,
 317                                            sizeof (*priv)));
 318     GNUNET_DISK_file_sync (fd);
 319     if (GNUNET_YES !=
 320         GNUNET_DISK_file_unlock (fd, 0,
 321                                  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
 322       LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
 323                          "fcntl",
 324                          filename);
 325     GNUNET_assert (GNUNET_YES ==
 326                    GNUNET_DISK_file_close (fd));
 327     return priv;
 328   }
 329   /* key file exists already, read it! */
 330   fd = GNUNET_DISK_file_open (filename,
 331                               GNUNET_DISK_OPEN_READ,
 332                               GNUNET_DISK_PERM_NONE);
 333   if (NULL == fd)
 334   {
 335     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR,
 336                        "open",
 337                        filename);
 338     return NULL;
 339   }
 340   cnt = 0;
 341   while (1)
 342   {
 343     if (GNUNET_YES !=
 344         GNUNET_DISK_file_lock (fd, 0,
 345                                sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
 346                                GNUNET_NO))
 347     {
 348       if (0 == ++cnt % 60)
 349       {
 350         ec = errno;
 351         LOG (GNUNET_ERROR_TYPE_ERROR,
 352              _("Could not acquire lock on file `%s': %s...\n"),
 353              filename,
 354              STRERROR (ec));
 355         LOG (GNUNET_ERROR_TYPE_ERROR,
 356              _("This may be ok if someone is currently generating a private key.\n"));
 357       }
 358       short_wait ();
 359       continue;
 360     }
 361     if (GNUNET_YES !=
 362         GNUNET_DISK_file_test (filename))
 363     {
 364       /* eh, what!? File we opened is now gone!? */
 365       LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
 366                          "stat",
 367                          filename);
 368       if (GNUNET_YES !=
 369           GNUNET_DISK_file_unlock (fd, 0,
 370                                    sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
 371         LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
 372                            "fcntl",
 373                            filename);
 374       GNUNET_assert (GNUNET_OK ==
 375                      GNUNET_DISK_file_close (fd));
 376
 377       return NULL;
 378     }
 379     if (GNUNET_OK !=
 380         GNUNET_DISK_file_size (filename,
 381                                &fs,
 382                                GNUNET_YES,
 383                                GNUNET_YES))
 384       fs = 0;
 385     if (fs < sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))
 386     {
 387       /* maybe we got the read lock before the key generating
 388        * process had a chance to get the write lock; give it up! */
 389       if (GNUNET_YES !=
 390           GNUNET_DISK_file_unlock (fd, 0,
 391                                    sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
 392         LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
 393                            "fcntl",
 394                            filename);
 395       if (0 == ++cnt % 10)
 396       {
 397         LOG (GNUNET_ERROR_TYPE_ERROR,
 398              _("When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
 399              filename, (unsigned int) fs,
 400              (unsigned int) sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
 401         LOG (GNUNET_ERROR_TYPE_ERROR,
 402              _("This may be ok if someone is currently generating a key.\n"));
 403       }
 404       short_wait ();                /* wait a bit longer! */
 405       continue;
 406     }
 407     break;
 408   }
 409   fs = sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
 410   priv = GNUNET_malloc (fs);
 411   sret = GNUNET_DISK_file_read (fd,
 412                                 priv,
 413                                 fs);
 414   GNUNET_assert ( (sret >= 0) &&
 415                   (fs == (size_t) sret) );
 416   if (GNUNET_YES !=
 417       GNUNET_DISK_file_unlock (fd, 0,
 418                                sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
 419     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
 420                        "fcntl",
 421                        filename);
 422   GNUNET_assert (GNUNET_YES ==
 423                  GNUNET_DISK_file_close (fd));
 424   return priv;
 425 }
 426
 427
 428 /**
 429  * Create a new private key by reading our peer's key from
 430  * the file specified in the configuration.
 431  *
 432  * @param cfg the configuration to use
 433  * @return new private key, NULL on error (for example,
 434  *   permission denied)
 435  */
 436 struct GNUNET_CRYPTO_EddsaPrivateKey *
 437 GNUNET_CRYPTO_eddsa_key_create_from_configuration (const struct GNUNET_CONFIGURATION_Handle *cfg)
 438 {
 439   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
 440   char *fn;
 441
 442   if (GNUNET_OK !=
 443       GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER", "PRIVATE_KEY", &fn))
 444     return NULL;
 445   priv = GNUNET_CRYPTO_eddsa_key_create_from_file (fn);
 446   GNUNET_free (fn);
 447   return priv;
 448 }
 449
 450
 451 /**
 452  * Retrieve the identity of the host's peer.
 453  *
 454  * @param cfg configuration to use
 455  * @param dst pointer to where to write the peer identity
 456  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the identity
 457  *         could not be retrieved
 458  */
 459 int
 460 GNUNET_CRYPTO_get_peer_identity (const struct GNUNET_CONFIGURATION_Handle *cfg,
 461                                  struct GNUNET_PeerIdentity *dst)
 462 {
 463   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
 464
 465   if (NULL == (priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg)))
 466   {
 467     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 468                 _("Could not load peer's private key\n"));
 469     return GNUNET_SYSERR;
 470   }
 471   GNUNET_CRYPTO_eddsa_key_get_public (priv, &dst->public_key);
 472   GNUNET_free (priv);
 473   return GNUNET_OK;
 474 }
 475
 476
 477 /**
 478  * Setup a key file for a peer given the name of the
 479  * configuration file (!).  This function is used so that
 480  * at a later point code can be certain that reading a
 481  * key is fast (for example in time-dependent testcases).
 482  *
 483  * @param cfg_name name of the configuration file to use
 484  */
 485 void
 486 GNUNET_CRYPTO_eddsa_setup_key (const char *cfg_name)
 487 {
 488   struct GNUNET_CONFIGURATION_Handle *cfg;
 489   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
 490
 491   cfg = GNUNET_CONFIGURATION_create ();
 492   (void) GNUNET_CONFIGURATION_load (cfg, cfg_name);
 493   priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
 494   if (NULL != priv)
 495     GNUNET_free (priv);
 496   GNUNET_CONFIGURATION_destroy (cfg);
 497 }
 498
 499 /* end of crypto_ecc_setup.c */