* An ECC signature of the 'origin' asserting the validity of
* the given ephemeral key.
*/
- struct GNUNET_CRYPTO_EccSignature signature;
+ struct GNUNET_CRYPTO_EddsaSignature signature;
/**
* Information about what is being signed.
* At what time was this key created (beginning of validity).
*/
struct GNUNET_TIME_AbsoluteNBO creation_time;
-
+
/**
* When does the given ephemeral key expire (end of validity).
*/
* Ephemeral public ECC key (always for NIST P-521) encoded in a format suitable
* for network transmission as created using 'gcry_sexp_sprint'.
*/
- struct GNUNET_CRYPTO_EccPublicEncryptKey ephemeral_key;
+ struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
/**
* Public key of the signing peer (persistent version, not the ephemeral public key).
/**
* Our private key.
*/
-static struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
+static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
/**
* Our ephemeral private key.
*/
-static struct GNUNET_CRYPTO_EccPrivateKey *my_ephemeral_key;
+static struct GNUNET_CRYPTO_EcdhePrivateKey *my_ephemeral_key;
/**
* Current message we send for a key exchange.
/**
* Task scheduled for periodic re-generation (and thus rekeying) of our
* ephemeral key.
- */
+ */
static GNUNET_SCHEDULER_TaskIdentifier rekey_task;
{
static const char ctx[] = "authentication key";
- GNUNET_CRYPTO_hmac_derive_key (akey, skey,
- &seed, sizeof (seed),
- skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
- ctx, sizeof (ctx),
+ GNUNET_CRYPTO_hmac_derive_key (akey, skey,
+ &seed, sizeof (seed),
+ skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
+ ctx, sizeof (ctx),
NULL);
}
GNUNET_CRYPTO_symmetric_derive_iv (iv, skey, &seed, sizeof (seed),
identity,
sizeof (struct GNUNET_PeerIdentity),
- &challenge, sizeof (challenge),
- ctx, sizeof (ctx),
+ &challenge, sizeof (challenge),
+ ctx, sizeof (ctx),
NULL);
}
* @param sender peer identity of the sender
* @param receiver peer identity of the sender
* @param key_material high entropy key material to use
- * @param skey set to derived session key
+ * @param skey set to derived session key
*/
static void
derive_aes_key (const struct GNUNET_PeerIdentity *sender,
* @param iv initialization vector to use
* @param in ciphertext
* @param out plaintext
- * @param size size of in/out
- * @return GNUNET_OK on success
+ * @param size size of @a in / @a out
+ * @return #GNUNET_OK on success
*/
static int
do_decrypt (struct GSC_KeyExchangeInfo *kx,
struct GNUNET_HashCode h1;
struct GNUNET_HashCode h2;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Initiating key exchange with `%s'\n",
GNUNET_i2s (pid));
GNUNET_STATISTICS_update (GSC_stats,
gettext_noop ("# key exchanges initiated"), 1,
GNUNET_NO);
- kx = GNUNET_malloc (sizeof (struct GSC_KeyExchangeInfo));
+ kx = GNUNET_new (struct GSC_KeyExchangeInfo);
kx->peer = *pid;
kx->set_key_retry_frequency = INITIAL_SET_KEY_RETRY_FREQUENCY;
GNUNET_CONTAINER_DLL_insert (kx_head,
kx);
GNUNET_CRYPTO_hash (pid, sizeof (struct GNUNET_PeerIdentity), &h1);
GNUNET_CRYPTO_hash (&GSC_my_identity, sizeof (struct GNUNET_PeerIdentity), &h2);
-
- if (0 < GNUNET_CRYPTO_hash_cmp (&h1,
+
+ kx->status = KX_STATE_KEY_SENT;
+ if (0 < GNUNET_CRYPTO_hash_cmp (&h1,
&h2))
{
/* peer with "lower" identity starts KX, otherwise we typically end up
- with both peers starting the exchange and transmit the 'set key'
+ with both peers starting the exchange and transmit the 'set key'
message twice */
- kx->status = KX_STATE_KEY_SENT;
send_key (kx);
}
+ else
+ {
+ /* peer with "higher" identity starts a delayed KX, if the "lower" peer
+ * does not start a KX since he sees no reasons to do so */
+ kx->retry_set_key_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+ &set_key_retry_task, kx);
+ }
return kx;
}
struct GNUNET_TIME_Absolute start_t;
struct GNUNET_TIME_Absolute end_t;
struct GNUNET_TIME_Absolute now;
- enum KxStateMachine sender_status;
+ enum KxStateMachine sender_status;
uint16_t size;
struct GNUNET_HashCode key_material;
-
+
size = ntohs (msg->size);
if (sizeof (struct EphemeralKeyMessage) != size)
{
end_t = GNUNET_TIME_absolute_ntoh (m->expiration_time);
if ( ( (KX_STATE_KEY_RECEIVED == kx->status) ||
(KX_STATE_UP == kx->status) ||
- (KX_STATE_REKEY_SENT == kx->status) ) &&
+ (KX_STATE_REKEY_SENT == kx->status) ) &&
(end_t.abs_value_us <= kx->foreign_key_expires.abs_value_us) )
{
GNUNET_STATISTICS_update (GSC_stats, gettext_noop ("# old ephemeral keys ignored"),
memcmp (&m->origin_identity,
&kx->peer.public_key,
sizeof (struct GNUNET_PeerIdentity)))
- {
+ {
GNUNET_break_op (0);
return;
}
sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
sizeof (struct GNUNET_TIME_AbsoluteNBO) +
sizeof (struct GNUNET_TIME_AbsoluteNBO) +
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey)) ||
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)) ||
(GNUNET_OK !=
- GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_SET_ECC_KEY,
+ GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_SET_ECC_KEY,
&m->purpose,
&m->signature, &m->origin_identity.public_key)))
{
}
if (GNUNET_OK !=
GNUNET_CRYPTO_ecc_ecdh (my_ephemeral_key,
- &m->ephemeral_key,
+ &m->ephemeral_key,
&key_material))
{
GNUNET_break (0);
setup_fresh_ping (kx);
/* check if we still need to send the sender our key */
- sender_status = (enum KxStateMachine) ntohl (m->sender_status);
+ sender_status = (enum KxStateMachine) ntohl (m->sender_status);
switch (sender_status)
{
case KX_STATE_DOWN:
/* fine, need to send our key after updating our status, see below */
break;
case KX_STATE_KEY_RECEIVED:
- case KX_STATE_UP:
+ case KX_STATE_UP:
case KX_STATE_REKEY_SENT:
/* other peer already got our key */
break;
send_key (kx);
send_ping (kx);
break;
- case KX_STATE_UP:
+ case KX_STATE_UP:
kx->status = KX_STATE_REKEY_SENT;
if (KX_STATE_KEY_SENT == sender_status)
send_key (kx);
GNUNET_STATISTICS_update (GSC_stats,
gettext_noop ("# PING messages received"), 1,
GNUNET_NO);
- if ( (kx->status != KX_STATE_KEY_RECEIVED) &&
+ if ( (kx->status != KX_STATE_KEY_RECEIVED) &&
(kx->status != KX_STATE_UP) &&
(kx->status != KX_STATE_REKEY_SENT))
{
{
GNUNET_SCHEDULER_cancel (kx->retry_set_key_task);
kx->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
- }
+ }
switch (kx->status)
{
case KX_STATE_DOWN:
kx->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
}
/* always update sender status in SET KEY message */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending key to `%s' (my status: %d)\n",
GNUNET_i2s (&kx->peer),
kx->status);
- current_ekm.sender_status = htonl ((int32_t) (kx->status));
+ current_ekm.sender_status = htonl ((int32_t) (kx->status));
GSC_NEIGHBOURS_transmit (&kx->peer, ¤t_ekm.header,
kx->set_key_retry_frequency);
kx->retry_set_key_task =
used - ENCRYPTED_HEADER_SIZE));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypted %u bytes for %s\n",
used - ENCRYPTED_HEADER_SIZE, GNUNET_i2s (&kx->peer));
- derive_auth_key (&auth_key,
- &kx->encrypt_key,
+ derive_auth_key (&auth_key,
+ &kx->encrypt_key,
ph->iv_seed);
GNUNET_CRYPTO_hmac (&auth_key, &em->sequence_number,
used - ENCRYPTED_HEADER_SIZE, &em->hmac);
if (0 != memcmp (&ph, &m->hmac, sizeof (struct GNUNET_HashCode)))
{
/* checksum failed */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Failed checksum validation for a message from `%s'\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Failed checksum validation for a message from `%s'\n",
GNUNET_i2s (&kx->peer));
return;
}
current_ekm.purpose.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
sizeof (struct GNUNET_TIME_AbsoluteNBO) +
sizeof (struct GNUNET_TIME_AbsoluteNBO) +
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
+ sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
+ sizeof (struct GNUNET_PeerIdentity));
current_ekm.creation_time = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (GSC_cfg,
{
current_ekm.expiration_time = GNUNET_TIME_absolute_hton (GNUNET_TIME_UNIT_FOREVER_ABS);
}
- GNUNET_CRYPTO_ecc_key_get_public_for_encryption (my_ephemeral_key,
- ¤t_ekm.ephemeral_key);
+ GNUNET_CRYPTO_ecdhe_key_get_public (my_ephemeral_key,
+ ¤t_ekm.ephemeral_key);
current_ekm.origin_identity = GSC_my_identity;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_ecc_sign (my_private_key,
+ GNUNET_CRYPTO_eddsa_sign (my_private_key,
¤t_ekm.purpose,
¤t_ekm.signature));
}
NULL);
if (NULL != my_ephemeral_key)
GNUNET_free (my_ephemeral_key);
- my_ephemeral_key = GNUNET_CRYPTO_ecc_key_create ();
+ my_ephemeral_key = GNUNET_CRYPTO_ecdhe_key_create ();
GNUNET_assert (NULL != my_ephemeral_key);
sign_ephemeral_key ();
for (pos = kx_head; NULL != pos; pos = pos->next)
* Initialize KX subsystem.
*
* @param pk private key to use for the peer
- * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
*/
int
-GSC_KX_init (struct GNUNET_CRYPTO_EccPrivateKey *pk)
+GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
{
GNUNET_assert (NULL != pk);
my_private_key = pk;
- GNUNET_CRYPTO_ecc_key_get_public_for_signature (my_private_key,
+ GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
&GSC_my_identity.public_key);
- if (GNUNET_YES ==
- GNUNET_CONFIGURATION_get_value_yesno (GSC_cfg,
- "core",
- "USE_EPHEMERAL_KEYS"))
- {
- my_ephemeral_key = GNUNET_CRYPTO_ecc_key_create ();
- if (NULL == my_ephemeral_key)
- {
- GNUNET_break (0);
- GNUNET_free (my_private_key);
- my_private_key = NULL;
- return GNUNET_SYSERR;
- }
- sign_ephemeral_key ();
- rekey_task = GNUNET_SCHEDULER_add_delayed (REKEY_FREQUENCY,
- &do_rekey,
- NULL);
- }
- else
+ my_ephemeral_key = GNUNET_CRYPTO_ecdhe_key_create ();
+ if (NULL == my_ephemeral_key)
{
- my_ephemeral_key = my_private_key;
- sign_ephemeral_key ();
+ GNUNET_break (0);
+ GNUNET_free (my_private_key);
+ my_private_key = NULL;
+ return GNUNET_SYSERR;
}
+ sign_ephemeral_key ();
+ rekey_task = GNUNET_SCHEDULER_add_delayed (REKEY_FREQUENCY,
+ &do_rekey,
+ NULL);
mst = GNUNET_SERVER_mst_create (&deliver_message, NULL);
return GNUNET_OK;
}
GNUNET_SCHEDULER_cancel (rekey_task);
rekey_task = GNUNET_SCHEDULER_NO_TASK;
}
- if ( (NULL != my_ephemeral_key) &&
- (my_ephemeral_key != my_private_key) )
+ if (NULL != my_ephemeral_key)
{
GNUNET_free (my_ephemeral_key);
my_ephemeral_key = NULL;