fs_publish_ublock.c File Reference

publish a UBLOCK in GNUnet More...

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_signatures.h"
#include "fs_publish_ublock.h"
#include "fs_api.h"
#include "fs_tree.h"

Include dependency graph for fs_publish_ublock.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_FS_PublishUblockContext
	Context for 'ublock_put_cont'. More...

Functions
static void	derive_ublock_encryption_key (struct GNUNET_CRYPTO_AeadSecretKey *skey, struct GNUNET_CRYPTO_AeadNonce *iv, const char *label, const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
	Derive the key for symmetric encryption/decryption from the public key and the label.
void	GNUNET_FS_ublock_decrypt_ (const void *input, size_t input_len, const struct GNUNET_CRYPTO_EddsaPublicKey *ns, const char *label, void *output)
	Decrypt the given UBlock, storing the result in output.
static void	ublock_put_cont (void *cls, int32_t success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
	Continuation of GNUNET_FS_publish_ublock_().
static void	run_cont (void *cls)
	Run the continuation.
struct GNUNET_FS_PublishUblockContext *	GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h, struct GNUNET_DATASTORE_Handle *dsh, const char *label, const char *ulabel, const struct GNUNET_CRYPTO_EddsaPrivateKey *ns, const struct GNUNET_FS_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_UBlockContinuation cont, void *cont_cls)
	Publish a UBlock.
void	GNUNET_FS_publish_ublock_cancel_ (struct GNUNET_FS_PublishUblockContext *uc)
	Abort UBlock publishing operation.

Detailed Description

publish a UBLOCK in GNUnet

See also

https://gnunet.org/encoding and #2564

Author

Krista Bennett

Christian Grothoff

Definition in file fs_publish_ublock.c.

Function Documentation

derive_ublock_encryption_key()

static void derive_ublock_encryption_key ( struct GNUNET_CRYPTO_AeadSecretKey *  skey, struct GNUNET_CRYPTO_AeadNonce *  iv, const char *  label, const struct GNUNET_CRYPTO_EddsaPublicKey *  pub  )

static

Derive the key for symmetric encryption/decryption from the public key and the label.

Parameters

skey	where to store symmetric key
iv	where to store the IV
label	label to use for key derivation
pub	public key to use for key derivation

Definition at line 46 of file fs_publish_ublock.c.

{
  struct GNUNET_HashCode key;
 
  /* derive key from 'label' and public key of the namespace */
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CRYPTO_hkdf_gnunet (
                   &key, sizeof(key),
                   "UBLOCK-ENC", strlen ("UBLOCK-ENC"),
                   label, strlen (label),
                   GNUNET_CRYPTO_kdf_arg_auto (pub)));
  GNUNET_FS_hash_to_symmetric_key (&key, skey, iv);
}

References GNUNET_assert, GNUNET_CRYPTO_hkdf_gnunet, GNUNET_CRYPTO_kdf_arg_auto, GNUNET_FS_hash_to_symmetric_key(), GNUNET_YES, key, and pub.

Referenced by GNUNET_FS_publish_ublock_(), and GNUNET_FS_ublock_decrypt_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_ublock_decrypt_()

void GNUNET_FS_ublock_decrypt_	(	const void *	input,
		size_t	input_len,
		const struct GNUNET_CRYPTO_EddsaPublicKey *	ns,
		const char *	label,
		void *	output
	)

Decrypt the given UBlock, storing the result in output.

Parameters

input	input data
input_len	number of bytes in input
ns	public key under which the UBlock was stored
label	label under which the UBlock was stored
output	where to write the result, has input_len bytes

Definition at line 66 of file fs_publish_ublock.c.

{
  struct GNUNET_CRYPTO_AeadNonce iv;
  struct GNUNET_CRYPTO_AeadSecretKey skey;
  struct GNUNET_CRYPTO_AeadMac *mac;
 
  derive_ublock_encryption_key (&skey, &iv,
                                label, ns);
  mac = (struct GNUNET_CRYPTO_AeadMac*) (((char*) input) + input_len - sizeof *
                                         mac);
  GNUNET_CRYPTO_aead_decrypt (input_len - sizeof (*mac),
                              input,
                              0,
                              NULL,
                              &skey,
                              &iv,
                              mac,
                              output);
}

References derive_ublock_encryption_key(), GNUNET_CRYPTO_aead_decrypt(), GNUNET_CRYPTO_AeadMac::mac, and ns.

Referenced by decrypt_block_with_keyword(), process_kblock_for_unindex(), and process_sblock().

Here is the call graph for this function:

Here is the caller graph for this function:

ublock_put_cont()

static void ublock_put_cont ( void *  cls, int32_t  success, struct GNUNET_TIME_Absolute  min_expiration, const char *  msg  )

static

Continuation of GNUNET_FS_publish_ublock_().

Parameters

cls	closure of type "struct GNUNET_FS_PublishUblockContext*"
success	GNUNET_SYSERR on failure (including timeout/queue drop) GNUNET_NO if content was already there GNUNET_YES (or other positive value) on success
min_expiration	minimum expiration time required for 0-priority content to be stored by the datacache at this time, zero for unknown, forever if we have no space for 0-priority content
msg	NULL on success, otherwise an error message

Definition at line 131 of file fs_publish_ublock.c.

{
  struct GNUNET_FS_PublishUblockContext *uc = cls;
 
  uc->qre = NULL;
  uc->cont (uc->cont_cls, msg);
  GNUNET_free (uc);
}

References GNUNET_free, msg, and uc.

Referenced by GNUNET_FS_publish_ublock_().

Here is the caller graph for this function:

run_cont()

static void run_cont ( void *  cls )

static

Run the continuation.

Parameters

cls	the struct GNUNET_FS_PublishUblockContext *

Definition at line 150 of file fs_publish_ublock.c.

{
  struct GNUNET_FS_PublishUblockContext *uc = cls;
 
  uc->task = NULL;
  uc->cont (uc->cont_cls, NULL);
  GNUNET_free (uc);
}

References GNUNET_free, and uc.

Referenced by GNUNET_FS_publish_ublock_().

Here is the caller graph for this function:

GNUNET_FS_publish_ublock_()

struct GNUNET_FS_PublishUblockContext * GNUNET_FS_publish_ublock_	(	struct GNUNET_FS_Handle *	h,
		struct GNUNET_DATASTORE_Handle *	dsh,
		const char *	label,
		const char *	ulabel,
		const struct GNUNET_CRYPTO_EddsaPrivateKey *	ns,
		const struct GNUNET_FS_MetaData *	meta,
		const struct GNUNET_FS_Uri *	uri,
		const struct GNUNET_FS_BlockOptions *	bo,
		enum GNUNET_FS_PublishOptions	options,
		GNUNET_FS_UBlockContinuation	cont,
		void *	cont_cls
	)

Publish a UBlock.

Parameters

h	handle to the file sharing subsystem
dsh	datastore handle to use for storage operation
label	identifier to use
ulabel	update label to use, may be an empty string for none
ns	namespace to publish in
meta	metadata to use
uri	URI to refer to in the UBlock
bo	per-block options
options	publication options
cont	continuation
cont_cls	closure for cont

Returns

NULL on error (cont will still be called)

Definition at line 161 of file fs_publish_ublock.c.

{
  struct GNUNET_FS_PublishUblockContext *uc;
  struct GNUNET_HashCode query;
  struct GNUNET_CRYPTO_AeadNonce iv;
  struct GNUNET_CRYPTO_AeadSecretKey skey;
  struct GNUNET_CRYPTO_EddsaPrivateScalar nsd;
  struct GNUNET_CRYPTO_EddsaPublicKey pub;
  char *uris;
  size_t size;
  char *kbe;
  char *sptr;
  ssize_t mdsize;
  size_t slen;
  size_t ulen;
  struct UBlock *ub_plain;
  struct UBlock *ub_enc;
 
  /* compute ublock to publish */
  if (NULL == meta)
    mdsize = 0;
  else
    mdsize = GNUNET_FS_meta_data_get_serialized_size (meta);
  GNUNET_assert (mdsize >= 0);
  uris = GNUNET_FS_uri_to_string (uri);
  slen = strlen (uris) + 1;
  if (NULL == ulabel)
    ulen = 1;
  else
    ulen = strlen (ulabel) + 1;
  size = mdsize + sizeof(struct UBlock) + slen + ulen;
  if (size > MAX_UBLOCK_SIZE)
  {
    size = MAX_UBLOCK_SIZE;
    mdsize = size - sizeof(struct UBlock) - (slen + ulen);
  }
  ub_plain = GNUNET_malloc (size);
  kbe = (char *) &ub_plain[1];
  if (NULL != ulabel)
    GNUNET_memcpy (kbe, ulabel, ulen);
  kbe += ulen;
  GNUNET_memcpy (kbe, uris, slen);
  kbe += slen;
  GNUNET_free (uris);
  sptr = kbe;
  if (NULL != meta)
    mdsize =
      GNUNET_FS_meta_data_serialize (meta, &sptr, mdsize,
                                     GNUNET_FS_META_DATA_SERIALIZE_PART);
  if (-1 == mdsize)
  {
    GNUNET_break (0);
    GNUNET_free (ub_plain);
    cont (cont_cls, _ ("Internal error."));
    return NULL;
  }
  size = sizeof(struct UBlock) + slen + mdsize + ulen + sizeof (struct
                                                                GNUNET_CRYPTO_AeadMac);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Publishing under identifier `%s'\n",
              label);
  /* get public key of the namespace */
  GNUNET_CRYPTO_eddsa_key_get_public (ns,
                                      &pub);
  derive_ublock_encryption_key (&skey, &iv,
                                label, &pub);
 
  /* encrypt ublock */
  {
    struct GNUNET_CRYPTO_AeadMac *mac;
    ub_enc = GNUNET_malloc (size);
    mac = (struct GNUNET_CRYPTO_AeadMac*) (((char*) &ub_enc[1]) + size - sizeof
                                           *mac);
    GNUNET_CRYPTO_aead_encrypt (ulen + slen + mdsize,
                                (unsigned char*) &ub_plain[1],
                                0,
                                NULL,
                                &skey,
                                &iv,
                                &ub_enc[1],
                                mac);
  }
  GNUNET_free (ub_plain);
  ub_enc->purpose.size = htonl (size
                                - sizeof(struct GNUNET_CRYPTO_EddsaSignature));
  ub_enc->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK);
 
  /* derive signing-key from 'label' and public key of the namespace */
  GNUNET_CRYPTO_eddsa_private_key_derive (ns, label, "fs-ublock", &nsd);
  GNUNET_CRYPTO_eddsa_key_get_public_from_scalar (&nsd,
                                                  &ub_enc->verification_key);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CRYPTO_eddsa_sign_derived (ns,
                                                   label,
                                                   "fs-ublock",
                                                   &ub_enc->purpose,
                                                   &ub_enc->signature));
  GNUNET_CRYPTO_hash (&ub_enc->verification_key,
                      sizeof(ub_enc->verification_key),
                      &query);
 
  uc = GNUNET_new (struct GNUNET_FS_PublishUblockContext);
  uc->cont = cont;
  uc->cont_cls = cont_cls;
  if (NULL != dsh)
  {
    uc->qre =
      GNUNET_DATASTORE_put (dsh,
                            0,
                            &query,
                            size,
                            ub_enc,
                            GNUNET_BLOCK_TYPE_FS_UBLOCK,
                            bo->content_priority,
                            bo->anonymity_level,
                            bo->replication_level,
                            bo->expiration_time,
                            -2, 1,
                            &ublock_put_cont, uc);
  }
  else
  {
    uc->task = GNUNET_SCHEDULER_add_now (&run_cont,
                                         uc);
  }
  GNUNET_free (ub_enc);
  return uc;
}

References _, GNUNET_FS_BlockOptions::anonymity_level, bo, GNUNET_FS_BlockOptions::content_priority, derive_ublock_encryption_key(), dsh, GNUNET_FS_BlockOptions::expiration_time, GNUNET_assert, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_break, GNUNET_CRYPTO_aead_encrypt(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_eddsa_key_get_public_from_scalar(), GNUNET_CRYPTO_eddsa_private_key_derive(), GNUNET_CRYPTO_eddsa_sign_derived(), GNUNET_CRYPTO_hash(), GNUNET_DATASTORE_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_FS_meta_data_get_serialized_size(), GNUNET_FS_meta_data_serialize(), GNUNET_FS_META_DATA_SERIALIZE_PART, GNUNET_FS_uri_to_string(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK, GNUNET_CRYPTO_AeadMac::mac, MAX_UBLOCK_SIZE, meta, ns, pub, UBlock::purpose, GNUNET_CRYPTO_SignaturePurpose::purpose, GNUNET_FS_BlockOptions::replication_level, run_cont(), UBlock::signature, GNUNET_CRYPTO_SignaturePurpose::size, size, ublock_put_cont(), uc, uri, and UBlock::verification_key.

Referenced by GNUNET_FS_publish_sks(), and publish_ksk_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_ublock_cancel_()

void GNUNET_FS_publish_ublock_cancel_

(

struct GNUNET_FS_PublishUblockContext *

uc

)

Abort UBlock publishing operation.

Parameters

uc	operation to abort.

Definition at line 307 of file fs_publish_ublock.c.

{
  if (NULL != uc->qre)
    GNUNET_DATASTORE_cancel (uc->qre);
  if (NULL != uc->task)
    GNUNET_SCHEDULER_cancel (uc->task);
  GNUNET_free (uc);
}

References GNUNET_DATASTORE_cancel(), GNUNET_free, GNUNET_SCHEDULER_cancel(), and uc.

Referenced by GNUNET_FS_publish_ksk_cancel(), and GNUNET_FS_publish_sks_cancel().

Here is the call graph for this function:

Here is the caller graph for this function: