Secret Sharing service

Verifiable additive secret sharing and cooperative decryption. More...

Data Structures
struct	GNUNET_SECRETSHARING_PublicKey
	Public key of a group sharing a secret. More...
struct	GNUNET_SECRETSHARING_Ciphertext
	Encrypted field element. More...
struct	GNUNET_SECRETSHARING_Plaintext
	Plain, unencrypted message that can be encrypted with a group public key. More...

Macros
#define	GNUNET_SECRETSHARING_ELGAMAL_BITS   1024
	Number of bits for secretsharing elements. More...
#define	GNUNET_SECRETSHARING_ELGAMAL_P_HEX
	The q-parameter for ElGamal encryption, a 1024-bit safe prime. More...
#define	GNUNET_SECRETSHARING_ELGAMAL_Q_HEX
	The q-parameter for ElGamal encryption, a 1023-bit Sophie Germain prime, q = (p-1)/2. More...
#define	GNUNET_SECRETSHARING_ELGAMAL_G_HEX
	The g-parameter for ElGamal encryption, a generator of the unique size q subgroup of Z_p^*. More...

Typedefs
typedef void(*	GNUNET_SECRETSHARING_SecretReadyCallback) (void *cls, struct GNUNET_SECRETSHARING_Share *my_share, struct GNUNET_SECRETSHARING_PublicKey *public_key, unsigned int num_ready_peers, const struct GNUNET_PeerIdentity *ready_peers)
	Called once the secret has been established with all peers, or the deadline is due. More...
typedef void(*	GNUNET_SECRETSHARING_DecryptCallback) (void *cls, const struct GNUNET_SECRETSHARING_Plaintext *plaintext)
	Called when a decryption has succeeded. More...

Functions
struct GNUNET_SECRETSHARING_Session *	GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int num_peers, const struct GNUNET_PeerIdentity *peers, const struct GNUNET_HashCode *session_id, struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute deadline, unsigned int threshold, GNUNET_SECRETSHARING_SecretReadyCallback cb, void *cls)
	Create a session that will eventually establish a shared secret with the other peers. More...
void	GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *s)
	Destroy a secret sharing session. More...
int	GNUNET_SECRETSHARING_encrypt (const struct GNUNET_SECRETSHARING_PublicKey *public_key, const struct GNUNET_SECRETSHARING_Plaintext *plaintext, struct GNUNET_SECRETSHARING_Ciphertext *result_ciphertext)
	Encrypt a value. More...
struct GNUNET_SECRETSHARING_DecryptionHandle *	GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SECRETSHARING_Share *share, const struct GNUNET_SECRETSHARING_Ciphertext *ciphertext, struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute deadline, GNUNET_SECRETSHARING_DecryptCallback decrypt_cb, void *decrypt_cb_cls)
	Publish the given ciphertext for decryption. More...
void	GNUNET_SECRETSHARING_decrypt_cancel (struct GNUNET_SECRETSHARING_DecryptionHandle *dh)
	Cancel a decryption. More...
struct GNUNET_SECRETSHARING_Share *	GNUNET_SECRETSHARING_share_read (const void *data, size_t len, size_t *readlen)
	Read a share from its binary representation. More...
int	GNUNET_SECRETSHARING_share_write (const struct GNUNET_SECRETSHARING_Share *share, void *buf, size_t buflen, size_t *writelen)
	Convert a share to its binary representation. More...
void	GNUNET_SECRETSHARING_share_destroy (struct GNUNET_SECRETSHARING_Share *share)
int	GNUNET_SECRETSHARING_plaintext_generate (struct GNUNET_SECRETSHARING_Plaintext *plaintext, gcry_mpi_t exponent)
int	GNUNET_SECRETSHARING_plaintext_generate_i (struct GNUNET_SECRETSHARING_Plaintext *plaintext, int64_t exponent)

Detailed Description

Verifiable additive secret sharing and cooperative decryption.

Macro Definition Documentation

GNUNET_SECRETSHARING_ELGAMAL_BITS

#define GNUNET_SECRETSHARING_ELGAMAL_BITS   1024

Number of bits for secretsharing elements.

Must be smaller than the Pallier key size used internally by the secretsharing service. When changing this value, other internal parameters must also be adjusted.

Definition at line 57 of file gnunet_secretsharing_service.h.

GNUNET_SECRETSHARING_ELGAMAL_P_HEX

#define GNUNET_SECRETSHARING_ELGAMAL_P_HEX

Value:

  "0x08a347d3d69e8b2dd7d1b12a08dfbccbebf4ca" \
  "6f4269a0814e158a34312964d946b3ef22882317" \
  "2bcf30fc08f772774cb404f9bc002a6f66b09a79" \
  "d810d67c4f8cb3bedc6060e3c8ef874b1b64df71" \
  "6c7d2b002da880e269438d5a776e6b5f253c8df5" \
  "6a16b1c7ce58def07c03db48238aadfc52a354a2" \
  "7ed285b0c1675cad3f3"

The q-parameter for ElGamal encryption, a 1024-bit safe prime.

Definition at line 63 of file gnunet_secretsharing_service.h.

GNUNET_SECRETSHARING_ELGAMAL_Q_HEX

#define GNUNET_SECRETSHARING_ELGAMAL_Q_HEX

Value:

  "0x0451a3e9eb4f4596ebe8d895046fde65f5fa65" \
  "37a134d040a70ac51a1894b26ca359f79144118b" \
  "95e7987e047bb93ba65a027cde001537b3584d3c" \
  "ec086b3e27c659df6e303071e477c3a58db26fb8" \
  "b63e958016d4407134a1c6ad3bb735af929e46fa" \
  "b50b58e3e72c6f783e01eda411c556fe2951aa51" \
  "3f6942d860b3ae569f9"

The q-parameter for ElGamal encryption, a 1023-bit Sophie Germain prime, q = (p-1)/2.

Definition at line 76 of file gnunet_secretsharing_service.h.

GNUNET_SECRETSHARING_ELGAMAL_G_HEX

#define GNUNET_SECRETSHARING_ELGAMAL_G_HEX

Value:

  "0x05c00c36d2e822950087ef09d8252994adc4e4" \
  "8fe3ec70269f035b46063aff0c99b633fd64df43" \
  "02442e1914c829a41505a275438871f365e91c12" \
  "3d5303ef9e90f4b8cb89bf86cc9b513e74a72634" \
  "9cfd9f953674fab5d511e1c078fc72d72b34086f" \
  "c82b4b951989eb85325cb203ff98df76bc366bba" \
  "1d7024c3650f60d0da"

The g-parameter for ElGamal encryption, a generator of the unique size q subgroup of Z_p^*.

Definition at line 89 of file gnunet_secretsharing_service.h.

Typedef Documentation

GNUNET_SECRETSHARING_SecretReadyCallback

typedef void(* GNUNET_SECRETSHARING_SecretReadyCallback) (void *cls, struct GNUNET_SECRETSHARING_Share *my_share, struct GNUNET_SECRETSHARING_PublicKey *public_key, unsigned int num_ready_peers, const struct GNUNET_PeerIdentity *ready_peers)

Called once the secret has been established with all peers, or the deadline is due.

Note that the number of peers can be smaller than 'k' (this threshold parameter), which makes the threshold crypto system useless. However, in this case one can still determine which peers were able to participate in the secret sharing successfully.

If the secret sharing failed, num_ready_peers is 0 and my_share and public_key is NULL.

After this callback has been called, the secretsharing session will be invalid.

Parameters

cls	closure
my_share	the share of this peer
public_key	public key of the session
num_ready_peers	number of peers in ready_peers
ready_peers	peers that successfully participated in establishing the shared secret

Definition at line 171 of file gnunet_secretsharing_service.h.

GNUNET_SECRETSHARING_DecryptCallback

typedef void(* GNUNET_SECRETSHARING_DecryptCallback) (void *cls, const struct GNUNET_SECRETSHARING_Plaintext *plaintext)

Called when a decryption has succeeded.

Parameters

cls	closure
data	decrypted value
data_size	number of bytes in data

Definition at line 190 of file gnunet_secretsharing_service.h.

Function Documentation

GNUNET_SECRETSHARING_create_session()

struct GNUNET_SECRETSHARING_Session * GNUNET_SECRETSHARING_create_session	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		unsigned int	num_peers,
		const struct GNUNET_PeerIdentity *	peers,
		const struct GNUNET_HashCode *	session_id,
		struct GNUNET_TIME_Absolute	start,
		struct GNUNET_TIME_Absolute	deadline,
		unsigned int	threshold,
		GNUNET_SECRETSHARING_SecretReadyCallback	cb,
		void *	cls
	)

Create a session that will eventually establish a shared secret with the other peers.

Parameters

cfg	configuration to use
num_peers	number of peers in peers
peers	array of peers that we will share secrets with, can optionally contain the local peer
session_id	unique session id
start	When should all peers be available for sharing the secret? Random number generation can take place before the start time.
deadline	point in time where the session must be established; taken as hint by underlying consensus sessions
threshold	minimum number of peers that must cooperate to decrypt a value
cb	called when the secret has been established
cls	closure for cb

Definition at line 244 of file secretsharing_api.c.

{
  struct GNUNET_SECRETSHARING_Session *s
    = GNUNET_new (struct GNUNET_SECRETSHARING_Session);
  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
    GNUNET_MQ_hd_var_size (secret_ready,
                           GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY,
                           struct GNUNET_SECRETSHARING_SecretReadyMessage,
                           s),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SECRETSHARING_CreateMessage *msg;
 
  s->mq = GNUNET_CLIENT_connect (cfg,
                                 "secretsharing",
                                 mq_handlers,
                                 &handle_session_client_error,
                                 s);
  if (NULL == s->mq)
  {
    /* secretsharing not configured correctly */
    GNUNET_break (0);
    GNUNET_free (s);
    return NULL;
  }
  s->secret_ready_cb = cb;
  s->secret_ready_cls = cls;
  ev = GNUNET_MQ_msg_extra (msg,
                            num_peers * sizeof(struct GNUNET_PeerIdentity),
                            GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_GENERATE);
 
  msg->threshold = htons (threshold);
  msg->num_peers = htons (num_peers);
  msg->session_id = *session_id;
  msg->start = GNUNET_TIME_absolute_hton (start);
  msg->deadline = GNUNET_TIME_absolute_hton (deadline);
  GNUNET_memcpy (&msg[1], peers, num_peers * sizeof(struct
                                                    GNUNET_PeerIdentity));
 
  GNUNET_MQ_send (s->mq, ev);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Secretsharing session created with %u peers\n",
       num_peers);
  return s;
}

References cfg, GNUNET_SECRETSHARING_CreateMessage::deadline, GNUNET_break, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_GENERATE, GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_TIME_absolute_hton(), handle_session_client_error(), LOG, GNUNET_SECRETSHARING_Session::mq, msg, num_peers, peers, GNUNET_SECRETSHARING_Session::secret_ready_cb, GNUNET_SECRETSHARING_Session::secret_ready_cls, GNUNET_SECRETSHARING_CreateMessage::session_id, start, and GNUNET_SECRETSHARING_CreateMessage::threshold.

Here is the call graph for this function:

GNUNET_SECRETSHARING_session_destroy()

void GNUNET_SECRETSHARING_session_destroy

(

struct GNUNET_SECRETSHARING_Session *

s

)

Destroy a secret sharing session.

The secret ready callback will not be called.

Parameters

s	session to destroy

Definition at line 219 of file secretsharing_api.c.

{
  GNUNET_MQ_destroy (s->mq);
  s->mq = NULL;
  GNUNET_free (s);
}

References GNUNET_free, GNUNET_MQ_destroy(), and GNUNET_SECRETSHARING_Session::mq.

Referenced by handle_secret_ready(), and handle_session_client_error().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SECRETSHARING_encrypt()

int GNUNET_SECRETSHARING_encrypt	(	const struct GNUNET_SECRETSHARING_PublicKey *	public_key,
		const struct GNUNET_SECRETSHARING_Plaintext *	plaintext,
		struct GNUNET_SECRETSHARING_Ciphertext *	result_ciphertext
	)

Encrypt a value.

This operation is executed locally, no communication is necessary.

This is a helper function, encryption can be done solely with a session's public key and the crypto system parameters.

Parameters

public_key	public key to use for decryption
message	message to encrypt
message_size	number of bytes in message
result_ciphertext	pointer to store the resulting ciphertext

Returns

GNUNET_YES on success, GNUNET_SYSERR if the message is invalid (invalid range)

Definition at line 422 of file secretsharing_api.c.

{
  /* pubkey */
  gcry_mpi_t h;
  /* nonce */
  gcry_mpi_t y;
  /* plaintext message */
  gcry_mpi_t m;
  /* temp value */
  gcry_mpi_t tmp;
 
  ensure_elgamal_initialized ();
 
  GNUNET_assert (NULL != (h = gcry_mpi_new (0)));
  GNUNET_assert (NULL != (y = gcry_mpi_new (0)));
  GNUNET_assert (NULL != (tmp = gcry_mpi_new (0)));
 
  GNUNET_CRYPTO_mpi_scan_unsigned (&h, public_key, sizeof *public_key);
  GNUNET_CRYPTO_mpi_scan_unsigned (&m, plaintext, sizeof *plaintext);
 
  // Randomize y such that 0 < y < elgamal_q.
  // The '- 1' is necessary as bitlength(q) = bitlength(p) - 1.
  do
  {
    gcry_mpi_randomize (y, GNUNET_SECRETSHARING_ELGAMAL_BITS - 1,
                        GCRY_WEAK_RANDOM);
  }
  while ((gcry_mpi_cmp_ui (y, 0) == 0) || (gcry_mpi_cmp (y, elgamal_q) >= 0));
 
  // tmp <- g^y
  gcry_mpi_powm (tmp, elgamal_g, y, elgamal_p);
  // write tmp to c1
  GNUNET_CRYPTO_mpi_print_unsigned (&result_ciphertext->c1_bits,
                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
 
  // tmp <- h^y
  gcry_mpi_powm (tmp, h, y, elgamal_p);
  // tmp <- tmp * m
  gcry_mpi_mulm (tmp, tmp, m, elgamal_p);
  // write tmp to c2
  GNUNET_CRYPTO_mpi_print_unsigned (&result_ciphertext->c2_bits,
                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
 
  return GNUNET_OK;
}

References GNUNET_SECRETSHARING_Ciphertext::c1_bits, GNUNET_SECRETSHARING_Ciphertext::c2_bits, elgamal_g, elgamal_p, elgamal_q, ensure_elgamal_initialized(), GNUNET_assert, GNUNET_CRYPTO_mpi_print_unsigned(), GNUNET_CRYPTO_mpi_scan_unsigned(), GNUNET_OK, GNUNET_SECRETSHARING_ELGAMAL_BITS, h, and m.

Here is the call graph for this function:

GNUNET_SECRETSHARING_decrypt()

struct GNUNET_SECRETSHARING_DecryptionHandle * GNUNET_SECRETSHARING_decrypt	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		struct GNUNET_SECRETSHARING_Share *	share,
		const struct GNUNET_SECRETSHARING_Ciphertext *	ciphertext,
		struct GNUNET_TIME_Absolute	start,
		struct GNUNET_TIME_Absolute	deadline,
		GNUNET_SECRETSHARING_DecryptCallback	decrypt_cb,
		void *	decrypt_cb_cls
	)

Publish the given ciphertext for decryption.

Once a sufficient (>=k) number of peers has published the same value, it will be decrypted.

When the operation is canceled, the decrypt_cb is not called anymore, but the calling peer may already have irrevocably contributed its share for the decryption of the value.

Parameters

cfg	configuration to use
share	our secret share to use for decryption
ciphertext	ciphertext to publish in order to decrypt it (if enough peers agree)
decrypt_cb	callback called once the decryption succeeded
start	By when should the cooperation for decryption start?
deadline	By when should the decryption be finished?
decrypt_cb_cls	closure for decrypt_cb

Returns

handle to cancel the operation

Definition at line 320 of file secretsharing_api.c.

{
  struct GNUNET_SECRETSHARING_DecryptionHandle *s
    = GNUNET_new (struct GNUNET_SECRETSHARING_DecryptionHandle);
  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
    GNUNET_MQ_hd_fixed_size (decrypt_done,
                             GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE,
                             struct GNUNET_SECRETSHARING_DecryptResponseMessage,
                             s),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SECRETSHARING_DecryptRequestMessage *msg;
  size_t share_size;
 
  s->decrypt_cb = decrypt_cb;
  s->decrypt_cls = decrypt_cb_cls;
  s->mq = GNUNET_CLIENT_connect (cfg,
                                 "secretsharing",
                                 mq_handlers,
                                 &handle_decrypt_client_error,
                                 s);
  if (NULL == s->mq)
  {
    GNUNET_free (s);
    return NULL;
  }
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_SECRETSHARING_share_write (share, NULL, 0,
                                                   &share_size));
 
  ev = GNUNET_MQ_msg_extra (msg,
                            share_size,
                            GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT);
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_SECRETSHARING_share_write (share,
                                                   &msg[1],
                                                   share_size,
                                                   NULL));
 
  msg->start = GNUNET_TIME_absolute_hton (start);
  msg->deadline = GNUNET_TIME_absolute_hton (deadline);
  msg->ciphertext = *ciphertext;
 
  GNUNET_MQ_send (s->mq, ev);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "decrypt session created\n");
  return s;
}

References cfg, GNUNET_SECRETSHARING_DecryptRequestMessage::ciphertext, GNUNET_SECRETSHARING_DecryptRequestMessage::deadline, GNUNET_SECRETSHARING_DecryptionHandle::decrypt_cb, GNUNET_SECRETSHARING_DecryptionHandle::decrypt_cls, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT, GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_OK, GNUNET_SECRETSHARING_share_write(), GNUNET_TIME_absolute_hton(), handle_decrypt_client_error(), LOG, GNUNET_SECRETSHARING_DecryptionHandle::mq, msg, and start.

Here is the call graph for this function:

GNUNET_SECRETSHARING_decrypt_cancel()

void GNUNET_SECRETSHARING_decrypt_cancel

(

struct GNUNET_SECRETSHARING_DecryptionHandle *

dh

)

Cancel a decryption.

The decrypt_cb is not called anymore, but the calling peer may already have irrevocably contributed its share for the decryption of the value.

Parameters

dh

to cancel

Definition at line 483 of file secretsharing_api.c.

{
  GNUNET_MQ_destroy (dh->mq);
  dh->mq = NULL;
  GNUNET_free (dh);
}

References GNUNET_free, GNUNET_MQ_destroy(), and GNUNET_SECRETSHARING_DecryptionHandle::mq.

Referenced by handle_decrypt_client_error(), and handle_decrypt_done().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SECRETSHARING_share_read()

struct GNUNET_SECRETSHARING_Share * GNUNET_SECRETSHARING_share_read	(	const void *	data,
		size_t	len,
		size_t *	readlen
	)

Read a share from its binary representation.

Parameters

	data	Binary representation of the share.
	len	Length of data.
[out]	readlen	Number of bytes read, ignored if NULL.

Returns

The share, or NULL on error.

Definition at line 34 of file secretsharing_common.c.

{
  struct GNUNET_SECRETSHARING_Share *share;
  const struct GNUNET_SECRETSHARING_ShareHeaderNBO *sh = data;
  const char *p;
  size_t n;
  uint16_t payload_size;
 
  payload_size = ntohs (sh->num_peers)
                 * (sizeof(uint16_t) + sizeof(struct
                                              GNUNET_SECRETSHARING_FieldElement)
                    + sizeof(struct GNUNET_PeerIdentity));
 
  if (NULL != readlen)
    *readlen = payload_size + sizeof *sh;
 
  share = GNUNET_new (struct GNUNET_SECRETSHARING_Share);
 
  share->threshold = ntohs (sh->threshold);
  share->num_peers = ntohs (sh->num_peers);
  share->my_peer = ntohs (sh->my_peer);
 
  share->my_share = sh->my_share;
  share->public_key = sh->public_key;
 
  p = (const char *) &sh[1];
 
  n = share->num_peers * sizeof(struct GNUNET_PeerIdentity);
  share->peers = GNUNET_new_array (share->num_peers,
                                   struct GNUNET_PeerIdentity);
  GNUNET_memcpy (share->peers, p, n);
  p += n;
 
  n = share->num_peers * sizeof(struct GNUNET_SECRETSHARING_FieldElement);
  share->sigmas = GNUNET_new_array (share->num_peers,
                                    struct GNUNET_SECRETSHARING_FieldElement);
  GNUNET_memcpy (share->sigmas, p, n);
  p += n;
 
  n = share->num_peers * sizeof(uint16_t);
  share->original_indices = GNUNET_new_array (share->num_peers,
                                              uint16_t);
  GNUNET_memcpy (share->original_indices, p, n);
 
  return share;
}

References data, GNUNET_memcpy, GNUNET_new, GNUNET_new_array, GNUNET_SECRETSHARING_Share::my_peer, GNUNET_SECRETSHARING_Share::my_share, GNUNET_SECRETSHARING_Share::num_peers, GNUNET_SECRETSHARING_Share::original_indices, p, GNUNET_SECRETSHARING_Share::peers, GNUNET_SECRETSHARING_Share::public_key, sh, GNUNET_SECRETSHARING_Share::sigmas, and GNUNET_SECRETSHARING_Share::threshold.

Referenced by handle_client_decrypt(), and handle_secret_ready().

Here is the caller graph for this function:

GNUNET_SECRETSHARING_share_write()

int GNUNET_SECRETSHARING_share_write	(	const struct GNUNET_SECRETSHARING_Share *	share,
		void *	buf,
		size_t	buflen,
		size_t *	writelen
	)

Convert a share to its binary representation.

Can be called with a NULL buf to get the size of the share.

Parameters

	share	Share to write.
	buf	Buffer to write to.
	buflen	Number of writable bytes in buf.
[out]	writelen	Pointer to store number of bytes written, ignored if NULL.

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure.

Definition at line 96 of file secretsharing_common.c.

{
  uint16_t payload_size;
  struct GNUNET_SECRETSHARING_ShareHeaderNBO *sh;
  char *p;
  int n;
 
  payload_size = share->num_peers
                 * (sizeof(uint16_t) + sizeof(struct
                                              GNUNET_SECRETSHARING_FieldElement)
                    + sizeof(struct GNUNET_PeerIdentity));
 
  if (NULL != writelen)
    *writelen = payload_size + sizeof(struct
                                      GNUNET_SECRETSHARING_ShareHeaderNBO);
 
  /* just a query for the writelen */
  if (buf == NULL)
    return GNUNET_OK;
 
  /* wrong buffer size */
  if (buflen < payload_size + sizeof(struct
                                     GNUNET_SECRETSHARING_ShareHeaderNBO))
    return GNUNET_SYSERR;
 
  sh = buf;
 
  sh->threshold = htons (share->threshold);
  sh->num_peers = htons (share->num_peers);
  sh->my_peer = htons (share->my_peer);
 
  sh->my_share = share->my_share;
  sh->public_key = share->public_key;
 
  p = (void *) &sh[1];
 
  n = share->num_peers * sizeof(struct GNUNET_PeerIdentity);
  GNUNET_memcpy (p, share->peers, n);
  p += n;
 
  n = share->num_peers * sizeof(struct GNUNET_SECRETSHARING_FieldElement);
  GNUNET_memcpy (p, share->sigmas, n);
  p += n;
 
  n = share->num_peers * sizeof(uint16_t);
  GNUNET_memcpy (p, share->original_indices, n);
 
  return GNUNET_OK;
}

References GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, GNUNET_SECRETSHARING_Share::my_peer, GNUNET_SECRETSHARING_Share::my_share, GNUNET_SECRETSHARING_Share::num_peers, GNUNET_SECRETSHARING_Share::original_indices, p, GNUNET_SECRETSHARING_Share::peers, GNUNET_SECRETSHARING_Share::public_key, sh, GNUNET_SECRETSHARING_Share::sigmas, and GNUNET_SECRETSHARING_Share::threshold.

Referenced by GNUNET_SECRETSHARING_decrypt(), and keygen_round2_conclude().

Here is the caller graph for this function:

GNUNET_SECRETSHARING_share_destroy()

void GNUNET_SECRETSHARING_share_destroy

(

struct GNUNET_SECRETSHARING_Share *

share

)

Definition at line 150 of file secretsharing_common.c.

{
  GNUNET_free (share->original_indices);
  share->original_indices = NULL;
  GNUNET_free (share->sigmas);
  share->sigmas = NULL;
  GNUNET_free (share->peers);
  share->peers = NULL;
  GNUNET_free (share);
}

References GNUNET_free, GNUNET_SECRETSHARING_Share::original_indices, GNUNET_SECRETSHARING_Share::peers, and GNUNET_SECRETSHARING_Share::sigmas.

Referenced by decrypt_session_destroy(), and keygen_round2_conclude().

Here is the caller graph for this function:

GNUNET_SECRETSHARING_plaintext_generate()

int GNUNET_SECRETSHARING_plaintext_generate	(	struct GNUNET_SECRETSHARING_Plaintext *	plaintext,
		gcry_mpi_t	exponent
	)

GNUNET_SECRETSHARING_plaintext_generate_i()

int GNUNET_SECRETSHARING_plaintext_generate_i	(	struct GNUNET_SECRETSHARING_Plaintext *	plaintext,
		int64_t	exponent
	)

Definition at line 381 of file secretsharing_api.c.

{
  int negative;
  gcry_mpi_t x;
 
  ensure_elgamal_initialized ();
 
  GNUNET_assert (NULL != (x = gcry_mpi_new (0)));
 
  negative = GNUNET_NO;
  if (exponent < 0)
  {
    negative = GNUNET_YES;
    exponent = -exponent;
  }
 
  gcry_mpi_set_ui (x, exponent);
 
  gcry_mpi_powm (x, elgamal_g, x, elgamal_p);
 
  if (GNUNET_YES == negative)
  {
    int res;
    res = gcry_mpi_invm (x, x, elgamal_p);
    if (0 == res)
      return GNUNET_SYSERR;
  }
 
  GNUNET_CRYPTO_mpi_print_unsigned (plaintext,
                                    sizeof(struct
                                           GNUNET_SECRETSHARING_Plaintext),
                                    x);
 
  return GNUNET_OK;
}

References elgamal_g, elgamal_p, ensure_elgamal_initialized(), GNUNET_assert, GNUNET_CRYPTO_mpi_print_unsigned(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, and res.

Here is the call graph for this function: