API for GNS record-related crypto. More...

#include "platform.h"
#include "gnsrecord_crypto.h"

Include dependency graph for gnsrecord_crypto.c:

Data Structures
struct	KeyCacheLine
	Line in cache mapping private keys to public keys. More...

struct	EncryptionContextData

Macros
#define	LOG(kind, ...) GNUNET_log_from (kind, "gnsrecord", __VA_ARGS__)

#define	CSIZE 64

Functions
void	GNR_derive_block_aes_key (unsigned char ctr, unsigned char key, const char label, uint64_t exp, const struct GNUNET_CRYPTO_EcdsaPublicKey pub)
	Derive session key and iv from label and public key.

void	GNR_derive_block_xsalsa_key (unsigned char nonce, unsigned char key, const char label, uint64_t exp, const struct GNUNET_CRYPTO_EddsaPublicKey pub)
	Derive session key and iv from label and public key.

static enum GNUNET_GenericReturnValue	block_sign_ecdsa (const struct GNUNET_CRYPTO_EcdsaPrivateKey key, const struct GNUNET_CRYPTO_EcdsaPublicKey pkey, const char label, struct GNUNET_GNSRECORD_Block block)

static enum GNUNET_GenericReturnValue	block_sign_eddsa (const struct GNUNET_CRYPTO_EddsaPrivateKey key, const struct GNUNET_CRYPTO_EddsaPublicKey pkey, const char label, struct GNUNET_GNSRECORD_Block block)

enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_sign (const struct GNUNET_CRYPTO_BlindablePrivateKey key, const char label, struct GNUNET_GNSRECORD_Block *block)
	Sign a block create with GNUNET_GNSRECORD_block_create_unsigned.

static enum GNUNET_GenericReturnValue	block_create_ecdsa (const struct GNUNET_CRYPTO_EcdsaPrivateKey key, const struct GNUNET_CRYPTO_EcdsaPublicKey pkey, struct GNUNET_TIME_Absolute expire, const char label, const struct GNUNET_GNSRECORD_Data rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block **block, int sign)
	Sign name and records.

static enum GNUNET_GenericReturnValue	block_create_eddsa (const struct GNUNET_CRYPTO_EddsaPrivateKey key, const struct GNUNET_CRYPTO_EddsaPublicKey pkey, struct GNUNET_TIME_Absolute expire, const char label, const struct GNUNET_GNSRECORD_Data rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block **block, int sign)
	Sign name and records (EDDSA version)

enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create (const struct GNUNET_CRYPTO_BlindablePrivateKey key, struct GNUNET_TIME_Absolute expire, const char label, const struct GNUNET_GNSRECORD_Data rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block *result)
	Sign name and records.

static enum GNUNET_GenericReturnValue	block_create2 (const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, struct GNUNET_TIME_Absolute expire, const char label, const struct GNUNET_GNSRECORD_Data rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block *result, int sign)

enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create_unsigned (const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, struct GNUNET_TIME_Absolute expire, const char label, const struct GNUNET_GNSRECORD_Data rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block *result)
	Create name and records but do not sign! Sign later with GNUNET_GNSRECORD_block_sign().

enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create2 (const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, struct GNUNET_TIME_Absolute expire, const char label, const struct GNUNET_GNSRECORD_Data rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block *result)
	Sign name and records, cache derived public key (also keeps the private key in static memory, so do not use this function if keeping the private key in the process'es RAM is a major issue).

enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_verify (const struct GNUNET_GNSRECORD_Block *block)
	Check if a signature is valid.

static enum GNUNET_GenericReturnValue	block_decrypt_ecdsa (const struct GNUNET_GNSRECORD_Block block, const struct GNUNET_CRYPTO_EcdsaPublicKey zone_key, const char label, GNUNET_GNSRECORD_RecordCallback proc, void proc_cls)

static enum GNUNET_GenericReturnValue	block_decrypt_eddsa (const struct GNUNET_GNSRECORD_Block block, const struct GNUNET_CRYPTO_EddsaPublicKey zone_key, const char label, GNUNET_GNSRECORD_RecordCallback proc, void proc_cls)

void	GNUNET_GNSRECORD_query_from_private_key (const struct GNUNET_CRYPTO_BlindablePrivateKey zone, const char label, struct GNUNET_HashCode *query)
	Calculate the DHT query for a given label in a given zone.

void	GNUNET_GNSRECORD_query_from_public_key (const struct GNUNET_CRYPTO_BlindablePublicKey pub, const char label, struct GNUNET_HashCode *query)
	Calculate the DHT query for a given label in a given zone.

static enum GNUNET_GenericReturnValue	block_open_ecdsa (void cls, const char label, const struct GNUNET_GNSRECORD_Block block, GNUNET_GNSRECORD_RecordCallback proc, void proc_cls)

static enum GNUNET_GenericReturnValue	block_open_eddsa (void cls, const char label, const struct GNUNET_GNSRECORD_Block block, GNUNET_GNSRECORD_RecordCallback proc, void proc_cls)

static enum GNUNET_GenericReturnValue	block_seal_not_implemented (void cls, const char label, struct GNUNET_TIME_Absolute expire, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data rd[rd_count], struct GNUNET_GNSRECORD_Block **result)

static enum GNUNET_GenericReturnValue	block_seal (void cls, const char label, struct GNUNET_TIME_Absolute expire, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data rd[rd_count], struct GNUNET_GNSRECORD_Block **result)

struct GNUNET_GNSRECORD_EncryptionContext *	GNUNET_GNSRECORD_encryption_context_setup_owner (const struct GNUNET_CRYPTO_BlindablePrivateKey *sk)
	Create a new encryption context for the zone owner.

struct GNUNET_GNSRECORD_EncryptionContext *	GNUNET_GNSRECORD_encryption_context_setup_resolver (const struct GNUNET_CRYPTO_BlindablePublicKey *zkey)
	Create a new encryption context for a resolver.

void	GNUNET_GNSRECORD_encryption_context_destroy (struct GNUNET_GNSRECORD_EncryptionContext *ec)
	Cleanup and free the encryption context.

enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_decrypt (const struct GNUNET_GNSRECORD_Block block, const struct GNUNET_CRYPTO_BlindablePublicKey zone_key, const char label, GNUNET_GNSRECORD_RecordCallback proc, void proc_cls)
	Decrypt block.

Detailed Description

API for GNS record-related crypto.

Author: Martin Schanzenbach; Matthias Wachs; Christian Grothoff

Definition in file gnsrecord_crypto.c.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "gnsrecord", __VA_ARGS__)

Definition at line 31 of file gnsrecord_crypto.c.

◆ CSIZE

#define CSIZE 64

Function Documentation

◆ GNR_derive_block_aes_key()

void GNR_derive_block_aes_key	(	unsigned char *	ctr,
		unsigned char *	key,
		const char *	label,
		uint64_t	exp,
		const struct GNUNET_CRYPTO_EcdsaPublicKey *	pub
	)

Derive session key and iv from label and public key.

Parameters

iv	initialization vector to initialize
skey	session key to initialize
label	label to use for KDF
pub	public key to use for KDF

4 byte nonce

Expiration time 64 bit.

Set counter part to 1

Definition at line 34 of file gnsrecord_crypto.c.

{
  static const char ctx_key[] = "gns-aes-ctx-key";
  static const char ctx_iv[] = "gns-aes-ctx-iv";
 
  GNUNET_CRYPTO_hkdf_gnunet (key, GNUNET_CRYPTO_AES_KEY_LENGTH,
                             ctx_key, strlen (ctx_key),
                             pub, sizeof(struct
                                         GNUNET_CRYPTO_EcdsaPublicKey),
                             GNUNET_CRYPTO_kdf_arg_string (label));
  memset (ctr, 0, GNUNET_CRYPTO_AES_KEY_LENGTH / 2);
  GNUNET_CRYPTO_hkdf_gnunet (ctr, 4,
                             ctx_iv, strlen (ctx_iv),
                             pub, sizeof(struct
                                         GNUNET_CRYPTO_EcdsaPublicKey),
                             GNUNET_CRYPTO_kdf_arg_string (label));
  memcpy (ctr + 4, &exp, sizeof (exp));
  ctr[15] |= 0x01;
}

References GNUNET_CRYPTO_AES_KEY_LENGTH, GNUNET_CRYPTO_hkdf_gnunet, GNUNET_CRYPTO_kdf_arg_string, key, and pub.

Referenced by block_create_ecdsa(), block_decrypt_ecdsa(), and run_pkey().

Here is the caller graph for this function:

◆ GNR_derive_block_xsalsa_key()

void GNR_derive_block_xsalsa_key	(	unsigned char *	nonce,
		unsigned char *	key,
		const char *	label,
		uint64_t	exp,
		const struct GNUNET_CRYPTO_EddsaPublicKey *	pub
	)

Derive session key and iv from label and public key.

Parameters

nonce	initialization vector to initialize
skey	session key to initialize
label	label to use for KDF
pub	public key to use for KDF

16 byte nonce

Expiration time 64 bit.

Definition at line 63 of file gnsrecord_crypto.c.

{
  static const char ctx_key[] = "gns-xsalsa-ctx-key";
  static const char ctx_iv[] = "gns-xsalsa-ctx-iv";
 
  GNUNET_CRYPTO_hkdf_gnunet (
    key, crypto_secretbox_KEYBYTES,
    ctx_key, strlen (ctx_key),
    pub, sizeof(struct GNUNET_CRYPTO_EddsaPublicKey),
    GNUNET_CRYPTO_kdf_arg_string (label));
  memset (nonce, 0, crypto_secretbox_NONCEBYTES);
  GNUNET_CRYPTO_hkdf_gnunet (
    nonce, (crypto_secretbox_NONCEBYTES - sizeof (exp)),
    ctx_iv, strlen (ctx_iv),
    pub, sizeof(struct GNUNET_CRYPTO_EddsaPublicKey),
    GNUNET_CRYPTO_kdf_arg_string (label));
  memcpy (nonce + (crypto_secretbox_NONCEBYTES - sizeof (exp)),
          &exp, sizeof (exp));
}

References GNUNET_CRYPTO_hkdf_gnunet, GNUNET_CRYPTO_kdf_arg_string, key, and pub.

Referenced by block_create_eddsa(), block_decrypt_eddsa(), and run_edkey().

Here is the caller graph for this function:

◆ block_sign_ecdsa()

static enum GNUNET_GenericReturnValue block_sign_ecdsa	(	const struct GNUNET_CRYPTO_EcdsaPrivateKey *	key,
		const struct GNUNET_CRYPTO_EcdsaPublicKey *	pkey,
		const char *	label,
		struct GNUNET_GNSRECORD_Block *	block
	)

static

Definition at line 91 of file gnsrecord_crypto.c.

{
  struct GNRBlockPS *gnr_block;
  struct GNUNET_GNSRECORD_EcdsaBlock *ecblock;
  size_t size = ntohl (block->size) - sizeof (*block) + sizeof (*gnr_block);
 
  gnr_block = GNUNET_malloc (size);
  ecblock = &(block)->ecdsa_block;
  gnr_block->purpose.size = htonl (size);
  gnr_block->purpose.purpose =
    htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
  gnr_block->expiration_time = ecblock->expiration_time;
  /* encrypt and sign */
  GNUNET_memcpy (&gnr_block[1], &ecblock[1],
                 size - sizeof (*gnr_block));
  GNUNET_CRYPTO_ecdsa_public_key_derive (pkey,
                                         label,
                                         "gns",
                                         &ecblock->derived_key);
  if (GNUNET_OK !=
      GNUNET_CRYPTO_ecdsa_sign_derived (key,
                                        label,
                                        "gns",
                                        &gnr_block->purpose,
                                        &ecblock->signature))
  {
    GNUNET_break (0);
    GNUNET_free (gnr_block);
    return GNUNET_SYSERR;
  }
  GNUNET_free (gnr_block);
  return GNUNET_OK;
}

References GNUNET_GNSRECORD_EcdsaBlock::derived_key, GNUNET_GNSRECORD_EcdsaBlock::expiration_time, GNRBlockPS::expiration_time, GNUNET_break, GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_ecdsa_sign_derived(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN, GNUNET_SYSERR, key, pkey, GNUNET_CRYPTO_SignaturePurpose::purpose, GNRBlockPS::purpose, GNUNET_GNSRECORD_EcdsaBlock::signature, GNUNET_CRYPTO_SignaturePurpose::size, GNUNET_GNSRECORD_Block::size, and size.

Referenced by block_create_ecdsa(), and GNUNET_GNSRECORD_block_sign().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_sign_eddsa()

static enum GNUNET_GenericReturnValue block_sign_eddsa	(	const struct GNUNET_CRYPTO_EddsaPrivateKey *	key,
		const struct GNUNET_CRYPTO_EddsaPublicKey *	pkey,
		const char *	label,
		struct GNUNET_GNSRECORD_Block *	block
	)

static

Definition at line 132 of file gnsrecord_crypto.c.

{
  struct GNRBlockPS *gnr_block;
  struct GNUNET_GNSRECORD_EddsaBlock *edblock;
  size_t size = ntohl (block->size) - sizeof (*block) + sizeof (*gnr_block);
  gnr_block = GNUNET_malloc (size);
  edblock = &(block)->eddsa_block;
  gnr_block->purpose.size = htonl (size);
  gnr_block->purpose.purpose =
    htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
  gnr_block->expiration_time = edblock->expiration_time;
  GNUNET_memcpy (&gnr_block[1], &edblock[1],
                 size - sizeof (*gnr_block));
  /* encrypt and sign */
  GNUNET_CRYPTO_eddsa_public_key_derive (pkey,
                                         label,
                                         "gns",
                                         &edblock->derived_key);
  GNUNET_CRYPTO_eddsa_sign_derived (key,
                                    label,
                                    "gns",
                                    &gnr_block->purpose,
                                    &edblock->signature);
  GNUNET_free (gnr_block);
  return GNUNET_OK;
}

References GNUNET_GNSRECORD_EddsaBlock::derived_key, GNUNET_GNSRECORD_EddsaBlock::expiration_time, GNRBlockPS::expiration_time, GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_eddsa_sign_derived(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN, key, pkey, GNUNET_CRYPTO_SignaturePurpose::purpose, GNRBlockPS::purpose, GNUNET_GNSRECORD_EddsaBlock::signature, GNUNET_CRYPTO_SignaturePurpose::size, GNUNET_GNSRECORD_Block::size, and size.

Referenced by block_create_eddsa(), and GNUNET_GNSRECORD_block_sign().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_create_ecdsa()

static enum GNUNET_GenericReturnValue block_create_ecdsa	(	const struct GNUNET_CRYPTO_EcdsaPrivateKey *	key,
		const struct GNUNET_CRYPTO_EcdsaPublicKey *	pkey,
		struct GNUNET_TIME_Absolute	expire,
		const char *	label,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Block **	block,
		int	sign
	)

static

Sign name and records.

Parameters

key	the private key
pkey	associated public key
expire	block expiration
label	the name for the records
rd	record data
rd_count	number of records
block	the block result. Must be allocated sufficiently.
sign	sign the block GNUNET_NO if block will be signed later.

Returns: GNUNET_SYSERR on error (otherwise GNUNET_OK)

Definition at line 215 of file gnsrecord_crypto.c.

{
  ssize_t payload_len = GNUNET_GNSRECORD_records_get_size (rd_count,
                                                           rd);
  struct GNUNET_GNSRECORD_EcdsaBlock *ecblock;
  unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2];
  unsigned char skey[GNUNET_CRYPTO_AES_KEY_LENGTH];
  struct GNUNET_GNSRECORD_Data rdc[GNUNET_NZL (rd_count)];
  struct GNUNET_TIME_Absolute now;
 
  if (payload_len < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (payload_len > GNUNET_GNSRECORD_MAX_BLOCK_SIZE)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  /* convert relative to absolute times */
  now = GNUNET_TIME_absolute_get ();
  for (unsigned int i = 0; i < rd_count; i++)
  {
    rdc[i] = rd[i];
    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    {
      struct GNUNET_TIME_Relative t;
 
      /* encrypted blocks must never have relative expiration times, convert! */
      rdc[i].flags &= ~GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
      t.rel_value_us = rdc[i].expiration_time;
      rdc[i].expiration_time = GNUNET_TIME_absolute_add (now, t).abs_value_us;
    }
  }
  /* serialize */
  *block = GNUNET_malloc (sizeof (struct GNUNET_GNSRECORD_Block) + payload_len);
  (*block)->size = htonl (sizeof (struct GNUNET_GNSRECORD_Block) + payload_len);
  {
    char payload[payload_len];
 
    GNUNET_assert (payload_len ==
                   GNUNET_GNSRECORD_records_serialize (rd_count,
                                                       rdc,
                                                       payload_len,
                                                       payload));
    ecblock = &(*block)->ecdsa_block;
    (*block)->type = htonl (GNUNET_GNSRECORD_TYPE_PKEY);
    ecblock->expiration_time = GNUNET_TIME_absolute_hton (expire);
    GNR_derive_block_aes_key (ctr,
                              skey,
                              label,
                              ecblock->expiration_time.abs_value_us__,
                              pkey);
    GNUNET_CRYPTO_aes_ctr (payload,
                           payload_len,
                           skey,
                           ctr,
                           &ecblock[1]);
  }
  if (GNUNET_YES != sign)
    return GNUNET_OK;
  if (GNUNET_OK !=
      block_sign_ecdsa (key, pkey, label, *block))
  {
    GNUNET_break (0);
    GNUNET_free (*block);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_TIME_AbsoluteNBO::abs_value_us__, block_sign_ecdsa(), GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_EcdsaBlock::expiration_time, expire, GNUNET_GNSRECORD_Data::flags, GNR_derive_block_aes_key(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_aes_ctr(), GNUNET_CRYPTO_AES_KEY_LENGTH, GNUNET_free, GNUNET_GNSRECORD_MAX_BLOCK_SIZE, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_malloc, GNUNET_NZL, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GNUNET_YES, key, payload, pkey, rd, rd_count, and t.

Referenced by block_create2(), and GNUNET_GNSRECORD_block_create().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_create_eddsa()

static enum GNUNET_GenericReturnValue block_create_eddsa	(	const struct GNUNET_CRYPTO_EddsaPrivateKey *	key,
		const struct GNUNET_CRYPTO_EddsaPublicKey *	pkey,
		struct GNUNET_TIME_Absolute	expire,
		const char *	label,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Block **	block,
		int	sign
	)

static

Sign name and records (EDDSA version)

Parameters

key	the private key
pkey	associated public key
expire	block expiration
label	the name for the records
rd	record data
rd_count	number of records
block	where to store the block. Must be allocated sufficiently.
sign	GNUNET_YES if block shall be signed as well

Returns: GNUNET_SYSERR on error (otherwise GNUNET_OK)

Definition at line 309 of file gnsrecord_crypto.c.

{
  ssize_t payload_len = GNUNET_GNSRECORD_records_get_size (rd_count,
                                                           rd);
  struct GNUNET_GNSRECORD_EddsaBlock *edblock;
  unsigned char nonce[crypto_secretbox_NONCEBYTES];
  unsigned char skey[crypto_secretbox_KEYBYTES];
  struct GNUNET_GNSRECORD_Data rdc[GNUNET_NZL (rd_count)];
  struct GNUNET_TIME_Absolute now;
 
  if (payload_len < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (payload_len > GNUNET_GNSRECORD_MAX_BLOCK_SIZE)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  /* convert relative to absolute times */
  now = GNUNET_TIME_absolute_get ();
  for (unsigned int i = 0; i < rd_count; i++)
  {
    rdc[i] = rd[i];
    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    {
      struct GNUNET_TIME_Relative t;
 
      /* encrypted blocks must never have relative expiration times, convert! */
      rdc[i].flags &= ~GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
      t.rel_value_us = rdc[i].expiration_time;
      rdc[i].expiration_time = GNUNET_TIME_absolute_add (now, t).abs_value_us;
    }
  }
  /* serialize */
  *block = GNUNET_malloc (sizeof (struct GNUNET_GNSRECORD_Block)
                          + payload_len + crypto_secretbox_MACBYTES);
  (*block)->size = htonl (sizeof (struct GNUNET_GNSRECORD_Block)
                          + payload_len + crypto_secretbox_MACBYTES);
  {
    char payload[payload_len];
 
    GNUNET_assert (payload_len ==
                   GNUNET_GNSRECORD_records_serialize (rd_count,
                                                       rdc,
                                                       payload_len,
                                                       payload));
    edblock = &(*block)->eddsa_block;
    (*block)->type = htonl (GNUNET_GNSRECORD_TYPE_EDKEY);
    edblock->expiration_time = GNUNET_TIME_absolute_hton (expire);
    GNR_derive_block_xsalsa_key (nonce,
                                 skey,
                                 label,
                                 edblock->expiration_time.abs_value_us__,
                                 pkey);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CRYPTO_xsalsa20poly1305_encrypt (
                     payload_len,
                     (unsigned char*) payload,
                     skey,
                     nonce,
                     &edblock[1]));
    if (GNUNET_YES != sign)
      return GNUNET_OK;
    block_sign_eddsa (key, pkey, label, *block);
  }
  return GNUNET_OK;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_TIME_AbsoluteNBO::abs_value_us__, block_sign_eddsa(), GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_EddsaBlock::expiration_time, expire, GNUNET_GNSRECORD_Data::flags, GNR_derive_block_xsalsa_key(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_xsalsa20poly1305_encrypt(), GNUNET_GNSRECORD_MAX_BLOCK_SIZE, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_malloc, GNUNET_NZL, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GNUNET_YES, key, payload, pkey, rd, rd_count, and t.

Referenced by block_create2(), and GNUNET_GNSRECORD_block_create().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_create2()

static enum GNUNET_GenericReturnValue block_create2	(	const struct GNUNET_CRYPTO_BlindablePrivateKey *	pkey,
		struct GNUNET_TIME_Absolute	expire,
		const char *	label,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Block **	result,
		int	sign
	)

static

Definition at line 452 of file gnsrecord_crypto.c.

{
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *key;
  struct GNUNET_CRYPTO_EddsaPublicKey edpubkey;
  enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
  char *norm_label;
#define CSIZE 64
  static struct KeyCacheLine cache[CSIZE];
  struct KeyCacheLine *line;
 
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
 
  if (GNUNET_PUBLIC_KEY_TYPE_ECDSA == ntohl (pkey->type))
  {
    key = &pkey->ecdsa_key;
 
    line = &cache[(*(unsigned int *) key) % CSIZE];
    if (0 != memcmp (&line->key,
                     key,
                     sizeof(*key)))
    {
      /* cache miss, recompute */
      line->key = *key;
      GNUNET_CRYPTO_ecdsa_key_get_public (key,
                                          &line->pkey);
    }
    res = block_create_ecdsa (key,
                              &line->pkey,
                              expire,
                              norm_label,
                              rd,
                              rd_count,
                              result,
                              sign);
  }
  else if (GNUNET_PUBLIC_KEY_TYPE_EDDSA == ntohl (pkey->type))
  {
    GNUNET_CRYPTO_eddsa_key_get_public (&pkey->eddsa_key,
                                        &edpubkey);
    res = block_create_eddsa (&pkey->eddsa_key,
                              &edpubkey,
                              expire,
                              norm_label,
                              rd,
                              rd_count,
                              result,
                              sign);
  }
#undef CSIZE
  GNUNET_free (norm_label);
  return res;
}

References block_create_ecdsa(), block_create_eddsa(), CSIZE, expire, GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_free, GNUNET_GNSRECORD_string_normalize(), GNUNET_PUBLIC_KEY_TYPE_ECDSA, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_SYSERR, key, KeyCacheLine::key, line, pkey, rd, rd_count, res, and result.

Referenced by block_seal(), GNUNET_GNSRECORD_block_create2(), and GNUNET_GNSRECORD_block_create_unsigned().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_decrypt_ecdsa()

static enum GNUNET_GenericReturnValue block_decrypt_ecdsa	(	const struct GNUNET_GNSRECORD_Block *	block,
		const struct GNUNET_CRYPTO_EcdsaPublicKey *	zone_key,
		const char *	label,
		GNUNET_GNSRECORD_RecordCallback	proc,
		void *	proc_cls
	)

static

Definition at line 605 of file gnsrecord_crypto.c.

{
  size_t payload_len = ntohl (block->size)
                       - sizeof (struct GNUNET_GNSRECORD_Block);
  unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2];
  unsigned char key[GNUNET_CRYPTO_AES_KEY_LENGTH];
 
  if (ntohl (block->size) <
      sizeof (struct GNUNET_GNSRECORD_Block))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  GNUNET_assert (payload_len <= UINT16_MAX);
  GNR_derive_block_aes_key (ctr,
                            key,
                            label,
                            block->ecdsa_block.expiration_time.abs_value_us__,
                            zone_key);
  {
    char payload[payload_len];
    unsigned int rd_count;
 
    GNUNET_CRYPTO_aes_ctr (&block[1],
                           payload_len,
                           key,
                           ctr,
                           payload);
    rd_count = GNUNET_GNSRECORD_records_deserialize_get_size (payload_len,
                                                              payload);
    if (rd_count > 2048)
    {
      /* limit to sane value */
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    {
      struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
      unsigned int j;
      struct GNUNET_TIME_Absolute now;
 
      if (GNUNET_OK !=
          GNUNET_GNSRECORD_records_deserialize (payload_len,
                                                payload,
                                                rd_count,
                                                rd))
      {
        GNUNET_break_op (0);
        return GNUNET_SYSERR;
      }
      /* hide expired records */
      now = GNUNET_TIME_absolute_get ();
      j = 0;
      for (unsigned int i = 0; i < rd_count; i++)
      {
        if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
        {
          /* encrypted blocks must never have relative expiration times, skip! */
          GNUNET_break_op (0);
          continue;
        }
 
        if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW))
        {
          int include_record = GNUNET_YES;
          /* Shadow record, figure out if we have a not expired active record */
          for (unsigned int k = 0; k < rd_count; k++)
          {
            if (k == i)
              continue;
            if (rd[i].expiration_time < now.abs_value_us)
              include_record = GNUNET_NO;       /* Shadow record is expired */
            if ((rd[k].record_type == rd[i].record_type) &&
                (rd[k].expiration_time >= now.abs_value_us) &&
                (0 == (rd[k].flags & GNUNET_GNSRECORD_RF_SHADOW)))
            {
              include_record = GNUNET_NO;         /* We have a non-expired, non-shadow record of the same type */
              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                          "Ignoring shadow record\n");
              break;
            }
          }
          if (GNUNET_YES == include_record)
          {
            rd[i].flags ^= GNUNET_GNSRECORD_RF_SHADOW;       /* Remove Flag */
            if (j != i)
              rd[j] = rd[i];
            j++;
          }
        }
        else if (rd[i].expiration_time >= now.abs_value_us)
        {
          /* Include this record */
          if (j != i)
            rd[j] = rd[i];
          j++;
        }
        else
        {
          struct GNUNET_TIME_Absolute at;
 
          at.abs_value_us = rd[i].expiration_time;
          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                      "Excluding record that expired %s (%llu ago)\n",
                      GNUNET_STRINGS_absolute_time_to_string (at),
                      (unsigned long long) rd[i].expiration_time
                      - now.abs_value_us);
        }
      }
      rd_count = j;
      if (NULL != proc)
        proc (proc_cls,
              rd_count,
              (0 != rd_count) ? rd : NULL);
    }
  }
  return GNUNET_OK;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_TIME_AbsoluteNBO::abs_value_us__, GNUNET_GNSRECORD_Block::ecdsa_block, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_EcdsaBlock::expiration_time, GNUNET_GNSRECORD_Data::flags, GNR_derive_block_aes_key(), GNUNET_assert, GNUNET_break_op, GNUNET_CRYPTO_aes_ctr(), GNUNET_CRYPTO_AES_KEY_LENGTH, GNUNET_ERROR_TYPE_INFO, GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_records_deserialize_get_size(), GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_log, GNUNET_NO, GNUNET_NZL, GNUNET_OK, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_YES, key, payload, rd, rd_count, and GNUNET_GNSRECORD_Block::size.

Referenced by block_open_ecdsa().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_decrypt_eddsa()

static enum GNUNET_GenericReturnValue block_decrypt_eddsa	(	const struct GNUNET_GNSRECORD_Block *	block,
		const struct GNUNET_CRYPTO_EddsaPublicKey *	zone_key,
		const char *	label,
		GNUNET_GNSRECORD_RecordCallback	proc,
		void *	proc_cls
	)

static

Definition at line 731 of file gnsrecord_crypto.c.

{
  size_t payload_len = ntohl (block->size)
                       - sizeof (struct GNUNET_GNSRECORD_Block);
  unsigned char nonce[crypto_secretbox_NONCEBYTES];
  unsigned char key[crypto_secretbox_KEYBYTES];
 
  if (ntohl (block->size) <
      sizeof(struct GNUNET_GNSRECORD_Block))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  GNR_derive_block_xsalsa_key (nonce,
                               key,
                               label,
                               block->eddsa_block.expiration_time.abs_value_us__
                               ,
                               zone_key);
  {
    char payload[payload_len];
    unsigned int rd_count;
 
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CRYPTO_xsalsa20poly1305_decrypt (
                     payload_len,
                     (unsigned char*) &block[1],
                     key,
                     nonce,
                     payload));
    payload_len -= crypto_secretbox_MACBYTES;
    rd_count = GNUNET_GNSRECORD_records_deserialize_get_size (payload_len,
                                                              payload);
    if (rd_count > 2048)
    {
      /* limit to sane value */
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    {
      struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
      unsigned int j;
      struct GNUNET_TIME_Absolute now;
 
      if (GNUNET_OK !=
          GNUNET_GNSRECORD_records_deserialize (payload_len,
                                                payload,
                                                rd_count,
                                                rd))
      {
        GNUNET_break_op (0);
        return GNUNET_SYSERR;
      }
      /* hide expired records */
      now = GNUNET_TIME_absolute_get ();
      j = 0;
      for (unsigned int i = 0; i < rd_count; i++)
      {
        if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
        {
          /* encrypted blocks must never have relative expiration times, skip! */
          GNUNET_break_op (0);
          continue;
        }
 
        if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW))
        {
          int include_record = GNUNET_YES;
          /* Shadow record, figure out if we have a not expired active record */
          for (unsigned int k = 0; k < rd_count; k++)
          {
            if (k == i)
              continue;
            if (rd[i].expiration_time < now.abs_value_us)
              include_record = GNUNET_NO;       /* Shadow record is expired */
            if ((rd[k].record_type == rd[i].record_type) &&
                (rd[k].expiration_time >= now.abs_value_us) &&
                (0 == (rd[k].flags & GNUNET_GNSRECORD_RF_SHADOW)))
            {
              include_record = GNUNET_NO;         /* We have a non-expired, non-shadow record of the same type */
              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                          "Ignoring shadow record\n");
              break;
            }
          }
          if (GNUNET_YES == include_record)
          {
            rd[i].flags ^= GNUNET_GNSRECORD_RF_SHADOW;       /* Remove Flag */
            if (j != i)
              rd[j] = rd[i];
            j++;
          }
        }
        else if (rd[i].expiration_time >= now.abs_value_us)
        {
          /* Include this record */
          if (j != i)
            rd[j] = rd[i];
          j++;
        }
        else
        {
          struct GNUNET_TIME_Absolute at;
 
          at.abs_value_us = rd[i].expiration_time;
          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                      "Excluding record that expired %s (%llu ago)\n",
                      GNUNET_STRINGS_absolute_time_to_string (at),
                      (unsigned long long) rd[i].expiration_time
                      - now.abs_value_us);
        }
      }
      rd_count = j;
      if (NULL != proc)
        proc (proc_cls,
              rd_count,
              (0 != rd_count) ? rd : NULL);
    }
  }
  return GNUNET_OK;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_TIME_AbsoluteNBO::abs_value_us__, GNUNET_GNSRECORD_Block::eddsa_block, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_EddsaBlock::expiration_time, GNUNET_GNSRECORD_Data::flags, GNR_derive_block_xsalsa_key(), GNUNET_assert, GNUNET_break_op, GNUNET_CRYPTO_xsalsa20poly1305_decrypt(), GNUNET_ERROR_TYPE_INFO, GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_records_deserialize_get_size(), GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_log, GNUNET_NO, GNUNET_NZL, GNUNET_OK, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_YES, key, payload, rd, rd_count, and GNUNET_GNSRECORD_Block::size.

Referenced by block_open_eddsa().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_open_ecdsa()

static enum GNUNET_GenericReturnValue block_open_ecdsa	(	void *	cls,
		const char *	label,
		const struct GNUNET_GNSRECORD_Block *	block,
		GNUNET_GNSRECORD_RecordCallback	proc,
		void *	proc_cls
	)

static

Definition at line 943 of file gnsrecord_crypto.c.

{
  struct EncryptionContextData *ecd = cls;
  enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
  char *norm_label;
 
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
  return block_decrypt_ecdsa (block,
                              &ecd->zkey.ecdsa_key,
                              norm_label, proc,
                              proc_cls);
  GNUNET_free (norm_label);
  return res;
 
}

References block_decrypt_ecdsa(), GNUNET_CRYPTO_BlindablePublicKey::ecdsa_key, GNUNET_free, GNUNET_GNSRECORD_string_normalize(), GNUNET_SYSERR, res, and EncryptionContextData::zkey.

Referenced by GNUNET_GNSRECORD_encryption_context_setup_owner(), and GNUNET_GNSRECORD_encryption_context_setup_resolver().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_open_eddsa()

static enum GNUNET_GenericReturnValue block_open_eddsa	(	void *	cls,
		const char *	label,
		const struct GNUNET_GNSRECORD_Block *	block,
		GNUNET_GNSRECORD_RecordCallback	proc,
		void *	proc_cls
	)

static

Definition at line 965 of file gnsrecord_crypto.c.

{
  struct EncryptionContextData *ecd = cls;
  enum GNUNET_GenericReturnValue res;
  char *norm_label;
 
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
  res = block_decrypt_eddsa (block,
                             &ecd->zkey.eddsa_key,
                             norm_label, proc,
                             proc_cls);
  GNUNET_free (norm_label);
  return res;
}

References block_decrypt_eddsa(), GNUNET_CRYPTO_BlindablePublicKey::eddsa_key, GNUNET_free, GNUNET_GNSRECORD_string_normalize(), res, and EncryptionContextData::zkey.

Referenced by GNUNET_GNSRECORD_encryption_context_setup_owner(), and GNUNET_GNSRECORD_encryption_context_setup_resolver().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_seal_not_implemented()

static enum GNUNET_GenericReturnValue block_seal_not_implemented	(	void *	cls,
		const char *	label,
		struct GNUNET_TIME_Absolute	expire,
		unsigned int	rd_count,
		const struct GNUNET_GNSRECORD_Data	rd[rd_count],
		struct GNUNET_GNSRECORD_Block **	result
	)

static

Definition at line 986 of file gnsrecord_crypto.c.

{
  GNUNET_break (0);
  return GNUNET_SYSERR;
}

References GNUNET_break, and GNUNET_SYSERR.

Referenced by GNUNET_GNSRECORD_encryption_context_setup_resolver().

Here is the caller graph for this function:

◆ block_seal()

static enum GNUNET_GenericReturnValue block_seal	(	void *	cls,
		const char *	label,
		struct GNUNET_TIME_Absolute	expire,
		unsigned int	rd_count,
		const struct GNUNET_GNSRECORD_Data	rd[rd_count],
		struct GNUNET_GNSRECORD_Block **	result
	)

static

Definition at line 999 of file gnsrecord_crypto.c.

{
  struct EncryptionContextData *ecd = cls;
 
  return block_create2 (ecd->sk,
                        expire,
                        label,
                        rd,
                        rd_count,
                        result,
                        GNUNET_YES);
}

References block_create2(), expire, GNUNET_YES, rd, rd_count, result, and EncryptionContextData::sk.

Referenced by GNUNET_GNSRECORD_encryption_context_setup_owner().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

◆ CSIZE

Function Documentation

◆ GNR_derive_block_aes_key()

◆ GNR_derive_block_xsalsa_key()

◆ block_sign_ecdsa()

◆ block_sign_eddsa()

◆ block_create_ecdsa()

◆ block_create_eddsa()

◆ block_create2()

◆ block_decrypt_ecdsa()

◆ block_decrypt_eddsa()

◆ block_open_ecdsa()

◆ block_open_eddsa()

◆ block_seal_not_implemented()

◆ block_seal()