#include "messenger_api_message.h"
#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "gnunet_signatures.h"

Include dependency graph for messenger_api_message.c:

Data Structures
struct	GNUNET_MESSENGER_MessageSignature

struct	GNUNET_MESSENGER_ShortMessage

Macros
#define	member_size(type, member) sizeof(((type*) NULL)->member)

#define	max(x, y) (x > y? x : y)

#define	min(x, y) (x < y? x : y)

#define	encode_step_ext(dst, offset, src, size)

#define	encode_step(dst, offset, src)

#define	encode_step_key(dst, offset, src, length)

#define	encode_step_signature(dst, offset, src, length)

#define	decode_step_ext(src, offset, dst, size)

#define	decode_step(src, offset, dst)

#define	decode_step_malloc(src, offset, dst, size, zero)

#define	decode_step_key(src, offset, dst, length)

Typedefs
typedef uint32_t	kind_t

Functions
struct GNUNET_MESSENGER_Message *	create_message (enum GNUNET_MESSENGER_MessageKind kind)
	Creates and allocates a new message with a specific kind. More...

struct GNUNET_MESSENGER_Message *	copy_message (const struct GNUNET_MESSENGER_Message *message)
	Creates and allocates a copy of a given message. More...

void	copy_message_header (struct GNUNET_MESSENGER_Message message, const struct GNUNET_MESSENGER_MessageHeader header)
	Copy message header details from another message to a given message. More...

static void	destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, struct GNUNET_MESSENGER_MessageBody *body)

void	cleanup_message (struct GNUNET_MESSENGER_Message *message)
	Frees the messages body memory. More...

void	destroy_message (struct GNUNET_MESSENGER_Message *message)
	Destroys a message and frees its memory fully. More...

enum GNUNET_GenericReturnValue	is_message_session_bound (const struct GNUNET_MESSENGER_Message *message)
	Returns if the message should be bound to a member session. More...

static void	fold_short_message (const struct GNUNET_MESSENGER_Message message, struct GNUNET_MESSENGER_ShortMessage shortened)

static void	unfold_short_message (struct GNUNET_MESSENGER_ShortMessage shortened, struct GNUNET_MESSENGER_Message message)

static uint16_t	get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind)

uint16_t	get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind, enum GNUNET_GenericReturnValue include_header)
	Returns the minimal size in bytes to encode a message of a specific kind. More...

static uint16_t	get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET_MESSENGER_MessageBody *body)

uint16_t	get_message_size (const struct GNUNET_MESSENGER_Message *message, enum GNUNET_GenericReturnValue include_header)
	Returns the exact size in bytes to encode a given message. More...

static uint16_t	get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message, enum GNUNET_GenericReturnValue include_body)

static uint16_t	calc_usual_padding ()

static uint16_t	calc_padded_length (uint16_t length)

static void	encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET_MESSENGER_MessageBody body, uint16_t length, char buffer, uint16_t offset)

void	encode_message (const struct GNUNET_MESSENGER_Message message, uint16_t length, char buffer, enum GNUNET_GenericReturnValue include_header)
	Encodes a given message into a buffer of a maximal length in bytes. More...

static void	encode_short_message (const struct GNUNET_MESSENGER_ShortMessage message, uint16_t length, char buffer)

static uint16_t	decode_message_body (enum GNUNET_MESSENGER_MessageKind kind, struct GNUNET_MESSENGER_MessageBody body, uint16_t length, const char *buffer, uint16_t offset)

enum GNUNET_GenericReturnValue	decode_message (struct GNUNET_MESSENGER_Message message, uint16_t length, const char buffer, enum GNUNET_GenericReturnValue include_header, uint16_t *padding)
	Decodes a message from a given buffer of a maximal length in bytes. More...

static enum GNUNET_GenericReturnValue	decode_short_message (struct GNUNET_MESSENGER_ShortMessage message, uint16_t length, const char buffer)

void	hash_message (const struct GNUNET_MESSENGER_Message message, uint16_t length, const char buffer, struct GNUNET_HashCode *hash)
	Calculates a hash of a given buffer with a length in bytes from a message. More...

void	sign_message (struct GNUNET_MESSENGER_Message message, uint16_t length, char buffer, const struct GNUNET_HashCode hash, const struct GNUNET_CRYPTO_PrivateKey key)
	Signs the hash of a message with a given private key and writes the signature into the buffer as well. More...

void	sign_message_by_peer (struct GNUNET_MESSENGER_Message message, uint16_t length, char buffer, const struct GNUNET_HashCode hash, const struct GNUNET_CONFIGURATION_Handle cfg)
	Signs the hash of a message with the peer identity of a given config and writes the signature into the buffer as well. More...

static void	calc_message_hmac (const struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_SymmetricSessionKey key, struct GNUNET_HashCode *hmac)

void	sign_message_by_key (struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_SymmetricSessionKey key)
	Signs the message body via it's own hmac with a specific shared key. More...

enum GNUNET_GenericReturnValue	verify_message (const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode hash, const struct GNUNET_CRYPTO_PublicKey *key)
	Verifies the signature of a given message and its hash with a specific public key. More...

enum GNUNET_GenericReturnValue	verify_message_by_peer (const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode hash, const struct GNUNET_PeerIdentity *identity)
	Verifies the signature of a given message and its hash with a specific peer's identity. More...

enum GNUNET_GenericReturnValue	verify_message_by_key (const struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_SymmetricSessionKey key)
	Verifies the hmac of a given message body with a specific shared key. More...

enum GNUNET_GenericReturnValue	encrypt_message (struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_PublicKey key)
	Encrypts a message using a given public key and replaces its body and kind with the now private encrypted message. More...

enum GNUNET_GenericReturnValue	decrypt_message (struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_PrivateKey key)
	Decrypts a private message using a given private key and replaces its body and kind with the inner encrypted message. More...

struct GNUNET_MESSENGER_Message *	transcribe_message (const struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_PublicKey key)
	Transcribes a message as a new transcript message using a given public key from the recipient of the encrypted message content. More...

enum GNUNET_GenericReturnValue	encrypt_secret_message (struct GNUNET_MESSENGER_Message message, const union GNUNET_MESSENGER_EpochIdentifier identifier, const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
	Encrypts a message using a given shared key from an announcement of an epoch and replaces its body and kind with the inner encrypted message. More...

enum GNUNET_GenericReturnValue	decrypt_secret_message (struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_SymmetricSessionKey key)
	Decrypts a secret message using a given shared key and replaces its body and kind with the inner encrypted message. More...

enum GNUNET_GenericReturnValue	read_transcript_message (struct GNUNET_MESSENGER_Message *message)
	Read the original message from a transcript message and replaces its body and kind with the inner encrypted message. More...

enum GNUNET_GenericReturnValue	extract_access_message_key (const struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_EcdhePrivateKey key, struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key)
	Extracts the shared epoch or group key from an access message using the private ephemeral key from an epoch and verifies it via the HMAC from the message body. More...

enum GNUNET_GenericReturnValue	extract_authorization_message_key (struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_SymmetricSessionKey key, struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key)
	Extracts the shared epoch or group key from an authorization message using a previously exchanged shared key and verifies it via the HMAC from the message body. More...

struct GNUNET_TIME_Relative	get_message_timeout (const struct GNUNET_MESSENGER_Message *message)
	Return the relative timeout of the content from a given message that controls when a delayed handling action of this message needs to be processed at least. More...

struct GNUNET_MQ_Envelope *	pack_message (struct GNUNET_MESSENGER_Message message, struct GNUNET_HashCode hash, const GNUNET_MESSENGER_SignFunction sign, enum GNUNET_MESSENGER_PackMode mode, const void *cls)
	Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_PACK_MODE_ENVELOPE. More...

enum GNUNET_GenericReturnValue	is_peer_message (const struct GNUNET_MESSENGER_Message *message)
	Returns whether a specific kind of message can be sent by the service without usage of a clients private key. More...

enum GNUNET_GenericReturnValue	is_service_message (const struct GNUNET_MESSENGER_Message *message)
	Returns whether a specific kind of message contains service critical information. More...

enum GNUNET_GenericReturnValue	is_epoch_message (const struct GNUNET_MESSENGER_Message *message)
	Returns whether a certain kind of message from storage contains some specific details that might be required for the overall message graph to function as intended. More...

enum GNUNET_GenericReturnValue	filter_message_sending (const struct GNUNET_MESSENGER_Message *message)
	Returns whether a specific kind of message should be sent by a client. More...

const struct GNUNET_ShortHashCode *	get_message_discourse (const struct GNUNET_MESSENGER_Message *message)
	Returns the discourse hash of a message depending on its kind. More...

Variables
const uint16_t	encryption_overhead

Macro Definition Documentation

◆ member_size

#define member_size	(	type,
		member
	)	sizeof(((type*) NULL)->member)

Definition at line 300 of file messenger_api_message.c.

◆ max

#define max	(	x,
		y
	)	(x > y? x : y)

Definition at line 588 of file messenger_api_message.c.

◆ min

#define min	(	x,
		y
	)	(x < y? x : y)

Definition at line 617 of file messenger_api_message.c.

◆ encode_step_ext

#define encode_step_ext	(	dst,
		offset,
		src,
		size
	)

Value:

          do { \
          GNUNET_memcpy (dst + offset, src, size);   \
          offset += size;                            \
} while (0)

Definition at line 619 of file messenger_api_message.c.

◆ encode_step

#define encode_step	(	dst,
		offset,
		src
	)

Value:

          do {                  \
          encode_step_ext (dst, offset, src, sizeof(*src)); \
} while (0)

Definition at line 624 of file messenger_api_message.c.

◆ encode_step_key

#define encode_step_key	(	dst,
		offset,
		src,
		length
	)

Value:

          do {                \
          ssize_t result = GNUNET_CRYPTO_write_public_key_to_buffer ( \
            src, dst + offset, length - offset);                      \
          if (result < 0)                                             \
          GNUNET_break (0);                                           \
          else                                                        \
          offset += result;                                           \
} while (0)

Definition at line 628 of file messenger_api_message.c.

◆ encode_step_signature

#define encode_step_signature	(	dst,
		offset,
		src,
		length
	)

Value:

          do {         \
          ssize_t result = GNUNET_CRYPTO_write_signature_to_buffer ( \
            src, dst + offset, length - offset);                     \
          if (result < 0)                                            \
          GNUNET_break (0);                                          \
          else                                                       \
          offset += result;                                          \
} while (0)

Definition at line 637 of file messenger_api_message.c.

◆ decode_step_ext

#define decode_step_ext	(	src,
		offset,
		dst,
		size
	)

Value:

          do { \
          GNUNET_memcpy (dst, src + offset, size);   \
          offset += size;                            \
} while (0)

Definition at line 907 of file messenger_api_message.c.

◆ decode_step

#define decode_step	(	src,
		offset,
		dst
	)

Value:

          do {                  \
          decode_step_ext (src, offset, dst, sizeof(*dst)); \
} while (0)

Definition at line 912 of file messenger_api_message.c.

◆ decode_step_malloc

#define decode_step_malloc	(	src,
		offset,
		dst,
		size,
		zero
	)

Value:

          do { \
          dst = GNUNET_malloc (size + zero);                  \
          if (zero) dst[size] = 0;                            \
          decode_step_ext (src, offset, dst, size);           \
} while (0)

Definition at line 916 of file messenger_api_message.c.

◆ decode_step_key

#define decode_step_key	(	src,
		offset,
		dst,
		length
	)

Value:

          do {         \
          enum GNUNET_GenericReturnValue result;               \
          size_t read;                                         \
          result = GNUNET_CRYPTO_read_public_key_from_buffer ( \
            src + offset, length - offset, dst, &read);        \
          if (GNUNET_SYSERR == result)                         \
          GNUNET_break (0);                                    \
          else                                                 \
          offset += read;                                      \
} while (0)

Definition at line 922 of file messenger_api_message.c.

Typedef Documentation

◆ kind_t

typedef uint32_t kind_t

Definition at line 454 of file messenger_api_message.c.

Function Documentation

◆ create_message()

struct GNUNET_MESSENGER_Message * create_message ( enum GNUNET_MESSENGER_MessageKind kind )

Creates and allocates a new message with a specific kind.

Parameters

[in] kind Kind of message

Returns: New message

Definition at line 48 of file messenger_api_message.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  message = GNUNET_new (struct GNUNET_MESSENGER_Message);
  message->header.kind = kind;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_NAME:
    message->body.name.name = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TEXT:
    message->body.text.text = NULL;
    break;
  case GNUNET_MESSENGER_KIND_FILE:
    message->body.file.uri = NULL;
    break;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    message->body.privacy.length = 0;
    message->body.privacy.data = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TICKET:
    message->body.ticket.identifier = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    message->body.transcript.length = 0;
    message->body.transcript.data = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    message->body.tag.tag = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    message->body.talk.length = 0;
    message->body.talk.data = NULL;
    break;
  case GNUNET_MESSENGER_KIND_SECRET:
    message->body.secret.length = 0;
    message->body.secret.data = NULL;
    break;
  default:
    break;
  }
 
  return message;
}

Referenced by create_message_access(), create_message_announcement(), create_message_appeal(), create_message_authorization(), create_message_connection(), create_message_deletion(), create_message_group(), create_message_id(), create_message_info(), create_message_join(), create_message_key(), create_message_leave(), create_message_merge(), create_message_miss(), create_message_name(), create_message_peer(), create_message_request(), create_message_revolution(), create_message_subscribtion(), get_store_message(), and transcribe_message().

Here is the caller graph for this function:

◆ copy_message()

struct GNUNET_MESSENGER_Message * copy_message ( const struct GNUNET_MESSENGER_Message * message )

Creates and allocates a copy of a given message.

Parameters

[in] message Message

Returns: New message

Definition at line 97 of file messenger_api_message.c.

{
  struct GNUNET_MESSENGER_Message *copy;
 
  GNUNET_assert (message);
 
  copy = GNUNET_new (struct GNUNET_MESSENGER_Message);
  GNUNET_memcpy (copy, message, sizeof(struct GNUNET_MESSENGER_Message));
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_NAME:
    copy->body.name.name = message->body.name.name? GNUNET_strdup (
      message->body.name.name) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_TEXT:
    copy->body.text.text = message->body.text.text? GNUNET_strdup (
      message->body.text.text) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_FILE:
    copy->body.file.uri = message->body.file.uri? GNUNET_strdup (
      message->body.file.uri) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc (
      copy->body.privacy.length) : NULL;
 
    if (copy->body.privacy.data)
      GNUNET_memcpy (copy->body.privacy.data, message->body.privacy.data,
                     copy->body.privacy.length);
 
    break;
  case GNUNET_MESSENGER_KIND_TICKET:
    copy->body.ticket.identifier = message->body.ticket.identifier?
                                   GNUNET_strdup (
      message->body.ticket.identifier) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    copy->body.transcript.data = copy->body.transcript.length ? GNUNET_malloc (
      copy->body.transcript.length) : NULL;
 
    if (copy->body.transcript.data)
      GNUNET_memcpy (copy->body.transcript.data, message->body.transcript.data,
                     copy->body.transcript.length);
 
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    copy->body.tag.tag = message->body.tag.tag? GNUNET_strdup (
      message->body.tag.tag) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    copy->body.talk.data = copy->body.talk.length ? GNUNET_malloc (
      copy->body.talk.length) : NULL;
 
    if (copy->body.talk.data)
      GNUNET_memcpy (copy->body.talk.data, message->body.talk.data,
                     copy->body.talk.length);
 
    break;
  case GNUNET_MESSENGER_KIND_SECRET:
    copy->body.secret.data = copy->body.secret.length ? GNUNET_malloc (
      copy->body.secret.length) : NULL;
 
    if (copy->body.secret.data)
      GNUNET_memcpy (copy->body.secret.data, message->body.secret.data,
                     copy->body.secret.length);
 
    break;
  default:
    break;
  }
 
  return copy;
}

Referenced by enqueue_message_control(), forward_tunnel_message(), GNUNET_MESSENGER_send_message(), handle_private_message(), handle_room_message(), handle_transcript_message(), handle_tunnel_message(), send_srv_handle_message(), and update_room_secret_message().

Here is the caller graph for this function:

◆ copy_message_header()

void copy_message_header	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_MESSENGER_MessageHeader *	header
	)

Copy message header details from another message to a given message.

Parameters

[in,out]	message	Message
[in]	header	Message header

Definition at line 174 of file messenger_api_message.c.

{
  enum GNUNET_MESSENGER_MessageKind kind;
 
  GNUNET_assert ((message) && (header));
 
  kind = message->header.kind;
 
  GNUNET_memcpy (&(message->header), header,
                 sizeof(struct GNUNET_MESSENGER_MessageHeader));
 
  message->header.kind = kind;
}

References GNUNET_assert, GNUNET_memcpy, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by handle_room_message(), and handle_transcript_message().

Here is the caller graph for this function:

◆ destroy_message_body()

static void destroy_message_body	(	enum GNUNET_MESSENGER_MessageKind	kind,
		struct GNUNET_MESSENGER_MessageBody *	body
	)

static

Definition at line 191 of file messenger_api_message.c.

{
  GNUNET_assert (body);
 
  switch (kind)
  {
  case GNUNET_MESSENGER_KIND_NAME:
    if (body->name.name)
      GNUNET_free (body->name.name);
    break;
  case GNUNET_MESSENGER_KIND_TEXT:
    if (body->text.text)
      GNUNET_free (body->text.text);
    break;
  case GNUNET_MESSENGER_KIND_FILE:
    if (body->file.uri)
      GNUNET_free (body->file.uri);
    break;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    if (body->privacy.data)
      GNUNET_free (body->privacy.data);
    break;
  case GNUNET_MESSENGER_KIND_TICKET:
    if (body->ticket.identifier)
      GNUNET_free (body->ticket.identifier);
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    if (body->transcript.data)
      GNUNET_free (body->transcript.data);
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    if (body->tag.tag)
      GNUNET_free (body->tag.tag);
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    if (body->talk.data)
      GNUNET_free (body->talk.data);
    break;
  case GNUNET_MESSENGER_KIND_SECRET:
    if (body->secret.data)
      GNUNET_free (body->secret.data);
    break;
  default:
    break;
  }
}

Referenced by cleanup_message(), destroy_message(), encrypt_message(), encrypt_secret_message(), and unfold_short_message().

Here is the caller graph for this function:

◆ cleanup_message()

void cleanup_message ( struct GNUNET_MESSENGER_Message * message )

Frees the messages body memory.

Parameters

[in,out] message Message

Definition at line 241 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  destroy_message_body (message->header.kind, &(message->body));
}

References GNUNET_MESSENGER_Message::body, destroy_message_body(), GNUNET_assert, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by check_recv_message(), check_send_message(), handle_recv_message(), handle_send_message(), and handle_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_message()

void destroy_message ( struct GNUNET_MESSENGER_Message * message )

Destroys a message and frees its memory fully.

Parameters

[in,out] message Message

Definition at line 250 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  destroy_message_body (message->header.kind, &(message->body));
 
  GNUNET_free (message);
}

References GNUNET_MESSENGER_Message::body, destroy_message_body(), GNUNET_assert, GNUNET_free, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by clear_queue_messages(), create_message_access(), create_message_authorization(), create_message_peer(), dequeue_from_messages(), dequeue_message_from_room(), destroy_message_control(), enqueue_to_messages(), forward_tunnel_message(), get_store_message(), handle_discourse_subscription(), handle_private_message(), handle_room_delayed_deletion(), handle_transcript_message(), iterate_destroy_message(), iterate_destroy_messages(), iterate_destroy_subscription(), iterate_flag_for_cleanup_discourse_message(), keep_subscription_alive(), send_message_to_room_with_key(), send_tunnel_message(), task_message_control(), update_room_message(), and update_room_secret_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_message_session_bound()

enum GNUNET_GenericReturnValue is_message_session_bound ( const struct GNUNET_MESSENGER_Message * message )

Returns if the message should be bound to a member session.

Parameters

[in] message Message

Returns: GNUNET_YES or GNUNET_NO

Definition at line 261 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) ||
      (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) ||
      (GNUNET_MESSENGER_KIND_NAME == message->header.kind) ||
      (GNUNET_MESSENGER_KIND_KEY == message->header.kind) ||
      (GNUNET_MESSENGER_KIND_ID == message->header.kind))
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

References GNUNET_assert, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_NAME, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by enqueue_message_to_room(), and update_member_session_history().

Here is the caller graph for this function:

◆ fold_short_message()

static void fold_short_message	(	const struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_MESSENGER_ShortMessage *	shortened
	)

static

Definition at line 277 of file messenger_api_message.c.

{
  shortened->kind = message->header.kind;
 
  GNUNET_memcpy (&(shortened->body), &(message->body), sizeof(struct
                                                              GNUNET_MESSENGER_MessageBody));
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_ShortMessage::body, GNUNET_memcpy, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, and GNUNET_MESSENGER_ShortMessage::kind.

Referenced by encrypt_message(), encrypt_secret_message(), and transcribe_message().

Here is the caller graph for this function:

◆ unfold_short_message()

static void unfold_short_message	(	struct GNUNET_MESSENGER_ShortMessage *	shortened,
		struct GNUNET_MESSENGER_Message *	message
	)

static

Definition at line 288 of file messenger_api_message.c.

{
  destroy_message_body (message->header.kind, &(message->body));
 
  message->header.kind = shortened->kind;
 
  GNUNET_memcpy (&(message->body), &(shortened->body),
                 sizeof(struct GNUNET_MESSENGER_MessageBody));
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_ShortMessage::body, destroy_message_body(), GNUNET_memcpy, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, and GNUNET_MESSENGER_ShortMessage::kind.

Referenced by decrypt_message(), decrypt_secret_message(), encrypt_message(), encrypt_secret_message(), and read_transcript_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_message_body_kind_size()

static uint16_t get_message_body_kind_size ( enum GNUNET_MESSENGER_MessageKind kind )

static

Definition at line 303 of file messenger_api_message.c.

{
  uint16_t length;
 
  length = 0;
 
  switch (kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.info.messenger_version);
    break;
  case GNUNET_MESSENGER_KIND_JOIN:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.join.epoch);
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.leave.epoch);
    break;
  case GNUNET_MESSENGER_KIND_PEER:
    length += member_size (struct GNUNET_MESSENGER_Message, body.peer.peer);
    break;
  case GNUNET_MESSENGER_KIND_ID:
    length += member_size (struct GNUNET_MESSENGER_Message, body.id.id);
    break;
  case GNUNET_MESSENGER_KIND_MISS:
    length += member_size (struct GNUNET_MESSENGER_Message, body.miss.peer);
    break;
  case GNUNET_MESSENGER_KIND_MERGE:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.merge.epochs[0]);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.merge.epochs[1]);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.merge.previous);
    break;
  case GNUNET_MESSENGER_KIND_REQUEST:
    length += member_size (struct GNUNET_MESSENGER_Message, body.request.hash);
    break;
  case GNUNET_MESSENGER_KIND_INVITE:
    length += member_size (struct GNUNET_MESSENGER_Message, body.invite.door);
    length += member_size (struct GNUNET_MESSENGER_Message, body.invite.key);
    break;
  case GNUNET_MESSENGER_KIND_FILE:
    length += member_size (struct GNUNET_MESSENGER_Message, body.file.key);
    length += member_size (struct GNUNET_MESSENGER_Message, body.file.hash);
    length += member_size (struct GNUNET_MESSENGER_Message, body.file.name);
    break;
  case GNUNET_MESSENGER_KIND_DELETION:
    length += member_size (struct GNUNET_MESSENGER_Message, body.deletion.hash);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.deletion.delay);
    break;
  case GNUNET_MESSENGER_KIND_CONNECTION:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.connection.amount);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.connection.flags);
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.transcript.hash);
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    length += member_size (struct GNUNET_MESSENGER_Message, body.tag.hash);
    break;
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.subscribtion.discourse);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.subscribtion.time);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.subscribtion.flags);
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.talk.discourse);
    break;
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.announcement.identifier);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.announcement.key);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.announcement.nonce);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.announcement.timeout);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.announcement.hmac);
    break;
  case GNUNET_MESSENGER_KIND_SECRET:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.secret.identifier);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.secret.iv);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.secret.hmac);
    break;
  case GNUNET_MESSENGER_KIND_APPEAL:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.appeal.event);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.appeal.key);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.appeal.timeout);
    break;
  case GNUNET_MESSENGER_KIND_ACCESS:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.access.event);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.access.key);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.access.hmac);
    break;
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.revolution.identifier);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.revolution.nonce);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.revolution.hmac);
    break;
  case GNUNET_MESSENGER_KIND_GROUP:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.group.identifier);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.group.initiator);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.group.partner);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.group.timeout);
    break;
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.authorization.identifier);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.authorization.event);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.authorization.key);
    length += member_size (struct GNUNET_MESSENGER_Message,
                           body.authorization.hmac);
    break;
  default:
    break;
  }
 
  return length;
}

Referenced by get_message_kind_size(), and get_short_message_size().

Here is the caller graph for this function:

◆ get_message_kind_size()

uint16_t get_message_kind_size	(	enum GNUNET_MESSENGER_MessageKind	kind,
		enum GNUNET_GenericReturnValue	include_header
	)

Returns the minimal size in bytes to encode a message of a specific kind.

Parameters

[in]	kind	Kind of message
[in]	include_header	Flag to include header

Returns: Minimal size to encode

Definition at line 457 of file messenger_api_message.c.

{
  uint16_t length;
 
  length = 0;
 
  if (GNUNET_YES == include_header)
  {
    length += member_size (struct GNUNET_MESSENGER_Message, header.timestamp);
    length += member_size (struct GNUNET_MESSENGER_Message, header.sender_id);
    length += member_size (struct GNUNET_MESSENGER_Message, header.previous);
  }
 
  length += sizeof(kind_t);
 
  return length + get_message_body_kind_size (kind);
}

References get_message_body_kind_size(), GNUNET_YES, GNUNET_MESSENGER_Message::header, member_size, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageHeader::sender_id, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by calc_usual_padding(), check_recv_message(), check_send_message(), check_tunnel_message(), decode_message(), get_message_size(), and get_store_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_message_body_size()

static uint16_t get_message_body_size	(	enum GNUNET_MESSENGER_MessageKind	kind,
		const struct GNUNET_MESSENGER_MessageBody *	body
	)

static

Definition at line 478 of file messenger_api_message.c.

{
  uint16_t length;
 
  length = 0;
 
  switch (kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    length += GNUNET_CRYPTO_public_key_get_length (&(body->join.key));
    break;
  case GNUNET_MESSENGER_KIND_NAME:
    length += (body->name.name ? strlen (body->name.name) : 0);
    break;
  case GNUNET_MESSENGER_KIND_KEY:
    length += GNUNET_CRYPTO_public_key_get_length (&(body->key.key));
    break;
  case GNUNET_MESSENGER_KIND_TEXT:
    length += (body->text.text ? strlen (body->text.text) : 0);
    break;
  case GNUNET_MESSENGER_KIND_FILE:
    length += (body->file.uri ? strlen (body->file.uri) : 0);
    break;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    length += body->privacy.length;
    break;
  case GNUNET_MESSENGER_KIND_TICKET:
    length += (body->ticket.identifier ? strlen (body->ticket.identifier) : 0);
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    length += GNUNET_CRYPTO_public_key_get_length (&(body->transcript.key));
    length += body->transcript.length;
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    length += (body->tag.tag ? strlen (body->tag.tag) : 0);
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    length += body->talk.length;
    break;
  case GNUNET_MESSENGER_KIND_SECRET:
    length += body->secret.length;
    break;
  default:
    break;
  }
 
  return length;
}

Referenced by get_message_size(), and get_short_message_size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_message_size()

uint16_t get_message_size	(	const struct GNUNET_MESSENGER_Message *	message,
		enum GNUNET_GenericReturnValue	include_header
	)

Returns the exact size in bytes to encode a given message.

Parameters

[in]	message	Message
[in]	include_header	Flag to include header

Returns: Size to encode

Definition at line 530 of file messenger_api_message.c.

{
  uint16_t length;
 
  GNUNET_assert (message);
 
  length = 0;
 
  if (GNUNET_YES == include_header)
    length += GNUNET_CRYPTO_signature_get_length (
      &(message->header.signature));
 
  length += get_message_kind_size (message->header.kind, include_header);
  length += get_message_body_size (message->header.kind, &(message->body));
 
  return length;
}

References GNUNET_MESSENGER_Message::body, get_message_body_size(), get_message_kind_size(), GNUNET_assert, GNUNET_CRYPTO_signature_get_length(), GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, and GNUNET_MESSENGER_MessageHeader::signature.

Referenced by iterate_save_messages(), notify_srv_handle_message(), pack_message(), and send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_short_message_size()

static uint16_t get_short_message_size	(	const struct GNUNET_MESSENGER_ShortMessage *	message,
		enum GNUNET_GenericReturnValue	include_body
	)

static

Definition at line 551 of file messenger_api_message.c.

{
  uint16_t minimum_size;
 
  minimum_size = sizeof(struct GNUNET_HashCode) + sizeof(kind_t);
 
  if (message)
    return minimum_size + get_message_body_kind_size (message->kind)
           + (include_body == GNUNET_YES?
              get_message_body_size (message->kind, &(message->body)) : 0);
  else
    return minimum_size;
}

References GNUNET_MESSENGER_ShortMessage::body, get_message_body_kind_size(), get_message_body_size(), GNUNET_YES, and GNUNET_MESSENGER_ShortMessage::kind.

Referenced by decode_short_message(), encrypt_message(), encrypt_secret_message(), and transcribe_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calc_usual_padding()

static uint16_t calc_usual_padding ( )

static

Definition at line 568 of file messenger_api_message.c.

{
  uint16_t padding;
  uint16_t kind_size;
 
  padding = 0;
 
  for (unsigned int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++)
  {
    kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i,
                                       GNUNET_YES);
 
    if (kind_size > padding)
      padding = kind_size;
  }
 
  return padding + GNUNET_MESSENGER_PADDING_MIN;
}

References get_message_kind_size(), GNUNET_MESSENGER_KIND_MAX, GNUNET_MESSENGER_PADDING_MIN, and GNUNET_YES.

Referenced by calc_padded_length().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calc_padded_length()

static uint16_t calc_padded_length ( uint16_t length )

static

Definition at line 591 of file messenger_api_message.c.

{
  static uint16_t usual_padding = 0;
  uint16_t padded_length;
 
  if (! usual_padding)
    usual_padding = calc_usual_padding ();
 
  padded_length = max (
    length + GNUNET_MESSENGER_PADDING_MIN,
    usual_padding);
 
  if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL0)
    return GNUNET_MESSENGER_PADDING_LEVEL0;
 
  if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL1)
    return GNUNET_MESSENGER_PADDING_LEVEL1;
 
  if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL2)
    return GNUNET_MESSENGER_PADDING_LEVEL2;
 
  return GNUNET_MESSENGER_MAX_MESSAGE_SIZE;
 
}

References calc_usual_padding(), GNUNET_MESSENGER_MAX_MESSAGE_SIZE, GNUNET_MESSENGER_PADDING_LEVEL0, GNUNET_MESSENGER_PADDING_LEVEL1, GNUNET_MESSENGER_PADDING_LEVEL2, GNUNET_MESSENGER_PADDING_MIN, and max.

Referenced by encrypt_message(), encrypt_secret_message(), and pack_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_message_body()

static void encode_message_body	(	enum GNUNET_MESSENGER_MessageKind	kind,
		const struct GNUNET_MESSENGER_MessageBody *	body,
		uint16_t	length,
		char *	buffer,
		uint16_t	offset
	)

static

Definition at line 647 of file messenger_api_message.c.

{
  uint32_t value0, value1;
 
  GNUNET_assert ((body) && (buffer));
 
  switch (kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
    value0 = GNUNET_htobe32 (body->info.messenger_version);
 
    encode_step (buffer, offset, &value0);
    break;
  case GNUNET_MESSENGER_KIND_JOIN:
    encode_step (buffer, offset, &(body->join.epoch));
    encode_step_key (buffer, offset, &(body->join.key), length);
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    encode_step (buffer, offset, &(body->leave.epoch));
    break;
  case GNUNET_MESSENGER_KIND_NAME:
    if (body->name.name)
      encode_step_ext (
        buffer,
        offset,
        body->name.name,
        min (length - offset, strlen (body->name.name)));
    break;
  case GNUNET_MESSENGER_KIND_KEY:
    encode_step_key (buffer, offset, &(body->key.key), length);
    break;
  case GNUNET_MESSENGER_KIND_PEER:
    encode_step (buffer, offset, &(body->peer.peer));
    break;
  case GNUNET_MESSENGER_KIND_ID:
    encode_step (buffer, offset, &(body->id.id));
    break;
  case GNUNET_MESSENGER_KIND_MISS:
    encode_step (buffer, offset, &(body->miss.peer));
    break;
  case GNUNET_MESSENGER_KIND_MERGE:
    encode_step (buffer, offset, &(body->merge.epochs[0]));
    encode_step (buffer, offset, &(body->merge.epochs[1]));
    encode_step (buffer, offset, &(body->merge.previous));
    break;
  case GNUNET_MESSENGER_KIND_REQUEST:
    encode_step (buffer, offset, &(body->request.hash));
    break;
  case GNUNET_MESSENGER_KIND_INVITE:
    encode_step (buffer, offset, &(body->invite.door));
    encode_step (buffer, offset, &(body->invite.key));
    break;
  case GNUNET_MESSENGER_KIND_TEXT:
    if (body->text.text)
      encode_step_ext (
        buffer,
        offset,
        body->text.text,
        min (length - offset, strlen (body->text.text)));
    break;
  case GNUNET_MESSENGER_KIND_FILE:
    encode_step (buffer, offset, &(body->file.key));
    encode_step (buffer, offset, &(body->file.hash));
    encode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name));
    if (body->file.uri)
      encode_step_ext (buffer, offset, body->file.uri, min (length - offset,
                                                            strlen (
                                                              body->file.uri)));
    break;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    if (body->privacy.data)
      encode_step_ext (buffer, offset, body->privacy.data, min (length - offset,
                                                                body->privacy.
                                                                length));
    break;
  case GNUNET_MESSENGER_KIND_DELETION:
    encode_step (buffer, offset, &(body->deletion.hash));
    encode_step (buffer, offset, &(body->deletion.delay));
    break;
  case GNUNET_MESSENGER_KIND_CONNECTION:
    value0 = GNUNET_htobe32 (body->connection.amount);
    value1 = GNUNET_htobe32 (body->connection.flags);
 
    encode_step (buffer, offset, &value0);
    encode_step (buffer, offset, &value1);
    break;
  case GNUNET_MESSENGER_KIND_TICKET:
    encode_step_ext (buffer, offset, body->ticket.identifier,
                     min (length - offset, strlen (body->ticket.identifier)));
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    encode_step (buffer, offset, &(body->transcript.hash));
    encode_step_key (buffer, offset, &(body->transcript.key), length);
 
    if (body->transcript.data)
      encode_step_ext (buffer, offset, body->transcript.data, min (length
                                                                   - offset,
                                                                   body->
                                                                   transcript.
                                                                   length));
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    encode_step (buffer, offset, &(body->tag.hash));
 
    if (body->tag.tag)
      encode_step_ext (buffer, offset, body->tag.tag, min (length - offset,
                                                           strlen (
                                                             body->tag.tag)));
    break;
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    value0 = GNUNET_htobe32 (body->subscribtion.flags);
 
    encode_step (buffer, offset, &(body->subscribtion.discourse));
    encode_step (buffer, offset, &(body->subscribtion.time));
    encode_step (buffer, offset, &value0);
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    encode_step (buffer, offset, &(body->talk.discourse));
 
    if (body->talk.data)
      encode_step_ext (buffer, offset, body->talk.data, min (length - offset,
                                                             body->talk.
                                                             length));
    break;
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    encode_step (buffer, offset, &(body->announcement.identifier));
    encode_step (buffer, offset, &(body->announcement.key));
    encode_step (buffer, offset, &(body->announcement.nonce));
    encode_step (buffer, offset, &(body->announcement.timeout));
    encode_step (buffer, offset, &(body->announcement.hmac));
    break;
  case GNUNET_MESSENGER_KIND_SECRET:
    encode_step (buffer, offset, &(body->secret.identifier));
    encode_step (buffer, offset, &(body->secret.iv));
    encode_step (buffer, offset, &(body->secret.hmac));
 
    if (body->secret.data)
      encode_step_ext (buffer, offset, body->secret.data, min (length - offset,
                                                               body->secret.
                                                               length));
    break;
  case GNUNET_MESSENGER_KIND_APPEAL:
    encode_step (buffer, offset, &(body->appeal.event));
    encode_step (buffer, offset, &(body->appeal.key));
    encode_step (buffer, offset, &(body->appeal.timeout));
    break;
  case GNUNET_MESSENGER_KIND_ACCESS:
    encode_step (buffer, offset, &(body->access.event));
    encode_step (buffer, offset, &(body->access.key));
    encode_step (buffer, offset, &(body->access.hmac));
    break;
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    encode_step (buffer, offset, &(body->revolution.identifier));
    encode_step (buffer, offset, &(body->revolution.nonce));
    encode_step (buffer, offset, &(body->revolution.hmac));
    break;
  case GNUNET_MESSENGER_KIND_GROUP:
    encode_step (buffer, offset, &(body->group.identifier));
    encode_step (buffer, offset, &(body->group.initiator));
    encode_step (buffer, offset, &(body->group.partner));
    encode_step (buffer, offset, &(body->group.timeout));
    break;
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    encode_step (buffer, offset, &(body->authorization.identifier));
    encode_step (buffer, offset, &(body->authorization.event));
    encode_step (buffer, offset, &(body->authorization.key));
    encode_step (buffer, offset, &(body->authorization.hmac));
    break;
  default:
    break;
  }
 
  if (offset >= length)
    return;
 
  {
    uint16_t padding;
    uint16_t used_padding;
 
    padding = length - offset;
    used_padding = sizeof(padding) + sizeof(char);
 
    GNUNET_assert (padding >= used_padding);
 
    buffer[offset++] = '\0';
 
    if (padding > used_padding)
      GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset,
                                  padding - used_padding);
 
    GNUNET_memcpy (buffer + length - sizeof(padding), &padding,
                   sizeof(padding));
  }
}

Referenced by encode_message(), and encode_short_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_message()

void encode_message	(	const struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		char *	buffer,
		enum GNUNET_GenericReturnValue	include_header
	)

Encodes a given message into a buffer of a maximal length in bytes.

Parameters

[in]	message	Message
[in]	length	Maximal length to encode
[out]	buffer	Buffer
[in]	include_header	Flag to include header

Definition at line 848 of file messenger_api_message.c.

{
  uint16_t offset;
  kind_t kind;
 
  GNUNET_assert ((message) && (buffer));
 
  offset = 0;
 
  if (GNUNET_YES == include_header)
    encode_step_signature (buffer, offset, &(message->header.signature),
                           length);
 
  kind = GNUNET_htobe32 ((kind_t) message->header.kind);
 
  if (GNUNET_YES == include_header)
  {
    encode_step (buffer, offset, &(message->header.timestamp));
    encode_step (buffer, offset, &(message->header.sender_id));
    encode_step (buffer, offset, &(message->header.previous));
  }
 
  encode_step (buffer, offset, &kind);
 
  encode_message_body (message->header.kind, &(message->body),
                       length, buffer, offset);
}

References GNUNET_MESSENGER_Message::body, encode_message_body(), encode_step, encode_step_signature, GNUNET_assert, GNUNET_htobe32, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageHeader::sender_id, GNUNET_MESSENGER_MessageHeader::signature, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by iterate_save_messages(), notify_srv_handle_message(), pack_message(), and send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_short_message()

static void encode_short_message	(	const struct GNUNET_MESSENGER_ShortMessage *	message,
		uint16_t	length,
		char *	buffer
	)

static

Definition at line 881 of file messenger_api_message.c.

{
  struct GNUNET_HashCode hash;
  uint16_t offset;
  kind_t kind;
 
  GNUNET_assert ((message) && (buffer));
 
  offset = sizeof(hash);
  kind = GNUNET_htobe32 ((kind_t) message->kind);
 
  encode_step (buffer, offset, &kind);
 
  encode_message_body (message->kind, &(message->body), length, buffer, offset);
 
  GNUNET_CRYPTO_hash (
    buffer + sizeof(hash),
    length - sizeof(hash),
    &hash);
 
  GNUNET_memcpy (buffer, &hash, sizeof(hash));
}

References GNUNET_MESSENGER_ShortMessage::body, encode_message_body(), encode_step, GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_htobe32, GNUNET_memcpy, and GNUNET_MESSENGER_ShortMessage::kind.

Referenced by encrypt_message(), encrypt_secret_message(), and transcribe_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decode_message_body()

static uint16_t decode_message_body	(	enum GNUNET_MESSENGER_MessageKind *	kind,
		struct GNUNET_MESSENGER_MessageBody *	body,
		uint16_t	length,
		const char *	buffer,
		uint16_t	offset
	)

static

Definition at line 934 of file messenger_api_message.c.

{
  uint16_t padding;
  uint32_t value0, value1;
 
  GNUNET_assert ((kind) && (body) && (buffer));
 
  padding = 0;
 
  GNUNET_memcpy (&padding, buffer + length - sizeof(padding), sizeof(padding));
 
  if (padding > length - offset)
    padding = 0;
 
  {
    uint16_t end_zero;
    end_zero = length - padding;
 
    if ((padding) && (buffer[end_zero] != '\0'))
      padding = 0;
  }
 
  length -= padding;
 
  switch (*kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
    decode_step (buffer, offset, &value0);
 
    body->info.messenger_version = GNUNET_be32toh (value0);
    break;
  case GNUNET_MESSENGER_KIND_JOIN:
    decode_step (buffer, offset, &(body->join.epoch));
    decode_step_key (buffer, offset, &(body->join.key), length);
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    decode_step (buffer, offset, &(body->leave.epoch));
    break;
  case GNUNET_MESSENGER_KIND_NAME:
    if (length > offset)
      decode_step_malloc (buffer, offset, body->name.name, length - offset, 1);
    else
      body->name.name = NULL;
    break;
  case GNUNET_MESSENGER_KIND_KEY:
    decode_step_key (buffer, offset, &(body->key.key), length);
    break;
  case GNUNET_MESSENGER_KIND_PEER:
    decode_step (buffer, offset, &(body->peer.peer));
    break;
  case GNUNET_MESSENGER_KIND_ID:
    decode_step (buffer, offset, &(body->id.id));
    break;
  case GNUNET_MESSENGER_KIND_MISS:
    decode_step (buffer, offset, &(body->miss.peer));
    break;
  case GNUNET_MESSENGER_KIND_MERGE:
    decode_step (buffer, offset, &(body->merge.epochs[0]));
    decode_step (buffer, offset, &(body->merge.epochs[1]));
    decode_step (buffer, offset, &(body->merge.previous));
    break;
  case GNUNET_MESSENGER_KIND_REQUEST:
    decode_step (buffer, offset, &(body->request.hash));
    break;
  case GNUNET_MESSENGER_KIND_INVITE:
    decode_step (buffer, offset, &(body->invite.door));
    decode_step (buffer, offset, &(body->invite.key));
    break;
  case GNUNET_MESSENGER_KIND_TEXT:
    if (length > offset)
      decode_step_malloc (buffer, offset, body->text.text, length - offset, 1);
    else
      body->text.text = NULL;
    break;
  case GNUNET_MESSENGER_KIND_FILE:
    decode_step (buffer, offset, &(body->file.key));
    decode_step (buffer, offset, &(body->file.hash));
    decode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name));
    if (length > offset)
      decode_step_malloc (buffer, offset, body->file.uri, length - offset, 1);
    else
      body->file.uri = NULL;
    break;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    if (length > offset)
    {
      body->privacy.length = (length - offset);
      decode_step_malloc (buffer, offset, body->privacy.data, length - offset,
                          0);
    }
    else
    {
      body->privacy.length = 0;
      body->privacy.data = NULL;
    }
 
    break;
  case GNUNET_MESSENGER_KIND_DELETION:
    decode_step (buffer, offset, &(body->deletion.hash));
    decode_step (buffer, offset, &(body->deletion.delay));
    break;
  case GNUNET_MESSENGER_KIND_CONNECTION:
    decode_step (buffer, offset, &value0);
    decode_step (buffer, offset, &value1);
 
    body->connection.amount = GNUNET_be32toh (value0);
    body->connection.flags = GNUNET_be32toh (value1);
    break;
  case GNUNET_MESSENGER_KIND_TICKET:
    if (length > offset)
      decode_step_malloc (buffer, offset, body->ticket.identifier, length
                          - offset, 1);
    else
      body->ticket.identifier = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    decode_step (buffer, offset, &(body->transcript.hash));
    decode_step_key (buffer, offset, &(body->transcript.key), length);
 
    if (length > offset)
    {
      body->transcript.length = (length - offset);
      decode_step_malloc (buffer, offset, body->transcript.data,
                          length - offset, 0);
    }
    else
    {
      body->transcript.length = 0;
      body->transcript.data = NULL;
    }
 
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    decode_step (buffer, offset, &(body->tag.hash));
    if (length > offset)
      decode_step_malloc (buffer, offset, body->tag.tag, length - offset, 1);
    else
      body->tag.tag = NULL;
    break;
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    decode_step (buffer, offset, &(body->subscribtion.discourse));
    decode_step (buffer, offset, &(body->subscribtion.time));
    decode_step (buffer, offset, &value0);
 
    body->subscribtion.flags = GNUNET_be32toh (value0);
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    decode_step (buffer, offset, &(body->talk.discourse));
 
    if (length > offset)
    {
      body->talk.length = (length - offset);
      decode_step_malloc (buffer, offset, body->talk.data, length - offset,
                          0);
    }
    else
    {
      body->talk.length = 0;
      body->talk.data = NULL;
    }
 
    break;
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    decode_step (buffer, offset, &(body->announcement.identifier));
    decode_step (buffer, offset, &(body->announcement.key));
    decode_step (buffer, offset, &(body->announcement.nonce));
    decode_step (buffer, offset, &(body->announcement.timeout));
    decode_step (buffer, offset, &(body->announcement.hmac));
    break;
  case GNUNET_MESSENGER_KIND_SECRET:
    decode_step (buffer, offset, &(body->secret.identifier));
    decode_step (buffer, offset, &(body->secret.iv));
    decode_step (buffer, offset, &(body->secret.hmac));
 
    if (length > offset)
    {
      body->secret.length = (length - offset);
      decode_step_malloc (buffer, offset, body->secret.data, length - offset,
                          0);
    }
    else
    {
      body->secret.length = 0;
      body->secret.data = NULL;
    }
 
    break;
  case GNUNET_MESSENGER_KIND_APPEAL:
    decode_step (buffer, offset, &(body->appeal.event));
    decode_step (buffer, offset, &(body->appeal.key));
    decode_step (buffer, offset, &(body->appeal.timeout));
    break;
  case GNUNET_MESSENGER_KIND_ACCESS:
    decode_step (buffer, offset, &(body->access.event));
    decode_step (buffer, offset, &(body->access.key));
    decode_step (buffer, offset, &(body->access.hmac));
    break;
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    decode_step (buffer, offset, &(body->revolution.identifier));
    decode_step (buffer, offset, &(body->revolution.nonce));
    decode_step (buffer, offset, &(body->revolution.hmac));
    break;
  case GNUNET_MESSENGER_KIND_GROUP:
    decode_step (buffer, offset, &(body->group.identifier));
    decode_step (buffer, offset, &(body->group.initiator));
    decode_step (buffer, offset, &(body->group.partner));
    decode_step (buffer, offset, &(body->group.timeout));
    break;
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    decode_step (buffer, offset, &(body->authorization.identifier));
    decode_step (buffer, offset, &(body->authorization.event));
    decode_step (buffer, offset, &(body->authorization.key));
    decode_step (buffer, offset, &(body->authorization.hmac));
    break;
  default:
    *kind = GNUNET_MESSENGER_KIND_UNKNOWN;
    break;
  }
 
  return padding;
}

Referenced by decode_message(), and decode_short_message().

Here is the caller graph for this function:

◆ decode_message()

enum GNUNET_GenericReturnValue decode_message	(	struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		const char *	buffer,
		enum GNUNET_GenericReturnValue	include_header,
		uint16_t *	padding
	)

Decodes a message from a given buffer of a maximal length in bytes.

If the buffer is too small for a message of its decoded kind the function fails with resulting GNUNET_NO after decoding only the messages header.

On success the function returns GNUNET_YES.

Parameters

[out]	message	Message
[in]	length	Maximal length to decode
[in]	buffer	Buffer
[in]	include_header	Flag to include header
[out]	padding	Padding

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1162 of file messenger_api_message.c.

{
  uint16_t offset;
  uint16_t count;
  kind_t kind;
 
  GNUNET_assert (
    (message) &&
    (buffer) &&
    (length >= get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
                                      include_header)));
 
  offset = 0;
 
  if (GNUNET_YES == include_header)
  {
    ssize_t result;
 
    result = GNUNET_CRYPTO_read_signature_from_buffer (
      &(message->header.signature), buffer, length - offset);
 
    if (result < 0)
      return GNUNET_NO;
    else
      offset += result;
  }
 
  count = length - offset;
  if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
                                     include_header))
    return GNUNET_NO;
 
  if (GNUNET_YES == include_header)
  {
    decode_step (buffer, offset, &(message->header.timestamp));
    decode_step (buffer, offset, &(message->header.sender_id));
    decode_step (buffer, offset, &(message->header.previous));
  }
 
  decode_step (buffer, offset, &kind);
  kind = GNUNET_be32toh (kind);
 
  message->header.kind = (enum GNUNET_MESSENGER_MessageKind) kind;
 
  if (count < get_message_kind_size (message->header.kind, include_header))
    return GNUNET_NO;
 
  {
    uint16_t result;
    result = decode_message_body (&(message->header.kind),
                                  &(message->body), length, buffer, offset);
 
    if (padding)
      *padding = result;
  }
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_Message::body, decode_message_body(), decode_step, get_message_kind_size(), GNUNET_assert, GNUNET_be32toh, GNUNET_CRYPTO_read_signature_from_buffer(), GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageHeader::previous, result, GNUNET_MESSENGER_MessageHeader::sender_id, GNUNET_MESSENGER_MessageHeader::signature, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by check_recv_message(), check_send_message(), check_tunnel_message(), get_store_message(), handle_recv_message(), handle_send_message(), and handle_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decode_short_message()

static enum GNUNET_GenericReturnValue decode_short_message	(	struct GNUNET_MESSENGER_ShortMessage *	message,
		uint16_t	length,
		const char *	buffer
	)

static

Definition at line 1227 of file messenger_api_message.c.

{
  struct GNUNET_HashCode expected, hash;
  uint16_t offset;
  kind_t kind;
 
  GNUNET_assert ((message) && (buffer));
 
  offset = sizeof(hash);
 
  if (length < get_short_message_size (NULL, GNUNET_NO))
    return GNUNET_NO;
 
  GNUNET_memcpy (&hash, buffer, sizeof(hash));
 
  GNUNET_CRYPTO_hash (
    buffer + sizeof(hash),
    length - sizeof(hash),
    &expected);
 
  if (0 != GNUNET_CRYPTO_hash_cmp (&hash, &expected))
    return GNUNET_NO;
 
  decode_step (buffer, offset, &kind);
  kind = GNUNET_be32toh (kind);
 
  message->kind = (enum GNUNET_MESSENGER_MessageKind) kind;
 
  if (length < get_short_message_size (message, GNUNET_NO))
    return GNUNET_NO;
 
  decode_message_body (&(message->kind), &(message->body), length, buffer,
                       offset);
 
  if (GNUNET_MESSENGER_KIND_UNKNOWN == message->kind)
    return GNUNET_NO;
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_ShortMessage::body, decode_message_body(), decode_step, get_short_message_size(), GNUNET_assert, GNUNET_be32toh, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_cmp(), GNUNET_memcpy, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_NO, GNUNET_YES, and GNUNET_MESSENGER_ShortMessage::kind.

Referenced by decrypt_message(), decrypt_secret_message(), and read_transcript_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hash_message()

void hash_message	(	const struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		const char *	buffer,
		struct GNUNET_HashCode *	hash
	)

Calculates a hash of a given buffer with a length in bytes from a message.

Parameters

[in]	message	Message
[in]	length	Length of buffer
[in]	buffer	Buffer
[out]	hash	Hash

Definition at line 1271 of file messenger_api_message.c.

{
  ssize_t offset;
 
  GNUNET_assert ((message) && (buffer) && (hash));
 
  offset = GNUNET_CRYPTO_signature_get_length (&(message->header.signature));
 
  GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash);
}

References GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_signature_get_length(), GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::signature.

Referenced by check_tunnel_message(), get_store_message(), handle_tunnel_message(), pack_message(), and send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sign_message()

void sign_message	(	struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		char *	buffer,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_CRYPTO_PrivateKey *	key
	)

Signs the hash of a message with a given private key and writes the signature into the buffer as well.

Parameters

[in,out]	message	Message
[in]	length	Length of buffer
[out]	buffer	Buffer
[in]	hash	Hash of message
[in]	key	Private key

Definition at line 1287 of file messenger_api_message.c.

{
  GNUNET_assert ((message) && (buffer) && (hash) && (key));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by member: %s\n",
              GNUNET_h2s (hash));
 
  {
    struct GNUNET_MESSENGER_MessageSignature signature;
 
    signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
    signature.purpose.size = htonl (sizeof(signature));
 
    GNUNET_memcpy (&(signature.hash), hash, sizeof(signature.hash));
    GNUNET_CRYPTO_sign (key, &signature, &(message->header.signature));
  }
 
  message->header.signature.type = key->type;
 
  {
    uint16_t offset = 0;
    encode_step_signature (
      buffer,
      offset,
      &(message->header.signature),
      length);
  }
}

References encode_step_signature, GNUNET_assert, GNUNET_CRYPTO_sign, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, GNUNET_MESSENGER_MessageSignature::hash, GNUNET_MESSENGER_Message::header, key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_MESSENGER_MessageSignature::purpose, GNUNET_MESSENGER_MessageHeader::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, and GNUNET_CRYPTO_Signature::type.

Referenced by send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sign_message_by_peer()

void sign_message_by_peer	(	struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		char *	buffer,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

Signs the hash of a message with the peer identity of a given config and writes the signature into the buffer as well.

Parameters

[in,out]	message	Message
[in]	length	Length of buffer
[out]	buffer	Buffer
[in]	hash	Hash of message
[in]	cfg	Peer configuration

Definition at line 1322 of file messenger_api_message.c.

{
  GNUNET_assert ((message) && (buffer) && (hash) && (cfg));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by peer: %s\n",
              GNUNET_h2s (hash));
 
  {
    struct GNUNET_MESSENGER_MessageSignature signature;
    signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
    signature.purpose.size = htonl (sizeof (signature));
 
    GNUNET_memcpy (&(signature.hash), hash, sizeof (signature.hash));
    GNUNET_CRYPTO_sign_by_peer_identity (cfg, &(signature.purpose),
                                         &(message->header.signature.
                                           eddsa_signature));
  }
 
  message->header.signature.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
 
  {
    uint16_t offset = 0;
    encode_step_signature (
      buffer,
      offset,
      &(message->header.signature),
      length);
  }
}

References cfg, encode_step_signature, GNUNET_assert, GNUNET_CRYPTO_sign_by_peer_identity(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, GNUNET_MESSENGER_MessageSignature::hash, GNUNET_MESSENGER_Message::header, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_MESSENGER_MessageSignature::purpose, GNUNET_MESSENGER_MessageHeader::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, and GNUNET_CRYPTO_Signature::type.

Referenced by sign_srv_room_message_by_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calc_message_hmac()

static void calc_message_hmac	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	key,
		struct GNUNET_HashCode *	hmac
	)

static

Definition at line 1358 of file messenger_api_message.c.

{
  struct GNUNET_CRYPTO_AuthKey auth_key;
 
  GNUNET_assert ((message) && (key) && (hmac));
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    GNUNET_CRYPTO_hmac_derive_key (
      &auth_key, key,
      &(message->body.announcement.nonce),
      GNUNET_MESSENGER_EPOCH_NONCE_BYTES,
      &(message->body.announcement.identifier),
      sizeof (message->body.announcement.identifier),
      NULL);
 
    GNUNET_CRYPTO_hmac (&auth_key, &(message->body.announcement),
                        sizeof (message->body.announcement)
                        - sizeof (*hmac),
                        hmac);
    break;
  case GNUNET_MESSENGER_KIND_ACCESS:
    GNUNET_CRYPTO_hmac_derive_key (
      &auth_key, key, &(message->body.access.event),
      sizeof (message->body.access.event), NULL);
 
    GNUNET_CRYPTO_hmac (&auth_key, &(message->body.access),
                        sizeof (message->body.access)
                        - sizeof (*hmac),
                        hmac);
    break;
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    GNUNET_CRYPTO_hmac_derive_key (
      &auth_key, key,
      &(message->body.revolution.nonce),
      GNUNET_MESSENGER_EPOCH_NONCE_BYTES,
      &(message->body.revolution.identifier),
      sizeof (message->body.revolution.identifier),
      NULL);
 
    GNUNET_CRYPTO_hmac (&auth_key, &(message->body.revolution),
                        sizeof (message->body.revolution)
                        - sizeof (*hmac),
                        hmac);
    break;
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    GNUNET_CRYPTO_hmac_derive_key (
      &auth_key, key,
      &(message->body.authorization.event),
      sizeof (message->body.authorization.event),
      &(message->body.authorization.identifier),
      sizeof (message->body.authorization.identifier),
      NULL);
 
    GNUNET_CRYPTO_hmac (&auth_key, &(message->body.authorization),
                        sizeof (message->body.authorization)
                        - sizeof (*hmac),
                        hmac);
    break;
  default:
    break;
  }
}

Referenced by sign_message_by_key(), and verify_message_by_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sign_message_by_key()

void sign_message_by_key	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	key
	)

Signs the message body via it's own hmac with a specific shared key.

It requires the message to be of a supported kind of message which contains such an hmac.

On success the message can be verified via verify_message_by_key() afterwards.

Parameters

[in,out]	message	Message
[in]	key	Shared key

Definition at line 1427 of file messenger_api_message.c.

{
  struct GNUNET_HashCode *hmac;
 
  GNUNET_assert ((message) && (key));
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    hmac = &(message->body.announcement.hmac);
    break;
  case GNUNET_MESSENGER_KIND_ACCESS:
    hmac = &(message->body.access.hmac);
    break;
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    hmac = &(message->body.revolution.hmac);
    break;
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    hmac = &(message->body.authorization.hmac);
    break;
  default:
    hmac = NULL;
    break;
  }
 
  if (! hmac)
    return;
 
  calc_message_hmac (message, key, hmac);
}

Referenced by create_message_access(), create_message_announcement(), create_message_authorization(), and create_message_revolution().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_message()

enum GNUNET_GenericReturnValue verify_message	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_CRYPTO_PublicKey *	key
	)

Verifies the signature of a given message and its hash with a specific public key.

The function returns GNUNET_OK if the signature was valid, otherwise GNUNET_SYSERR.

Parameters

[in]	message	Message
[in]	hash	Hash of message
[in]	key	Public key

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 1461 of file messenger_api_message.c.

{
  struct GNUNET_MESSENGER_MessageSignature signature;
 
  GNUNET_assert ((message) && (hash) && (key));
 
  if (key->type != message->header.signature.type)
    return GNUNET_SYSERR;
 
  signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
  signature.purpose.size = htonl (sizeof(signature));
 
  GNUNET_memcpy (&(signature.hash), hash, sizeof(signature.hash));
 
  return GNUNET_CRYPTO_signature_verify (
    GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature,
    &(message->header.signature), key);
}

References GNUNET_assert, GNUNET_CRYPTO_signature_verify, GNUNET_memcpy, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, GNUNET_SYSERR, GNUNET_MESSENGER_MessageSignature::hash, GNUNET_MESSENGER_Message::header, key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_MESSENGER_MessageSignature::purpose, GNUNET_MESSENGER_MessageHeader::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, and GNUNET_CRYPTO_Signature::type.

Referenced by verify_member_session_as_sender().

Here is the caller graph for this function:

◆ verify_message_by_peer()

enum GNUNET_GenericReturnValue verify_message_by_peer	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_PeerIdentity *	identity
	)

Verifies the signature of a given message and its hash with a specific peer's identity.

The function returns GNUNET_OK if the signature was valid, otherwise GNUNET_SYSERR.

Parameters

[in]	message	Message
[in]	hash	Hash of message
[in]	identity	Peer identity

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 1484 of file messenger_api_message.c.

{
  struct GNUNET_MESSENGER_MessageSignature signature;
 
  GNUNET_assert ((message) && (hash) && (identity));
 
  if (ntohl (GNUNET_PUBLIC_KEY_TYPE_EDDSA) != message->header.signature.type)
    return GNUNET_SYSERR;
 
  signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
  signature.purpose.size = htonl (sizeof(signature));
 
  GNUNET_memcpy (&(signature.hash), hash, sizeof(signature.hash));
 
  return GNUNET_CRYPTO_verify_peer_identity (
    GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &(signature.purpose),
    &(message->header.signature.
      eddsa_signature), identity);
}

References GNUNET_assert, GNUNET_CRYPTO_verify_peer_identity(), GNUNET_memcpy, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, GNUNET_SYSERR, GNUNET_MESSENGER_MessageSignature::hash, GNUNET_MESSENGER_Message::header, identity, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_MESSENGER_MessageSignature::purpose, GNUNET_MESSENGER_MessageHeader::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, and GNUNET_CRYPTO_Signature::type.

Referenced by get_store_peer_of(), and verify_store_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_message_by_key()

enum GNUNET_GenericReturnValue verify_message_by_key	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	key
	)

Verifies the hmac of a given message body with a specific shared key.

The function returns GNUNET_OK if the signature was valid, otherwise GNUNET_SYSERR.

Parameters

[in]	message	Message
[in]	key	Shared key

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 1508 of file messenger_api_message.c.

{
  const struct GNUNET_HashCode *msg_hmac;
  struct GNUNET_HashCode hmac;
 
  GNUNET_assert ((message) && (key));
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    msg_hmac = &(message->body.announcement.hmac);
    break;
  case GNUNET_MESSENGER_KIND_ACCESS:
    msg_hmac = &(message->body.access.hmac);
    break;
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    msg_hmac = &(message->body.revolution.hmac);
    break;
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    msg_hmac = &(message->body.authorization.hmac);
    break;
  default:
    msg_hmac = NULL;
    break;
  }
 
  if (! msg_hmac)
    return GNUNET_SYSERR;
 
  calc_message_hmac (message, key, &hmac);
 
  if (0 == GNUNET_CRYPTO_hash_cmp (&hmac, msg_hmac))
    return GNUNET_OK;
 
  return GNUNET_SYSERR;
}

Referenced by extract_access_message_key(), extract_authorization_message_key(), handle_access_message(), handle_authorization_message(), handle_epoch_announcement(), handle_epoch_group_announcement(), handle_revolution_message(), and send_epoch_announcement_authorization().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encrypt_message()

enum GNUNET_GenericReturnValue encrypt_message	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_PublicKey *	key
	)

Encrypts a message using a given public key and replaces its body and kind with the now private encrypted message.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in,out]	message	Message
[in]	key	Public key

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1548 of file messenger_api_message.c.

{
  struct GNUNET_CRYPTO_EcdhePublicKey hpke_key;
  enum GNUNET_GenericReturnValue result;
  struct GNUNET_MESSENGER_ShortMessage shortened;
  uint16_t length, padded_length, encoded_length;
  uint8_t *data;
 
  GNUNET_assert ((message) && (key));
 
  if (GNUNET_YES == is_service_message (message))
    return GNUNET_NO;
 
  fold_short_message (message, &shortened);
 
  length = get_short_message_size (&shortened, GNUNET_YES);
  padded_length = calc_padded_length (length + encryption_overhead);
 
  GNUNET_assert (padded_length >= length + encryption_overhead);
 
  message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
  message->body.privacy.data = GNUNET_malloc (padded_length);
  message->body.privacy.length = padded_length;
 
  GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_hpke_pk_to_x25519 (key, &hpke_key));
  encoded_length = (padded_length - encryption_overhead);
 
  GNUNET_assert (padded_length == encoded_length + encryption_overhead);
 
  result = GNUNET_NO;
  data = GNUNET_malloc (encoded_length);
 
  encode_short_message (&shortened, encoded_length, (char *) data);
 
  if (GNUNET_OK != GNUNET_CRYPTO_hpke_seal_oneshot (&hpke_key,
                                                    (const uint8_t*)
                                                    "messenger",
                                                    strlen ("messenger"),
                                                    NULL, 0,
                                                    (const uint8_t*) data,
                                                    encoded_length,
                                                    (uint8_t*) message->body.
                                                    privacy.data,
                                                    NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n");
 
    unfold_short_message (&shortened, message);
    goto cleanup;
  }
 
  destroy_message_body (shortened.kind, &(shortened.body));
  result = GNUNET_YES;
 
cleanup:
  GNUNET_free (data);
  return result;
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_ShortMessage::body, calc_padded_length(), cleanup(), data, GNUNET_MESSENGER_MessagePrivate::data, destroy_message_body(), encode_short_message(), encryption_overhead, fold_short_message(), get_short_message_size(), GNUNET_assert, GNUNET_CRYPTO_hpke_pk_to_x25519(), GNUNET_CRYPTO_hpke_seal_oneshot(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Message::header, is_service_message(), key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_ShortMessage::kind, GNUNET_MESSENGER_MessagePrivate::length, GNUNET_MESSENGER_MessageBody::privacy, result, and unfold_short_message().

Referenced by dequeue_message_from_room(), and send_message_to_room_with_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decrypt_message()

enum GNUNET_GenericReturnValue decrypt_message	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_PrivateKey *	key
	)

Decrypts a private message using a given private key and replaces its body and kind with the inner encrypted message.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in,out]	message	Message
[in]	key	Private key

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1610 of file messenger_api_message.c.

{
  struct GNUNET_CRYPTO_EcdhePrivateKey hpke_key;
  enum GNUNET_GenericReturnValue result;
  uint16_t padded_length, encoded_length;
  uint8_t *data;
 
  GNUNET_assert ((message) && (key) &&
                 (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind));
 
  padded_length = message->body.privacy.length;
 
  if (padded_length < encryption_overhead)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Message length too short to decrypt!\n");
 
    return GNUNET_NO;
  }
 
  GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_hpke_sk_to_x25519 (key, &hpke_key));
  encoded_length = (padded_length - encryption_overhead);
 
  GNUNET_assert (padded_length == encoded_length + encryption_overhead);
 
  result = GNUNET_NO;
  data = GNUNET_malloc (encoded_length);
 
  if (GNUNET_OK !=
      GNUNET_CRYPTO_hpke_open_oneshot (&hpke_key,
                                       (uint8_t*) "messenger",
                                       strlen ("messenger"),
                                       NULL, 0,
                                       (uint8_t*) message->body.privacy.data,
                                       padded_length,
                                       (uint8_t*) data,
                                       NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting message failed!\n");
 
    goto cleanup;
  }
 
  {
    struct GNUNET_MESSENGER_ShortMessage shortened;
    if (GNUNET_YES != decode_short_message (&shortened,
                                            encoded_length,
                                            (char*) data))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Decoding decrypted message failed!\n");
 
      goto cleanup;
    }
 
    unfold_short_message (&shortened, message);
    result = GNUNET_YES;
  }
 
cleanup:
  GNUNET_free (data);
  return result;
}

References GNUNET_MESSENGER_Message::body, cleanup(), data, GNUNET_MESSENGER_MessagePrivate::data, decode_short_message(), encryption_overhead, GNUNET_assert, GNUNET_CRYPTO_hpke_open_oneshot(), GNUNET_CRYPTO_hpke_sk_to_x25519(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessagePrivate::length, GNUNET_MESSENGER_MessageBody::privacy, result, and unfold_short_message().

Referenced by handle_private_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transcribe_message()

struct GNUNET_MESSENGER_Message * transcribe_message	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_PublicKey *	key
	)

Transcribes a message as a new transcript message using a given public key from the recipient of the encrypted message content.

Parameters

[in]	message	Message
[in]	key	Public key

Returns: Message transcript

Definition at line 1677 of file messenger_api_message.c.

{
  struct GNUNET_MESSENGER_Message *transcript;
 
  GNUNET_assert ((message) && (key));
 
  if (GNUNET_YES == is_service_message (message))
    return NULL;
 
  transcript = create_message (GNUNET_MESSENGER_KIND_TRANSCRIPT);
 
  if (! transcript)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Transcribing message failed!\n");
    return NULL;
  }
 
  GNUNET_memcpy (&(transcript->body.transcript.key), key,
                 sizeof(transcript->body.transcript.key));
 
  {
    struct GNUNET_MESSENGER_ShortMessage shortened;
    uint16_t data_length;
 
    fold_short_message (message, &shortened);
 
    data_length = get_short_message_size (&shortened, GNUNET_YES);
 
    transcript->body.transcript.data = GNUNET_malloc (data_length);
    transcript->body.transcript.length = data_length;
 
    encode_short_message (&shortened, data_length,
                          transcript->body.transcript.data);
  }
 
  return transcript;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_MessageTranscript::data, encode_short_message(), fold_short_message(), get_short_message_size(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSENGER_KIND_TRANSCRIPT, GNUNET_YES, is_service_message(), key, GNUNET_MESSENGER_MessageTranscript::key, GNUNET_MESSENGER_MessageTranscript::length, and GNUNET_MESSENGER_MessageBody::transcript.

Referenced by send_message_to_room_with_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encrypt_secret_message()

enum GNUNET_GenericReturnValue encrypt_secret_message	(	struct GNUNET_MESSENGER_Message *	message,
		const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	key
	)

Encrypts a message using a given shared key from an announcement of an epoch and replaces its body and kind with the inner encrypted message.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in,out]	message	Message
[in]	identifier	Epoch identifier
[in]	key	Shared secret key

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1718 of file messenger_api_message.c.

{
  enum GNUNET_GenericReturnValue result;
  struct GNUNET_MESSENGER_ShortMessage shortened;
  uint16_t length, padded_length;
  uint8_t *data;
 
  GNUNET_assert ((message) && (identifier) && (key));
 
  fold_short_message (message, &shortened);
 
  length = get_short_message_size (&shortened, GNUNET_YES);
  padded_length = calc_padded_length (length + 0);
 
  GNUNET_assert (padded_length >= length + 0);
 
  message->header.kind = GNUNET_MESSENGER_KIND_SECRET;
 
  GNUNET_memcpy (&(message->body.secret.identifier), identifier,
                 sizeof (message->body.secret.identifier));
 
  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
                              &(message->body.secret.iv),
                              GNUNET_MESSENGER_SECRET_IV_BYTES);
 
  message->body.secret.data = GNUNET_malloc (padded_length);
  message->body.secret.length = padded_length;
 
  result = GNUNET_NO;
  data = GNUNET_malloc (padded_length);
 
  encode_short_message (&shortened, padded_length, (char *) data);
 
  {
    struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
 
    GNUNET_CRYPTO_symmetric_derive_iv (&iv, key,
                                       message->body.secret.iv,
                                       GNUNET_MESSENGER_SECRET_IV_BYTES,
                                       NULL);
 
    if (-1 == GNUNET_CRYPTO_symmetric_encrypt (data, padded_length, key,
                                               &iv, message->body.secret.data))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n");
 
      unfold_short_message (&shortened, message);
      goto cleanup;
    }
  }
 
  {
    struct GNUNET_CRYPTO_AuthKey auth_key;
 
    GNUNET_CRYPTO_hmac_derive_key (&auth_key, key,
                                   message->body.secret.iv,
                                   GNUNET_MESSENGER_SECRET_IV_BYTES,
                                   NULL);
 
    GNUNET_CRYPTO_hmac (&auth_key, data, padded_length, &(message->body.secret.
                                                          hmac));
  }
 
  destroy_message_body (shortened.kind, &(shortened.body));
  result = GNUNET_YES;
 
cleanup:
  GNUNET_free (data);
  return result;
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_ShortMessage::body, calc_padded_length(), cleanup(), data, GNUNET_MESSENGER_MessageSecret::data, destroy_message_body(), encode_short_message(), fold_short_message(), get_short_message_size(), GNUNET_assert, GNUNET_CRYPTO_hmac(), GNUNET_CRYPTO_hmac_derive_key(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_block(), GNUNET_CRYPTO_symmetric_derive_iv(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSENGER_KIND_SECRET, GNUNET_MESSENGER_SECRET_IV_BYTES, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageSecret::identifier, GNUNET_MESSENGER_MessageSecret::iv, key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_ShortMessage::kind, GNUNET_MESSENGER_MessageSecret::length, result, GNUNET_MESSENGER_MessageBody::secret, and unfold_short_message().

Referenced by send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decrypt_secret_message()

enum GNUNET_GenericReturnValue decrypt_secret_message	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	key
	)

Decrypts a secret message using a given shared key and replaces its body and kind with the inner encrypted message.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in,out]	message	Message
[in]	key	Shared secret key

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1794 of file messenger_api_message.c.

{
  enum GNUNET_GenericReturnValue result;
  uint16_t padded_length;
  uint8_t *data;
 
  GNUNET_assert ((message) && (key) &&
                 (GNUNET_MESSENGER_KIND_SECRET == message->header.kind));
 
  padded_length = message->body.secret.length;
 
  result = GNUNET_NO;
  data = GNUNET_malloc (padded_length);
 
  {
    struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
 
    GNUNET_CRYPTO_symmetric_derive_iv (&iv, key,
                                       message->body.secret.iv,
                                       GNUNET_MESSENGER_SECRET_IV_BYTES,
                                       NULL);
 
    if (-1 == GNUNET_CRYPTO_symmetric_decrypt (message->body.secret.data,
                                               padded_length,
                                               key, &iv, data))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting message failed!\n");
 
      goto cleanup;
    }
  }
 
  {
    struct GNUNET_CRYPTO_AuthKey auth_key;
    struct GNUNET_HashCode hmac;
 
    GNUNET_CRYPTO_hmac_derive_key (&auth_key, key,
                                   message->body.secret.iv,
                                   GNUNET_MESSENGER_SECRET_IV_BYTES,
                                   NULL);
 
    GNUNET_CRYPTO_hmac (&auth_key, data, padded_length, &hmac);
 
    if (0 != GNUNET_CRYPTO_hash_cmp (&(message->body.secret.hmac), &hmac))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Decrypted message does not match HMAC!\n");
 
      goto cleanup;
    }
  }
 
  {
    struct GNUNET_MESSENGER_ShortMessage shortened;
    if (GNUNET_YES != decode_short_message (&shortened,
                                            padded_length,
                                            (char*) data))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Decoding decrypted message failed!\n");
 
      goto cleanup;
    }
 
    unfold_short_message (&shortened, message);
    result = GNUNET_YES;
  }
 
cleanup:
  GNUNET_free (data);
  return result;
}

Referenced by update_room_secret_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_transcript_message()

enum GNUNET_GenericReturnValue read_transcript_message ( struct GNUNET_MESSENGER_Message * message )

Read the original message from a transcript message and replaces its body and kind with the inner encrypted message.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in,out] message Message transcript

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1870 of file messenger_api_message.c.

{
  uint16_t data_length;
  struct GNUNET_MESSENGER_ShortMessage shortened;
 
  GNUNET_assert ((message) &&
                 (GNUNET_MESSENGER_KIND_TRANSCRIPT == message->header.kind));
 
  data_length = message->body.transcript.length;
 
  if (GNUNET_YES != decode_short_message (&shortened,
                                          data_length,
                                          message->body.transcript.data))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Decoding decrypted message failed!\n");
 
    return GNUNET_NO;
  }
 
  unfold_short_message (&shortened, message);
  return GNUNET_YES;
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessageTranscript::data, decode_short_message(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_KIND_TRANSCRIPT, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageTranscript::length, GNUNET_MESSENGER_MessageBody::transcript, and unfold_short_message().

Referenced by handle_transcript_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extract_access_message_key()

enum GNUNET_GenericReturnValue extract_access_message_key	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_EcdhePrivateKey *	key,
		struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key
	)

Extracts the shared epoch or group key from an access message using the private ephemeral key from an epoch and verifies it via the HMAC from the message body.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in]	message	Access message
[in]	key	Private ephemeral key
[out]	shared_key	Shared key

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1896 of file messenger_api_message.c.

{
  GNUNET_assert ((message) && (key) && (shared_key) &&
                 (GNUNET_MESSENGER_KIND_ACCESS == message->header.kind));
 
  if (GNUNET_OK !=
      GNUNET_CRYPTO_hpke_open_oneshot (key,
                                       (uint8_t*) "messenger",
                                       strlen ("messenger"),
                                       NULL, 0,
                                       (uint8_t*) message->body.access.key,
                                       GNUNET_MESSENGER_ACCESS_KEY_BYTES,
                                       (uint8_t*) shared_key,
                                       NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting shared key failed!\n");
    return GNUNET_NO;
  }
 
  if (GNUNET_OK != verify_message_by_key (message, shared_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Shared key mismatches HMAC!\n");
    return GNUNET_NO;
  }
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_MessageBody::access, GNUNET_MESSENGER_Message::body, GNUNET_assert, GNUNET_CRYPTO_hpke_open_oneshot(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_ACCESS_KEY_BYTES, GNUNET_MESSENGER_KIND_ACCESS, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageAccess::key, GNUNET_MESSENGER_MessageHeader::kind, and verify_message_by_key().

Referenced by handle_epoch_announcement_access(), and handle_epoch_group_access().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extract_authorization_message_key()

enum GNUNET_GenericReturnValue extract_authorization_message_key	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	key,
		struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key
	)

Extracts the shared epoch or group key from an authorization message using a previously exchanged shared key and verifies it via the HMAC from the message body.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in]	message	Access message
[in]	key	Previous shared key
[out]	shared_key	Shared key

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1929 of file messenger_api_message.c.

{
  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
 
  GNUNET_assert ((message) && (key) && (shared_key) &&
                 (GNUNET_MESSENGER_KIND_AUTHORIZATION == message->header.kind));
 
  GNUNET_CRYPTO_symmetric_derive_iv (&iv, key,
                                     &(message->body.authorization.event),
                                     sizeof (message->body.authorization.event),
                                     &(message->body.authorization.identifier),
                                     sizeof (message->body.authorization.
                                             identifier),
                                     NULL);
 
  if (-1 == GNUNET_CRYPTO_symmetric_decrypt (message->body.authorization.key,
                                             GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES,
                                             key,
                                             &iv,
                                             shared_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting shared key failed!\n");
    return GNUNET_NO;
  }
 
  if (GNUNET_OK != verify_message_by_key (message, shared_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Shared key mismatches HMAC!\n");
    return GNUNET_NO;
  }
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_MessageBody::authorization, GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessageAuthorization::event, GNUNET_assert, GNUNET_CRYPTO_symmetric_decrypt(), GNUNET_CRYPTO_symmetric_derive_iv(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES, GNUNET_MESSENGER_KIND_AUTHORIZATION, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageAuthorization::identifier, key, GNUNET_MESSENGER_MessageAuthorization::key, GNUNET_MESSENGER_MessageHeader::kind, and verify_message_by_key().

Referenced by handle_authorization_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_message_timeout()

struct GNUNET_TIME_Relative get_message_timeout ( const struct GNUNET_MESSENGER_Message * message )

Return the relative timeout of the content from a given message that controls when a delayed handling action of this message needs to be processed at least.

Parameters

[in] message Message

Returns: Relative timeout of message

Definition at line 1969 of file messenger_api_message.c.

{
  struct GNUNET_TIME_Absolute timestamp;
  struct GNUNET_TIME_Relative timeout;
 
  GNUNET_assert (message);
 
  timestamp = GNUNET_TIME_absolute_ntoh (message->header.timestamp);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_DELETION:
    timeout = GNUNET_TIME_relative_ntoh (message->body.deletion.delay);
    break;
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    timeout = GNUNET_TIME_relative_ntoh (message->body.announcement.timeout);
    break;
  case GNUNET_MESSENGER_KIND_APPEAL:
    timeout = GNUNET_TIME_relative_ntoh (message->body.appeal.timeout);
    break;
  case GNUNET_MESSENGER_KIND_GROUP:
    timeout = GNUNET_TIME_relative_ntoh (message->body.group.timeout);
    break;
  default:
    timeout = GNUNET_TIME_relative_get_zero_ ();
    break;
  }
 
  timestamp = GNUNET_TIME_absolute_add (timestamp, timeout);
 
  timeout = GNUNET_TIME_absolute_get_remaining (timestamp);
  timeout = GNUNET_TIME_relative_min (timeout,
                                      GNUNET_TIME_relative_get_minute_ ());
 
  return timeout;
}

References GNUNET_assert, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_MESSENGER_KIND_APPEAL, GNUNET_MESSENGER_KIND_DELETION, GNUNET_MESSENGER_KIND_GROUP, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_get_minute_(), GNUNET_TIME_relative_get_zero_(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_ntoh(), timeout, and timestamp().

Referenced by handle_appeal_message(), handle_delete_message(), handle_epoch_announcement(), handle_epoch_announcement_delay(), handle_message_delete(), handle_room_delayed_deletion(), and set_epoch_proposal_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pack_message()

struct GNUNET_MQ_Envelope * pack_message	(	struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_HashCode *	hash,
		const GNUNET_MESSENGER_SignFunction	sign,
		enum GNUNET_MESSENGER_PackMode	mode,
		const void *	cls
	)

Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_PACK_MODE_ENVELOPE.

Independent of the mode the message will be hashed if hash is not NULL and it will be signed if the sign function is not NULL.

Parameters

[out]	message	Message
[out]	hash	Hash of message
[in]	sign	Function to sign
[in]	mode	Mode of packing
[in,out]	cls	Closure for signing

Returns: Envelope or NULL

Definition at line 2008 of file messenger_api_message.c.

{
  struct GNUNET_MessageHeader *header;
  uint16_t length, padded_length;
  struct GNUNET_MQ_Envelope *env;
  char *buffer;
 
  GNUNET_assert (message);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Packing message kind=%u and sender: %s\n",
              message->header.kind, GNUNET_sh2s (&(message->header.sender_id)));
 
  length = get_message_size (message, GNUNET_YES);
  padded_length = calc_padded_length (length);
 
  if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode)
  {
    env = GNUNET_MQ_msg_extra (header, padded_length,
                               GNUNET_MESSAGE_TYPE_CADET_CLI);
    buffer = (char*) &(header[1]);
  }
  else
  {
    env = NULL;
    buffer = GNUNET_malloc (padded_length);
  }
 
  encode_message (message, padded_length, buffer, GNUNET_YES);
 
  if (hash)
  {
    hash_message (message, length, buffer, hash);
 
    if (sign)
      sign (cls, message, length, buffer, hash);
  }
 
  if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode)
    GNUNET_free (buffer);
 
  return env;
}

References calc_padded_length(), encode_message(), env, get_message_size(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MESSENGER_PACK_MODE_ENVELOPE, GNUNET_MQ_msg_extra, GNUNET_sh2s(), GNUNET_YES, hash_message(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, mode, and GNUNET_MESSENGER_MessageHeader::sender_id.

Referenced by forward_tunnel_message(), iterate_send_room_message(), and pack_srv_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_peer_message()

enum GNUNET_GenericReturnValue is_peer_message ( const struct GNUNET_MESSENGER_Message * message )

Returns whether a specific kind of message can be sent by the service without usage of a clients private key.

The function returns GNUNET_YES if the kind of message can be signed via a peer's identity, otherwise GNUNET_NO.

Parameters

[in] message Message

Returns: GNUNET_YES if sending is allowed, GNUNET_NO otherwise

Definition at line 2058 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
  case GNUNET_MESSENGER_KIND_PEER:
  case GNUNET_MESSENGER_KIND_MISS:
  case GNUNET_MESSENGER_KIND_MERGE:
  case GNUNET_MESSENGER_KIND_CONNECTION:
    return GNUNET_YES;
  default:
    return GNUNET_NO;
  }
}

References GNUNET_assert, GNUNET_MESSENGER_KIND_CONNECTION, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_MERGE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_PEER, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by callback_found_message(), callback_room_handle_message(), enqueue_message_control(), filter_message_sending(), get_store_member_of(), get_store_peer_of(), handle_room_messages(), is_service_message(), notify_about_members(), notify_srv_handle_message(), pack_srv_room_message(), process_message_control(), and task_message_control().

Here is the caller graph for this function:

◆ is_service_message()

enum GNUNET_GenericReturnValue is_service_message ( const struct GNUNET_MESSENGER_Message * message )

Returns whether a specific kind of message contains service critical information.

That kind of information should not be encrypted via private messages for example to guarantee the service to work properly. The function returns GNUNET_YES if the kind of message needs to be transferred accessible to all peers and their running service. It returns GNUNET_NO if the message can be encrypted to specific subgroups of members without issues. If the kind of message is unknown it returns GNUNET_SYSERR.

Parameters

[in] message Message

Returns: GNUNET_YES if encrypting is disallowed, GNUNET_NO or GNUNET_SYSERR otherwise

Definition at line 2077 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  if (GNUNET_YES == is_peer_message (message))
    return GNUNET_YES;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
    return GNUNET_YES; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_JOIN:
    return GNUNET_YES; // Reserved for member handling only!
  case GNUNET_MESSENGER_KIND_LEAVE:
    return GNUNET_YES; // Reserved for member handling only!
  case GNUNET_MESSENGER_KIND_NAME:
    return GNUNET_YES; // Reserved for member name handling only!
  case GNUNET_MESSENGER_KIND_KEY:
    return GNUNET_YES; // Reserved for member key handling only!
  case GNUNET_MESSENGER_KIND_PEER:
    return GNUNET_YES; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_ID:
    return GNUNET_YES; // Reserved for member id handling only!
  case GNUNET_MESSENGER_KIND_MISS:
    return GNUNET_YES; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_MERGE:
    return GNUNET_YES; // Reserved for peers only!
  case GNUNET_MESSENGER_KIND_REQUEST:
    return GNUNET_YES; // Requests should not apply individually! (inefficiently)
  case GNUNET_MESSENGER_KIND_INVITE:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_TEXT:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_FILE:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    return GNUNET_YES; // Prevent duplicate encryption breaking all access!
  case GNUNET_MESSENGER_KIND_DELETION:
    return GNUNET_YES; // Deletion should not apply individually! (inefficiently)
  case GNUNET_MESSENGER_KIND_CONNECTION:
    return GNUNET_YES; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_TICKET:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_TAG:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    return GNUNET_YES; // Reserved for subscription handling only!
  case GNUNET_MESSENGER_KIND_TALK:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    return GNUNET_YES; // Reserved for epoch and group key exchange!
  case GNUNET_MESSENGER_KIND_SECRET:
    return GNUNET_YES; // Prevent duplicate encryption breaking all access!
  case GNUNET_MESSENGER_KIND_APPEAL:
    return GNUNET_YES; // Reserved for epoch key exchange!
  case GNUNET_MESSENGER_KIND_ACCESS:
    return GNUNET_YES; // Reserved for epoch and group key exchange!
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    return GNUNET_YES; // Reserved for epoch and group key revoking!
  case GNUNET_MESSENGER_KIND_GROUP:
    return GNUNET_YES; // Reserved for group key exchange!
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    return GNUNET_YES; // Reserved for epoch and group key exchange!
  default:
    return GNUNET_SYSERR;
  }
}

Referenced by encrypt_message(), send_message_to_room(), and transcribe_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_message()

enum GNUNET_GenericReturnValue is_epoch_message ( const struct GNUNET_MESSENGER_Message * message )

Returns whether a certain kind of message from storage contains some specific details that might be required for the overall message graph to function as intended.

The function returns GNUNET_YES if you may not delete the given message because of that, otherwise it returns GNUNET_NO.

Parameters

[in] message Message

Returns: GNUNET_YES if the message contains epoch graph information, GNUNET_NO otherwise

Definition at line 2149 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_LEAVE:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_MERGE:
    return GNUNET_YES;
  default:
    return GNUNET_NO;
  }
}

References GNUNET_assert, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MERGE, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by delete_store_message(), GNUNET_MESSENGER_delete_message(), handle_message(), pack_srv_room_message(), request_room_message_step(), and send_message_to_room().

Here is the caller graph for this function:

◆ filter_message_sending()

enum GNUNET_GenericReturnValue filter_message_sending ( const struct GNUNET_MESSENGER_Message * message )

Returns whether a specific kind of message should be sent by a client.

The function returns GNUNET_YES or GNUNET_NO for recommendations and GNUNET_SYSERR for specific kinds of messages which should not be sent manually at all.

Parameters

[in] message Message

Returns: GNUNET_YES if sending is allowed, GNUNET_NO or GNUNET_SYSERR otherwise

Definition at line 2168 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  if (GNUNET_YES == is_peer_message (message))
    return GNUNET_SYSERR; // Requires signature of peer rather than member!
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
    return GNUNET_SYSERR; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_JOIN:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_enter_room(...) instead!
  case GNUNET_MESSENGER_KIND_LEAVE:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_close_room(...) instead!
  case GNUNET_MESSENGER_KIND_NAME:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_KEY:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_set_key(...) instead!
  case GNUNET_MESSENGER_KIND_PEER:
    return GNUNET_SYSERR; // Use #GNUNET_MESSENGER_open_room(...) instead!
  case GNUNET_MESSENGER_KIND_ID:
    return GNUNET_NO; // Reserved for member id handling only!
  case GNUNET_MESSENGER_KIND_MISS:
    return GNUNET_SYSERR; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_MERGE:
    return GNUNET_SYSERR; // Reserved for peers only!
  case GNUNET_MESSENGER_KIND_REQUEST:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_get_message(...) instead!
  case GNUNET_MESSENGER_KIND_INVITE:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_TEXT:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_FILE:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_send_message(...) with a contact instead!
  case GNUNET_MESSENGER_KIND_DELETION:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_delete_message(...) instead!
  case GNUNET_MESSENGER_KIND_CONNECTION:
    return GNUNET_SYSERR; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_TICKET:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_send_message(...) with a contact instead!
  case GNUNET_MESSENGER_KIND_TAG:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_TALK:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    return GNUNET_NO; // Should only be used for implicit key exchange!
  case GNUNET_MESSENGER_KIND_SECRET:
    return GNUNET_NO; // Should only be used for implicit forward secrecy!
  case GNUNET_MESSENGER_KIND_APPEAL:
    return GNUNET_NO; // Should only be used for implicit key exchange!
  case GNUNET_MESSENGER_KIND_ACCESS:
    return GNUNET_NO; // Should only be used for implicit key exchange!
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    return GNUNET_NO; // Should only be used for implicit key exchange!
  case GNUNET_MESSENGER_KIND_GROUP:
    return GNUNET_NO; // Should only be used for implicit key exchange!
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    return GNUNET_NO; // Should only be used for implicit key exchange!
  default:
    return GNUNET_SYSERR;
  }
}

Referenced by check_send_message(), and GNUNET_MESSENGER_send_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_message_discourse()

const struct GNUNET_ShortHashCode * get_message_discourse ( const struct GNUNET_MESSENGER_Message * message )

Returns the discourse hash of a message depending on its kind.

If a message contains a discourse hash it will not be stored locally on peers.

Parameters

[in] message Message

Returns: Discourse hash of message or NULL

Definition at line 2240 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    return &(message->body.subscribtion.discourse);
  case GNUNET_MESSENGER_KIND_TALK:
    return &(message->body.talk.discourse);
  default:
    return NULL;
  }
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessageSubscribtion::discourse, GNUNET_MESSENGER_MessageTalk::discourse, GNUNET_assert, GNUNET_MESSENGER_KIND_SUBSCRIBTION, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::subscribtion, and GNUNET_MESSENGER_MessageBody::talk.

Referenced by handle_message_control(), iterate_flag_for_cleanup_discourse_message(), put_store_message(), send_message_to_room(), and update_message_state().

Here is the caller graph for this function:

Variable Documentation

◆ encryption_overhead

const uint16_t encryption_overhead

Initial value:

=

GNUNET_CRYPTO_HPKE_SEAL_ONESHOT_OVERHEAD_BYTES

#define GNUNET_CRYPTO_HPKE_SEAL_ONESHOT_OVERHEAD_BYTES

Definition: gnunet_crypto_lib.h:2136

Definition at line 32 of file messenger_api_message.c.

Referenced by decrypt_message(), and encrypt_message().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ member_size

◆ max

◆ min

◆ encode_step_ext

◆ encode_step

◆ encode_step_key

◆ encode_step_signature

◆ decode_step_ext

◆ decode_step

◆ decode_step_malloc

◆ decode_step_key

Typedef Documentation

◆ kind_t

Function Documentation

◆ create_message()

◆ copy_message()

◆ copy_message_header()

◆ destroy_message_body()

◆ cleanup_message()

◆ destroy_message()

◆ is_message_session_bound()

◆ fold_short_message()

◆ unfold_short_message()

◆ get_message_body_kind_size()

◆ get_message_kind_size()

◆ get_message_body_size()

◆ get_message_size()

◆ get_short_message_size()

◆ calc_usual_padding()

◆ calc_padded_length()

◆ encode_message_body()

◆ encode_message()

◆ encode_short_message()

◆ decode_message_body()

◆ decode_message()

◆ decode_short_message()

◆ hash_message()

◆ sign_message()

◆ sign_message_by_peer()

◆ calc_message_hmac()

◆ sign_message_by_key()

◆ verify_message()

◆ verify_message_by_peer()

◆ verify_message_by_key()

◆ encrypt_message()

◆ decrypt_message()

◆ transcribe_message()

◆ encrypt_secret_message()

◆ decrypt_secret_message()

◆ read_transcript_message()

◆ extract_access_message_key()

◆ extract_authorization_message_key()

◆ get_message_timeout()

◆ pack_message()

◆ is_peer_message()

◆ is_service_message()

◆ is_epoch_message()

◆ filter_message_sending()

◆ get_message_discourse()

Variable Documentation

◆ encryption_overhead