Identity service

Identity management. More...

Collaboration diagram for Identity service:

Data Structures
struct	GNUNET_IDENTITY_PrivateKey
	A private key for an identity as per LSD0001. More...
struct	GNUNET_IDENTITY_PublicKey
	An identity key as per LSD0001. More...
struct	GNUNET_IDENTITY_Signature
	An identity signature as per LSD0001. More...

Macros
#define	GNUNET_IDENTITY_VERSION   0x00000100
	Version number of GNUnet Identity API. More...
#define	GNUNET_IDENTITY_sign(priv, ps, sig)
	Sign a given block with GNUNET_IDENTITY_PrivateKey. More...
#define	GNUNET_IDENTITY_signature_verify(purp, ps, sig, pub)
	Verify a given signature with GNUNET_IDENTITY_PublicKey. More...
#define	GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES

Typedefs
typedef void(*	GNUNET_IDENTITY_Callback) (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
	Method called to inform about the egos of this peer. More...
typedef void(*	GNUNET_IDENTITY_Continuation) (void *cls, enum GNUNET_ErrorCode ec)
	Function called once the requested operation has been completed. More...
typedef void(*	GNUNET_IDENTITY_CreateContinuation) (void *cls, const struct GNUNET_IDENTITY_PrivateKey *pk, enum GNUNET_ErrorCode ec)
	Function called once the requested operation has been completed. More...
typedef void(*	GNUNET_IDENTITY_EgoCallback) (void *cls, struct GNUNET_IDENTITY_Ego *ego)
	Function called with the result. More...
typedef void(*	GNUNET_IDENTITY_EgoSuffixCallback) (void *cls, const struct GNUNET_IDENTITY_PrivateKey *priv, const char *ego_name)
	Function called with the result. More...

Enumerations
enum	GNUNET_IDENTITY_KeyType { GNUNET_IDENTITY_TYPE_ECDSA = 65536 , GNUNET_IDENTITY_TYPE_EDDSA = 65556 }

Functions
const struct GNUNET_IDENTITY_PrivateKey *	GNUNET_IDENTITY_ego_get_private_key (const struct GNUNET_IDENTITY_Ego *ego)
	Obtain the ECC key associated with a ego. More...
struct GNUNET_IDENTITY_Ego *	GNUNET_IDENTITY_ego_get_anonymous (void)
	Obtain the ego representing 'anonymous' users. More...
void	GNUNET_IDENTITY_ego_get_public_key (struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_IDENTITY_PublicKey *pk)
	Get the identifier (public key) of an ego. More...
struct GNUNET_IDENTITY_Handle *	GNUNET_IDENTITY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
	Connect to the identity service. More...
struct GNUNET_IDENTITY_Operation *	GNUNET_IDENTITY_get (struct GNUNET_IDENTITY_Handle *id, const char *service_name, GNUNET_IDENTITY_Callback cb, void *cb_cls)
	Obtain the ego that is currently preferred/default for a service. More...
struct GNUNET_IDENTITY_Operation *	GNUNET_IDENTITY_set (struct GNUNET_IDENTITY_Handle *id, const char *service_name, struct GNUNET_IDENTITY_Ego *ego, GNUNET_IDENTITY_Continuation cont, void *cont_cls)
	Set the preferred/default ego for a service. More...
void	GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h)
	Disconnect from identity service. More...
struct GNUNET_IDENTITY_Operation *	GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *id, const char *name, const struct GNUNET_IDENTITY_PrivateKey *privkey, enum GNUNET_IDENTITY_KeyType ktype, GNUNET_IDENTITY_CreateContinuation cont, void *cont_cls)
	Create a new ego with the given name. More...
struct GNUNET_IDENTITY_Operation *	GNUNET_IDENTITY_rename (struct GNUNET_IDENTITY_Handle *id, const char *old_name, const char *new_name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
	Renames an existing ego. More...
struct GNUNET_IDENTITY_Operation *	GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *id, const char *name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
	Delete an existing ego. More...
void	GNUNET_IDENTITY_cancel (struct GNUNET_IDENTITY_Operation *op)
	Cancel an identity operation. More...
ssize_t	GNUNET_IDENTITY_public_key_get_length (const struct GNUNET_IDENTITY_PublicKey *key)
	Get the compacted length of a GNUNET_IDENTITY_PublicKey. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_read_public_key_from_buffer (const void *buffer, size_t len, struct GNUNET_IDENTITY_PublicKey *key, size_t *read)
	Reads a GNUNET_IDENTITY_PublicKey from a compact buffer. More...
ssize_t	GNUNET_IDENTITY_private_key_get_length (const struct GNUNET_IDENTITY_PrivateKey *key)
	Get the compacted length of a GNUNET_IDENTITY_PrivateKey. More...
ssize_t	GNUNET_IDENTITY_write_public_key_to_buffer (const struct GNUNET_IDENTITY_PublicKey *key, void *buffer, size_t len)
	Writes a GNUNET_IDENTITY_PublicKey to a compact buffer. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_read_private_key_from_buffer (const void *buffer, size_t len, struct GNUNET_IDENTITY_PrivateKey *key, size_t *read)
	Reads a GNUNET_IDENTITY_PrivateKey from a compact buffer. More...
ssize_t	GNUNET_IDENTITY_write_private_key_to_buffer (const struct GNUNET_IDENTITY_PrivateKey *key, void *buffer, size_t len)
	Writes a GNUNET_IDENTITY_PrivateKey to a compact buffer. More...
ssize_t	GNUNET_IDENTITY_signature_get_length (const struct GNUNET_IDENTITY_Signature *sig)
	Get the compacted length of a GNUNET_IDENTITY_Signature. More...
ssize_t	GNUNET_IDENTITY_signature_get_raw_length_by_type (uint32_t type)
	Get the compacted length of a signature by type. More...
ssize_t	GNUNET_IDENTITY_read_signature_from_buffer (struct GNUNET_IDENTITY_Signature *sig, const void *buffer, size_t len)
	Reads a GNUNET_IDENTITY_Signature from a compact buffer. More...
ssize_t	GNUNET_IDENTITY_write_signature_to_buffer (const struct GNUNET_IDENTITY_Signature *sig, void *buffer, size_t len)
	Writes a GNUNET_IDENTITY_Signature to a compact buffer. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_sign_ (const struct GNUNET_IDENTITY_PrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_IDENTITY_Signature *sig)
	Sign a given block. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_sign_raw_ (const struct GNUNET_IDENTITY_PrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, unsigned char *sig)
	Sign a given block. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_signature_verify_ (uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_IDENTITY_Signature *sig, const struct GNUNET_IDENTITY_PublicKey *pub)
	Verify a given signature. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_signature_verify_raw_ (uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const unsigned char *sig, const struct GNUNET_IDENTITY_PublicKey *pub)
	Verify a given signature. More...
ssize_t	GNUNET_IDENTITY_encrypt_old (const void *block, size_t size, const struct GNUNET_IDENTITY_PublicKey *pub, struct GNUNET_CRYPTO_EcdhePublicKey *ecc, void *result)
	Encrypt a block with GNUNET_IDENTITY_PublicKey and derives a GNUNET_CRYPTO_EcdhePublicKey which is required for decryption using ecdh to derive a symmetric key. More...
ssize_t	GNUNET_IDENTITY_decrypt_old (const void *block, size_t size, const struct GNUNET_IDENTITY_PrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *ecc, void *result)
	Decrypt a given block with GNUNET_IDENTITY_PrivateKey and a given GNUNET_CRYPTO_EcdhePublicKey using ecdh to derive a symmetric key. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_encrypt (const void *block, size_t size, const struct GNUNET_IDENTITY_PublicKey *pub, void *result, size_t result_size)
	Encrypt a block with GNUNET_IDENTITY_PublicKey and derives a GNUNET_CRYPTO_EcdhePublicKey which is required for decryption using ecdh to derive a symmetric key. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_decrypt (const void *block, size_t size, const struct GNUNET_IDENTITY_PrivateKey *priv, void *result, size_t result_size)
	Decrypt a given block with GNUNET_IDENTITY_PrivateKey and a given GNUNET_CRYPTO_EcdhePublicKey using ecdh to derive a symmetric key. More...
char *	GNUNET_IDENTITY_public_key_to_string (const struct GNUNET_IDENTITY_PublicKey *key)
	Creates a (Base32) string representation of the public key. More...
char *	GNUNET_IDENTITY_private_key_to_string (const struct GNUNET_IDENTITY_PrivateKey *key)
	Creates a (Base32) string representation of the private key. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_public_key_from_string (const char *str, struct GNUNET_IDENTITY_PublicKey *key)
	Parses a (Base32) string representation of the public key. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_private_key_from_string (const char *str, struct GNUNET_IDENTITY_PrivateKey *key)
	Parses a (Base32) string representation of the private key. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_key_get_public (const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
	Retrieves the public key representation of a private key. More...
struct GNUNET_IDENTITY_EgoLookup *	GNUNET_IDENTITY_ego_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_IDENTITY_EgoCallback cb, void *cb_cls)
	Lookup an ego by name. More...
void	GNUNET_IDENTITY_ego_lookup_cancel (struct GNUNET_IDENTITY_EgoLookup *el)
	Abort ego lookup attempt. More...
struct GNUNET_IDENTITY_EgoSuffixLookup *	GNUNET_IDENTITY_ego_lookup_by_suffix (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *suffix, GNUNET_IDENTITY_EgoSuffixCallback cb, void *cb_cls)
	Obtain the ego with the maximum suffix match between the ego's name and the given domain name suffix. More...
void	GNUNET_IDENTITY_ego_lookup_by_suffix_cancel (struct GNUNET_IDENTITY_EgoSuffixLookup *el)
	Abort ego suffix lookup attempt. More...

Detailed Description

Identity management.

Egos in GNUnet are ECDSA keys. You assume an ego by using (signing with) a particular private key. As GNUnet users are expected to have many egos, we need an identity service to allow users to manage their egos. The identity service manages the egos (private keys) of the local user; it does NOT manage egos of other users (public keys). For giving names to other users and manage their public keys securely, we use GNS.

See also

Documentation

Macro Definition Documentation

GNUNET_IDENTITY_VERSION

#define GNUNET_IDENTITY_VERSION   0x00000100

Version number of GNUnet Identity API.

Definition at line 63 of file gnunet_identity_service.h.

GNUNET_IDENTITY_sign

#define GNUNET_IDENTITY_sign	(		priv,
			ps,
			sig
	)

Value:

          do {                \
          /* check size is set correctly */                                     \
          GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps)));         \
          /* check 'ps' begins with the purpose */                              \
          GNUNET_static_assert (((void*) (ps)) ==                               \
                                ((void*) &(ps)->purpose));                      \
          GNUNET_assert (GNUNET_OK ==                                           \
                         GNUNET_IDENTITY_sign_ (priv,               \
                                                &(ps)->purpose,             \
                                                sig));                      \
} while (0)

Sign a given block with GNUNET_IDENTITY_PrivateKey.

The ps data must be a fixed-size struct for which the signature is to be created. The size field in ps->purpose must correctly indicate the number of bytes of the data structure, including its header.

Parameters

	priv	private key to use for the signing
	ps	packed struct with what to sign, MUST begin with a purpose
[out]	sig	where to write the signature

Definition at line 623 of file gnunet_identity_service.h.

GNUNET_IDENTITY_signature_verify

#define GNUNET_IDENTITY_signature_verify	(		purp,
			ps,
			sig,
			pub
	)

Value:

    ({             \
    /* check size is set correctly */                                     \
    GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps)));         \
    /* check 'ps' begins with the purpose */                              \
    GNUNET_static_assert (((void*) (ps)) ==                               \
                          ((void*) &(ps)->purpose));                      \
    GNUNET_IDENTITY_signature_verify_ (purp,                              \
                                       &(ps)->purpose,                    \
                                       sig,                               \
                                       pub);                              \
  })

Verify a given signature with GNUNET_IDENTITY_PublicKey.

The ps data must be a fixed-size struct for which the signature is to be created. The size field in ps->purpose must correctly indicate the number of bytes of the data structure, including its header.

Parameters

purp	purpose of the signature, must match 'ps->purpose.purpose' (except in host byte order)
ps	packed struct with what to sign, MUST begin with a purpose
sig	where to read the signature from
pub	public key to use for the verifying

Definition at line 696 of file gnunet_identity_service.h.

GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES

#define GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES

Value:

                                                (crypto_secretbox_MACBYTES \
                                                + sizeof (struct \
                                                          GNUNET_CRYPTO_FoKemC))

Definition at line 754 of file gnunet_identity_service.h.

Typedef Documentation

GNUNET_IDENTITY_Callback

typedef void(* GNUNET_IDENTITY_Callback) (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)

Method called to inform about the egos of this peer.

When used with GNUNET_IDENTITY_connect, this function is initially called for all egos and then again whenever a ego's name changes or if it is deleted. At the end of the initial pass over all egos, the function is once called with 'NULL' for ego. That does NOT mean that the callback won't be invoked in the future or that there was an error.

When used with GNUNET_IDENTITY_create or GNUNET_IDENTITY_get, this function is only called ONCE, and 'NULL' being passed in ego does indicate an error (for example because name is taken or no default value is known). If ego is non-NULL and if '*ctx' is set in those callbacks, the value WILL be passed to a subsequent call to the identity callback of GNUNET_IDENTITY_connect (if that one was not NULL).

When an identity is renamed, this function is called with the (known) ego but the NEW name.

When an identity is deleted, this function is called with the (known) ego and "NULL" for the name. In this case, the ego is henceforth invalid (and the ctx should also be cleaned up).

Parameters

cls	closure
ego	ego handle
ctx	context for application to store data for this ego (during the lifetime of this process, initially NULL)
name	name assigned by the user for this ego, NULL if the user just deleted the ego and it must thus no longer be used

Definition at line 242 of file gnunet_identity_service.h.

GNUNET_IDENTITY_Continuation

typedef void(* GNUNET_IDENTITY_Continuation) (void *cls, enum GNUNET_ErrorCode ec)

Function called once the requested operation has been completed.

Parameters

cls	closure
ec	the GNUNET_ErrorCode

Definition at line 286 of file gnunet_identity_service.h.

GNUNET_IDENTITY_CreateContinuation

typedef void(* GNUNET_IDENTITY_CreateContinuation) (void *cls, const struct GNUNET_IDENTITY_PrivateKey *pk, enum GNUNET_ErrorCode ec)

Function called once the requested operation has been completed.

Parameters

cls	closure
pk	private key, NULL on error
ec	the GNUNET_ErrorCode

Definition at line 326 of file gnunet_identity_service.h.

GNUNET_IDENTITY_EgoCallback

typedef void(* GNUNET_IDENTITY_EgoCallback) (void *cls, struct GNUNET_IDENTITY_Ego *ego)

Function called with the result.

Parameters

cls	closure
ego	NULL on error / ego not found

Definition at line 873 of file gnunet_identity_service.h.

GNUNET_IDENTITY_EgoSuffixCallback

typedef void(* GNUNET_IDENTITY_EgoSuffixCallback) (void *cls, const struct GNUNET_IDENTITY_PrivateKey *priv, const char *ego_name)

Function called with the result.

Parameters

cls	closure
ego	NULL on error / ego not found
ego_name	NULL on error, name of the ego otherwise

Definition at line 914 of file gnunet_identity_service.h.

Enumeration Type Documentation

GNUNET_IDENTITY_KeyType

enum GNUNET_IDENTITY_KeyType

Enumerator
GNUNET_IDENTITY_TYPE_ECDSA	The identity type. The value is the same as the PKEY record type.
GNUNET_IDENTITY_TYPE_EDDSA	EDDSA identity. The value is the same as the EDKEY record type.

Definition at line 65 of file gnunet_identity_service.h.

{
  GNUNET_IDENTITY_TYPE_ECDSA = 65536,
 
  GNUNET_IDENTITY_TYPE_EDDSA = 65556
};

Function Documentation

GNUNET_IDENTITY_ego_get_private_key()

const struct GNUNET_IDENTITY_PrivateKey* GNUNET_IDENTITY_ego_get_private_key

(

const struct GNUNET_IDENTITY_Ego *

ego

)

Obtain the ECC key associated with a ego.

Parameters

ego

the ego

Returns

associated ECC key, valid as long as the ego is valid

Definition at line 560 of file identity_api.c.

{
  return &ego->pk;
}

References GNUNET_IDENTITY_Ego::pk.

Referenced by add_attribute_cont(), add_credential_cont(), authorize_endpoint(), callback_ego_lookup(), callback_update_ego(), code_redirect(), collect_orphans(), consume_ticket_cont(), delete_attribute_cont(), delete_credential_cont(), directory_trim_complete(), display_record(), ego_callback(), ego_cb(), ego_get_all(), ego_get_response(), get_ego(), get_identity_for_string(), get_srv_handle_ego(), GNUNET_CONVERSATION_phone_create(), handle_gns_response(), id_connect_cb(), identity_cb(), list_attribute_cont(), list_credential_cont(), list_tickets_cont(), namestore_add_or_update(), namestore_delete(), namestore_get(), namestore_import(), origin_lookup_cb(), print_ego(), read_encrypted_message(), remove_did_document_ego_lookup_cb(), revoke_ticket_cont(), sign_cb(), store_cb(), uri_ksk_continuation(), and userinfo_endpoint().

Here is the caller graph for this function:

GNUNET_IDENTITY_ego_get_anonymous()

struct GNUNET_IDENTITY_Ego* GNUNET_IDENTITY_ego_get_anonymous

(

void

)

Obtain the ego representing 'anonymous' users.

Returns

handle for the anonymous user, MUST NOT be freed

Definition at line 157 of file identity_api.c.

{
  static struct GNUNET_IDENTITY_Ego anon;
  static int setup;
  ssize_t key_len;
 
  if (setup)
    return &anon;
  anon.pk.type = htonl (GNUNET_IDENTITY_TYPE_ECDSA);
  anon.pub.type = htonl (GNUNET_IDENTITY_TYPE_ECDSA);
  anon.pk.ecdsa_key = *GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
  key_len = GNUNET_IDENTITY_private_key_get_length (&anon.pk);
  GNUNET_assert (0 < key_len);
  GNUNET_CRYPTO_hash (&anon.pk,
                      key_len,
                      &anon.id);
  setup = 1;
  return &anon;
}

References GNUNET_IDENTITY_PrivateKey::ecdsa_key, GNUNET_assert, GNUNET_CRYPTO_ecdsa_key_get_anonymous(), GNUNET_CRYPTO_hash(), GNUNET_IDENTITY_private_key_get_length(), GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_IDENTITY_Ego::id, GNUNET_IDENTITY_Ego::pk, GNUNET_IDENTITY_Ego::pub, httpdomain.autohttp.bottle::setup(), GNUNET_IDENTITY_PrivateKey::type, and GNUNET_IDENTITY_PublicKey::type.

Referenced by get_anonymous_public_key(), and get_srv_handle_ego().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_ego_get_public_key()

void GNUNET_IDENTITY_ego_get_public_key	(	struct GNUNET_IDENTITY_Ego *	ego,
		struct GNUNET_IDENTITY_PublicKey *	pk
	)

Get the identifier (public key) of an ego.

Parameters

ego	identity handle with the private key
pk	set to ego's public key

Definition at line 573 of file identity_api.c.

{
  if (GNUNET_NO == ego->pub_initialized)
  {
    GNUNET_IDENTITY_key_get_public (&ego->pk, &ego->pub);
    ego->pub_initialized = GNUNET_YES;
  }
  *pk = ego->pub;
}

References GNUNET_IDENTITY_key_get_public(), GNUNET_NO, GNUNET_YES, pk, GNUNET_IDENTITY_Ego::pk, GNUNET_IDENTITY_Ego::pub, and GNUNET_IDENTITY_Ego::pub_initialized.

Referenced by code_redirect(), consume_ticket_cont(), DID_did_to_pkey(), DID_ego_to_did(), DID_identity_to_did_document(), ego_callback(), find_ego(), get_anonymous_public_key(), get_ego(), get_identity_for_string(), get_srv_handle_ego(), id_connect_cb(), list_ego(), print_ego(), revoke_ticket_cont(), and store_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_connect()

struct GNUNET_IDENTITY_Handle* GNUNET_IDENTITY_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_IDENTITY_Callback	cb,
		void *	cb_cls
	)

Connect to the identity service.

Parameters

cfg	Configuration to contact the identity service.
cb	function to call on all identity events, can be NULL
cb_cls	closure for cb

Returns

handle to communicate with identity service

Parameters

cfg	the configuration to use
cb	function to call on all identity events, can be NULL
cb_cls	closure for cb

Returns

handle to use

Definition at line 531 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Handle *h;
 
  h = GNUNET_new (struct GNUNET_IDENTITY_Handle);
  h->cfg = cfg;
  h->cb = cb;
  h->cb_cls = cb_cls;
  h->egos = GNUNET_CONTAINER_multihashmap_create (16,
                                                  GNUNET_YES);
  reconnect (h);
  if (NULL == h->mq)
  {
    GNUNET_free (h);
    return NULL;
  }
  return h;
}

References GNUNET_IDENTITY_Handle::cb, GNUNET_IDENTITY_Handle::cb_cls, cfg, GNUNET_ARM_Handle::cfg, GNUNET_CONTAINER_multihashmap_create(), GNUNET_free, GNUNET_new, GNUNET_YES, h, GNUNET_ARM_Handle::mq, and reconnect().

Referenced by init_ego_store(), libgnunet_plugin_rest_identity_init(), libgnunet_plugin_rest_namestore_init(), libgnunet_plugin_rest_openid_connect_init(), libgnunet_plugin_rest_reclaim_init(), run(), and run_service().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_get()

struct GNUNET_IDENTITY_Operation* GNUNET_IDENTITY_get	(	struct GNUNET_IDENTITY_Handle *	id,
		const char *	service_name,
		GNUNET_IDENTITY_Callback	cb,
		void *	cb_cls
	)

Obtain the ego that is currently preferred/default for a service.

Parameters

id	identity service to query
service_name	for which service is an identity wanted
cb	function to call with the result (will only be called once)
cb_cls	closure for cb

Returns

handle to abort the operation

GNUNET_IDENTITY_set()

struct GNUNET_IDENTITY_Operation* GNUNET_IDENTITY_set	(	struct GNUNET_IDENTITY_Handle *	id,
		const char *	service_name,
		struct GNUNET_IDENTITY_Ego *	ego,
		GNUNET_IDENTITY_Continuation	cont,
		void *	cont_cls
	)

Set the preferred/default ego for a service.

Parameters

id	identity service to inform
service_name	for which service is an identity set
ego	new default identity to be set for this service
cont	function to call once the operation finished
cont_cls	closure for cont

Returns

handle to abort the operation

GNUNET_IDENTITY_disconnect()

void GNUNET_IDENTITY_disconnect

(

struct GNUNET_IDENTITY_Handle *

h

)

Disconnect from identity service.

Parameters

h	identity service to disconnect
h	handle to destroy

Definition at line 757 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Operation *op;
 
  GNUNET_assert (NULL != h);
  if (h->reconnect_task != NULL)
  {
    GNUNET_SCHEDULER_cancel (h->reconnect_task);
    h->reconnect_task = NULL;
  }
  if (NULL != h->egos)
  {
    GNUNET_CONTAINER_multihashmap_iterate (h->egos,
                                           &free_ego,
                                           h);
    GNUNET_CONTAINER_multihashmap_destroy (h->egos);
    h->egos = NULL;
  }
  while (NULL != (op = h->op_head))
  {
    GNUNET_break (NULL == op->cont);
    GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
    memset (&op->pk,
            0,
            sizeof (op->pk));
    GNUNET_free (op);
  }
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  GNUNET_free (h);
}

Referenced by cleanup(), clear_ego_store(), do_cleanup(), do_shutdown(), do_stop_task(), libgnunet_plugin_rest_identity_done(), libgnunet_plugin_rest_namestore_done(), libgnunet_plugin_rest_openid_connect_done(), libgnunet_plugin_rest_reclaim_done(), process_stdin(), and shutdown_task().

Here is the caller graph for this function:

GNUNET_IDENTITY_create()

struct GNUNET_IDENTITY_Operation* GNUNET_IDENTITY_create	(	struct GNUNET_IDENTITY_Handle *	id,
		const char *	name,
		const struct GNUNET_IDENTITY_PrivateKey *	privkey,
		enum GNUNET_IDENTITY_KeyType	ktype,
		GNUNET_IDENTITY_CreateContinuation	cont,
		void *	cont_cls
	)

Create a new ego with the given name.

Parameters

id	identity service to use
name	desired name
privkey	desired private key or NULL to create one
ktype	the type of key to create. Ignored if privkey != NULL.
cont	function to call with the result (will only be called once)
cont_cls	closure for cont

Returns

handle to abort the operation

Definition at line 586 of file identity_api.c.

{
  struct GNUNET_IDENTITY_PrivateKey private_key;
  struct GNUNET_IDENTITY_Operation *op;
  struct GNUNET_MQ_Envelope *env;
  struct CreateRequestMessage *crm;
  size_t slen;
  size_t key_len;
 
  if (NULL == h->mq)
    return NULL;
  slen = strlen (name) + 1;
  if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof(struct CreateRequestMessage))
  {
    GNUNET_break (0);
    return NULL;
  }
  op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
  op->h = h;
  op->create_cont = cont;
  op->cls = cont_cls;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  if (NULL == privkey)
  {
    GNUNET_assert (GNUNET_OK ==
                   private_key_create (ktype, &private_key));
  }
  else
    private_key = *privkey;
  key_len = GNUNET_IDENTITY_private_key_get_length (&private_key);
  env = GNUNET_MQ_msg_extra (crm, slen + key_len,
                             GNUNET_MESSAGE_TYPE_IDENTITY_CREATE);
  crm->name_len = htons (slen);
  GNUNET_IDENTITY_write_private_key_to_buffer (&private_key,
                                               &crm[1],
                                               key_len);
  crm->key_len = htons (key_len);
  op->pk = private_key;
  GNUNET_memcpy ((char*) &crm[1] + key_len, name, slen);
  GNUNET_MQ_send (h->mq, env);
  return op;
}

References env, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_IDENTITY_private_key_get_length(), GNUNET_IDENTITY_write_private_key_to_buffer(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_CREATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_OK, GNUNET_ARM_Operation::h, h, CreateRequestMessage::key_len, GNUNET_ARM_Handle::mq, name, CreateRequestMessage::name_len, op, and private_key_create().

Referenced by create_did_ego_lockup_cb(), create_store_ego(), ego_create(), origin_lookup_cb(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_rename()

struct GNUNET_IDENTITY_Operation* GNUNET_IDENTITY_rename	(	struct GNUNET_IDENTITY_Handle *	h,
		const char *	old_name,
		const char *	new_name,
		GNUNET_IDENTITY_Continuation	cb,
		void *	cb_cls
	)

Renames an existing ego.

Parameters

id	identity service to use
old_name	old name
new_name	desired new name
cb	function to call with the result (will only be called once)
cb_cls	closure for cb

Returns

handle to abort the operation

Renames an existing ego.

Parameters

h	identity service to use
old_name	old name
new_name	desired new name
cb	function to call with the result (will only be called once)
cb_cls	closure for cb

Returns

handle to abort the operation

Definition at line 646 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Operation *op;
  struct GNUNET_MQ_Envelope *env;
  struct RenameMessage *grm;
  size_t slen_old;
  size_t slen_new;
  char *dst;
 
  if (NULL == h->mq)
    return NULL;
  slen_old = strlen (old_name) + 1;
  slen_new = strlen (new_name) + 1;
  if ((slen_old >= GNUNET_MAX_MESSAGE_SIZE) ||
      (slen_new >= GNUNET_MAX_MESSAGE_SIZE) ||
      (slen_old + slen_new >=
       GNUNET_MAX_MESSAGE_SIZE - sizeof(struct RenameMessage)))
  {
    GNUNET_break (0);
    return NULL;
  }
  op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
  op->h = h;
  op->cont = cb;
  op->cls = cb_cls;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  env = GNUNET_MQ_msg_extra (grm,
                             slen_old + slen_new,
                             GNUNET_MESSAGE_TYPE_IDENTITY_RENAME);
  grm->old_name_len = htons (slen_old);
  grm->new_name_len = htons (slen_new);
  dst = (char *) &grm[1];
  GNUNET_memcpy (dst, old_name, slen_old);
  GNUNET_memcpy (&dst[slen_old], new_name, slen_new);
  GNUNET_MQ_send (h->mq, env);
  return op;
}

References env, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_RENAME, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_ARM_Operation::h, h, GNUNET_ARM_Handle::mq, RenameMessage::new_name_len, RenameMessage::old_name_len, and op.

Referenced by ego_edit(), and rename_store_ego().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_delete()

struct GNUNET_IDENTITY_Operation* GNUNET_IDENTITY_delete	(	struct GNUNET_IDENTITY_Handle *	h,
		const char *	name,
		GNUNET_IDENTITY_Continuation	cb,
		void *	cb_cls
	)

Delete an existing ego.

Parameters

id	identity service to use
name	name of the identity to delete
cb	function to call with the result (will only be called once)
cb_cls	closure for cb

Returns

handle to abort the operation

Delete an existing ego.

Parameters

h	identity service to use
name	name of the identity to delete
cb	function to call with the result (will only be called once)
cb_cls	closure for cb

Returns

handle to abort the operation

Definition at line 699 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Operation *op;
  struct GNUNET_MQ_Envelope *env;
  struct DeleteMessage *gdm;
  size_t slen;
 
  if (NULL == h->mq)
    return NULL;
  slen = strlen (name) + 1;
  if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof(struct DeleteMessage))
  {
    GNUNET_break (0);
    return NULL;
  }
  op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
  op->h = h;
  op->cont = cb;
  op->cls = cb_cls;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  env = GNUNET_MQ_msg_extra (gdm, slen, GNUNET_MESSAGE_TYPE_IDENTITY_DELETE);
  gdm->name_len = htons (slen);
  gdm->reserved = htons (0);
  GNUNET_memcpy (&gdm[1], name, slen);
  GNUNET_MQ_send (h->mq, env);
  return op;
}

References env, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_DELETE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_ARM_Operation::h, h, GNUNET_ARM_Handle::mq, name, DeleteMessage::name_len, op, and DeleteMessage::reserved.

Referenced by ego_delete_name(), ego_delete_pubkey(), renew_store_ego(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_cancel()

void GNUNET_IDENTITY_cancel

(

struct GNUNET_IDENTITY_Operation *

op

)

Cancel an identity operation.

Note that the operation MAY still be executed; this merely cancels the continuation; if the request was already transmitted, the service may still choose to complete the operation.

Parameters

op	operation to cancel

Definition at line 740 of file identity_api.c.

{
  op->cont = NULL;
  op->cb = NULL;
  op->create_cont = NULL;
  memset (&op->pk,
          0,
          sizeof (op->pk));
}

References op.

Referenced by clear_ego_store(), do_shutdown(), and shutdown_task().

Here is the caller graph for this function:

GNUNET_IDENTITY_public_key_get_length()

ssize_t GNUNET_IDENTITY_public_key_get_length

(

const struct GNUNET_IDENTITY_PublicKey *

key

)

Get the compacted length of a GNUNET_IDENTITY_PublicKey.

Compacted means that it returns the minimum number of bytes this key is long, as opposed to the union structure inside GNUNET_IDENTITY_PublicKey. Useful for compact serializations.

Parameters

key

the key.

Returns

-1 on error, else the compacted length of the key.

Definition at line 830 of file identity_api.c.

{
  switch (ntohl (key->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return sizeof (key->type) + sizeof (key->ecdsa_key);
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return sizeof (key->type) + sizeof (key->eddsa_key);
  default:
    GNUNET_break (0);
  }
  return -1;
}

References GNUNET_break, GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_IDENTITY_TYPE_EDDSA, and key.

Referenced by attr_iter_cb(), change_handle_ego(), check_credential_iteration_start(), check_signature(), consume_result_cb(), ego_callback(), get_message_body_size(), gns_string_to_value(), GNUNET_GNS_lookup_limited(), GNUNET_IDENTITY_public_key_to_string(), GNUNET_IDENTITY_read_private_key_from_buffer(), GNUNET_MESSENGER_send_message(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_RECLAIM_read_ticket_from_buffer(), GNUNET_RECLAIM_ticket_issue(), GNUNET_REVOCATION_proof_get_size(), GNUNET_REVOCATION_query(), handle_client_call_message(), run(), run_edkey(), run_pkey(), run_with_key(), and run_with_zone_pkey().

Here is the caller graph for this function:

GNUNET_IDENTITY_read_public_key_from_buffer()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_read_public_key_from_buffer	(	const void *	buffer,
		size_t	len,
		struct GNUNET_IDENTITY_PublicKey *	key,
		size_t *	read
	)

Reads a GNUNET_IDENTITY_PublicKey from a compact buffer.

The buffer has to contain at least the compacted length of a GNUNET_IDENTITY_PublicKey in bytes. If the buffer is too small, the function returns -1 as error. If the buffer does not contain a valid key, it returns -2 as error.

Parameters

buffer	the buffer
len	the length of buffer
key	the key
the	amount of bytes read from the buffer

Returns

GNUNET_SYSERR on error

Definition at line 847 of file identity_api.c.

{
  if (len < sizeof (key->type))
    return GNUNET_SYSERR;
  GNUNET_memcpy (&key->type,
                 buffer,
                 sizeof (key->type));
  ssize_t length = GNUNET_IDENTITY_public_key_get_length (key);
  if (len < length)
    return GNUNET_SYSERR;
  if (length < 0)
    return GNUNET_SYSERR;
  GNUNET_memcpy (&key->ecdsa_key,
                 buffer + sizeof (key->type),
                 length - sizeof (key->type));
  *kb_read = length;
  return GNUNET_OK;
}

Referenced by check_get_key(), check_send_message(), do_flood(), handle_attribute_result(), handle_cadet_ring_message(), handle_consume_ticket_result(), handle_credential_result(), handle_get_key(), handle_issue_ticket_message(), handle_lookup(), handle_phone_ring(), handle_send_message(), and handle_zone_to_name().

Here is the caller graph for this function:

GNUNET_IDENTITY_private_key_get_length()

ssize_t GNUNET_IDENTITY_private_key_get_length

(

const struct GNUNET_IDENTITY_PrivateKey *

key

)

Get the compacted length of a GNUNET_IDENTITY_PrivateKey.

Compacted means that it returns the minimum number of bytes this key is long, as opposed to the union structure inside GNUNET_IDENTITY_PrivateKey. Useful for compact serializations.

Parameters

key

the key.

Returns

-1 on error, else the compacted length of the key.

Definition at line 809 of file identity_api.c.

{
  switch (ntohl (key->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return sizeof (key->type) + sizeof (key->ecdsa_key);
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return sizeof (key->type) + sizeof (key->eddsa_key);
    break;
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Got key type %u\n", ntohl (key->type));
    GNUNET_break (0);
  }
  return -1;
}

References GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_IDENTITY_TYPE_EDDSA, GNUNET_log, and key.

Referenced by check_zone_to_name(), create_update_message(), GNUNET_IDENTITY_create(), GNUNET_IDENTITY_ego_get_anonymous(), GNUNET_IDENTITY_private_key_from_string(), GNUNET_IDENTITY_write_private_key_to_buffer(), GNUNET_NAMESTORE_records_store2(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NAMESTORE_zone_iteration_start2(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_credential_delete(), GNUNET_RECLAIM_credential_store(), GNUNET_RECLAIM_get_attributes_start(), GNUNET_RECLAIM_get_credentials_start(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_issue(), GNUNET_RECLAIM_ticket_iteration_start(), GNUNET_RECLAIM_ticket_revoke(), handle_gns_response(), handle_identity_update(), notify_listeners(), records_lookup(), and send_lookup_response_with_filter().

Here is the caller graph for this function:

GNUNET_IDENTITY_write_public_key_to_buffer()

ssize_t GNUNET_IDENTITY_write_public_key_to_buffer	(	const struct GNUNET_IDENTITY_PublicKey *	key,
		void *	buffer,
		size_t	len
	)

Writes a GNUNET_IDENTITY_PublicKey to a compact buffer.

The buffer requires space for at least the compacted length of a GNUNET_IDENTITY_PublicKey in bytes. If the buffer is too small, the function returns -1 as error. If the key is not valid, it returns -2 as error.

Parameters

key	the key
buffer	the buffer
len	the length of buffer

Returns

-1 or -2 on error, else the amount of bytes written to the buffer

Definition at line 890 of file identity_api.c.

{
  const ssize_t length = GNUNET_IDENTITY_public_key_get_length (key);
  if (len < length)
    return -1;
  if (length < 0)
    return -2;
  GNUNET_memcpy (buffer, &(key->type), sizeof (key->type));
  GNUNET_memcpy (buffer + sizeof (key->type), &(key->ecdsa_key), length
                 - sizeof (key->type));
  return length;
}

Referenced by attr_iter_cb(), change_handle_ego(), check_credential_iteration_start(), check_signature(), consume_result_cb(), GNUNET_GNS_lookup_limited(), GNUNET_MESSENGER_send_message(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_RECLAIM_ticket_issue(), GNUNET_RECLAIM_write_ticket_to_buffer(), GNUNET_REVOCATION_query(), and handle_client_call_message().

Here is the caller graph for this function:

GNUNET_IDENTITY_read_private_key_from_buffer()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_read_private_key_from_buffer	(	const void *	buffer,
		size_t	len,
		struct GNUNET_IDENTITY_PrivateKey *	key,
		size_t *	read
	)

Reads a GNUNET_IDENTITY_PrivateKey from a compact buffer.

The buffer has to contain at least the compacted length of a GNUNET_IDENTITY_PrivateKey in bytes. If the buffer is too small, the function returns GNUNET_SYSERR as error.

Parameters

buffer	the buffer
len	the length of buffer
key	the key
the	amount of bytes read from the buffer

Returns

GNUNET_SYSERR on error

Definition at line 890 of file identity_api.c.

{
  if (len < sizeof (key->type))
    return GNUNET_SYSERR;
  GNUNET_memcpy (&key->type,
                 buffer,
                 sizeof (key->type));
  ssize_t length = GNUNET_IDENTITY_private_key_get_length (key);
  if (len < length)
    return GNUNET_SYSERR;
  if (length < 0)
    return GNUNET_SYSERR;
  GNUNET_memcpy (&key->ecdsa_key,
                 buffer + sizeof (key->type),
                 length - sizeof (key->type));
  *kb_read = length;
  return GNUNET_OK;
}

References GNUNET_IDENTITY_public_key_get_length(), GNUNET_memcpy, key, and len.

Referenced by handle_attribute_delete_message(), handle_attribute_store_message(), handle_client_call_message(), handle_consume_ticket_message(), handle_create_message(), handle_credential_delete_message(), handle_credential_iteration_start(), handle_credential_store_message(), handle_identity_update(), handle_issue_ticket_message(), handle_iteration_start(), handle_lookup_result(), handle_monitor_start(), handle_record_lookup(), handle_record_result(), handle_record_store(), handle_result(), handle_revoke_ticket_message(), handle_ticket_iteration_start(), handle_zone_to_name(), and handle_zone_to_name_response().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_write_private_key_to_buffer()

ssize_t GNUNET_IDENTITY_write_private_key_to_buffer	(	const struct GNUNET_IDENTITY_PrivateKey *	key,
		void *	buffer,
		size_t	len
	)

Writes a GNUNET_IDENTITY_PrivateKey to a compact buffer.

The buffer requires space for at least the compacted length of a GNUNET_IDENTITY_PrivateKey in bytes. If the buffer is too small, the function returns -1 as error. If the key is not valid, it returns -2 as error.

Parameters

key	the key
buffer	the buffer
len	the length of buffer

Returns

-1 or -2 on error, else the amount of bytes written to the buffer

Definition at line 933 of file identity_api.c.

{
  const ssize_t length = GNUNET_IDENTITY_private_key_get_length (key);
  if (len < length)
    return -1;
  if (length < 0)
    return -2;
  GNUNET_memcpy (buffer, &(key->type), sizeof (key->type));
  GNUNET_memcpy (buffer + sizeof (key->type), &(key->ecdsa_key), length
                 - sizeof (key->type));
  return length;
}

References GNUNET_IDENTITY_private_key_get_length(), GNUNET_memcpy, key, and len.

Referenced by check_zone_to_name(), create_update_message(), GNUNET_IDENTITY_create(), GNUNET_NAMESTORE_records_store2(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NAMESTORE_zone_iteration_start2(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_credential_delete(), GNUNET_RECLAIM_credential_store(), GNUNET_RECLAIM_get_attributes_start(), GNUNET_RECLAIM_get_credentials_start(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_issue(), GNUNET_RECLAIM_ticket_iteration_start(), GNUNET_RECLAIM_ticket_revoke(), handle_gns_response(), notify_listeners(), reconnect(), records_lookup(), and send_lookup_response_with_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_signature_get_length()

ssize_t GNUNET_IDENTITY_signature_get_length

(

const struct GNUNET_IDENTITY_Signature *

sig

)

Get the compacted length of a GNUNET_IDENTITY_Signature.

Compacted means that it returns the minimum number of bytes this signature is long, as opposed to the union structure inside GNUNET_IDENTITY_Signature. Useful for compact serializations.

Parameters

sig	the signature.

Returns

-1 on error, else the compacted length of the signature.

Definition at line 951 of file identity_api.c.

{
  switch (ntohl (sig->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return sizeof (sig->type) + sizeof (sig->ecdsa_signature);
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return sizeof (sig->type) + sizeof (sig->eddsa_signature);
    break;
  default:
    GNUNET_break (0);
  }
  return -1;
}

References GNUNET_IDENTITY_Signature::ecdsa_signature, GNUNET_IDENTITY_Signature::eddsa_signature, GNUNET_break, GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_IDENTITY_TYPE_EDDSA, and GNUNET_IDENTITY_Signature::type.

Referenced by get_message_size(), GNUNET_IDENTITY_read_signature_from_buffer(), GNUNET_IDENTITY_sign_(), handle_client_call_message(), and hash_message().

Here is the caller graph for this function:

GNUNET_IDENTITY_signature_get_raw_length_by_type()

ssize_t GNUNET_IDENTITY_signature_get_raw_length_by_type

(

uint32_t

type

)

Get the compacted length of a signature by type.

Compacted means that it returns the minimum number of bytes this signature is long, as opposed to the union structure inside GNUNET_IDENTITY_Signature. Useful for compact serializations.

Parameters

sig	the signature.

Returns

-1 on error, else the compacted length of the signature.

Definition at line 970 of file identity_api.c.

{
  switch (ntohl (type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return sizeof (struct GNUNET_CRYPTO_EddsaSignature);
    break;
  default:
    GNUNET_break (0);
  }
  return -1;
}

References GNUNET_break, GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_IDENTITY_TYPE_EDDSA, and type.

Referenced by GNUNET_REVOCATION_proof_get_size().

Here is the caller graph for this function:

GNUNET_IDENTITY_read_signature_from_buffer()

ssize_t GNUNET_IDENTITY_read_signature_from_buffer	(	struct GNUNET_IDENTITY_Signature *	sig,
		const void *	buffer,
		size_t	len
	)

Reads a GNUNET_IDENTITY_Signature from a compact buffer.

The buffer has to contain at least the compacted length of a GNUNET_IDENTITY_Signature in bytes. If the buffer is too small, the function returns -1 as error. If the buffer does not contain a valid key, it returns -2 as error.

Parameters

sig	the signature
buffer	the buffer
len	the length of buffer

Returns

-1 or -2 on error, else the amount of bytes read from the buffer

Definition at line 988 of file identity_api.c.

{
  if (len < sizeof (sig->type))
    return -1;
  GNUNET_memcpy (&(sig->type), buffer, sizeof (sig->type));
  const ssize_t length = GNUNET_IDENTITY_signature_get_length (sig);
  if (len < length)
    return -1;
  if (length < 0)
    return -2;
  GNUNET_memcpy (&(sig->ecdsa_signature), buffer + sizeof (sig->type), length
                 - sizeof (sig->type));
  return length;
}

References GNUNET_IDENTITY_Signature::ecdsa_signature, GNUNET_IDENTITY_signature_get_length(), GNUNET_memcpy, len, and GNUNET_IDENTITY_Signature::type.

Referenced by decode_message(), and handle_cadet_ring_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_write_signature_to_buffer()

ssize_t GNUNET_IDENTITY_write_signature_to_buffer	(	const struct GNUNET_IDENTITY_Signature *	sig,
		void *	buffer,
		size_t	len
	)

Writes a GNUNET_IDENTITY_Signature to a compact buffer.

The buffer requires space for at least the compacted length of a GNUNET_IDENTITY_Signature in bytes. If the buffer is too small, the function returns -1 as error. If the key is not valid, it returns -2 as error.

Parameters

sig	the signature
buffer	the buffer
len	the length of buffer

Returns

-1 or -2 on error, else the amount of bytes written to the buffer

Definition at line 1008 of file identity_api.c.

{
  const ssize_t length = GNUNET_IDENTITY_signature_get_length (sig);
  if (len < length)
    return -1;
  if (length < 0)
    return -2;
  GNUNET_memcpy (buffer, &(sig->type), sizeof (sig->type));
  GNUNET_memcpy (buffer + sizeof (sig->type), &(sig->ecdsa_signature), length
                 - sizeof (sig->type));
  return length;
}

Referenced by handle_client_call_message().

Here is the caller graph for this function:

GNUNET_IDENTITY_sign_()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_sign_	(	const struct GNUNET_IDENTITY_PrivateKey *	priv,
		const struct GNUNET_CRYPTO_EccSignaturePurpose *	purpose,
		struct GNUNET_IDENTITY_Signature *	sig
	)

Sign a given block.

The purpose data is the beginning of the data of which the signature is to be created. The size field in purpose must correctly indicate the number of bytes of the data structure, including its header. If possible, use GNUNET_IDENTITY_sign() instead of this function.

Parameters

	priv	private key to use for the signing
	purpose	what to sign (size, purpose)
[out]	sig	where to write the signature

Returns

GNUNET_SYSERR on error, GNUNET_OK on success

Definition at line 1008 of file identity_api.c.

{
  sig->type = priv->type;
  switch (ntohl (priv->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return GNUNET_CRYPTO_ecdsa_sign_ (&(priv->ecdsa_key), purpose,
                                      &(sig->ecdsa_signature));
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return GNUNET_CRYPTO_eddsa_sign_ (&(priv->eddsa_key), purpose,
                                      &(sig->eddsa_signature));
    break;
  default:
    GNUNET_break (0);
  }
 
  return GNUNET_SYSERR;
}

References GNUNET_IDENTITY_Signature::ecdsa_signature, GNUNET_IDENTITY_signature_get_length(), GNUNET_memcpy, len, and GNUNET_IDENTITY_Signature::type.

Referenced by check_code_challenge(), and GNUNET_ABD_delegate_issue().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_sign_raw_()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_sign_raw_	(	const struct GNUNET_IDENTITY_PrivateKey *	priv,
		const struct GNUNET_CRYPTO_EccSignaturePurpose *	purpose,
		unsigned char *	sig
	)

Sign a given block.

The purpose data is the beginning of the data of which the signature is to be created. The size field in purpose must correctly indicate the number of bytes of the data structure, including its header. The signature payload and length depends on the key type.

Parameters

	priv	private key to use for the signing
	purpose	what to sign (size, purpose)
[out]	sig	where to write the signature

Returns

GNUNET_SYSERR on error, GNUNET_OK on success

Definition at line 1008 of file identity_api.c.

{
  switch (ntohl (priv->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return GNUNET_CRYPTO_ecdsa_sign_ (&(priv->ecdsa_key), purpose,
                                      (struct
                                       GNUNET_CRYPTO_EcdsaSignature*) sig);
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return GNUNET_CRYPTO_eddsa_sign_ (&(priv->eddsa_key), purpose,
                                      (struct
                                       GNUNET_CRYPTO_EddsaSignature*) sig);
    break;
  default:
    GNUNET_break (0);
  }
 
  return GNUNET_SYSERR;
}

GNUNET_IDENTITY_signature_verify_()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_signature_verify_	(	uint32_t	purpose,
		const struct GNUNET_CRYPTO_EccSignaturePurpose *	validate,
		const struct GNUNET_IDENTITY_Signature *	sig,
		const struct GNUNET_IDENTITY_PublicKey *	pub
	)

Verify a given signature.

The validate data is the beginning of the data of which the signature is to be verified. The size field in validate must correctly indicate the number of bytes of the data structure, including its header. If purpose does not match the purpose given in validate (the latter must be in big endian), signature verification fails. If possible, use GNUNET_IDENTITY_signature_verify() instead of this function (only if validate is not fixed-size, you must use this function directly).

Parameters

purpose	what is the purpose that the signature should have?
validate	block to validate (size, purpose, data)
sig	signature that is being validated
pub	public key of the signer

Returns

GNUNET_OK if ok, GNUNET_SYSERR if invalid

Definition at line 1008 of file identity_api.c.

{
  /* check type matching of 'sig' and 'pub' */
  GNUNET_assert (ntohl (pub->type) == ntohl (sig->type));
  switch (ntohl (pub->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return GNUNET_CRYPTO_ecdsa_verify_ (purpose, validate,
                                        &(sig->ecdsa_signature),
                                        &(pub->ecdsa_key));
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return GNUNET_CRYPTO_eddsa_verify_ (purpose, validate,
                                        &(sig->eddsa_signature),
                                        &(pub->eddsa_key));
    break;
  default:
    GNUNET_break (0);
  }
 
  return GNUNET_SYSERR;
}

Referenced by GNUNET_ABD_delegate_deserialize(), GNUNET_ABD_delegate_serialize(), and OIDC_parse_authz_code().

Here is the caller graph for this function:

GNUNET_IDENTITY_signature_verify_raw_()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_signature_verify_raw_	(	uint32_t	purpose,
		const struct GNUNET_CRYPTO_EccSignaturePurpose *	validate,
		const unsigned char *	sig,
		const struct GNUNET_IDENTITY_PublicKey *	pub
	)

Verify a given signature.

The validate data is the beginning of the data of which the signature is to be verified. The size field in validate must correctly indicate the number of bytes of the data structure, including its header. If purpose does not match the purpose given in validate (the latter must be in big endian), signature verification fails.

Parameters

purpose	what is the purpose that the signature should have?
validate	block to validate (size, purpose, data)
sig	signature that is being validated
pub	public key of the signer

Returns

GNUNET_OK if ok, GNUNET_SYSERR if invalid

Definition at line 1008 of file identity_api.c.

{
  switch (ntohl (pub->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return GNUNET_CRYPTO_ecdsa_verify_ (purpose, validate,
                                        (struct
                                         GNUNET_CRYPTO_EcdsaSignature*) sig,
                                        &(pub->ecdsa_key));
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return GNUNET_CRYPTO_eddsa_verify_ (purpose, validate,
                                        (struct
                                         GNUNET_CRYPTO_EddsaSignature*) sig,
                                        &(pub->eddsa_key));
    break;
  default:
    GNUNET_break (0);
  }
 
  return GNUNET_SYSERR;
}

GNUNET_IDENTITY_encrypt_old()

ssize_t GNUNET_IDENTITY_encrypt_old	(	const void *	block,
		size_t	size,
		const struct GNUNET_IDENTITY_PublicKey *	pub,
		struct GNUNET_CRYPTO_EcdhePublicKey *	ecc,
		void *	result
	)

Encrypt a block with GNUNET_IDENTITY_PublicKey and derives a GNUNET_CRYPTO_EcdhePublicKey which is required for decryption using ecdh to derive a symmetric key.

Parameters

block	the block to encrypt
size	the size of the block
pub	public key to use for ecdh
ecc	where to write the ecc public key
result	the output parameter in which to store the encrypted result can be the same or overlap with block

Returns

the size of the encrypted block, -1 for errors. Due to the use of CFB and therefore an effective stream cipher, this size should be the same as len.

Definition at line 1139 of file identity_api.c.

{
  struct GNUNET_CRYPTO_EcdhePrivateKey pk;
  GNUNET_CRYPTO_ecdhe_key_create (&pk);
  struct GNUNET_HashCode hash;
  switch (ntohl (pub->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdh_ecdsa (&pk, &(pub->ecdsa_key),
                                                   &hash))
      return -1;
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdh_eddsa (&pk, &(pub->eddsa_key),
                                                   &hash))
      return -1;
    break;
  default:
    return -1;
  }
  GNUNET_CRYPTO_ecdhe_key_get_public (&pk, ecc);
  GNUNET_CRYPTO_ecdhe_key_clear (&pk);
  struct GNUNET_CRYPTO_SymmetricSessionKey key;
  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
  GNUNET_CRYPTO_hash_to_aes_key (&hash, &key, &iv);
  GNUNET_CRYPTO_zero_keys (&hash, sizeof(hash));
  const ssize_t encrypted = GNUNET_CRYPTO_symmetric_encrypt (block, size, &key,
                                                             &iv, result);
  GNUNET_CRYPTO_zero_keys (&key, sizeof(key));
  GNUNET_CRYPTO_zero_keys (&iv, sizeof(iv));
  return encrypted;
}

GNUNET_IDENTITY_decrypt_old()

ssize_t GNUNET_IDENTITY_decrypt_old	(	const void *	block,
		size_t	size,
		const struct GNUNET_IDENTITY_PrivateKey *	priv,
		const struct GNUNET_CRYPTO_EcdhePublicKey *	ecc,
		void *	result
	)

Decrypt a given block with GNUNET_IDENTITY_PrivateKey and a given GNUNET_CRYPTO_EcdhePublicKey using ecdh to derive a symmetric key.

Parameters

block	the data to decrypt, encoded as returned by encrypt
size	the size of the block to decrypt
priv	private key to use for ecdh
ecc	the ecc public key
result	address to store the result at can be the same or overlap with block

Returns

-1 on failure, size of decrypted block on success. Due to the use of CFB and therefore an effective stream cipher, this size should be the same as size.

Definition at line 1275 of file identity_api.c.

{
  struct GNUNET_HashCode hash;
  switch (ntohl (priv->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_ecdh (&(priv->ecdsa_key), ecc,
                                                   &hash))
      return -1;
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_ecdh (&(priv->eddsa_key), ecc,
                                                   &hash))
      return -1;
    break;
  default:
    return -1;
  }
  struct GNUNET_CRYPTO_SymmetricSessionKey key;
  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
  GNUNET_CRYPTO_hash_to_aes_key (&hash, &key, &iv);
  GNUNET_CRYPTO_zero_keys (&hash, sizeof(hash));
  const ssize_t decrypted = GNUNET_CRYPTO_symmetric_decrypt (block, size, &key,
                                                             &iv, result);
  GNUNET_CRYPTO_zero_keys (&key, sizeof(key));
  GNUNET_CRYPTO_zero_keys (&iv, sizeof(iv));
  return decrypted;
}

References GNUNET_IDENTITY_PrivateKey::ecdsa_key, GNUNET_IDENTITY_PrivateKey::eddsa_key, GNUNET_CRYPTO_ecdsa_ecdh(), GNUNET_CRYPTO_eddsa_ecdh(), GNUNET_CRYPTO_hash_to_aes_key(), GNUNET_CRYPTO_symmetric_decrypt(), GNUNET_CRYPTO_zero_keys(), GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_IDENTITY_TYPE_EDDSA, GNUNET_SYSERR, key, result, size, and GNUNET_IDENTITY_PrivateKey::type.

Here is the call graph for this function:

GNUNET_IDENTITY_encrypt()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_encrypt	(	const void *	block,
		size_t	size,
		const struct GNUNET_IDENTITY_PublicKey *	pub,
		void *	result,
		size_t	result_size
	)

Encrypt a block with GNUNET_IDENTITY_PublicKey and derives a GNUNET_CRYPTO_EcdhePublicKey which is required for decryption using ecdh to derive a symmetric key.

Note that the result buffer for the ciphertext must be the length of the message to encrypt plus GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES.

Parameters

block	the block to encrypt
size	the size of the block
pub	public key to encrypt for
result	the output parameter in which to store the encrypted result can be the same or overlap with block

Returns

GNUNET_OK on success.

Definition at line 1139 of file identity_api.c.

{
  struct GNUNET_HashCode k;
  struct GNUNET_CRYPTO_FoKemC kemc;
  struct GNUNET_CRYPTO_FoKemC *kemc_buf = (struct GNUNET_CRYPTO_FoKemC*) ct_buf;
  unsigned char *encrypted_data = (unsigned char*) &kemc_buf[1];
  unsigned char nonce[crypto_secretbox_NONCEBYTES];
  unsigned char key[crypto_secretbox_KEYBYTES];
 
  if (ct_size < pt_size + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Output buffer size for ciphertext too small: Got %lu, want >=%lu\n",
                ct_size, pt_size + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES);
    return GNUNET_SYSERR;
  }
  switch (ntohl (pub->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_fo_kem_encaps (&(pub->ecdsa_key),
                                                            &kemc,
                                                            &k))
      return GNUNET_SYSERR;
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_fo_kem_encaps (&pub->eddsa_key,
                                                            &kemc,
                                                            &k))
      return GNUNET_SYSERR;
    break;
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unsupported key type\n");
    return GNUNET_SYSERR;
  }
  memcpy (key, &k, crypto_secretbox_KEYBYTES);
  memcpy (nonce, ((char* ) &k) + crypto_secretbox_KEYBYTES,
          crypto_secretbox_NONCEBYTES);
  if (crypto_secretbox_easy (encrypted_data, pt, pt_size, nonce, key))
    return GNUNET_SYSERR;
  memcpy (kemc_buf, &kemc, sizeof (kemc));
  return GNUNET_OK;
}

Referenced by encrypt_message(), and write_encrypted_message().

Here is the caller graph for this function:

GNUNET_IDENTITY_decrypt()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_decrypt	(	const void *	block,
		size_t	size,
		const struct GNUNET_IDENTITY_PrivateKey *	priv,
		void *	result,
		size_t	result_size
	)

Decrypt a given block with GNUNET_IDENTITY_PrivateKey and a given GNUNET_CRYPTO_EcdhePublicKey using ecdh to derive a symmetric key.

Parameters

block	the data to decrypt, encoded as returned by encrypt
size	the size of the block to decrypt
priv	private key to use for ecdh
result	address to store the result at can be the same or overlap with block

Returns

GNUNET_OK on success.

Definition at line 1139 of file identity_api.c.

{
  struct GNUNET_HashCode k;
  struct GNUNET_CRYPTO_FoKemC *kemc = (struct GNUNET_CRYPTO_FoKemC*) ct_buf;
  unsigned char *encrypted_data = (unsigned char*) &kemc[1];
  unsigned char nonce[crypto_secretbox_NONCEBYTES];
  unsigned char key[crypto_secretbox_KEYBYTES];
  size_t expected_pt_len = ct_size - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES;
 
  if (pt_size < expected_pt_len)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Output buffer size for plaintext too small: Got %lu, want >=%lu\n",
                pt_size, expected_pt_len);
    return GNUNET_SYSERR;
  }
  switch (ntohl (priv->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_fo_kem_decaps (&(priv->ecdsa_key),
                                                            kemc,
                                                            &k))
      return GNUNET_SYSERR;
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_fo_kem_decaps (&(priv->eddsa_key),
                                                            kemc,
                                                            &k))
      return GNUNET_SYSERR;
    break;
  default:
    return GNUNET_SYSERR;
  }
  memcpy (key, &k, crypto_secretbox_KEYBYTES);
  memcpy (nonce, ((char* ) &k) + crypto_secretbox_KEYBYTES,
          crypto_secretbox_NONCEBYTES);
  if (crypto_secretbox_open_easy (pt, encrypted_data, ct_size - sizeof (*kemc),
                                  nonce, key))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References GNUNET_CRYPTO_ecdh_ecdsa(), GNUNET_CRYPTO_ecdh_eddsa(), GNUNET_CRYPTO_ecdhe_key_clear(), GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_CRYPTO_hash_to_aes_key(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_CRYPTO_zero_keys(), GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_IDENTITY_TYPE_EDDSA, GNUNET_SYSERR, key, pk, pub, result, and size.

Referenced by decrypt_message(), and read_encrypted_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_public_key_to_string()

char* GNUNET_IDENTITY_public_key_to_string

(

const struct GNUNET_IDENTITY_PublicKey *

key

)

Creates a (Base32) string representation of the public key.

The resulting string encodes a compacted representation of the key. See also #GNUNET_IDENTITY_key_get_length.

Parameters

key

the key.

Returns

the string representation of the key, or NULL on error.

Definition at line 1310 of file identity_api.c.

{
  size_t size = GNUNET_IDENTITY_public_key_get_length (key);
  return GNUNET_STRINGS_data_to_string_alloc (key,
                                              size);
}

References GNUNET_IDENTITY_public_key_get_length(), GNUNET_STRINGS_data_to_string_alloc(), key, and size.

Referenced by abd_value_to_string(), create_finished(), delegation_chain_fw_resolution_start(), DID_ego_to_did(), DID_pkey_to_did(), forward_resolution(), get_store_contact(), gns_value_to_string(), GNUNET_ABD_delegate_to_string(), GNUNET_GNSRECORD_pkey_to_zkey(), handle_get_key(), handle_intermediate_result(), handle_verify_result(), issue_ticket(), list_ego(), print_deleset(), print_ego(), RECLAIM_TICKETS_consume(), and store_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_private_key_to_string()

char* GNUNET_IDENTITY_private_key_to_string

(

const struct GNUNET_IDENTITY_PrivateKey *

key

)

Creates a (Base32) string representation of the private key.

The resulting string encodes a compacted representation of the key. See also #GNUNET_IDENTITY_key_get_length.

Parameters

key

the key.

Returns

the string representation of the key, or NULL on error.

Definition at line 1320 of file identity_api.c.

{
  size_t size = GNUNET_IDENTITY_private_key_get_length (key);
  return GNUNET_STRINGS_data_to_string_alloc (key,
                                              size);
}

Referenced by create_finished(), display_record(), ego_get_all(), ego_get_response(), and print_ego().

Here is the caller graph for this function:

GNUNET_IDENTITY_public_key_from_string()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_public_key_from_string	(	const char *	str,
		struct GNUNET_IDENTITY_PublicKey *	key
	)

Parses a (Base32) string representation of the public key.

See also GNUNET_IDENTITY_public_key_to_string.

Parameters

str	the encoded key.
key	where to write the key.

Returns

GNUNET_SYSERR on error.

Definition at line 1320 of file identity_api.c.

{
  enum GNUNET_GenericReturnValue ret;
  ret = GNUNET_STRINGS_string_to_data (str,
                                       strlen (str),
                                       key,
                                       sizeof (*key));
  if (GNUNET_OK != ret)
    return GNUNET_SYSERR;
  return check_key_type (ntohl (key->type));
 
}

Referenced by abd_string_to_value(), authorize_endpoint(), code_redirect(), create_response(), get_identity_for_string(), gns_string_to_value(), GNUNET_ABD_delegate_from_string(), GNUNET_GNS_lookup_with_tld(), GNUNET_GNSRECORD_data_from_identity(), identity_cb(), load_member_session(), load_member_session_next(), run(), run_with_zone_pkey(), sign_cb(), start_process(), tld_iter(), and write_encrypted_message().

Here is the caller graph for this function:

GNUNET_IDENTITY_private_key_from_string()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_private_key_from_string	(	const char *	str,
		struct GNUNET_IDENTITY_PrivateKey *	key
	)

Parses a (Base32) string representation of the private key.

See also GNUNET_IDENTITY_private_key_to_string.

Parameters

str	the encoded key.
key	where to write the key.

Returns

GNUNET_SYSERR on error.

Definition at line 1320 of file identity_api.c.

{
  enum GNUNET_GenericReturnValue ret;
  ret = GNUNET_STRINGS_string_to_data (str,
                                       strlen (str),
                                       key,
                                       sizeof (*key));
  if (GNUNET_OK != ret)
    return GNUNET_SYSERR;
  return check_key_type (ntohl (key->type));
}

References GNUNET_IDENTITY_private_key_get_length(), GNUNET_STRINGS_data_to_string_alloc(), key, and size.

Here is the call graph for this function:

GNUNET_IDENTITY_key_get_public()

enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public	(	const struct GNUNET_IDENTITY_PrivateKey *	privkey,
		struct GNUNET_IDENTITY_PublicKey *	key
	)

Retrieves the public key representation of a private key.

Parameters

privkey	the private key.
key	the public key result.

Returns

GNUNET_SYSERR on error.

Definition at line 157 of file identity_api.c.

{
  key->type = privkey->type;
  switch (ntohl (privkey->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    GNUNET_CRYPTO_ecdsa_key_get_public (&privkey->ecdsa_key,
                                        &key->ecdsa_key);
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    GNUNET_CRYPTO_eddsa_key_get_public (&privkey->eddsa_key,
                                        &key->eddsa_key);
    break;
  default:
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

Referenced by attr_iter_cb(), authorize_endpoint(), block_create2(), check_credential_iteration_start(), create_finished(), create_message_key(), DID_create(), filter_tickets_finished_cb(), get_nick_record(), GNUNET_ABD_delegate_issue(), GNUNET_GNSRECORD_query_from_private_key(), GNUNET_IDENTITY_ego_get_public_key(), handle_attribute_store_message(), handle_client_call_message(), handle_collect(), handle_credential_store_message(), identity_zone_cb(), issue_ticket(), RECLAIM_TICKETS_consume(), RECLAIM_TICKETS_revoke(), run_edkey(), run_pkey(), run_with_key(), and update_store_ego().

Here is the caller graph for this function:

GNUNET_IDENTITY_ego_lookup()

struct GNUNET_IDENTITY_EgoLookup* GNUNET_IDENTITY_ego_lookup	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	name,
		GNUNET_IDENTITY_EgoCallback	cb,
		void *	cb_cls
	)

Lookup an ego by name.

Parameters

cfg	configuration to use
name	name to look up
cb	callback to invoke with the result
cb_cls	closure for cb

Returns

NULL on error

Definition at line 186 of file identity_api_lookup.c.

{
  struct GNUNET_IDENTITY_EgoLookup *el;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *req;
  size_t nlen;
 
  GNUNET_assert (NULL != cb);
  el = GNUNET_new (struct GNUNET_IDENTITY_EgoLookup);
  el->cb = cb;
  el->cb_cls = cb_cls;
  {
    struct GNUNET_MQ_MessageHandler handlers[] =
    { GNUNET_MQ_hd_var_size (identity_result_code,
                             GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE,
                             struct ResultCodeMessage,
                             el),
      GNUNET_MQ_hd_var_size (identity_update,
                             GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE,
                             struct UpdateMessage,
                             el),
      GNUNET_MQ_handler_end () };
 
    el->mq =
      GNUNET_CLIENT_connect (cfg, "identity", handlers, &mq_error_handler, el);
  }
  if (NULL == el->mq)
  {
    GNUNET_break (0);
    GNUNET_free (el);
    return NULL;
  }
  el->name = GNUNET_strdup (name);
  nlen = strlen (name) + 1;
  env = GNUNET_MQ_msg_extra (req, nlen, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP);
  memcpy (&req[1], name, nlen);
  GNUNET_MQ_send (el->mq, env);
  return el;
}

References GNUNET_IDENTITY_EgoLookup::cb, GNUNET_IDENTITY_EgoLookup::cb_cls, cfg, el, env, GNUNET_assert, GNUNET_break, GNUNET_CLIENT_connect(), GNUNET_free, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_strdup, handlers, GNUNET_IDENTITY_EgoLookup::mq, mq_error_handler(), name, and GNUNET_IDENTITY_EgoLookup::name.

Referenced by add_continuation(), create_did(), create_did_ego_create_cb(), ego_sign_data(), lookup_store_ego(), parse(), remove_did_document(), replace_did_document_remove_cb(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_ego_lookup_cancel()

void GNUNET_IDENTITY_ego_lookup_cancel

(

struct GNUNET_IDENTITY_EgoLookup *

el

)

Abort ego lookup attempt.

Parameters

el	handle for lookup to abort

Definition at line 236 of file identity_api_lookup.c.

{
  GNUNET_MQ_destroy (el->mq);
  GNUNET_free (el->name);
  GNUNET_free (el);
}

References el, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_IDENTITY_EgoLookup::mq, and GNUNET_IDENTITY_EgoLookup::name.

Referenced by clear_ego_store(), do_shutdown(), handle_identity_result_code(), and handle_identity_update().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_ego_lookup_by_suffix()

struct GNUNET_IDENTITY_EgoSuffixLookup* GNUNET_IDENTITY_ego_lookup_by_suffix	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	suffix,
		GNUNET_IDENTITY_EgoSuffixCallback	cb,
		void *	cb_cls
	)

Obtain the ego with the maximum suffix match between the ego's name and the given domain name suffix.

For example, given a suffix "a.b.c" and egos with names "d.a.b.c", "b.c" and "c", we return the ego for "b.c".

Parameters

cfg	configuration to use
suffix	for which domain name suffix is an identity wanted
cb	function to call with the result (will only be called once)
cb_cls	closure for cb

Returns

handle to abort the operation

Obtain the ego with the maximum suffix match between the ego's name and the given domain name suffix.

Parameters

cfg	configuration to use
name	name to look up
cb	callback to invoke with the result
cb_cls	closure for cb

Returns

NULL on error

Definition at line 185 of file identity_api_suffix_lookup.c.

{
  struct GNUNET_IDENTITY_EgoSuffixLookup *el;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *req;
  size_t nlen;
 
  GNUNET_assert (NULL != cb);
  el = GNUNET_new (struct GNUNET_IDENTITY_EgoSuffixLookup);
  el->cb = cb;
  el->cb_cls = cb_cls;
  {
    struct GNUNET_MQ_MessageHandler handlers[] =
    { GNUNET_MQ_hd_var_size (identity_result_code,
                             GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE,
                             struct ResultCodeMessage,
                             el),
      GNUNET_MQ_hd_var_size (identity_update,
                             GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE,
                             struct UpdateMessage,
                             el),
      GNUNET_MQ_handler_end () };
 
    el->mq =
      GNUNET_CLIENT_connect (cfg, "identity", handlers, &mq_error_handler, el);
  }
  if (NULL == el->mq)
  {
    GNUNET_break (0);
    GNUNET_free (el);
    return NULL;
  }
  el->suffix = GNUNET_strdup (suffix);
  nlen = strlen (suffix) + 1;
  env = GNUNET_MQ_msg_extra (req, nlen,
                             GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP_BY_SUFFIX);
  memcpy (&req[1], suffix, nlen);
  GNUNET_MQ_send (el->mq, env);
  return el;
}

References GNUNET_IDENTITY_EgoLookup::cb, GNUNET_IDENTITY_EgoLookup::cb_cls, cfg, el, env, GNUNET_assert, GNUNET_break, GNUNET_CLIENT_connect(), GNUNET_free, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP_BY_SUFFIX, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_strdup, handlers, GNUNET_IDENTITY_EgoLookup::mq, and mq_error_handler().

Referenced by GNUNET_GNS_lookup_with_tld().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_IDENTITY_ego_lookup_by_suffix_cancel()

void GNUNET_IDENTITY_ego_lookup_by_suffix_cancel

(

struct GNUNET_IDENTITY_EgoSuffixLookup *

el

)

Abort ego suffix lookup attempt.

Parameters

el	handle for lookup to abort

Abort ego suffix lookup attempt.

Parameters

el	handle for lookup to abort

Definition at line 237 of file identity_api_suffix_lookup.c.

{
  GNUNET_MQ_destroy (el->mq);
  GNUNET_free (el->suffix);
  GNUNET_free (el);
}

References el, GNUNET_free, GNUNET_MQ_destroy(), and GNUNET_IDENTITY_EgoLookup::mq.

Referenced by GNUNET_GNS_lookup_with_tld_cancel(), handle_identity_result_code(), handle_identity_update(), and mq_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function: