2 This file is part of GNUnet.
3 (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009 Christian Grothoff (and other contributing authors)
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 2, or (at your
8 option) any later version.
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.
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.
22 * @file util/crypto_rsa.c
23 * @brief public key cryptography (RSA) with libgcrypt
24 * @author Christian Grothoff
26 * Note that the code locks often needlessly on the gcrypt-locking api.
27 * One would think that simple MPI operations should not require locking
28 * (since only global operations on the random pool must be locked,
29 * strictly speaking). But libgcrypt does sometimes require locking in
30 * unexpected places, so the safe solution is to always lock even if it
31 * is not required. The performance impact is minimal anyway.
36 #include "gnunet_common.h"
37 #include "gnunet_util_lib.h"
39 #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
41 #define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
43 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
47 * The private information of an RSA key pair.
48 * NOTE: this must match the definition in crypto_ksk.c and gnunet-rsa.c!
50 struct GNUNET_CRYPTO_RsaPrivateKey
56 #define HOSTKEY_LEN 2048
58 #define EXTRA_CHECKS ALLOW_EXTRA_CHECKS
62 * Log an error message at log-level 'level' that indicates
63 * a failure of the command 'cmd' with the message given
64 * by gcry_strerror(rc).
66 #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);
69 * If target != size, move target bytes to the
70 * end of the size-sized buffer and zero out the
71 * first target-size bytes.
74 adjust (unsigned char *buf, size_t size, size_t target)
78 memmove (&buf[target - size], buf, size);
79 memset (buf, 0, target - size);
85 * Free memory occupied by hostkey
86 * @param hostkey pointer to the memory to free
89 GNUNET_CRYPTO_rsa_key_free (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
91 gcry_sexp_release (hostkey->sexp);
92 GNUNET_free (hostkey);
100 key_from_sexp (gcry_mpi_t * array, gcry_sexp_t sexp, const char *topname,
103 gcry_sexp_t list, l2;
107 list = gcry_sexp_find_token (sexp, topname, 0);
112 l2 = gcry_sexp_cadr (list);
113 gcry_sexp_release (list);
121 for (s = elems; *s; s++, idx++)
123 l2 = gcry_sexp_find_token (list, s, 1);
126 for (i = 0; i < idx; i++)
128 gcry_free (array[i]);
131 gcry_sexp_release (list);
132 return 3; /* required parameter not found */
134 array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
135 gcry_sexp_release (l2);
138 for (i = 0; i < idx; i++)
140 gcry_free (array[i]);
143 gcry_sexp_release (list);
144 return 4; /* required parameter is invalid */
147 gcry_sexp_release (list);
152 * Extract the public key of the host.
153 * @param priv the private key
154 * @param pub where to write the public key
157 GNUNET_CRYPTO_rsa_key_get_public (const struct GNUNET_CRYPTO_RsaPrivateKey
159 struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
166 rc = key_from_sexp (skey, priv->sexp, "public-key", "ne");
168 rc = key_from_sexp (skey, priv->sexp, "private-key", "ne");
170 rc = key_from_sexp (skey, priv->sexp, "rsa", "ne");
171 GNUNET_assert (0 == rc);
173 htons (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) -
174 sizeof (pub->padding));
175 pub->sizen = htons (GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH);
177 size = GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
179 gcry_mpi_print (GCRYMPI_FMT_USG, &pub->key[0], size, &size,
181 adjust (&pub->key[0], size, GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH);
182 size = GNUNET_CRYPTO_RSA_KEY_LENGTH - GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
184 gcry_mpi_print (GCRYMPI_FMT_USG,
186 [GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH], size,
188 adjust (&pub->key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH], size,
189 GNUNET_CRYPTO_RSA_KEY_LENGTH -
190 GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH);
191 gcry_mpi_release (skey[0]);
192 gcry_mpi_release (skey[1]);
197 * Convert a public key to a string.
199 * @param pub key to convert
200 * @return string representing 'pub'
203 GNUNET_CRYPTO_rsa_public_key_to_string (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pub)
206 size_t keylen = (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)) * 8;
210 keylen += 5 - keylen % 5;
212 pubkeybuf = GNUNET_malloc (keylen + 1);
213 end = GNUNET_STRINGS_data_to_string ((unsigned char *) pub,
214 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
219 GNUNET_free (pubkeybuf);
228 * Convert a string representing a public key to a public key.
230 * @param enc encoded public key
231 * @param enclen number of bytes in enc (without 0-terminator)
232 * @param pub where to store the public key
233 * @return GNUNET_OK on success
236 GNUNET_CRYPTO_rsa_public_key_from_string (const char *enc,
238 struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pub)
240 size_t keylen = (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)) * 8;
243 keylen += 5 - keylen % 5;
245 if (enclen != keylen)
246 return GNUNET_SYSERR;
248 if (GNUNET_OK != GNUNET_STRINGS_string_to_data (enc, enclen,
249 (unsigned char*) pub,
250 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
251 return GNUNET_SYSERR;
252 if ( (ntohs (pub->len) != sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)) ||
253 (ntohs (pub->padding) != 0) ||
254 (ntohs (pub->sizen) != GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH) )
255 return GNUNET_SYSERR;
261 * Internal: publicKey => RSA-Key.
263 * Note that the return type is not actually a private
264 * key but rather an sexpression for the public key!
266 static struct GNUNET_CRYPTO_RsaPrivateKey *
267 public2PrivateKey (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
270 struct GNUNET_CRYPTO_RsaPrivateKey *ret;
278 if ((ntohs (publicKey->sizen) != GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH) ||
279 (ntohs (publicKey->len) !=
280 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) -
281 sizeof (publicKey->padding)))
286 size = GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
287 rc = gcry_mpi_scan (&n, GCRYMPI_FMT_USG, &publicKey->key[0], size, &size);
290 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
293 size = GNUNET_CRYPTO_RSA_KEY_LENGTH - GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
294 rc = gcry_mpi_scan (&e, GCRYMPI_FMT_USG,
295 &publicKey->key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH],
299 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
300 gcry_mpi_release (n);
303 rc = gcry_sexp_build (&result, &erroff, "(public-key(rsa(n %m)(e %m)))", n,
305 gcry_mpi_release (n);
306 gcry_mpi_release (e);
309 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc); /* erroff gives more info */
312 ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
319 * Encode the private key in a format suitable for
320 * storing it into a file.
321 * @returns encoding of the private key.
322 * The first 4 bytes give the size of the array, as usual.
324 struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *
325 GNUNET_CRYPTO_rsa_encode_key (const struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
327 struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *retval;
336 if (gcry_pk_testkey (hostkey->sexp))
343 memset (pkv, 0, sizeof (gcry_mpi_t) * 6);
344 rc = key_from_sexp (pkv, hostkey->sexp, "private-key", "nedpqu");
346 rc = key_from_sexp (pkv, hostkey->sexp, "rsa", "nedpqu");
348 rc = key_from_sexp (pkv, hostkey->sexp, "private-key", "nedpq");
350 rc = key_from_sexp (pkv, hostkey->sexp, "rsa", "nedpq");
352 rc = key_from_sexp (pkv, hostkey->sexp, "private-key", "ned");
354 rc = key_from_sexp (pkv, hostkey->sexp, "rsa", "ned");
355 GNUNET_assert (0 == rc);
356 size = sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded);
357 for (i = 0; i < 6; i++)
362 gcry_mpi_aprint (GCRYMPI_FMT_USG,
363 (unsigned char **) &pbu[i], &sizes[i],
373 GNUNET_assert (size < 65536);
374 retval = GNUNET_malloc (size);
375 retval->len = htons (size);
377 retval->sizen = htons (sizes[0]);
378 memcpy (&((char *) (&retval[1]))[i], pbu[0], sizes[0]);
380 retval->sizee = htons (sizes[1]);
381 memcpy (&((char *) (&retval[1]))[i], pbu[1], sizes[1]);
383 retval->sized = htons (sizes[2]);
384 memcpy (&((char *) (&retval[1]))[i], pbu[2], sizes[2]);
387 retval->sizep = htons (sizes[4]);
388 memcpy (&((char *) (&retval[1]))[i], pbu[4], sizes[4]);
390 retval->sizeq = htons (sizes[3]);
391 memcpy (&((char *) (&retval[1]))[i], pbu[3], sizes[3]);
393 retval->sizedmp1 = htons (0);
394 retval->sizedmq1 = htons (0);
395 memcpy (&((char *) (&retval[1]))[i], pbu[5], sizes[5]);
396 for (i = 0; i < 6; i++)
399 gcry_mpi_release (pkv[i]);
408 * Decode the private key from the file-format back
409 * to the "normal", internal format.
411 * @param buf the buffer where the private key data is stored
412 * @param len the length of the data in 'buffer'
414 struct GNUNET_CRYPTO_RsaPrivateKey *
415 GNUNET_CRYPTO_rsa_decode_key (const char *buf, uint16_t len)
417 struct GNUNET_CRYPTO_RsaPrivateKey *ret;
418 const struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *encoding =
419 (const struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *) buf;
421 gcry_mpi_t n, e, d, p, q, u;
427 enc_len = ntohs (encoding->len);
432 size = ntohs (encoding->sizen);
433 rc = gcry_mpi_scan (&n, GCRYMPI_FMT_USG,
434 &((const unsigned char *) (&encoding[1]))[pos], size,
436 pos += ntohs (encoding->sizen);
439 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
442 size = ntohs (encoding->sizee);
443 rc = gcry_mpi_scan (&e, GCRYMPI_FMT_USG,
444 &((const unsigned char *) (&encoding[1]))[pos], size,
446 pos += ntohs (encoding->sizee);
449 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
450 gcry_mpi_release (n);
453 size = ntohs (encoding->sized);
454 rc = gcry_mpi_scan (&d, GCRYMPI_FMT_USG,
455 &((const unsigned char *) (&encoding[1]))[pos], size,
457 pos += ntohs (encoding->sized);
460 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
461 gcry_mpi_release (n);
462 gcry_mpi_release (e);
466 size = ntohs (encoding->sizep);
469 rc = gcry_mpi_scan (&q, GCRYMPI_FMT_USG,
470 &((const unsigned char *) (&encoding[1]))[pos], size,
472 pos += ntohs (encoding->sizep);
475 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
476 gcry_mpi_release (n);
477 gcry_mpi_release (e);
478 gcry_mpi_release (d);
484 size = ntohs (encoding->sizeq);
487 rc = gcry_mpi_scan (&p, GCRYMPI_FMT_USG,
488 &((const unsigned char *) (&encoding[1]))[pos], size,
490 pos += ntohs (encoding->sizeq);
493 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
494 gcry_mpi_release (n);
495 gcry_mpi_release (e);
496 gcry_mpi_release (d);
498 gcry_mpi_release (q);
504 pos += ntohs (encoding->sizedmp1);
505 pos += ntohs (encoding->sizedmq1);
507 ntohs (encoding->len) - sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded) - pos;
510 rc = gcry_mpi_scan (&u, GCRYMPI_FMT_USG,
511 &((const unsigned char *) (&encoding[1]))[pos], size,
515 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
516 gcry_mpi_release (n);
517 gcry_mpi_release (e);
518 gcry_mpi_release (d);
520 gcry_mpi_release (p);
522 gcry_mpi_release (q);
529 if ((p != NULL) && (q != NULL) && (u != NULL))
531 rc = gcry_sexp_build (&res, &size, /* erroff */
532 "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)(u %m)))",
537 if ((p != NULL) && (q != NULL))
539 rc = gcry_sexp_build (&res, &size, /* erroff */
540 "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)))",
545 rc = gcry_sexp_build (&res, &size, /* erroff */
546 "(private-key(rsa(n %m)(e %m)(d %m)))", n, e, d);
549 gcry_mpi_release (n);
550 gcry_mpi_release (e);
551 gcry_mpi_release (d);
553 gcry_mpi_release (p);
555 gcry_mpi_release (q);
557 gcry_mpi_release (u);
560 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
562 if (gcry_pk_testkey (res))
564 LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
568 ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
575 * Create a new private key. Caller must free return value.
577 * @return fresh private key
579 static struct GNUNET_CRYPTO_RsaPrivateKey *
582 struct GNUNET_CRYPTO_RsaPrivateKey *ret;
584 gcry_sexp_t s_keyparam;
587 gcry_sexp_build (&s_keyparam, NULL,
588 "(genkey(rsa(nbits %d)(rsa-use-e 3:257)))",
590 GNUNET_assert (0 == gcry_pk_genkey (&s_key, s_keyparam));
591 gcry_sexp_release (s_keyparam);
593 GNUNET_assert (0 == gcry_pk_testkey (s_key));
595 ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
602 * Try to read the private key from the given file.
604 * @param filename file to read the key from
605 * @return NULL on error
607 static struct GNUNET_CRYPTO_RsaPrivateKey *
608 try_read_key (const char *filename)
610 struct GNUNET_CRYPTO_RsaPrivateKey *ret;
611 struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *enc;
612 struct GNUNET_DISK_FileHandle *fd;
616 if (GNUNET_YES != GNUNET_DISK_file_test (filename))
619 /* hostkey file exists already, read it! */
620 if (NULL == (fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
621 GNUNET_DISK_PERM_NONE)))
623 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
626 if (GNUNET_OK != (GNUNET_DISK_file_handle_size (fd, &fs)))
628 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "stat", filename);
629 (void) GNUNET_DISK_file_close (fd);
634 GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fd));
639 LOG (GNUNET_ERROR_TYPE_ERROR,
640 _("File `%s' does not contain a valid private key (too long, %llu bytes). Deleting it.\n"),
642 (unsigned long long) fs);
643 GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fd));
644 if (0 != UNLINK (filename))
645 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
649 enc = GNUNET_malloc (fs);
650 GNUNET_break (fs == GNUNET_DISK_file_read (fd, enc, fs));
651 len = ntohs (enc->len);
654 (NULL == (ret = GNUNET_CRYPTO_rsa_decode_key ((char *) enc, len))))
656 LOG (GNUNET_ERROR_TYPE_ERROR,
657 _("File `%s' does not contain a valid private key (failed decode, %llu bytes). Deleting it.\n"),
659 (unsigned long long) fs);
660 GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fd));
661 if (0 != UNLINK (filename))
662 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
668 GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fd));
674 * Wait for a short time (we're trying to lock a file or want
675 * to give another process a shot at finishing a disk write, etc.).
676 * Sleeps for 100ms (as that should be long enough for virtually all
677 * modern systems to context switch and allow another process to do
683 struct GNUNET_TIME_Relative timeout;
685 timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100);
686 GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
691 * Create a new private key by reading it from a file. If the
692 * files does not exist, create a new key and write it to the
693 * file. Caller must free return value. Note that this function
694 * can not guarantee that another process might not be trying
695 * the same operation on the same file at the same time.
696 * If the contents of the file
697 * are invalid the old file is deleted and a fresh key is
700 * @return new private key, NULL on error (for example,
703 struct GNUNET_CRYPTO_RsaPrivateKey *
704 GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
706 struct GNUNET_CRYPTO_RsaPrivateKey *ret;
707 struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *enc;
709 struct GNUNET_DISK_FileHandle *fd;
713 struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
714 struct GNUNET_PeerIdentity pid;
716 if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
718 while (GNUNET_YES != GNUNET_DISK_file_test (filename))
720 fd = GNUNET_DISK_file_open (filename,
721 GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
722 | GNUNET_DISK_OPEN_FAILIFEXISTS,
723 GNUNET_DISK_PERM_USER_READ |
724 GNUNET_DISK_PERM_USER_WRITE);
729 if (GNUNET_YES != GNUNET_DISK_file_test (filename))
731 /* must exist but not be accessible, fail for good! */
732 if (0 != ACCESS (filename, R_OK))
733 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
735 GNUNET_break (0); /* what is going on!? */
740 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
746 GNUNET_DISK_file_lock (fd, 0,
747 sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded),
754 LOG (GNUNET_ERROR_TYPE_ERROR,
755 _("Could not acquire lock on file `%s': %s...\n"), filename,
759 LOG (GNUNET_ERROR_TYPE_INFO,
760 _("Creating a new private key. This may take a while.\n"));
761 ret = rsa_key_create ();
762 GNUNET_assert (ret != NULL);
763 enc = GNUNET_CRYPTO_rsa_encode_key (ret);
764 GNUNET_assert (enc != NULL);
765 GNUNET_assert (ntohs (enc->len) ==
766 GNUNET_DISK_file_write (fd, enc, ntohs (enc->len)));
769 GNUNET_DISK_file_sync (fd);
771 GNUNET_DISK_file_unlock (fd, 0,
772 sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded)))
773 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
774 GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
775 GNUNET_CRYPTO_rsa_key_get_public (ret, &pub);
776 GNUNET_CRYPTO_hash (&pub, sizeof (pub), &pid.hashPubKey);
777 LOG (GNUNET_ERROR_TYPE_INFO,
778 _("I am host `%s'. Stored new private key in `%s'.\n"),
779 GNUNET_i2s (&pid), filename);
782 /* hostkey file exists already, read it! */
783 fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
784 GNUNET_DISK_PERM_NONE);
787 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
794 GNUNET_DISK_file_lock (fd, 0,
795 sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded),
801 LOG (GNUNET_ERROR_TYPE_ERROR,
802 _("Could not acquire lock on file `%s': %s...\n"), filename,
804 LOG (GNUNET_ERROR_TYPE_ERROR,
806 ("This may be ok if someone is currently generating a hostkey.\n"));
811 if (GNUNET_YES != GNUNET_DISK_file_test (filename))
813 /* eh, what!? File we opened is now gone!? */
814 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
816 GNUNET_DISK_file_unlock (fd, 0,
817 sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded)))
818 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
819 GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
823 if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
825 if (fs < sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded))
827 /* maybe we got the read lock before the hostkey generating
828 * process had a chance to get the write lock; give it up! */
830 GNUNET_DISK_file_unlock (fd, 0,
831 sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded)))
832 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
835 LOG (GNUNET_ERROR_TYPE_ERROR,
837 ("When trying to read hostkey file `%s' I found %u bytes but I need at least %u.\n"),
838 filename, (unsigned int) fs,
839 (unsigned int) sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded));
840 LOG (GNUNET_ERROR_TYPE_ERROR,
842 ("This may be ok if someone is currently generating a hostkey.\n"));
844 short_wait (1); /* wait a bit longer! */
849 enc = GNUNET_malloc (fs);
850 GNUNET_assert (fs == GNUNET_DISK_file_read (fd, enc, fs));
851 len = ntohs (enc->len);
854 (NULL == (ret = GNUNET_CRYPTO_rsa_decode_key ((char *) enc, len))))
856 LOG (GNUNET_ERROR_TYPE_ERROR,
857 _("File `%s' does not contain a valid private key. Deleting it.\n"),
859 if (0 != UNLINK (filename))
861 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
866 GNUNET_DISK_file_unlock (fd, 0,
867 sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded)))
868 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
869 GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
872 GNUNET_CRYPTO_rsa_key_get_public (ret, &pub);
873 GNUNET_CRYPTO_hash (&pub, sizeof (pub), &pid.hashPubKey);
874 LOG (GNUNET_ERROR_TYPE_INFO,
875 _("I am host `%s'. Read private key from `%s'.\n"), GNUNET_i2s (&pid),
883 * Handle to cancel private key generation and state for the
884 * key generation operation.
886 struct GNUNET_CRYPTO_RsaKeyGenerationContext
890 * Continuation to call upon completion.
892 GNUNET_CRYPTO_RsaKeyCallback cont;
895 * Closure for 'cont'.
905 * Handle to the helper process which does the key generation.
907 struct GNUNET_OS_Process *gnunet_rsa;
910 * Handle to 'stdout' of gnunet-rsa. We 'read' on stdout to detect
911 * process termination (instead of messing with SIGCHLD).
913 struct GNUNET_DISK_PipeHandle *gnunet_rsa_out;
916 * Location where we store the private key if it already existed.
917 * (if this is used, 'filename', 'gnunet_rsa' and 'gnunet_rsa_out' will
920 struct GNUNET_CRYPTO_RsaPrivateKey *pk;
923 * Task reading from 'gnunet_rsa_out' to wait for process termination.
925 GNUNET_SCHEDULER_TaskIdentifier read_task;
931 * Task called upon shutdown or process termination of 'gnunet-rsa' during
932 * RSA key generation. Check where we are and perform the appropriate
935 * @param cls the 'struct GNUNET_CRYPTO_RsaKeyGenerationContext'
936 * @param tc scheduler context
939 check_key_generation_completion (void *cls,
940 const struct GNUNET_SCHEDULER_TaskContext *tc)
942 struct GNUNET_CRYPTO_RsaKeyGenerationContext *gc = cls;
943 enum GNUNET_OS_ProcessStatusType type;
945 struct GNUNET_CRYPTO_RsaPrivateKey *pk;
949 gc->read_task = GNUNET_SCHEDULER_NO_TASK;
950 if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
952 gc->cont (gc->cont_cls, NULL, _("interrupted by shutdown"));
953 GNUNET_CRYPTO_rsa_key_create_stop (gc);
957 GNUNET_OS_process_status (gc->gnunet_rsa,
960 if (0 >= (ret = GNUNET_DISK_file_read (GNUNET_DISK_pipe_handle (gc->gnunet_rsa_out,
961 GNUNET_DISK_PIPE_END_READ),
965 gc->cont (gc->cont_cls, NULL, _("internal error"));
966 GNUNET_CRYPTO_rsa_key_create_stop (gc);
969 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
970 _("Unexpected gnunet-rsa output: %.*s\n"),
972 gc->read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
973 GNUNET_DISK_pipe_handle (gc->gnunet_rsa_out,
974 GNUNET_DISK_PIPE_END_READ),
975 &check_key_generation_completion,
979 GNUNET_OS_process_destroy (gc->gnunet_rsa);
980 gc->gnunet_rsa = NULL;
981 if ( (GNUNET_OS_PROCESS_EXITED != type) ||
984 gc->cont (gc->cont_cls, NULL, _("gnunet-rsa failed"));
985 GNUNET_CRYPTO_rsa_key_create_stop (gc);
988 if (NULL == (pk = try_read_key (gc->filename)))
991 gc->cont (gc->cont_cls, NULL, _("gnunet-rsa failed"));
992 GNUNET_CRYPTO_rsa_key_create_stop (gc);
995 gc->cont (gc->cont_cls, pk, NULL);
996 GNUNET_DISK_pipe_close (gc->gnunet_rsa_out);
997 GNUNET_free (gc->filename);
1003 * Return the private RSA key which already existed on disk
1004 * (asynchronously) to the caller.
1006 * @param cls the 'struct GNUNET_CRYPTO_RsaKeyGenerationContext'
1007 * @param tc scheduler context (unused)
1010 async_return_key (void *cls,
1011 const struct GNUNET_SCHEDULER_TaskContext *tc)
1013 struct GNUNET_CRYPTO_RsaKeyGenerationContext *gc = cls;
1015 gc->cont (gc->cont_cls,
1023 * Create a new private key by reading it from a file. If the files
1024 * does not exist, create a new key and write it to the file. If the
1025 * contents of the file are invalid the old file is deleted and a
1026 * fresh key is created.
1028 * @param filename name of file to use for storage
1029 * @param cont function to call when done (or on errors)
1030 * @param cont_cls closure for 'cont'
1031 * @return handle to abort operation, NULL on fatal errors (cont will not be called if NULL is returned)
1033 struct GNUNET_CRYPTO_RsaKeyGenerationContext *
1034 GNUNET_CRYPTO_rsa_key_create_start (const char *filename,
1035 GNUNET_CRYPTO_RsaKeyCallback cont,
1038 struct GNUNET_CRYPTO_RsaKeyGenerationContext *gc;
1039 struct GNUNET_CRYPTO_RsaPrivateKey *pk;
1040 const char *weak_random;
1042 if (NULL != (pk = try_read_key (filename)))
1044 /* quick happy ending: key already exists! */
1045 gc = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaKeyGenerationContext));
1048 gc->cont_cls = cont_cls;
1049 gc->read_task = GNUNET_SCHEDULER_add_now (&async_return_key,
1053 gc = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaKeyGenerationContext));
1054 gc->filename = GNUNET_strdup (filename);
1056 gc->cont_cls = cont_cls;
1057 gc->gnunet_rsa_out = GNUNET_DISK_pipe (GNUNET_NO,
1061 if (NULL == gc->gnunet_rsa_out)
1063 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "pipe");
1064 GNUNET_free (gc->filename);
1070 GNUNET_CRYPTO_random_is_weak ())
1072 gc->gnunet_rsa = GNUNET_OS_start_process (GNUNET_NO,
1073 GNUNET_OS_INHERIT_STD_ERR,
1081 if (NULL == gc->gnunet_rsa)
1083 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fork");
1084 GNUNET_DISK_pipe_close (gc->gnunet_rsa_out);
1085 GNUNET_free (gc->filename);
1089 GNUNET_assert (GNUNET_OK ==
1090 GNUNET_DISK_pipe_close_end (gc->gnunet_rsa_out,
1091 GNUNET_DISK_PIPE_END_WRITE));
1092 gc->read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
1093 GNUNET_DISK_pipe_handle (gc->gnunet_rsa_out,
1094 GNUNET_DISK_PIPE_END_READ),
1095 &check_key_generation_completion,
1102 * Abort RSA key generation.
1104 * @param gc key generation context to abort
1107 GNUNET_CRYPTO_rsa_key_create_stop (struct GNUNET_CRYPTO_RsaKeyGenerationContext *gc)
1109 if (GNUNET_SCHEDULER_NO_TASK != gc->read_task)
1111 GNUNET_SCHEDULER_cancel (gc->read_task);
1112 gc->read_task = GNUNET_SCHEDULER_NO_TASK;
1114 if (NULL != gc->gnunet_rsa)
1116 (void) GNUNET_OS_process_kill (gc->gnunet_rsa, SIGKILL);
1117 GNUNET_break (GNUNET_OK ==
1118 GNUNET_OS_process_wait (gc->gnunet_rsa));
1119 GNUNET_OS_process_destroy (gc->gnunet_rsa);
1120 GNUNET_DISK_pipe_close (gc->gnunet_rsa_out);
1123 if (NULL != gc->filename)
1125 if (0 != UNLINK (gc->filename))
1126 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", gc->filename);
1127 GNUNET_free (gc->filename);
1130 GNUNET_CRYPTO_rsa_key_free (gc->pk);
1136 * Setup a hostkey file for a peer given the name of the
1137 * configuration file (!). This function is used so that
1138 * at a later point code can be certain that reading a
1139 * hostkey is fast (for example in time-dependent testcases).
1141 * @param cfg_name name of the configuration file to use
1144 GNUNET_CRYPTO_setup_hostkey (const char *cfg_name)
1146 struct GNUNET_CONFIGURATION_Handle *cfg;
1147 struct GNUNET_CRYPTO_RsaPrivateKey *pk;
1150 cfg = GNUNET_CONFIGURATION_create ();
1151 (void) GNUNET_CONFIGURATION_load (cfg, cfg_name);
1153 GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY", &fn))
1155 pk = GNUNET_CRYPTO_rsa_key_create_from_file (fn);
1157 GNUNET_CRYPTO_rsa_key_free (pk);
1160 GNUNET_CONFIGURATION_destroy (cfg);
1165 * Encrypt a block with the public key of another host that uses the
1168 * @param block the block to encrypt
1169 * @param size the size of block
1170 * @param publicKey the encoded public key used to encrypt
1171 * @param target where to store the encrypted block
1172 * @returns GNUNET_SYSERR on error, GNUNET_OK if ok
1175 GNUNET_CRYPTO_rsa_encrypt (const void *block, size_t size,
1176 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
1178 struct GNUNET_CRYPTO_RsaEncryptedData *target)
1182 struct GNUNET_CRYPTO_RsaPrivateKey *pubkey;
1188 GNUNET_assert (size <= sizeof (struct GNUNET_HashCode));
1189 pubkey = public2PrivateKey (publicKey);
1191 return GNUNET_SYSERR;
1194 gcry_mpi_scan (&val, GCRYMPI_FMT_USG, block, isize, &isize));
1196 gcry_sexp_build (&data, &erroff,
1197 "(data (flags pkcs1)(value %m))", val));
1198 gcry_mpi_release (val);
1199 GNUNET_assert (0 == gcry_pk_encrypt (&result, data, pubkey->sexp));
1200 gcry_sexp_release (data);
1201 GNUNET_CRYPTO_rsa_key_free (pubkey);
1203 GNUNET_assert (0 == key_from_sexp (&rval, result, "rsa", "a"));
1204 gcry_sexp_release (result);
1205 isize = sizeof (struct GNUNET_CRYPTO_RsaEncryptedData);
1207 gcry_mpi_print (GCRYMPI_FMT_USG, (unsigned char *) target,
1208 isize, &isize, rval));
1209 gcry_mpi_release (rval);
1210 adjust (&target->encoding[0], isize,
1211 sizeof (struct GNUNET_CRYPTO_RsaEncryptedData));
1217 * Decrypt a given block with the hostkey.
1219 * @param key the key with which to decrypt this block
1220 * @param block the data to decrypt, encoded as returned by encrypt
1221 * @param result pointer to a location where the result can be stored
1222 * @param max the maximum number of bits to store for the result, if
1223 * the decrypted block is bigger, an error is returned
1224 * @return the size of the decrypted block, -1 on error
1227 GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey * key,
1228 const struct GNUNET_CRYPTO_RsaEncryptedData * block,
1229 void *result, size_t max)
1231 gcry_sexp_t resultsexp;
1236 unsigned char *endp;
1240 GNUNET_assert (0 == gcry_pk_testkey (key->sexp));
1242 size = sizeof (struct GNUNET_CRYPTO_RsaEncryptedData);
1244 gcry_mpi_scan (&val, GCRYMPI_FMT_USG, &block->encoding[0],
1247 gcry_sexp_build (&data, &erroff, "(enc-val(flags)(rsa(a %m)))",
1249 gcry_mpi_release (val);
1250 GNUNET_assert (0 == gcry_pk_decrypt (&resultsexp, data, key->sexp));
1251 gcry_sexp_release (data);
1252 /* resultsexp has format "(value %m)" */
1253 GNUNET_assert (NULL !=
1254 (val = gcry_sexp_nth_mpi (resultsexp, 1, GCRYMPI_FMT_USG)));
1255 gcry_sexp_release (resultsexp);
1256 tmp = GNUNET_malloc (max + HOSTKEY_LEN / 8);
1257 size = max + HOSTKEY_LEN / 8;
1258 GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG, tmp, size, &size, val));
1259 gcry_mpi_release (val);
1261 endp += (size - max);
1263 memcpy (result, endp, size);
1270 * Sign a given block.
1272 * @param key private key to use for the signing
1273 * @param purpose what to sign (size, purpose)
1274 * @param sig where to write the signature
1275 * @return GNUNET_SYSERR on error, GNUNET_OK on success
1278 GNUNET_CRYPTO_rsa_sign (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
1279 const struct GNUNET_CRYPTO_RsaSignaturePurpose *purpose,
1280 struct GNUNET_CRYPTO_RsaSignature *sig)
1286 struct GNUNET_HashCode hc;
1290 GNUNET_CRYPTO_hash (purpose, ntohl (purpose->size), &hc);
1291 #define FORMATSTRING "(4:data(5:flags5:pkcs1)(4:hash6:sha51264:0123456789012345678901234567890123456789012345678901234567890123))"
1292 bufSize = strlen (FORMATSTRING) + 1;
1293 buff = GNUNET_malloc (bufSize);
1294 memcpy (buff, FORMATSTRING, bufSize);
1298 ("0123456789012345678901234567890123456789012345678901234567890123))")
1299 - 1], &hc, sizeof (struct GNUNET_HashCode));
1300 GNUNET_assert (0 == gcry_sexp_new (&data, buff, bufSize, 0));
1302 GNUNET_assert (0 == gcry_pk_sign (&result, data, key->sexp));
1303 gcry_sexp_release (data);
1304 GNUNET_assert (0 == key_from_sexp (&rval, result, "rsa", "s"));
1305 gcry_sexp_release (result);
1306 ssize = sizeof (struct GNUNET_CRYPTO_RsaSignature);
1308 gcry_mpi_print (GCRYMPI_FMT_USG, (unsigned char *) sig, ssize,
1310 gcry_mpi_release (rval);
1311 adjust (sig->sig, ssize, sizeof (struct GNUNET_CRYPTO_RsaSignature));
1319 * @param purpose what is the purpose that the signature should have?
1320 * @param validate block to validate (size, purpose, data)
1321 * @param sig signature that is being validated
1322 * @param publicKey public key of the signer
1323 * @returns GNUNET_OK if ok, GNUNET_SYSERR if invalid
1326 GNUNET_CRYPTO_rsa_verify (uint32_t purpose,
1327 const struct GNUNET_CRYPTO_RsaSignaturePurpose
1329 const struct GNUNET_CRYPTO_RsaSignature *sig,
1330 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
1334 gcry_sexp_t sigdata;
1337 struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
1338 struct GNUNET_HashCode hc;
1344 if (purpose != ntohl (validate->purpose))
1345 return GNUNET_SYSERR; /* purpose mismatch */
1346 GNUNET_CRYPTO_hash (validate, ntohl (validate->size), &hc);
1347 size = sizeof (struct GNUNET_CRYPTO_RsaSignature);
1349 gcry_mpi_scan (&val, GCRYMPI_FMT_USG,
1350 (const unsigned char *) sig, size, &size));
1352 gcry_sexp_build (&sigdata, &erroff, "(sig-val(rsa(s %m)))",
1354 gcry_mpi_release (val);
1355 bufSize = strlen (FORMATSTRING) + 1;
1356 buff = GNUNET_malloc (bufSize);
1357 memcpy (buff, FORMATSTRING, bufSize);
1359 [strlen (FORMATSTRING) -
1361 ("0123456789012345678901234567890123456789012345678901234567890123))")],
1362 &hc, sizeof (struct GNUNET_HashCode));
1363 GNUNET_assert (0 == gcry_sexp_new (&data, buff, bufSize, 0));
1365 hostkey = public2PrivateKey (publicKey);
1366 if (hostkey == NULL)
1368 gcry_sexp_release (data);
1369 gcry_sexp_release (sigdata);
1370 return GNUNET_SYSERR;
1372 rc = gcry_pk_verify (sigdata, data, hostkey->sexp);
1373 GNUNET_CRYPTO_rsa_key_free (hostkey);
1374 gcry_sexp_release (data);
1375 gcry_sexp_release (sigdata);
1378 LOG (GNUNET_ERROR_TYPE_WARNING,
1379 _("RSA signature verification failed at %s:%d: %s\n"), __FILE__,
1380 __LINE__, gcry_strerror (rc));
1381 return GNUNET_SYSERR;
1387 /* end of crypto_rsa.c */