{
struct GNUNET_CRYPTO_EccSignature sig;
struct GNUNET_CRYPTO_EccSignaturePurpose purp;
- struct GNUNET_CRYPTO_EccPublicKey pkey;
+ struct GNUNET_CRYPTO_EccPublicSignKey pkey;
int i;
struct GNUNET_TIME_Absolute start;
int ok = GNUNET_OK;
FPRINTF (stderr, "%s", "W");
- GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
+ GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
start = GNUNET_TIME_absolute_get ();
purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
struct GNUNET_CRYPTO_EccSignature sig;
struct GNUNET_CRYPTO_EccSignaturePurpose purp;
struct GNUNET_CRYPTO_EccPrivateKey *dpriv;
- struct GNUNET_CRYPTO_EccPublicKey pkey;
- struct GNUNET_CRYPTO_EccPublicKey dpub;
+ struct GNUNET_CRYPTO_EccPublicSignKey pkey;
+ struct GNUNET_CRYPTO_EccPublicSignKey dpub;
- dpriv = GNUNET_CRYPTO_ecc_key_derive (key, "test-derive");
- GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
- GNUNET_CRYPTO_ecc_public_key_derive (&pkey, "test-derive", &dpub);
+ dpriv = GNUNET_CRYPTO_ecc_key_derive (key, "test-derive", "test-CTX");
+ GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
+ GNUNET_CRYPTO_ecc_public_key_derive (&pkey, "test-derive", "test-CTX", &dpub);
purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
if (GNUNET_SYSERR == GNUNET_CRYPTO_ecc_sign (dpriv, &purp, &sig))
{
FPRINTF (stderr, "%s", "GNUNET_CRYPTO_ecc_sign returned SYSERR\n");
- GNUNET_CRYPTO_ecc_key_free (dpriv);
+ GNUNET_free (dpriv);
return GNUNET_SYSERR;
}
if (GNUNET_SYSERR ==
- GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
+ GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
&purp, &sig,
&dpub))
{
printf ("GNUNET_CRYPTO_ecc_verify failed!\n");
- GNUNET_CRYPTO_ecc_key_free (dpriv);
+ GNUNET_free (dpriv);
return GNUNET_SYSERR;
}
if (GNUNET_SYSERR !=
- GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
+ GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
&purp, &sig,
&pkey))
{
printf ("GNUNET_CRYPTO_ecc_verify failed to fail!\n");
- GNUNET_CRYPTO_ecc_key_free (dpriv);
+ GNUNET_free (dpriv);
return GNUNET_SYSERR;
}
if (GNUNET_SYSERR !=
&purp, &sig, &dpub))
{
printf ("GNUNET_CRYPTO_ecc_verify failed to fail!\n");
- GNUNET_CRYPTO_ecc_key_free (dpriv);
+ GNUNET_free (dpriv);
return GNUNET_SYSERR;
}
- GNUNET_CRYPTO_ecc_key_free (dpriv);
+ GNUNET_free (dpriv);
return GNUNET_OK;
}
{
struct GNUNET_CRYPTO_EccSignaturePurpose purp;
struct GNUNET_CRYPTO_EccSignature sig;
- struct GNUNET_CRYPTO_EccPublicKey pkey;
+ struct GNUNET_CRYPTO_EccPublicSignKey pkey;
int i;
struct GNUNET_TIME_Absolute start;
int ok = GNUNET_OK;
purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
FPRINTF (stderr, "%s", "W");
- GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
+ GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
start = GNUNET_TIME_absolute_get ();
for (i = 0; i < ITER; i++)
{
continue;
}
}
- printf ("%d ECC sign operations %llu ms\n", ITER,
- (unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).rel_value);
+ printf ("%d ECC sign operations %s\n", ITER,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
+ GNUNET_YES));
return ok;
}
#endif
static int
testCreateFromFile ()
{
- struct GNUNET_CRYPTO_EccPublicKey p1;
- struct GNUNET_CRYPTO_EccPublicKey p2;
+ struct GNUNET_CRYPTO_EccPublicSignKey p1;
+ struct GNUNET_CRYPTO_EccPublicSignKey p2;
key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
- GNUNET_CRYPTO_ecc_key_get_public (key, &p1);
- GNUNET_CRYPTO_ecc_key_free (key);
+ GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p1);
+ GNUNET_free (key);
key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
- GNUNET_CRYPTO_ecc_key_get_public (key, &p2);
+ GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p2);
GNUNET_assert (0 == memcmp (&p1, &p2, sizeof (p1)));
- GNUNET_CRYPTO_ecc_key_free (key);
+ GNUNET_free (key);
GNUNET_assert (0 == UNLINK (KEYFILE));
key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
- GNUNET_CRYPTO_ecc_key_get_public (key, &p2);
+ GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p2);
GNUNET_assert (0 != memcmp (&p1, &p2, sizeof (p1)));
- GNUNET_CRYPTO_ecc_key_free (key);
+ GNUNET_free (key);
return GNUNET_OK;
}
{
struct GNUNET_CRYPTO_EccPrivateKey *priv1;
struct GNUNET_CRYPTO_EccPrivateKey *priv2;
- struct GNUNET_CRYPTO_EccPublicKey pub1;
- struct GNUNET_CRYPTO_EccPublicKey pub2;
+ struct GNUNET_CRYPTO_EccPublicEncryptKey pub1;
+ struct GNUNET_CRYPTO_EccPublicEncryptKey pub2;
struct GNUNET_HashCode ecdh1;
struct GNUNET_HashCode ecdh2;
priv1 = GNUNET_CRYPTO_ecc_key_create ();
priv2 = GNUNET_CRYPTO_ecc_key_create ();
- GNUNET_CRYPTO_ecc_key_get_public (priv1, &pub1);
- GNUNET_CRYPTO_ecc_key_get_public (priv2, &pub2);
+ GNUNET_CRYPTO_ecc_key_get_public_for_encryption (priv1, &pub1);
+ GNUNET_CRYPTO_ecc_key_get_public_for_encryption (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_CRYPTO_ecc_key_free (priv1);
- GNUNET_CRYPTO_ecc_key_free (priv2);
+ GNUNET_free (priv1);
+ GNUNET_free (priv2);
}
{
fprintf (stderr, ".");
pk = GNUNET_CRYPTO_ecc_key_create ();
- GNUNET_CRYPTO_ecc_key_free (pk);
+ GNUNET_free (pk);
}
fprintf (stderr, "\n");
printf ("Creating 10 ECC keys took %s\n",
#endif
if (GNUNET_OK != testSignVerify ())
failure_count++;
- GNUNET_CRYPTO_ecc_key_free (key);
+ GNUNET_free (key);
if (GNUNET_OK != testCreateFromFile ())
failure_count++;
GNUNET_assert (0 == UNLINK (KEYFILE));
if (0 != failure_count)
{
fprintf (stderr,
- "\n\n%d TESTS FAILED!\n\n",
+ "\n\n%d TESTS FAILED!\n\n",
failure_count);
return -1;
}