int main (int argc, char *argv[]) { struct GNUNET_CRYPTO_EcdhePrivateKey *priv1; struct GNUNET_CRYPTO_EcdhePrivateKey *priv2; struct GNUNET_CRYPTO_EcdhePublicKey pub1; struct GNUNET_CRYPTO_EcdhePublicKey pub2; struct GNUNET_HashCode ecdh1; struct GNUNET_HashCode ecdh2; if (! gcry_check_version ("1.6.0")) { FPRINTF (stderr, _ ("libgcrypt has not the expected version (version %s is required).\n"), "1.6.0"); return 0; } if (getenv ("GNUNET_GCRYPT_DEBUG")) gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0); GNUNET_log_setup ("test-crypto-ecdhe", "WARNING", NULL); priv1 = GNUNET_CRYPTO_ecdhe_key_create (); priv2 = GNUNET_CRYPTO_ecdhe_key_create (); GNUNET_CRYPTO_ecdhe_key_get_public (priv1, &pub1); GNUNET_CRYPTO_ecdhe_key_get_public (priv2, &pub2); GNUNET_CRYPTO_ecc_ecdh (priv1, &pub2, &ecdh1); GNUNET_CRYPTO_ecc_ecdh (priv2, &pub1, &ecdh2); GNUNET_assert (0 == memcmp (&ecdh1, &ecdh2, sizeof (struct GNUNET_HashCode))); GNUNET_free (priv1); GNUNET_free (priv2); return 0; }
static int test_ecdh() { struct GNUNET_CRYPTO_EddsaPrivateKey *priv_dsa; struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ecdh; struct GNUNET_CRYPTO_EddsaPublicKey id1; struct GNUNET_CRYPTO_EcdhePublicKey id2; struct GNUNET_HashCode dh[3]; /* Generate keys */ priv_dsa = GNUNET_CRYPTO_eddsa_key_create (); priv_ecdh = GNUNET_CRYPTO_ecdhe_key_create (); /* Extract public keys */ GNUNET_CRYPTO_eddsa_key_get_public (priv_dsa, &id1); GNUNET_CRYPTO_ecdhe_key_get_public (priv_ecdh, &id2); /* Do ECDH */ GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_ecdh (priv_dsa, &id2, &dh[0])); GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdh_eddsa (priv_ecdh, &id1, &dh[1])); /* Check that both DH results are equal. */ GNUNET_assert (0 == memcmp (&dh[0], &dh[1], sizeof (struct GNUNET_HashCode))); GNUNET_free (priv_dsa); GNUNET_free (priv_ecdh); return 0; }
/** * Sends an already built message on a tunnel, encrypting it and * choosing the best connection if not provided. * * @param message Message to send. Function modifies it. * @param t Tunnel on which this message is transmitted. * @param cont Continuation to call once message is really sent. * @param cont_cls Closure for @c cont. * @return Handle to cancel message. NULL if @c cont is NULL. */ struct CadetTunnelQueueEntry * GCT_send (struct CadetTunnel *t, const struct GNUNET_MessageHeader *message, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls) { struct CadetTunnelQueueEntry *tq; uint16_t payload_size; struct GNUNET_MQ_Envelope *env; struct GNUNET_CADET_Encrypted *ax_msg; /* FIXME: what about KX not yet being ready? (see "is_ready()" check in old code!) */ payload_size = ntohs (message->size); env = GNUNET_MQ_msg_extra (ax_msg, payload_size, GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED); t_ax_encrypt (t, &ax_msg[1], message, payload_size); ax_msg->Ns = htonl (t->ax.Ns++); ax_msg->PNs = htonl (t->ax.PNs); GNUNET_CRYPTO_ecdhe_key_get_public (t->ax.DHRs, &ax_msg->DHRs); t_h_encrypt (t, ax_msg); t_hmac (&ax_msg->Ns, AX_HEADER_SIZE + payload_size, 0, &t->ax.HKs, &ax_msg->hmac); // ax_msg->pid = htonl (GCC_get_pid (c, fwd)); // FIXME: connection flow-control not (re)implemented yet! tq = GNUNET_malloc (sizeof (*tq)); tq->t = t; tq->env = env; tq->cid = &ax_msg->cid; tq->cont = cont; tq->cont_cls = cont_cls; GNUNET_CONTAINER_DLL_insert_tail (t->tq_head, t->tq_tail, tq); trigger_transmissions (t); return tq; }
int main (int argc, char *argv[]) { int i; struct GNUNET_CRYPTO_EcdhePrivateKey *ecdhe[l]; struct GNUNET_CRYPTO_EcdhePublicKey dhpub[l]; struct GNUNET_CRYPTO_EddsaPrivateKey *eddsa[l]; struct GNUNET_CRYPTO_EddsaPublicKey dspub[l]; struct TestSig sig[l]; start = GNUNET_TIME_absolute_get(); for (i = 0; i < l; i++) { sig[i].purp.purpose = 0; sig[i].purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) + sizeof (struct GNUNET_HashCode)); GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &sig[i].h, sizeof (sig[i].h)); } log_duration ("", "Init"); start = GNUNET_TIME_absolute_get(); for (i = 0; i < l; i++) eddsa[i] = GNUNET_CRYPTO_eddsa_key_create(); log_duration ("EdDSA", "create key"); start = GNUNET_TIME_absolute_get(); for (i = 0; i < l; i++) GNUNET_CRYPTO_eddsa_key_get_public (eddsa[i], &dspub[i]); log_duration ("EdDSA", "get pubilc"); start = GNUNET_TIME_absolute_get(); for (i = 0; i < l; i++) GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (eddsa[i], &sig[i].purp, &sig[i].sig)); log_duration ("EdDSA", "sign HashCode"); start = GNUNET_TIME_absolute_get(); for (i = 0; i < l; i++) GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_verify (0, &sig[i].purp, &sig[i].sig, &dspub[i])); log_duration ("EdDSA", "verify HashCode"); start = GNUNET_TIME_absolute_get(); for (i = 0; i < l; i++) ecdhe[i] = GNUNET_CRYPTO_ecdhe_key_create(); log_duration ("ECDH", "create key"); start = GNUNET_TIME_absolute_get(); for (i = 0; i < l; i++) GNUNET_CRYPTO_ecdhe_key_get_public (ecdhe[i], &dhpub[i]); log_duration ("ECDH", "get public"); start = GNUNET_TIME_absolute_get(); for (i = 0; i < l - 1; i+=2) { GNUNET_CRYPTO_ecc_ecdh (ecdhe[i], &dhpub[i+1], &sig[i].h); GNUNET_CRYPTO_ecc_ecdh (ecdhe[i+1], &dhpub[i], &sig[i+1].h); } log_duration ("ECDH", "do DH"); return 0; }