/**
* Convert short hash to ASCII encoding.
*
* @param block the hash code
* @param result where to store the encoding (struct GNUNET_CRYPTO_ShortHashAsciiEncoded can be
* safely cast to char*, a '\\0' termination is set).
*/
void
GNUNET_CRYPTO_short_hash_to_enc (const struct GNUNET_CRYPTO_ShortHashCode * block,
struct GNUNET_CRYPTO_ShortHashAsciiEncoded *result)
{
char *np;
np = GNUNET_STRINGS_data_to_string ((const unsigned char *) block,
sizeof (struct GNUNET_CRYPTO_ShortHashCode),
(char*) result,
sizeof (struct GNUNET_CRYPTO_ShortHashAsciiEncoded) - 1);
GNUNET_assert (NULL != np);
*np = '\0';
}
static void
secret_ready_cb (void *cls,
struct GNUNET_SECRETSHARING_Share *my_share,
struct GNUNET_SECRETSHARING_PublicKey *public_key,
unsigned int num_ready_peers,
struct GNUNET_PeerIdentity *ready_peers)
{
struct GNUNET_SECRETSHARING_Session **sp = cls;
unsigned int n = sp - session_handles;
char pubkey_str[1024];
char *ret;
num_generated++;
*sp = NULL;
shares[n] = my_share;
if (NULL == my_share)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "key generation failed for peer #%u\n", n);
}
else
{
ret = GNUNET_STRINGS_data_to_string (public_key, sizeof *public_key, pubkey_str, 1024);
GNUNET_assert (NULL != ret);
*ret = '\0';
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "key generation successful for peer #%u, pubkey %s\n", n,
pubkey_str);
/* we're the first to get the key -> store it */
if (num_generated == 1)
{
common_pubkey = *public_key;
}
else if (0 != memcmp (public_key, &common_pubkey, sizeof (struct GNUNET_SECRETSHARING_PublicKey)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "generated public keys do not match\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
}
// we should still be connected
GNUNET_assert (NULL != connect_ops[n]);
// disconnect from the service, will call the disconnect callback
GNUNET_TESTBED_operation_done (connect_ops[n]);
}
/**
* Convert a zone key to a string (for printing debug messages).
* This is one of the very few calls in the entire API that is
* NOT reentrant!
*
* @param z the zone key
* @return string form; will be overwritten by next call to #GNUNET_GNSRECORD_z2s
*/
const char *
GNUNET_GNSRECORD_z2s (const struct GNUNET_CRYPTO_EcdsaPublicKey *z)
{
static char buf[sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) * 8];
char *end;
end = GNUNET_STRINGS_data_to_string ((const unsigned char *) z,
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
buf, sizeof (buf));
if (NULL == end)
{
GNUNET_break (0);
return NULL;
}
*end = '\0';
return buf;
}
static void
publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
{
char *msg;
struct GNUNET_FS_Uri *sks_uri;
char sbuf[1024];
char buf[1024];
char *ret;
if (NULL != emsg)
{
FPRINTF (stderr, "Error publishing: %s\n", emsg);
err = 1;
GNUNET_FS_stop (fs);
return;
}
ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof (nsid), buf, sizeof (buf));
GNUNET_assert (NULL != ret);
ret[0] = '\0';
GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", buf);
sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
if (NULL == sks_uri)
{
FPRINTF (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
err = 1;
GNUNET_FS_stop (fs);
GNUNET_free_non_null (msg);
return;
}
ksk_search =
GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
"ksk_search");
sks_search =
GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
"sks_search");
GNUNET_FS_uri_destroy (sks_uri);
}
static int
testNamespace (int i)
{
char *uri;
struct GNUNET_FS_Uri *ret;
char *emsg;
struct GNUNET_CRYPTO_EcdsaPrivateKey *ph;
struct GNUNET_CRYPTO_EcdsaPublicKey id;
char buf[1024];
char ubuf[1024];
char *sret;
if (NULL !=
(ret =
GNUNET_FS_uri_parse ("gnunet://fs/sks/D1KJS9H2A82Q65VKQ0ML3RFU6U1D3VUK",
&emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
if (NULL !=
(ret =
GNUNET_FS_uri_parse
("gnunet://fs/sks/XQHH4R288W26EBV369F6RCE0PJVJTX2Y74Q2FJPMPGA31HJX2JG/this", &emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
if (NULL != (ret = GNUNET_FS_uri_parse ("gnunet://fs/sks/test", &emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
ph = GNUNET_CRYPTO_ecdsa_key_create ();
GNUNET_CRYPTO_ecdsa_key_get_public (ph, &id);
sret = GNUNET_STRINGS_data_to_string (&id, sizeof (id),
ubuf, sizeof (ubuf) - 1);
GNUNET_assert (NULL != sret);
sret[0] = '\0';
GNUNET_snprintf (buf, sizeof (buf),
"gnunet://fs/sks/%s/test",
ubuf);
ret = GNUNET_FS_uri_parse (buf, &emsg);
if (NULL == ret)
{
GNUNET_free (emsg);
GNUNET_assert (0);
}
if (GNUNET_FS_uri_test_ksk (ret))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
if (!GNUNET_FS_uri_test_sks (ret))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
uri = GNUNET_FS_uri_to_string (ret);
if (0 !=
strcmp (uri,
buf))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_free (uri);
GNUNET_assert (0);
}
GNUNET_free (uri);
GNUNET_FS_uri_destroy (ret);
return 0;
}
static void
secret_ready_cb (void *cls,
struct GNUNET_SECRETSHARING_Share *my_share,
struct GNUNET_SECRETSHARING_PublicKey *public_key,
unsigned int num_ready_peers,
struct GNUNET_PeerIdentity *ready_peers)
{
struct GNUNET_SECRETSHARING_Session **sp = cls;
unsigned int n = sp - session_handles;
char pubkey_str[1024];
char *ret;
num_generated++;
*sp = NULL;
shares[n] = my_share;
if (NULL == my_share)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "key generation failed for peer #%u\n", n);
}
else
{
ret = GNUNET_STRINGS_data_to_string (public_key, sizeof *public_key, pubkey_str, 1024);
GNUNET_assert (NULL != ret);
*ret = '\0';
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "key generation successful for peer #%u, pubkey %s\n", n,
pubkey_str);
/* we're the first to get the key -> store it */
if (num_generated == 1)
{
common_pubkey = *public_key;
}
else if (0 != memcmp (public_key, &common_pubkey, sizeof (struct GNUNET_SECRETSHARING_PublicKey)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "generated public keys do not match\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
}
// FIXME: destroy testbed operation
if (num_generated == num_peers)
{
int i;
if (GNUNET_NO == decrypt)
{
GNUNET_SCHEDULER_shutdown ();
return;
}
decrypt_start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
decrypt_deadline = GNUNET_TIME_absolute_add (decrypt_start, timeout);
// compute g^42
GNUNET_SECRETSHARING_plaintext_generate_i (&reference_plaintext, 42);
GNUNET_SECRETSHARING_encrypt (&common_pubkey, &reference_plaintext, &ciphertext);
// FIXME: store the ops somewhere!
for (i = 0; i < num_peers; i++)
GNUNET_TESTBED_service_connect (NULL, peers[i], "secretsharing", &decrypt_connect_complete, NULL,
&decrypt_connect_adapter, &decrypt_disconnect_adapter, &decrypt_handles[i]);
}
}
