* 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_EccPublicKey ephemeral_key;
+ struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
/**
* Public key of the signing peer (persistent version, not the ephemeral public key).
*/
- struct GNUNET_CRYPTO_EccPublicKey origin_public_key;
+ struct GNUNET_PeerIdentity origin_identity;
};
* Key we use to encrypt our messages for the other peer
* (initialized by us when we do the handshake).
*/
- struct GNUNET_CRYPTO_AesSessionKey encrypt_key;
+ struct GNUNET_CRYPTO_SymmetricSessionKey encrypt_key;
/**
* Key we use to decrypt messages from the other peer
* (given to us by the other peer during the handshake).
*/
- struct GNUNET_CRYPTO_AesSessionKey decrypt_key;
+ struct GNUNET_CRYPTO_SymmetricSessionKey decrypt_key;
/**
* At what time did the other peer generate the decryption 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.
*/
static struct EphemeralKeyMessage current_ekm;
-/**
- * Our public key.
- */
-static struct GNUNET_CRYPTO_EccPublicKey my_public_key;
-
/**
* Our message stream tokenizer (for encrypted payload).
*/
/**
* Task scheduled for periodic re-generation (and thus rekeying) of our
* ephemeral key.
- */
+ */
static GNUNET_SCHEDULER_TaskIdentifier rekey_task;
*/
static void
derive_auth_key (struct GNUNET_CRYPTO_AuthKey *akey,
- const struct GNUNET_CRYPTO_AesSessionKey *skey, uint32_t seed)
+ const struct GNUNET_CRYPTO_SymmetricSessionKey *skey, uint32_t seed)
{
static const char ctx[] = "authentication key";
- GNUNET_CRYPTO_hmac_derive_key (akey, skey, &seed, sizeof (seed), &skey->key,
- sizeof (skey->key), ctx,
- sizeof (ctx), NULL);
+ GNUNET_CRYPTO_hmac_derive_key (akey, skey,
+ &seed, sizeof (seed),
+ skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
+ ctx, sizeof (ctx),
+ NULL);
}
* @param identity identity of the other peer to use
*/
static void
-derive_iv (struct GNUNET_CRYPTO_AesInitializationVector *iv,
- const struct GNUNET_CRYPTO_AesSessionKey *skey, uint32_t seed,
+derive_iv (struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
+ const struct GNUNET_CRYPTO_SymmetricSessionKey *skey, uint32_t seed,
const struct GNUNET_PeerIdentity *identity)
{
static const char ctx[] = "initialization vector";
- GNUNET_CRYPTO_aes_derive_iv (iv, skey, &seed, sizeof (seed),
- &identity->hashPubKey.bits,
- sizeof (identity->hashPubKey.bits), ctx,
- sizeof (ctx), NULL);
+ GNUNET_CRYPTO_symmetric_derive_iv (iv, skey, &seed, sizeof (seed),
+ identity,
+ sizeof (struct GNUNET_PeerIdentity), ctx,
+ sizeof (ctx), NULL);
}
* @param identity identity of the other peer to use
*/
static void
-derive_pong_iv (struct GNUNET_CRYPTO_AesInitializationVector *iv,
- const struct GNUNET_CRYPTO_AesSessionKey *skey, uint32_t seed,
+derive_pong_iv (struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
+ const struct GNUNET_CRYPTO_SymmetricSessionKey *skey, uint32_t seed,
uint32_t challenge, const struct GNUNET_PeerIdentity *identity)
{
static const char ctx[] = "pong initialization vector";
- GNUNET_CRYPTO_aes_derive_iv (iv, skey, &seed, sizeof (seed),
- &identity->hashPubKey.bits,
- sizeof (identity->hashPubKey.bits), &challenge,
- sizeof (challenge), 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),
+ 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,
const struct GNUNET_PeerIdentity *receiver,
const struct GNUNET_HashCode *key_material,
- struct GNUNET_CRYPTO_AesSessionKey *skey)
+ struct GNUNET_CRYPTO_SymmetricSessionKey *skey)
{
static const char ctx[] = "aes key generation vector";
- GNUNET_CRYPTO_kdf (skey, sizeof (struct GNUNET_CRYPTO_AesSessionKey),
+ GNUNET_CRYPTO_kdf (skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
ctx, sizeof (ctx),
key_material, sizeof (struct GNUNET_HashCode),
sender, sizeof (struct GNUNET_PeerIdentity),
*/
static int
do_encrypt (struct GSC_KeyExchangeInfo *kx,
- const struct GNUNET_CRYPTO_AesInitializationVector *iv,
+ const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
const void *in, void *out, size_t size)
{
if (size != (uint16_t) size)
return GNUNET_NO;
}
GNUNET_assert (size ==
- GNUNET_CRYPTO_aes_encrypt (in, (uint16_t) size,
+ GNUNET_CRYPTO_symmetric_encrypt (in, (uint16_t) size,
&kx->encrypt_key, iv, out));
GNUNET_STATISTICS_update (GSC_stats, gettext_noop ("# bytes encrypted"), size,
GNUNET_NO);
* @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,
- const struct GNUNET_CRYPTO_AesInitializationVector *iv,
+ const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
const void *in, void *out, size_t size)
{
if (size != (uint16_t) size)
return GNUNET_SYSERR;
}
if (size !=
- GNUNET_CRYPTO_aes_decrypt (in, (uint16_t) size, &kx->decrypt_key, iv,
+ GNUNET_CRYPTO_symmetric_decrypt (in, (uint16_t) size, &kx->decrypt_key, iv,
out))
{
GNUNET_break (0);
{
struct PingMessage pp;
struct PingMessage *pm;
- struct GNUNET_CRYPTO_AesInitializationVector iv;
+ struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
pm = &kx->ping;
pm->header.size = htons (sizeof (struct PingMessage));
GSC_KX_start (const struct GNUNET_PeerIdentity *pid)
{
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_tail,
kx);
- if (0 < GNUNET_CRYPTO_hash_cmp (&pid->hashPubKey,
- &GSC_my_identity.hashPubKey))
+ GNUNET_CRYPTO_hash (pid, sizeof (struct GNUNET_PeerIdentity), &h1);
+ GNUNET_CRYPTO_hash (&GSC_my_identity, sizeof (struct GNUNET_PeerIdentity), &h2);
+
+ 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;
- struct GNUNET_PeerIdentity signer_id;
- 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"),
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Core service receives `%s' request from `%4s'.\n", "EPHEMERAL_KEY",
GNUNET_i2s (&kx->peer));
- GNUNET_CRYPTO_hash (&m->origin_public_key,
- sizeof (struct GNUNET_CRYPTO_EccPublicKey),
- &signer_id.hashPubKey);
if (0 !=
- memcmp (&signer_id, &kx->peer,
+ 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_EccPublicKey) +
- sizeof (struct GNUNET_CRYPTO_EccPublicKey)) ||
+ 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_public_key)))
+ &m->signature, &m->origin_identity.public_key)))
{
/* invalid signature */
GNUNET_break_op (0);
}
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);
struct PingMessage t;
struct PongMessage tx;
struct PongMessage tp;
- struct GNUNET_CRYPTO_AesInitializationVector iv;
+ struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
uint16_t msize;
msize = ntohs (msg->size);
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))
{
{
const struct PongMessage *m;
struct PongMessage t;
- struct GNUNET_CRYPTO_AesInitializationVector iv;
+ struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
uint16_t msize;
msize = ntohs (msg->size);
{
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 =
char cbuf[used]; /* ciphertext */
struct EncryptedMessage *em; /* encrypted message */
struct EncryptedMessage *ph; /* plaintext header */
- struct GNUNET_CRYPTO_AesInitializationVector iv;
+ struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
struct GNUNET_CRYPTO_AuthKey auth_key;
ph = (struct EncryptedMessage *) pbuf;
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);
struct GNUNET_HashCode ph;
uint32_t snum;
struct GNUNET_TIME_Absolute t;
- struct GNUNET_CRYPTO_AesInitializationVector iv;
+ struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
struct GNUNET_CRYPTO_AuthKey auth_key;
struct DeliverMessageContext dmc;
uint16_t size = ntohs (msg->size);
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_EccPublicKey) +
- sizeof (struct GNUNET_CRYPTO_EccPublicKey));
+ 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 (my_ephemeral_key,
- ¤t_ekm.ephemeral_key);
- current_ekm.origin_public_key = my_public_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 (my_private_key, &my_public_key);
- GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
- &GSC_my_identity.hashPubKey);
- 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
+ GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
+ &GSC_my_identity.public_key);
+ 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;
projects / oweals / gnunet.git / blobdiff