Crypto library: hash operations

Provides hashing and operations on hashes. More...

Macros
#define	GNUNET_CRYPTO_hash_from_string(enc, result)   GNUNET_CRYPTO_hash_from_string2 (enc, strlen (enc), result)
	Convert ASCII encoding back to struct GNUNET_HashCode More...

Functions
uint8_t	GNUNET_CRYPTO_crc8_n (const void *buf, size_t len)
	Calculate the checksum of a buffer in one step. More...
uint16_t	GNUNET_CRYPTO_crc16_n (const void *buf, size_t len)
	Calculate the checksum of a buffer in one step. More...
int32_t	GNUNET_CRYPTO_crc32_n (const void *buf, size_t len)
	Compute the CRC32 checksum for the first len bytes of the buffer. More...
void	GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block, struct GNUNET_CRYPTO_HashAsciiEncoded *result)
	Convert hash to ASCII encoding. More...
int	GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen, struct GNUNET_HashCode *result)
	Convert ASCII encoding back to a 'struct GNUNET_HashCode'. More...
uint32_t	GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b)
	Compute the distance between 2 hashcodes. More...
void	GNUNET_CRYPTO_hash (const void *block, size_t size, struct GNUNET_HashCode *ret)
	Compute hash of a given block. More...
void	GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
	Calculate HMAC of a message (RFC 2104) More...
struct GNUNET_CRYPTO_FileHashContext *	GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority, const char *filename, size_t blocksize, GNUNET_CRYPTO_HashCompletedCallback callback, void *callback_cls)
	Compute the hash of an entire file. More...
void	GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode, struct GNUNET_HashCode *result)
	Create a random hash code. More...
void	GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b, struct GNUNET_HashCode *result)
	compute result = b - a More...
void	GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *delta, struct GNUNET_HashCode *result)
	compute result = a + delta More...
void	GNUNET_CRYPTO_hash_xor (const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b, struct GNUNET_HashCode *result)
	compute result = a ^ b More...
void	GNUNET_CRYPTO_hash_to_aes_key (const struct GNUNET_HashCode *hc, struct GNUNET_CRYPTO_SymmetricSessionKey *skey, struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
	Convert a hashcode into a key. More...
int	GNUNET_CRYPTO_hash_get_bit_ltr (const struct GNUNET_HashCode *code, unsigned int bit)
	Obtain a bit from a hashcode. More...
unsigned int	GNUNET_CRYPTO_hash_matching_bits (const struct GNUNET_HashCode *first, const struct GNUNET_HashCode *second)
	Determine how many low order bits match in two struct GNUNET_HashCodes. More...
int	GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
	Compare function for HashCodes, producing a total ordering of all hashcodes. More...
int	GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2, const struct GNUNET_HashCode *target)
	Find out which of the two GNUNET_CRYPTO_hash codes is closer to target in the XOR metric (Kademlia). More...
void	GNUNET_CRYPTO_hmac_derive_key_v (struct GNUNET_CRYPTO_AuthKey *key, const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey, const void *salt, size_t salt_len, va_list argp)
	Derive an authentication key. More...
void	GNUNET_CRYPTO_hmac_derive_key (struct GNUNET_CRYPTO_AuthKey *key, const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey, const void *salt, size_t salt_len,...)
	Derive an authentication key. More...
int	GNUNET_CRYPTO_hkdf (void *result, size_t out_len, int xtr_algo, int prf_algo, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
	Derive key. More...
int	GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo, const void *xts, size_t xts_len, const void *skm, size_t skm_len, va_list argp)
	Derive key. More...
int	GNUNET_CRYPTO_kdf (void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
	Derive key. More...

Detailed Description

Provides hashing and operations on hashes.

See also

Documentation

Macro Definition Documentation

GNUNET_CRYPTO_hash_from_string

#define GNUNET_CRYPTO_hash_from_string	(		enc,
			result
	)		GNUNET_CRYPTO_hash_from_string2 (enc, strlen (enc), result)

Convert ASCII encoding back to struct GNUNET_HashCode

Parameters

enc	the encoding
result	where to store the hash code

Returns

GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding

Definition at line 624 of file gnunet_crypto_lib.h.

Referenced by database_setup(), run(), uri_chk_parse(), and uri_loc_parse().

Function Documentation

GNUNET_CRYPTO_crc8_n()

uint8_t GNUNET_CRYPTO_crc8_n	(	const void *	buf,
		size_t	len
	)

Calculate the checksum of a buffer in one step.

Parameters

buf	buffer to calculate CRC over
len	number of bytes in buf

Returns

crc8 value

Definition at line 179 of file crypto_crc.c.

References buf, and data.

{
  const uint8_t *data = buf;
  unsigned int crc = 0;
  int i;
  int j;

  for (j = len; 0 != j; j--)
  {
    crc ^= (*data++ << 8);
    for (i = 8; 0 != i; i--)
    {
      if (0 != (crc & 0x8000))
        crc ^= (0x1070 << 3);
      crc <<= 1;
    }
  }
  return (uint8_t) (crc >> 8);
}

GNUNET_CRYPTO_crc16_n()

uint16_t GNUNET_CRYPTO_crc16_n	(	const void *	buf,
		size_t	len
	)

Calculate the checksum of a buffer in one step.

Parameters

buf	buffer to calculate CRC over (must be 16-bit aligned)
len	number of bytes in buf, must be multiple of 2

Returns

crc16 value

Parameters

buf	buffer to calculate CRC over (must be 16-bit aligned)
len	number of bytes in hdr, must be multiple of 2

Returns

crc16 value

Definition at line 161 of file crypto_crc.c.

References buf, GNUNET_CRYPTO_crc16_finish(), and GNUNET_CRYPTO_crc16_step().

Referenced by GNUNET_TUN_initialize_ipv4_header().

{
  const uint16_t *hdr = buf;
  uint32_t sum = GNUNET_CRYPTO_crc16_step (0, hdr, len);

  return GNUNET_CRYPTO_crc16_finish (sum);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_crc32_n()

int32_t GNUNET_CRYPTO_crc32_n	(	const void *	buf,
		size_t	len
	)

Compute the CRC32 checksum for the first len bytes of the buffer.

Parameters

buf	the data over which we're taking the CRC
len	the length of the buffer buf in bytes

Returns

the resulting CRC32 checksum

Parameters

buf	the data over which we're taking the CRC
len	the length of the buffer

Returns

the resulting CRC32 checksum

Definition at line 106 of file crypto_crc.c.

References crc32(), and Z_NULL.

Referenced by do_decrypt(), do_encrypt(), ibf_get_indices(), process_data(), and wlan_plugin_send().

{
  GNUNET_uLong crc;

  crc = crc32 (0L, Z_NULL, 0);
  crc = crc32 (crc, (char *) buf, len);
  return crc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_to_enc()

void GNUNET_CRYPTO_hash_to_enc	(	const struct GNUNET_HashCode *	block,
		struct GNUNET_CRYPTO_HashAsciiEncoded *	result
	)

Convert hash to ASCII encoding.

Parameters

block	the hash code
result	where to store the encoding (struct GNUNET_CRYPTO_HashAsciiEncoded can be safely cast to char*, a '\0' termination is set).

Convert hash to ASCII encoding.

The ASCII encoding is rather GNUnet specific. It was chosen such that it only uses characters in [0-9A-V], can be produced without complex arithmetics and uses a small number of characters. The GNUnet encoding uses 103 characters plus a null terminator.

Parameters

block	the hash code
result	where to store the encoding (struct GNUNET_CRYPTO_HashAsciiEncoded can be safely cast to char*, a '\0' termination is set).

Definition at line 73 of file crypto_hash.c.

References GNUNET_assert, and GNUNET_STRINGS_data_to_string().

Referenced by get_update_information_directory(), GNUNET_e2s(), GNUNET_e2s2(), GNUNET_h2s(), GNUNET_h2s2(), GNUNET_h2s_full(), GNUNET_NETWORK_shorten_unixpath(), GNUNET_p2s(), GNUNET_p2s2(), store_and_free_entries(), uri_chk_to_string(), and uri_loc_to_string().

{
  char *np;

  np = GNUNET_STRINGS_data_to_string ((const unsigned char *) block,
                                      sizeof(struct GNUNET_HashCode),
                                      (char *) result,
                                      sizeof(struct
                                             GNUNET_CRYPTO_HashAsciiEncoded)
                                      - 1);
  GNUNET_assert (NULL != np);
  *np = '\0';
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_from_string2()

int GNUNET_CRYPTO_hash_from_string2	(	const char *	enc,
		size_t	enclen,
		struct GNUNET_HashCode *	result
	)

Convert ASCII encoding back to a 'struct GNUNET_HashCode'.

Parameters

enc	the encoding
enclen	number of characters in enc (without 0-terminator, which can be missing)
result	where to store the hash code

Returns

GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding

Convert ASCII encoding back to a 'struct GNUNET_HashCode'.

Parameters

enc	the encoding
enclen	number of characters in enc (without 0-terminator, which can be missing)
result	where to store the hash code

Returns

GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding

Definition at line 98 of file crypto_hash.c.

References GNUNET_STRINGS_string_to_data(), and GNUNET_STRINGS_utf8_toupper().

{
  char upper_enc[enclen];
  char *up_ptr = upper_enc;

  GNUNET_STRINGS_utf8_toupper (enc, up_ptr);

  return GNUNET_STRINGS_string_to_data (upper_enc, enclen,
                                        (unsigned char *) result,
                                        sizeof(struct GNUNET_HashCode));
}

Here is the call graph for this function:

GNUNET_CRYPTO_hash_distance_u32()

unsigned int GNUNET_CRYPTO_hash_distance_u32	(	const struct GNUNET_HashCode *	a,
		const struct GNUNET_HashCode *	b
	)

Compute the distance between 2 hashcodes.

The computation must be fast, not involve a[0] or a[4] (they're used elsewhere), and be somewhat consistent. And of course, the result should be a positive number.

Parameters

a	some hash code
b	some hash code

Returns

number between 0 and UINT32_MAX

The computation must be fast, not involve bits[0] or bits[4] (they're used elsewhere), and be somewhat consistent. And of course, the result should be a positive number.

Parameters

a	some hash code
b	some hash code

Returns

a positive number which is a measure for hashcode proximity.

Definition at line 127 of file crypto_hash.c.

References GNUNET_HashCode::bits.

Referenced by score_content().

{
  unsigned int x1 = (a->bits[1] - b->bits[1]) >> 16;
  unsigned int x2 = (b->bits[1] - a->bits[1]) >> 16;

  return(x1 * x2);
}

Here is the caller graph for this function:

GNUNET_CRYPTO_hash()

void GNUNET_CRYPTO_hash	(	const void *	block,
		size_t	size,
		struct GNUNET_HashCode *	ret
	)

Compute hash of a given block.

Parameters

block	the data to hash
size	size of the block
ret	pointer to where to write the hashcode

Compute hash of a given block.

Parameters

block	the data to GNUNET_CRYPTO_hash, length is given as a second argument
size	the length of the data to GNUNET_CRYPTO_hash in block
ret	pointer to where to write the hashcode

Definition at line 48 of file crypto_hash.c.

References BENCHMARK_END, and BENCHMARK_START.

Referenced by add_file(), add_known_to_bloom(), add_to_keyword_counter(), add_to_meta_counter(), advertise_dns_exit(), automaton_create_proofs(), block_plugin_dht_evaluate(), block_plugin_dns_evaluate(), block_plugin_fs_evaluate(), block_plugin_fs_get_key(), block_plugin_gns_evaluate(), block_plugin_gns_get_key(), block_plugin_revocation_evaluate(), block_plugin_revocation_get_key(), block_plugin_template_evaluate(), block_plugin_test_evaluate(), build_authz_response(), calculate_hmac(), check_authorization(), client_request_complete_alice(), code_redirect(), collector(), commit_set(), cookie_identity_interpretation(), core_init(), create_response(), data_to_ecdsa_value(), database_setup(), decrypt_new_element(), delayed_put(), derive_aes_key(), derive_auth_key(), derive_iv(), derive_pong_iv(), determine_id(), do_rekey(), ego_get_all(), ego_get_response(), encrypt_existing_match(), evaluate_block_regex(), evaluate_block_regex_accept(), find_advertisable_hello(), find_trees(), forward_reply(), GC_u2h(), GCT_handle_kx_auth(), get_cadet(), get_destination_key_from_ip(), get_fair_encryption_challenge(), get_file_handle(), get_gns_cont(), get_matching_bits(), get_update_information_directory(), get_url_parameter_copy(), GNUNET_BLOCK_mingle_hash(), GNUNET_CONVERSATION_phone_create(), GNUNET_CRYPTO_ecc_ecdh(), GNUNET_CRYPTO_ecdh_ecdsa(), GNUNET_CRYPTO_ecdh_eddsa(), GNUNET_CRYPTO_ecdsa_ecdh(), GNUNET_CRYPTO_eddsa_ecdh(), GNUNET_CRYPTO_rsa_public_key_hash(), GNUNET_e2s(), GNUNET_e2s2(), GNUNET_FS_handle_on_demand_block(), GNUNET_FS_namespace_list_updateable(), GNUNET_FS_publish_ublock_(), GNUNET_FS_search_start_searching_(), GNUNET_FS_tree_encoder_next(), GNUNET_FS_unindex_do_remove_kblocks_(), GNUNET_FS_uri_to_key(), GNUNET_GNSRECORD_query_from_public_key(), GNUNET_HELLO_extract_address(), GNUNET_HELLO_sign_address(), GNUNET_IDENTITY_ego_get_anonymous(), GNUNET_NETWORK_shorten_unixpath(), GNUNET_p2s(), GNUNET_p2s2(), GNUNET_TESTBED_barrier_init_(), GNUNET_TUN_service_name_to_hash(), GSC_KX_encrypt_and_transmit(), GSC_KX_init(), GSC_TYPEMAP_hash(), GSF_cadet_start_server(), handle_barrier_cancel(), handle_barrier_init(), handle_barrier_status(), handle_barrier_wait(), handle_client_decrypt(), handle_core_connect(), handle_encrypted(), handle_ephemeral_key(), handle_identity_set_default(), handle_identity_update(), handle_put(), handle_query_message(), handle_regex_result(), handle_transport_notify_connect(), hash_hosts(), hash_pkey_and_label(), header_iterator(), iface_proc(), insert_decrypt_element(), insert_round1_element(), iterate_initial_edge(), iterateBits(), load_plugin(), load_state(), login_cont(), lookup_diff(), lookup_rfn(), lookup_set(), lookup_task(), maint_child_death(), mysql_plugin_put(), namecache_cache_block(), namecache_postgres_cache_block(), namecache_sqlite_cache_block(), namestore_get(), ns_lookup_result_cb(), peerinfo_get(), peerstore_flat_store_record(), PEERSTORE_hash_key(), persist_access_token(), post_data_iter(), postgres_plugin_put(), process_client_result(), process_kblock_for_unindex(), process_reply(), publicize_rm(), put_diff(), put_rfn(), put_set(), put_task(), queue(), REGEX_BLOCK_check_proof(), REGEX_BLOCK_get_key(), REGEX_INTERNAL_get_first_key(), remove_high_frequency_keywords(), reset_cadet(), run(), schedule_next_hello(), schedule_transmit_search_request(), score_content(), send_key(), send_kx_auth(), set_result_cb(), setup_filter(), sock_read(), sqlite_plugin_put(), start_intersection(), token_endpoint(), try_connect(), try_match_block(), try_open_exit(), try_top_down_reconstruction(), url_iterator(), and userinfo_endpoint().

{
  BENCHMARK_START (hash);
  gcry_md_hash_buffer (GCRY_MD_SHA512, ret, block, size);
  BENCHMARK_END (hash);
}

GNUNET_CRYPTO_hmac()

void GNUNET_CRYPTO_hmac	(	const struct GNUNET_CRYPTO_AuthKey *	key,
		const void *	plaintext,
		size_t	plaintext_len,
		struct GNUNET_HashCode *	hmac
	)

Calculate HMAC of a message (RFC 2104)

Parameters

key	secret key
plaintext	input plaintext
plaintext_len	length of plaintext
hmac	where to store the hmac

Definition at line 455 of file crypto_hash.c.

References GNUNET_CRYPTO_hmac_raw(), and GNUNET_CRYPTO_AuthKey::key.

Referenced by dv_hmac(), GSC_KX_encrypt_and_transmit(), handle_encrypted(), RPS_sampler_elem_next(), t_ax_hmac_hash(), and t_hmac().

{
  GNUNET_CRYPTO_hmac_raw ((void *) key->key, sizeof(key->key),
                          plaintext, plaintext_len,
                          hmac);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_file()

struct GNUNET_CRYPTO_FileHashContext* GNUNET_CRYPTO_hash_file	(	enum GNUNET_SCHEDULER_Priority	priority,
		const char *	filename,
		size_t	blocksize,
		GNUNET_CRYPTO_HashCompletedCallback	callback,
		void *	callback_cls
	)

Compute the hash of an entire file.

Parameters

priority	scheduling priority to use
filename	name of file to hash
blocksize	number of bytes to process in one task
callback	function to call upon completion
callback_cls	closure for callback

Returns

NULL on (immediate) errror

Definition at line 178 of file crypto_hash_file.c.

References GNUNET_CRYPTO_FileHashContext::bsize, GNUNET_CRYPTO_FileHashContext::buffer, GNUNET_CRYPTO_FileHashContext::callback, GNUNET_CRYPTO_FileHashContext::callback_cls, GNUNET_CRYPTO_FileHashContext::fh, file_hash_task(), GNUNET_CRYPTO_FileHashContext::filename, GNUNET_CRYPTO_FileHashContext::fsize, GNUNET_assert, GNUNET_break, GNUNET_DISK_file_open(), GNUNET_DISK_file_size(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_free, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_with_priority(), GNUNET_strdup, GNUNET_YES, GNUNET_CRYPTO_FileHashContext::md, GNUNET_CRYPTO_FileHashContext::priority, and GNUNET_CRYPTO_FileHashContext::task.

Referenced by deserialize_unindex_file(), GNUNET_FS_publish_main_(), GNUNET_FS_unindex_start(), and handle_client_index_start().

{
  struct GNUNET_CRYPTO_FileHashContext *fhc;

  GNUNET_assert (blocksize > 0);
  fhc =
    GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_FileHashContext) + blocksize);
  fhc->callback = callback;
  fhc->callback_cls = callback_cls;
  fhc->buffer = (unsigned char *) &fhc[1];
  fhc->filename = GNUNET_strdup (filename);
  if (GPG_ERR_NO_ERROR != gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0))
  {
    GNUNET_break (0);
    GNUNET_free (fhc);
    return NULL;
  }
  fhc->bsize = blocksize;
  if (GNUNET_OK !=
      GNUNET_DISK_file_size (filename,
                             &fhc->fsize,
                             GNUNET_NO,
                             GNUNET_YES))
  {
    GNUNET_free (fhc->filename);
    GNUNET_free (fhc);
    return NULL;
  }
  fhc->fh = GNUNET_DISK_file_open (filename,
                                   GNUNET_DISK_OPEN_READ,
                                   GNUNET_DISK_PERM_NONE);
  if (! fhc->fh)
  {
    GNUNET_free (fhc->filename);
    GNUNET_free (fhc);
    return NULL;
  }
  fhc->priority = priority;
  fhc->task = GNUNET_SCHEDULER_add_with_priority (priority,
                                                  &file_hash_task,
                                                  fhc);
  return fhc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_create_random()

void GNUNET_CRYPTO_hash_create_random	(	enum GNUNET_CRYPTO_Quality	mode,
		struct GNUNET_HashCode *	result
	)

Create a random hash code.

Parameters

mode	desired quality level
result	hash code that is randomized

Definition at line 144 of file crypto_hash.c.

References GNUNET_HashCode::bits, and GNUNET_CRYPTO_random_u32().

Referenced by commit_set(), do_consensus(), GDS_DATACACHE_get_random_key(), and run().

{
  int i;

  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(uint32_t)) - 1; i >= 0; i--)
    result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, UINT32_MAX);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_difference()

void GNUNET_CRYPTO_hash_difference	(	const struct GNUNET_HashCode *	a,
		const struct GNUNET_HashCode *	b,
		struct GNUNET_HashCode *	result
	)

compute result = b - a

Parameters

a	some hash code
b	some hash code
result	set to b - a

compute result = b - a

Parameters

a	some hash code
b	some hash code
result	set to b - a

Definition at line 162 of file crypto_hash.c.

References GNUNET_HashCode::bits.

{
  int i;

  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0;
       i--)
    result->bits[i] = b->bits[i] - a->bits[i];
}

GNUNET_CRYPTO_hash_sum()

void GNUNET_CRYPTO_hash_sum	(	const struct GNUNET_HashCode *	a,
		const struct GNUNET_HashCode *	delta,
		struct GNUNET_HashCode *	result
	)

compute result = a + delta

Parameters

a	some hash code
delta	some hash code
result	set to a + delta

compute result = a + delta

Parameters

a	some hash code
delta	some hash code
result	set to a + delta

Definition at line 182 of file crypto_hash.c.

References GNUNET_HashCode::bits.

{
  int i;

  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0;
       i--)
    result->bits[i] = delta->bits[i] + a->bits[i];
}

GNUNET_CRYPTO_hash_xor()

void GNUNET_CRYPTO_hash_xor	(	const struct GNUNET_HashCode *	a,
		const struct GNUNET_HashCode *	b,
		struct GNUNET_HashCode *	result
	)

compute result = a ^ b

Parameters

a	some hash code
b	some hash code
result	set to a ^ b
a	some hash code
b	some hash code
result	set to a ^ b

Definition at line 202 of file crypto_hash.c.

References GNUNET_HashCode::bits.

Referenced by determine_id(), filter_all(), filtered_map_initialization(), GNUNET_BLOCK_mingle_hash(), initialize_map_unfiltered(), iterator_bf_reduce(), and process_sks_result().

{
  int i;

  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0;
       i--)
    result->bits[i] = a->bits[i] ^ b->bits[i];
}

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_to_aes_key()

void GNUNET_CRYPTO_hash_to_aes_key	(	const struct GNUNET_HashCode *	hc,
		struct GNUNET_CRYPTO_SymmetricSessionKey *	skey,
		struct GNUNET_CRYPTO_SymmetricInitializationVector *	iv
	)

Convert a hashcode into a key.

Parameters

hc	hash code that serves to generate the key
skey	set to a valid session key
iv	set to a valid initialization vector

Definition at line 222 of file crypto_hash.c.

References GNUNET_assert, GNUNET_CRYPTO_kdf(), and GNUNET_YES.

Referenced by derive_ublock_encryption_key(), encrypt_existing_match(), GNUNET_FS_handle_on_demand_block(), GNUNET_FS_tree_encoder_next(), process_result_with_request(), and try_match_block().

{
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CRYPTO_kdf (skey, sizeof(struct
                                                 GNUNET_CRYPTO_SymmetricSessionKey),
                                    "Hash key derivation", strlen (
                                      "Hash key derivation"),
                                    hc, sizeof(struct GNUNET_HashCode),
                                    NULL, 0));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CRYPTO_kdf (iv, sizeof(struct
                                               GNUNET_CRYPTO_SymmetricInitializationVector),
                                    "Initialization vector derivation", strlen (
                                      "Initialization vector derivation"),
                                    hc, sizeof(struct GNUNET_HashCode),
                                    NULL, 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_get_bit_ltr()

int GNUNET_CRYPTO_hash_get_bit_ltr	(	const struct GNUNET_HashCode *	code,
		unsigned int	bit
	)

Obtain a bit from a hashcode.

Parameters

code	the struct GNUNET_HashCode to index bit-wise
bit	index into the hashcode, [0...159] where 0 is the leftmost bit (bytes in code interpreted big endian)

Returns

Bit bit from hashcode code, -1 for invalid index

Parameters

code	the GNUNET_CRYPTO_hash to index bit-wise
bit	index into the hashcode, [0...511] where 0 is the leftmost bit (bytes in code interpreted big endian)

Returns

Bit bit from hashcode code, -1 for invalid index

Definition at line 252 of file crypto_hash.c.

References GNUNET_assert.

Referenced by count_leading_zeroes().

{
  GNUNET_assert (bit < 8 * sizeof(struct GNUNET_HashCode));
  return (((unsigned char *) code)[bit >> 3] & (128 >> (bit & 7))) > 0;
}

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_matching_bits()

unsigned int GNUNET_CRYPTO_hash_matching_bits	(	const struct GNUNET_HashCode *	first,
		const struct GNUNET_HashCode *	second
	)

Determine how many low order bits match in two struct GNUNET_HashCodes.

i.e. - 010011 and 011111 share the first two lowest order bits, and therefore the return value is two (NOT XOR distance, nor how many bits match absolutely!).

Parameters

first	the first hashcode
second	the hashcode to compare first to

Returns

the number of bits that match

Determine how many low order bits match in two struct GNUNET_HashCodes.

i.e. - 010011 and 011111 share the first two lowest order bits, and therefore the return value is two (NOT XOR distance, nor how many bits match absolutely!).

Parameters

first	the first hashcode
second	the hashcode to compare first to

Returns

the number of bits that match

Definition at line 289 of file crypto_hash.c.

References GNUNET_CRYPTO_hash_get_bit_rtl().

Referenced by find_bucket(), GDS_am_closest_peer(), GDS_DATACACHE_handle_put(), get_distance(), get_matching_bits(), handle_dht_p2p_get(), and handle_dht_p2p_put().

{
  unsigned int i;

  for (i = 0; i < sizeof(struct GNUNET_HashCode) * 8; i++)
    if (GNUNET_CRYPTO_hash_get_bit_rtl (first, i) !=
        GNUNET_CRYPTO_hash_get_bit_rtl (second, i))
      return i;
  return sizeof(struct GNUNET_HashCode) * 8;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_cmp()

int GNUNET_CRYPTO_hash_cmp	(	const struct GNUNET_HashCode *	h1,
		const struct GNUNET_HashCode *	h2
	)

Compare function for HashCodes, producing a total ordering of all hashcodes.

Parameters

h1	some hash code
h2	some hash code

Returns

1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.

Parameters

h1	some hash code
h2	some hash code

Returns

1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.

Definition at line 311 of file crypto_hash.c.

Referenced by element_cmp(), find_closest(), handle_client_join(), handle_core_connect(), handle_transport_notify_connect(), op_get_element_iterator(), REGEX_BLOCK_check_proof(), and RPS_sampler_elem_next().

{
  unsigned int *i1;
  unsigned int *i2;
  int i;

  i1 = (unsigned int *) h1;
  i2 = (unsigned int *) h2;
  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0;
       i--)
  {
    if (i1[i] > i2[i])
      return 1;
    if (i1[i] < i2[i])
      return -1;
  }
  return 0;
}

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_xorcmp()

int GNUNET_CRYPTO_hash_xorcmp	(	const struct GNUNET_HashCode *	h1,
		const struct GNUNET_HashCode *	h2,
		const struct GNUNET_HashCode *	target
	)

Find out which of the two GNUNET_CRYPTO_hash codes is closer to target in the XOR metric (Kademlia).

Parameters

h1	some hash code
h2	some hash code
target	some hash code

Returns

-1 if h1 is closer, 1 if h2 is closer and 0 if h1== h2.

Find out which of the two GNUNET_CRYPTO_hash codes is closer to target in the XOR metric (Kademlia).

Parameters

h1	some hash code
h2	some hash code
target	some hash code

Returns

-1 if h1 is closer, 1 if h2 is closer and 0 if h1==h2.

Definition at line 342 of file crypto_hash.c.

{
  int i;
  unsigned int d1;
  unsigned int d2;

  for (i = sizeof(struct GNUNET_HashCode) / sizeof(unsigned int) - 1; i >= 0;
       i--)
  {
    d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i];
    d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i];
    if (d1 > d2)
      return 1;
    else if (d1 < d2)
      return -1;
  }
  return 0;
}

GNUNET_CRYPTO_hmac_derive_key_v()

void GNUNET_CRYPTO_hmac_derive_key_v	(	struct GNUNET_CRYPTO_AuthKey *	key,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	rkey,
		const void *	salt,
		size_t	salt_len,
		va_list	argp
	)

Derive an authentication key.

Parameters

key	authentication key
rkey	root key
salt	salt
salt_len	size of the salt
argp	pair of void * & size_t for context chunks, terminated by NULL
key	authentication key
rkey	root key
salt	salt
salt_len	size of the salt
argp	pair of void * & size_t for context chunks, terminated by NULL

Definition at line 395 of file crypto_hash.c.

References GNUNET_CRYPTO_kdf_v(), and GNUNET_CRYPTO_AuthKey::key.

Referenced by GNUNET_CRYPTO_hmac_derive_key().

{
  GNUNET_CRYPTO_kdf_v (key->key, sizeof(key->key),
                       salt, salt_len,
                       rkey, sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey),
                       argp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hmac_derive_key()

void GNUNET_CRYPTO_hmac_derive_key	(	struct GNUNET_CRYPTO_AuthKey *	key,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	rkey,
		const void *	salt,
		size_t	salt_len,
			...
	)

Derive an authentication key.

Parameters

key	authentication key
rkey	root key
salt	salt
salt_len	size of the salt
...	pair of void * & size_t for context chunks, terminated by NULL
key	authentication key
rkey	root key
salt	salt
salt_len	size of the salt
...	pair of void * & size_t for context chunks, terminated by NULL

Definition at line 373 of file crypto_hash.c.

References GNUNET_CRYPTO_hmac_derive_key_v().

Referenced by derive_auth_key(), t_ax_hmac_hash(), and t_hmac().

{
  va_list argp;

  va_start (argp, salt_len);
  GNUNET_CRYPTO_hmac_derive_key_v (key, rkey, salt, salt_len, argp);
  va_end (argp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hkdf()

int GNUNET_CRYPTO_hkdf	(	void *	result,
		size_t	out_len,
		int	xtr_algo,
		int	prf_algo,
		const void *	xts,
		size_t	xts_len,
		const void *	skm,
		size_t	skm_len,
			...
	)

Derive key.

Parameters

result	buffer for the derived key, allocated by caller
out_len	desired length of the derived key
xtr_algo	hash algorithm for the extraction phase, GCRY_MD_...
prf_algo	hash algorithm for the expansion phase, GCRY_MD_...
xts	salt
xts_len	length of xts
skm	source key material
skm_len	length of skm
...	pair of void * & size_t for context chunks, terminated by NULL

Returns

GNUNET_YES on success

Parameters

result	buffer for the derived key, allocated by caller
out_len	desired length of the derived key
xtr_algo	hash algorithm for the extraction phase, GCRY_MD_...
prf_algo	hash algorithm for the expansion phase, GCRY_MD_...
xts	salt
xts_len	length of xts
skm	source key material
skm_len	length of skm

Returns

GNUNET_YES on success

Definition at line 320 of file crypto_hkdf.c.

References GNUNET_CRYPTO_hkdf_v(), and ret.

Referenced by calculate_cmac(), get_iv_key(), and get_kid().

{
  va_list argp;
  int ret;

  va_start (argp, skm_len);
  ret =
    GNUNET_CRYPTO_hkdf_v (result, out_len, xtr_algo, prf_algo, xts, xts_len,
                          skm, skm_len, argp);
  va_end (argp);

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hkdf_v()

int GNUNET_CRYPTO_hkdf_v	(	void *	result,
		size_t	out_len,
		int	xtr_algo,
		int	prf_algo,
		const void *	xts,
		size_t	xts_len,
		const void *	skm,
		size_t	skm_len,
		va_list	argp
	)

Derive key.

Parameters

result	buffer for the derived key, allocated by caller
out_len	desired length of the derived key
xtr_algo	hash algorithm for the extraction phase, GCRY_MD_...
prf_algo	hash algorithm for the expansion phase, GCRY_MD_...
xts	salt
xts_len	length of xts
skm	source key material
skm_len	length of skm
argp	va_list of void * & size_t pairs for context chunks

Returns

GNUNET_YES on success

Definition at line 144 of file crypto_hkdf.c.

References gnunet-chk::args, BENCHMARK_END, BENCHMARK_START, ctx, doHMAC(), dump, getPRK(), GNUNET_break, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_SYSERR, GNUNET_YES, len, ret, and t.

Referenced by GNUNET_CRYPTO_hkdf(), and GNUNET_CRYPTO_kdf_v().

{
  gcry_md_hd_t xtr;
  gcry_md_hd_t prf;
  const void *hc;
  unsigned long i;
  unsigned long t;
  unsigned long d;
  unsigned int k = gcry_md_get_algo_dlen (prf_algo);
  unsigned int xtr_len = gcry_md_get_algo_dlen (xtr_algo);
  char prk[xtr_len];
  int ret;
  size_t ctx_len;
  va_list args;

  BENCHMARK_START (hkdf);

  if (0 == k)
    return GNUNET_SYSERR;
  if (GPG_ERR_NO_ERROR !=
      gcry_md_open (&xtr, xtr_algo, GCRY_MD_FLAG_HMAC))
    return GNUNET_SYSERR;
  if (GPG_ERR_NO_ERROR !=
      gcry_md_open (&prf, prf_algo, GCRY_MD_FLAG_HMAC))
  {
    gcry_md_close (xtr);
    return GNUNET_SYSERR;
  }
  va_copy (args, argp);

  ctx_len = 0;
  while (NULL != va_arg (args, void *))
  {
    size_t nxt = va_arg (args, size_t);
    if (nxt + ctx_len < nxt)
    {
      /* integer overflow */
      GNUNET_break (0);
      va_end (args);
      goto hkdf_error;
    }
    ctx_len += nxt;
  }

  va_end (args);

  if ( (k + ctx_len < ctx_len) ||
       (k + ctx_len + 1 < ctx_len) )
  {
    /* integer overflow */
    GNUNET_break (0);
    goto hkdf_error;
  }

  memset (result, 0, out_len);
  if (getPRK (xtr, xts, xts_len, skm, skm_len, prk) != GNUNET_YES)
    goto hkdf_error;
#if DEBUG_HKDF
  dump ("PRK", prk, xtr_len);
#endif

  t = out_len / k;
  d = out_len % k;

  /* K(1) */
  {
    size_t plain_len = k + ctx_len + 1;
    char *plain;
    const void *ctx;
    char *dst;

    plain = GNUNET_malloc (plain_len);
    dst = plain + k;
    va_copy (args, argp);
    while ((ctx = va_arg (args, void *)))
    {
      size_t len;

      len = va_arg (args, size_t);
      GNUNET_memcpy (dst, ctx, len);
      dst += len;
    }
    va_end (args);

    if (t > 0)
    {
      plain[k + ctx_len] = (char) 1;
#if DEBUG_HKDF
      dump ("K(1)", plain, plain_len);
#endif
      hc = doHMAC (prf, prk, xtr_len, &plain[k], ctx_len + 1);
      if (hc == NULL)
      {
        GNUNET_free (plain);
        goto hkdf_error;
      }
      GNUNET_memcpy (result, hc, k);
      result += k;
    }

    /* K(i+1) */
    for (i = 1; i < t; i++)
    {
      GNUNET_memcpy (plain, result - k, k);
      plain[k + ctx_len] = (char) (i + 1);
      gcry_md_reset (prf);
#if DEBUG_HKDF
      dump ("K(i+1)", plain, plain_len);
#endif
      hc = doHMAC (prf, prk, xtr_len, plain, plain_len);
      if (hc == NULL)
      {
        GNUNET_free (plain);
        goto hkdf_error;
      }
      GNUNET_memcpy (result, hc, k);
      result += k;
    }

    /* K(t):d */
    if (d > 0)
    {
      if (t > 0)
      {
        GNUNET_memcpy (plain, result - k, k);
        i++;
      }
      plain[k + ctx_len] = (char) i;
      gcry_md_reset (prf);
#if DEBUG_HKDF
      dump ("K(t):d", plain, plain_len);
#endif
      if (t > 0)
        hc = doHMAC (prf, prk, xtr_len, plain, plain_len);
      else
        hc = doHMAC (prf, prk, xtr_len, plain + k, plain_len - k);
      if (hc == NULL)
      {
        GNUNET_free (plain);
        goto hkdf_error;
      }
      GNUNET_memcpy (result, hc, d);
    }
#if DEBUG_HKDF
    dump ("result", result - k, out_len);
#endif

    ret = GNUNET_YES;
    GNUNET_free (plain);
    goto hkdf_ok;
  }
hkdf_error:
  ret = GNUNET_SYSERR;
hkdf_ok:
  gcry_md_close (xtr);
  gcry_md_close (prf);
  BENCHMARK_END (hkdf);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_kdf()

int GNUNET_CRYPTO_kdf	(	void *	result,
		size_t	out_len,
		const void *	xts,
		size_t	xts_len,
		const void *	skm,
		size_t	skm_len,
			...
	)

Derive key.

Parameters

result	buffer for the derived key, allocated by caller
out_len	desired length of the derived key
xts	salt
xts_len	length of xts
skm	source key material
skm_len	length of skm
...	void * & size_t pairs for context chunks

Returns

GNUNET_YES on success

Definition at line 89 of file crypto_kdf.c.

References GNUNET_CRYPTO_kdf_v(), and ret.

Referenced by compute_global_id(), derive_aes_key(), derive_block_aes_key(), derive_h(), derive_ublock_encryption_key(), dv_setup_key_state_from_km(), get_ibf_key(), GNUNET_CRYPTO_hash_to_aes_key(), GNUNET_CRYPTO_kdf_mod_mpi(), hash_from_share_val(), run(), setup_cipher(), t_ax_decrypt_and_validate(), t_ax_encrypt(), t_hmac_derive_key(), and update_ax_by_kx().

{
  va_list argp;
  int ret;

  va_start (argp, skm_len);
  ret = GNUNET_CRYPTO_kdf_v (result,
                             out_len,
                             xts,
                             xts_len,
                             skm,
                             skm_len,
                             argp);
  va_end (argp);

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function: