/*
This file is part of GNUnet.
- (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
+ (C) 2009, 2010, 2011, 2012 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
#include "core.h"
+/**
+ * Set to GNUNET_YES to perform some slightly expensive internal invariant checks.
+ */
+#define EXTRA_CHECKS GNUNET_YES
+
/**
* How long do we wait for SET_KEY confirmation initially?
*/
* (excluding this value itself) will be encrypted and authenticated.
* ENCRYPTED_HEADER_SIZE must be set to the offset of the *next* field.
*/
- GNUNET_HashCode hmac;
+ struct GNUNET_HashCode hmac;
/**
* Sequence number, in network byte order. This field
static struct GNUNET_SERVER_MessageStreamTokenizer *mst;
+#if EXTRA_CHECKS
+/**
+ * Check internal invariants of the given KX record.
+ *
+ * @param kx record to check
+ * @param file filename for error reporting
+ * @param line line number for error reporting
+ */
+static void
+check_kx_record (struct GSC_KeyExchangeInfo *kx,
+ const char *file,
+ int line)
+{
+ struct GNUNET_HashCode hc;
+
+ if (NULL == kx->public_key)
+ return;
+ GNUNET_CRYPTO_hash (kx->public_key, sizeof (*kx->public_key), &hc);
+ GNUNET_assert_at (0 == memcmp (&hc, &kx->peer, sizeof (struct GNUNET_HashCode)), file, line);
+}
+
+
+/**
+ * Check internal invariants of the given KX record.
+ *
+ * @param kx record to check
+ */
+#define CHECK_KX(kx) check_kx_record(kx, __FILE__, __LINE__)
+#else
+#define CHECK_KX(kx)
+#endif
+
/**
* Derive an authentication key from "set key" information
*
* @param iv initialization vector to initialize
* @param skey session key to use
* @param seed seed to use
- * @param creation_time creation time to use
+ * @param identity identity of the other peer to use
*/
static void
derive_iv (struct GNUNET_CRYPTO_AesInitializationVector *iv,
* @param iv initialization vector to initialize
* @param skey session key to use
* @param seed seed to use
- * @param creation_time creation time to use
+ * @param challenge nonce to use
* @param identity identity of the other peer to use
*/
static void
struct GSC_KeyExchangeInfo *kx = cls;
struct SetKeyMessage *skm;
- if (err_msg != NULL)
+ CHECK_KX (kx);
+ if (NULL != err_msg)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Error in communication with PEERINFO service\n"));
&set_key_retry_task, kx);
return;
}
- if (peer == NULL)
+ if (NULL == peer)
{
kx->pitr = NULL;
- if (kx->public_key != NULL)
+ if (NULL != kx->public_key)
return; /* done here */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Failed to obtain public key for peer `%4s', delaying processing of SET_KEY\n",
&set_key_retry_task, kx);
return;
}
- if (kx->public_key != NULL)
+ GNUNET_break (0 == memcmp (peer, &kx->peer, sizeof (struct GNUNET_PeerIdentity)));
+ if (NULL != kx->public_key)
{
/* already have public key, why are we here? */
GNUNET_break (0);
GNUNET_break (0);
GNUNET_free (kx->public_key);
kx->public_key = NULL;
+ CHECK_KX (kx);
return;
}
+ CHECK_KX (kx);
send_key (kx);
if (NULL != kx->skm_received)
{
GNUNET_PEERINFO_iterate (peerinfo, pid,
GNUNET_TIME_UNIT_FOREVER_REL /* timeout? */ ,
&process_hello, kx);
+ CHECK_KX (kx);
return kx;
}
{
GNUNET_STATISTICS_update (GSC_stats, gettext_noop ("# key exchanges stopped"),
1, GNUNET_NO);
- if (kx->pitr != NULL)
+ if (NULL != kx->pitr)
{
GNUNET_PEERINFO_iterate_cancel (kx->pitr);
kx->pitr = NULL;
struct PongMessage *pong;
enum KxStateMachine sender_status;
uint16_t size;
-
+
+ CHECK_KX (kx);
size = ntohs (msg->size);
if (size != sizeof (struct SetKeyMessage))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Core service receives `%s' request from `%4s'.\n", "SET_KEY",
GNUNET_i2s (&kx->peer));
- if (kx->public_key == NULL)
+ if (NULL == kx->public_key)
{
GNUNET_free_non_null (kx->skm_received);
kx->skm_received = (struct SetKeyMessage *) GNUNET_copy_message (msg);
&m->signature, kx->public_key)))
{
/* invalid signature */
+ CHECK_KX (kx);
GNUNET_break_op (0);
return;
}
(GNUNET_OK != GNUNET_CRYPTO_aes_check_session_key (&k)))
{
/* failed to decrypt !? */
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Invalid key %x decrypted by %s from message %u (origin: %s)\n",
+ (unsigned int) GNUNET_CRYPTO_crc32_n (&k, sizeof (struct GNUNET_CRYPTO_AesSessionKey)),
+ GNUNET_i2s (&GSC_my_identity),
+ (unsigned int) GNUNET_CRYPTO_crc32_n (&m->encrypted_key, sizeof (struct GNUNET_CRYPTO_RsaEncryptedData)),
+ GNUNET_h2s (&kx->peer.hashPubKey));
GNUNET_break_op (0);
return;
}
GNUNET_break (0);
break;
}
- if (kx->ping_received != NULL)
+ if (NULL != kx->ping_received)
{
ping = kx->ping_received;
kx->ping_received = NULL;
GSC_KX_handle_ping (kx, &ping->header);
GNUNET_free (ping);
}
- if (kx->pong_received != NULL)
+ if (NULL != kx->pong_received)
{
pong = kx->pong_received;
kx->pong_received = NULL;
skm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SET_KEY);
skm->creation_time = GNUNET_TIME_absolute_hton (kx->encrypt_key_created);
skm->target = kx->peer;
+ CHECK_KX (kx);
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_rsa_encrypt (&kx->encrypt_key,
sizeof (struct
GNUNET_CRYPTO_AesSessionKey),
kx->public_key,
&skm->encrypted_key));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Encrypting key %x for %s resulting in message %u (origin: %s)\n",
+ (unsigned int) GNUNET_CRYPTO_crc32_n (&kx->encrypt_key, sizeof (struct GNUNET_CRYPTO_AesSessionKey)),
+ GNUNET_i2s (&kx->peer),
+ (unsigned int) GNUNET_CRYPTO_crc32_n (&skm->encrypted_key, sizeof (struct GNUNET_CRYPTO_RsaEncryptedData)),
+ GNUNET_h2s (&GSC_my_identity.hashPubKey));
+
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_rsa_sign (my_private_key, &skm->purpose,
&skm->signature));
kx->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
left = GNUNET_TIME_absolute_get_remaining (kx->timeout);
- if (left.rel_value == 0)
+ if (0 == left.rel_value)
{
GNUNET_STATISTICS_update (GSC_stats,
gettext_noop ("# sessions terminated by timeout"),
1, GNUNET_NO);
GSC_SESSIONS_end (&kx->peer);
kx->status = KX_STATE_DOWN;
+ send_key (kx);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending KEEPALIVE to `%s'\n",
{
struct GSC_KeyExchangeInfo *kx = cls;
+ GNUNET_break (KX_STATE_UP == kx->status);
kx->status = KX_STATE_REKEY;
kx->set_key_retry_frequency = INITIAL_SET_KEY_RETRY_FREQUENCY;
kx->retry_set_key_task =
uint16_t msize;
msize = ntohs (msg->size);
- if (msize != sizeof (struct PongMessage))
+ if (sizeof (struct PongMessage) != msize)
{
GNUNET_break_op (0);
return;
GNUNET_NO);
kx->status = KX_STATE_UP;
GSC_SESSIONS_create (&kx->peer, kx);
+ CHECK_KX (kx);
schedule_rekey (kx);
- GNUNET_assert (kx->keep_alive_task == GNUNET_SCHEDULER_NO_TASK);
- if (kx->emsg_received != NULL)
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
+ if (NULL != kx->emsg_received)
{
emsg = kx->emsg_received;
kx->emsg_received = NULL;
static void
send_key (struct GSC_KeyExchangeInfo *kx)
{
- GNUNET_assert (kx->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK);
+ CHECK_KX (kx);
+ if (GNUNET_SCHEDULER_NO_TASK != kx->retry_set_key_task)
+ {
+ GNUNET_SCHEDULER_cancel (kx->retry_set_key_task);
+ kx->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
+ }
if (KX_STATE_UP == kx->status)
return; /* nothing to do */
- if (kx->public_key == NULL)
+ if (NULL == kx->public_key)
{
+ if (NULL != kx->pitr)
+ return;
/* lookup public key, then try again */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Trying to obtain public key for `%s'\n",
{
const struct EncryptedMessage *m;
struct EncryptedMessage *pt; /* plaintext */
- GNUNET_HashCode ph;
+ struct GNUNET_HashCode ph;
uint32_t snum;
struct GNUNET_TIME_Absolute t;
struct GNUNET_CRYPTO_AesInitializationVector iv;
struct GNUNET_CRYPTO_AuthKey auth_key;
struct DeliverMessageContext dmc;
uint16_t size = ntohs (msg->size);
- char buf[size];
+ char buf[size] GNUNET_ALIGN;
if (size <
sizeof (struct EncryptedMessage) + sizeof (struct GNUNET_MessageHeader))
1, GNUNET_NO);
return;
}
- if (kx->status == KX_STATE_KEY_RECEIVED)
+ if (KX_STATE_KEY_RECEIVED == kx->status)
{
/* defer */
- GNUNET_free_non_null (kx->ping_received);
+ GNUNET_free_non_null (kx->emsg_received);
kx->emsg_received = (struct EncryptedMessage *) GNUNET_copy_message (msg);
return;
}
kx->decrypt_key_created);
GNUNET_CRYPTO_hmac (&auth_key, &m->sequence_number,
size - ENCRYPTED_HEADER_SIZE, &ph);
- if (0 != memcmp (&ph, &m->hmac, sizeof (GNUNET_HashCode)))
+ if (0 != memcmp (&ph, &m->hmac, sizeof (struct GNUNET_HashCode)))
{
/* checksum failed */
- GNUNET_break_op (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed checksum validation for a message from `%s'\n", GNUNET_i2s (&kx->peer));
return;
}
derive_iv (&iv, &kx->decrypt_key, m->iv_seed, &GSC_my_identity);
MAX_MESSAGE_AGE.rel_value)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Message received far too old (%llu ms). Content ignored.\n"),
- GNUNET_TIME_absolute_get_duration (t).rel_value);
+ _("Message received far too old (%s). Content ignored.\n"),
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (t), GNUNET_YES));
GNUNET_STATISTICS_update (GSC_stats,
gettext_noop
("# bytes dropped (ancient message)"), size,
* @param client who sent us the message (struct GSC_KeyExchangeInfo)
* @param m the message
*/
-static void
+static int
deliver_message (void *cls, void *client, const struct GNUNET_MessageHeader *m)
{
struct DeliverMessageContext *dmc = client;
case GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP:
case GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP:
GSC_SESSIONS_set_typemap (dmc->peer, m);
- return;
+ return GNUNET_OK;
default:
GSC_CLIENTS_deliver_message (dmc->peer, dmc->atsi, dmc->atsi_count, m,
ntohs (m->size),
sizeof (struct GNUNET_MessageHeader),
GNUNET_CORE_OPTION_SEND_HDR_INBOUND);
}
+ return GNUNET_OK;
}
/**
* Initialize KX subsystem.
*
+ * @param pk private key to use for the peer
* @return GNUNET_OK on success, GNUNET_SYSERR on failure
*/
int
-GSC_KX_init ()
+GSC_KX_init (struct GNUNET_CRYPTO_RsaPrivateKey *pk)
{
- char *keyfile;
-
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (GSC_cfg, "GNUNETD", "HOSTKEY",
- &keyfile))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _
- ("Core service is lacking HOSTKEY configuration setting. Exiting.\n"));
- return GNUNET_SYSERR;
- }
- my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
- GNUNET_free (keyfile);
- if (my_private_key == NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Core service could not access hostkey. Exiting.\n"));
- return GNUNET_SYSERR;
- }
+ my_private_key = pk;
GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
&GSC_my_identity.hashPubKey);
void
GSC_KX_done ()
{
- if (my_private_key != NULL)
+ if (NULL != my_private_key)
{
GNUNET_CRYPTO_rsa_key_free (my_private_key);
my_private_key = NULL;
}
- if (peerinfo != NULL)
+ if (NULL != peerinfo)
{
GNUNET_PEERINFO_disconnect (peerinfo);
peerinfo = NULL;
}
- if (mst != NULL)
+ if (NULL != mst)
{
GNUNET_SERVER_mst_destroy (mst);
mst = NULL;