src/util/gnunet-ecc.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2012, 2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file util/gnunet-ecc.c
  23  * @brief tool to manipulate EDDSA key files
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_testing_lib.h"
  29 #include <gcrypt.h>
  30
  31
  32 /**
  33  * Flag for listing public key.
  34  */
  35 static int list_keys;
  36
  37 /**
  38  * Flag for listing public key.
  39  */
  40 static int list_keys_count;
  41
  42 /**
  43  * Flag for printing public key.
  44  */
  45 static int print_public_key;
  46
  47 /**
  48  * Flag for printing the output of random example operations.
  49  */
  50 static int print_examples_flag;
  51
  52 /**
  53  * Flag for printing hash of public key.
  54  */
  55 static int print_peer_identity;
  56
  57 /**
  58  * Option set to create a bunch of keys at once.
  59  */
  60 static unsigned int make_keys;
  61
  62
  63 /**
  64  * Create a flat file with a large number of key pairs for testing.
  65  */
  66 static void
  67 create_keys (const char *fn)
  68 {
  69   FILE *f;
  70   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
  71
  72   if (NULL == (f = fopen (fn, "w+")))
  73   {
  74     fprintf (stderr,
  75              _("Failed to open `%s': %s\n"),
  76              fn,
  77              STRERROR (errno));
  78     return;
  79   }
  80   fprintf (stderr,
  81            _("Generating %u keys, please wait"),
  82            make_keys);
  83   while (0 < make_keys--)
  84   {
  85     fprintf (stderr,
  86              ".");
  87     if (NULL == (pk = GNUNET_CRYPTO_eddsa_key_create ()))
  88     {
  89        GNUNET_break (0);
  90        break;
  91     }
  92     if (GNUNET_TESTING_HOSTKEYFILESIZE !=
  93         fwrite (pk, 1,
  94                 GNUNET_TESTING_HOSTKEYFILESIZE, f))
  95     {
  96       fprintf (stderr,
  97                _("\nFailed to write to `%s': %s\n"),
  98                fn,
  99                STRERROR (errno));
 100       GNUNET_free (pk);
 101       break;
 102     }
 103     GNUNET_free (pk);
 104   }
 105   if (UINT_MAX == make_keys)
 106     fprintf (stderr,
 107              _("\nFinished!\n"));
 108   else
 109     fprintf (stderr,
 110              _("\nError, %u keys not generated\n"), make_keys);
 111   fclose (f);
 112 }
 113
 114
 115 static void
 116 print_examples_ecdh ()
 117 {
 118   struct GNUNET_CRYPTO_EcdhePrivateKey *dh_priv1;
 119   struct GNUNET_CRYPTO_EcdhePublicKey *dh_pub1;
 120   struct GNUNET_CRYPTO_EcdhePrivateKey *dh_priv2;
 121   struct GNUNET_CRYPTO_EcdhePublicKey *dh_pub2;
 122   struct GNUNET_HashCode hash;
 123   char buf[128];
 124
 125   dh_pub1 = GNUNET_new (struct GNUNET_CRYPTO_EcdhePublicKey);
 126   dh_priv1 = GNUNET_CRYPTO_ecdhe_key_create ();
 127   dh_pub2 = GNUNET_new (struct GNUNET_CRYPTO_EcdhePublicKey);
 128   dh_priv2 = GNUNET_CRYPTO_ecdhe_key_create ();
 129   GNUNET_CRYPTO_ecdhe_key_get_public (dh_priv1, dh_pub1);
 130   GNUNET_CRYPTO_ecdhe_key_get_public (dh_priv2, dh_pub2);
 131
 132   GNUNET_assert (NULL != GNUNET_STRINGS_data_to_string (dh_priv1, 32, buf, 128));
 133   printf ("ECDHE key 1:\n");
 134   printf ("private: %s\n", buf);
 135   GNUNET_assert (NULL != GNUNET_STRINGS_data_to_string (dh_pub1, 32, buf, 128));
 136   printf ("public: %s\n", buf);
 137
 138   GNUNET_assert (NULL != GNUNET_STRINGS_data_to_string (dh_priv2, 32, buf, 128));
 139   printf ("ECDHE key 2:\n");
 140   printf ("private: %s\n", buf);
 141   GNUNET_assert (NULL != GNUNET_STRINGS_data_to_string (dh_pub2, 32, buf, 128));
 142   printf ("public: %s\n", buf);
 143
 144   GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecc_ecdh (dh_priv1, dh_pub2, &hash));
 145   GNUNET_assert (NULL != GNUNET_STRINGS_data_to_string (&hash, 64, buf, 128));
 146   printf ("ECDH shared secret: %s\n", buf);
 147
 148   GNUNET_free (dh_priv1);
 149   GNUNET_free (dh_priv2);
 150   GNUNET_free (dh_pub1);
 151   GNUNET_free (dh_pub2);
 152 }
 153
 154
 155 /**
 156  * Print some random example operations to stdout.
 157  */
 158 static void
 159 print_examples ()
 160 {
 161   print_examples_ecdh ();
 162   // print_examples_ecdsa ();
 163   // print_examples_eddsa ();
 164 }
 165
 166
 167 static void
 168 print_key (const char *filename)
 169 {
 170   struct GNUNET_DISK_FileHandle *fd;
 171   struct GNUNET_CRYPTO_EddsaPrivateKey private_key;
 172   struct GNUNET_CRYPTO_EddsaPublicKey public_key;
 173   char *hostkeys_data;
 174   char *hostkey_str;
 175   uint64_t fs;
 176   unsigned int total_hostkeys;
 177   unsigned int c;
 178
 179   if (GNUNET_YES != GNUNET_DISK_file_test (filename))
 180   {
 181     fprintf (stderr,
 182              _("Hostkeys file `%s' not found\n"),
 183              filename);
 184     return;
 185   }
 186
 187   /* Check hostkey file size, read entire thing into memory */
 188   if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
 189     fs = 0;
 190   if (0 == fs)
 191   {
 192     fprintf (stderr,
 193              _("Hostkeys file `%s' is empty\n"),
 194              filename);
 195     return;       /* File is empty */
 196   }
 197   if (0 != (fs % GNUNET_TESTING_HOSTKEYFILESIZE))
 198   {
 199     fprintf (stderr,
 200              _("Incorrect hostkey file format: %s\n"),
 201              filename);
 202     return;
 203   }
 204   fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
 205                                          GNUNET_DISK_PERM_NONE);
 206   if (NULL == fd)
 207   {
 208     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename);
 209     return;
 210   }
 211   hostkeys_data = GNUNET_malloc (fs);
 212   if (fs != GNUNET_DISK_file_read (fd, hostkeys_data, fs))
 213   {
 214     fprintf (stderr,
 215              _("Could not read hostkey file: %s\n"),
 216              filename);
 217     GNUNET_free (hostkeys_data);
 218     GNUNET_DISK_file_close (fd);
 219     return;
 220   }
 221   GNUNET_DISK_file_close (fd);
 222
 223   if (NULL == hostkeys_data)
 224     return;
 225   total_hostkeys = fs / GNUNET_TESTING_HOSTKEYFILESIZE;
 226   for (c = 0; (c < total_hostkeys) && (c < list_keys_count); c++)
 227   {
 228     memcpy (&private_key,
 229             hostkeys_data + (c * GNUNET_TESTING_HOSTKEYFILESIZE),
 230             GNUNET_TESTING_HOSTKEYFILESIZE);
 231     GNUNET_CRYPTO_eddsa_key_get_public (&private_key, &public_key);
 232     hostkey_str = GNUNET_CRYPTO_eddsa_public_key_to_string (&public_key);
 233     if (NULL != hostkey_str)
 234     {
 235       fprintf (stderr, "%4u: %s\n", c, hostkey_str);
 236       GNUNET_free (hostkey_str);
 237     }
 238     else
 239       fprintf (stderr, "%4u: %s\n", c, "invalid");
 240   }
 241   GNUNET_free (hostkeys_data);
 242 }
 243
 244
 245 /**
 246  * Main function that will be run by the scheduler.
 247  *
 248  * @param cls closure
 249  * @param args remaining command-line arguments
 250  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 251  * @param cfg configuration
 252  */
 253 static void
 254 run (void *cls, char *const *args, const char *cfgfile,
 255      const struct GNUNET_CONFIGURATION_Handle *cfg)
 256 {
 257   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
 258   struct GNUNET_CRYPTO_EddsaPublicKey pub;
 259
 260   if (print_examples_flag)
 261   {
 262     print_examples ();
 263     return;
 264   }
 265   if (NULL == args[0])
 266   {
 267     FPRINTF (stderr,
 268              "%s",
 269              _("No hostkey file specified on command line\n"));
 270     return;
 271   }
 272   if (list_keys)
 273   {
 274     print_key (args[0]);
 275     return;
 276   }
 277   if (make_keys > 0)
 278   {
 279     create_keys (args[0]);
 280     return;
 281   }
 282   pk = GNUNET_CRYPTO_eddsa_key_create_from_file (args[0]);
 283   if (NULL == pk)
 284     return;
 285   if (print_public_key)
 286   {
 287     char *s;
 288
 289     GNUNET_CRYPTO_eddsa_key_get_public (pk, &pub);
 290     s = GNUNET_CRYPTO_eddsa_public_key_to_string (&pub);
 291     FPRINTF (stdout,
 292              "%s\n",
 293              s);
 294     GNUNET_free (s);
 295   }
 296   if (print_peer_identity)
 297   {
 298     char *str;
 299
 300     GNUNET_CRYPTO_eddsa_key_get_public (pk, &pub);
 301     str = GNUNET_CRYPTO_eddsa_public_key_to_string (&pub);
 302     FPRINTF (stdout,
 303              "%s\n",
 304              str);
 305     GNUNET_free (str);
 306   }
 307   GNUNET_free (pk);
 308 }
 309
 310
 311 /**
 312  * Program to manipulate ECC key files.
 313  *
 314  * @param argc number of arguments from the command line
 315  * @param argv command line arguments
 316  * @return 0 ok, 1 on error
 317  */
 318 int
 319 main (int argc, char *const *argv)
 320 {
 321   list_keys_count = UINT32_MAX;
 322   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 323     { 'i', "iterate", "FILE",
 324       gettext_noop ("list keys included in a file (for testing)"),
 325       0, &GNUNET_GETOPT_set_one, &list_keys },
 326     { 'e', "end=", "COUNT",
 327       gettext_noop ("number of keys to list included in a file (for testing)"),
 328       1, &GNUNET_GETOPT_set_uint, &list_keys_count },
 329     { 'g', "generate-keys", "COUNT",
 330       gettext_noop ("create COUNT public-private key pairs (for testing)"),
 331       1, &GNUNET_GETOPT_set_uint, &make_keys },
 332     { 'p', "print-public-key", NULL,
 333       gettext_noop ("print the public key in ASCII format"),
 334       0, &GNUNET_GETOPT_set_one, &print_public_key },
 335     { 'P', "print-peer-identity", NULL,
 336       gettext_noop ("print the hash of the public key in ASCII format"),
 337       0, &GNUNET_GETOPT_set_one, &print_peer_identity },
 338     { 'E', "examples", NULL,
 339       gettext_noop ("print examples of ECC operations (used for compatibility testing)"),
 340       0, &GNUNET_GETOPT_set_one, &print_examples_flag },
 341     GNUNET_GETOPT_OPTION_END
 342   };
 343   int ret;
 344
 345   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 346     return 2;
 347
 348   ret = (GNUNET_OK ==
 349          GNUNET_PROGRAM_run (argc, argv, "gnunet-ecc [OPTIONS] keyfile",
 350                              gettext_noop ("Manipulate GNUnet private ECC key files"),
 351                              options, &run, NULL)) ? 0 : 1;
 352   GNUNET_free ((void*) argv);
 353   return ret;
 354 }
 355
 356 /* end of gnunet-ecc.c */