Provides hashing and operations on hashes. More...

Collaboration diagram for Crypto library: hash operations:

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`

#define	GNUNET_CRYPTO_hkdf_gnunet(result, out_len, xts, xts_len, skm, skm_len, ...)
	A peculiar HKDF instantiation that tried to mimic Truncated NMAC.

#define	GNUNET_CRYPTO_hkdf_expand(result, out_len, prk, ...)
	HKDF-Expand using SHA256.

Functions
uint8_t	GNUNET_CRYPTO_crc8_n (const void *buf, size_t len)
	Calculate the checksum of a buffer in one step.

uint16_t	GNUNET_CRYPTO_crc16_n (const void *buf, size_t len)
	Calculate the checksum of a buffer in one step.

int32_t	GNUNET_CRYPTO_crc32_n (const void *buf, size_t len)
	Compute the CRC32 checksum for the first len bytes of the buffer.

void	GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode block, struct GNUNET_CRYPTO_HashAsciiEncoded result)
	Convert hash to ASCII encoding.

enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hash_from_string2 (const char enc, size_t enclen, struct GNUNET_HashCode result)
	Convert ASCII encoding back to a 'struct GNUNET_HashCode'.

uint32_t	GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode a, const struct GNUNET_HashCode b)
	Compute the distance between 2 hashcodes.

void	GNUNET_CRYPTO_hash (const void block, size_t size, struct GNUNET_HashCode ret)
	Compute hash of a given block.

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)

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.

void	GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode, struct GNUNET_HashCode *result)
	Create a random hash code.

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

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

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

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.

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.

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).

enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hkdf_extract (struct GNUNET_ShortHashCode prk, const void salt, size_t salt_len, const void *ikm, size_t ikm_len)
	HKDF-Extract using SHA256.

enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hkdf_gnunet_v (void result, size_t out_len, const void xts, size_t xts_len, const void *skm, size_t skm_len, size_t hkdf_args_count, const struct GNUNET_CRYPTO_KdfInputArgument hkdf_args[hkdf_args_count])
	Derive key.

enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hkdf_expand_v (void result, size_t out_len, const struct GNUNET_ShortHashCode prk, size_t hkdf_args_count, const struct GNUNET_CRYPTO_KdfInputArgument hkdf_args[hkdf_args_count])
	HKDF-Expand using SHA256.

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 1010 of file gnunet_crypto_lib.h.

◆ GNUNET_CRYPTO_hkdf_gnunet

#define GNUNET_CRYPTO_hkdf_gnunet	(	result,
		out_len,
		xts,
		xts_len,
		skm,
		skm_len,
		...
	)

Value:

        GNUNET_CRYPTO_hkdf_gnunet_v (result, out_len, xts, xts_len, skm, \
                                     skm_len, \
                                     _HKDF_ARGS_VECLEN_HELPER (__VA_ARGS__ \
                                                               ), \
                                     _HKDF_ARGS_VEC_HELPER (__VA_ARGS__))

A peculiar HKDF instantiation that tried to mimic Truncated NMAC.

But, what it actually does is HKDF-Extract with SHA512 and instead of truncating the PRK, it uses it as a 64 byte key in the HKDF-Expand phase with SHA256. (Truncated NMAC would require us to, well, truncate it to 32 byte.) ONLY USE FOR COMPATIBILITY WITH OLDER KEY DERIVATIONS. Use the more standard GNUNET_CRYPTO_hkdf_extract and #GNUNET_CRYPTO_HKDF_expand instead!

"Finally, we point out to a particularly advantageous instantiation using HMAC-SHA512 as XTR and HMAC-SHA256 in PRF* (in which case the output from SHA-512 is truncated to 256 bits). This makes sense in two ways: First, the extraction part is where we need a stronger hash function due to the unconventional demand from the hash function in the extraction setting. Second, as shown in Section 6, using HMAC with a truncated output as an extractor allows to prove the security of HKDF under considerably weaker assumptions on the underlying hash function."

http://eprint.iacr.org/2010/264

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
...	set of struct GNUNET_CRYPTO_KdfInputArgument for context chunks

Returns: GNUNET_YES on success

Definition at line 1449 of file gnunet_crypto_lib.h.

◆ GNUNET_CRYPTO_hkdf_expand

#define GNUNET_CRYPTO_hkdf_expand	(	result,
		out_len,
		prk,
		...
	)

Value:

        GNUNET_CRYPTO_hkdf_expand_v (result, out_len, \
                                     prk, \
                                     _HKDF_ARGS_VECLEN_HELPER (__VA_ARGS__ \
                                                               ), \
                                     _HKDF_ARGS_VEC_HELPER (__VA_ARGS__))

HKDF-Expand using SHA256.

RFC 5869

Parameters

result	buffer for the derived key, allocated by caller
out_len	desired length of the derived key
prk	pesudorandom key
...	set of struct GNUNET_CRYPTO_KdfInputArgument for context chunks

Returns: GNUNET_YES on success

Definition at line 1490 of file gnunet_crypto_lib.h.

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 151 of file crypto_crc.c.

{
  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);
}

References data.

◆ 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

Definition at line 133 of file crypto_crc.c.

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

References GNUNET_CRYPTO_crc16_finish(), and GNUNET_CRYPTO_crc16_step().

Referenced by GNUNET_TUN_initialize_ipv4_header().

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

Definition at line 99 of file crypto_crc.c.

{
  GNUNET_uLong crc;
 
  crc = gn_crc32 (0L, Z_NULL, 0);
  crc = gn_crc32 (crc, (char *) buf, len);
  return crc;
}

References gn_crc32(), and Z_NULL.

Referenced by ibf_get_indices(), read_handle_encryption_key(), read_handle_epoch_key(), store_handle_encryption_key(), and store_handle_epoch_key().

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).

Definition at line 55 of file crypto_hash.c.

{
  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';
}

References GNUNET_assert, GNUNET_STRINGS_data_to_string(), and result.

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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_CRYPTO_hash_from_string2()

enum GNUNET_GenericReturnValue 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

Definition at line 72 of file crypto_hash.c.

{
  enum GNUNET_GenericReturnValue ret;
  char *up_ptr;
 
  up_ptr = GNUNET_STRINGS_utf8_toupper (enc);
  if (NULL == up_ptr)
    return GNUNET_SYSERR;
  ret = GNUNET_STRINGS_string_to_data (up_ptr,
                                       strlen (up_ptr),
                                       (unsigned char *) result,
                                       sizeof(struct GNUNET_HashCode));
  GNUNET_free (up_ptr);
  return ret;
}

References enc, GNUNET_free, GNUNET_STRINGS_string_to_data(), GNUNET_STRINGS_utf8_toupper(), GNUNET_SYSERR, result, and ret.

Here is the call graph for this function:

◆ GNUNET_CRYPTO_hash_distance_u32()

uint32_t 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

Definition at line 92 of file crypto_hash.c.

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

References GNUNET_HashCode::bits.

Referenced by score_content().

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

Definition at line 41 of file crypto_hash.c.

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

References BENCHMARK_END, BENCHMARK_START, ret, and size.

Referenced by add_file(), add_member_session(), add_to_keyword_counter(), add_to_meta_counter(), advertise_dns_exit(), automaton_create_proofs(), block_plugin_dht_check_block(), block_plugin_dht_check_reply(), block_plugin_dht_get_key(), block_plugin_dns_check_reply(), block_plugin_fs_check_reply(), block_plugin_fs_get_key(), block_plugin_gns_check_reply(), block_plugin_regex_check_reply(), block_plugin_revocation_get_key(), block_plugin_test_check_reply(), build_authz_response(), calculate_hmac(), calculate_hmac(), check_and_remove_pending_reversal(), check_and_remove_pending_reversal(), checkvec(), client_request_complete_alice(), code_redirect(), collector(), commit_set(), connection_destroy(), consume_fail(), consume_ticket(), convert_messenger_key_to_port(), cookie_identity_interpretation(), create_peers(), create_response(), create_stream(), create_subnet_peers(), create_subnets(), create_target(), cs_full_domain_hash(), data_to_ecdsa_value(), decode_short_message(), decrypt_new_element(), delayed_put(), determine_id(), ego_get_all(), ego_get_response(), ego_sign_data(), encode_short_message(), encrypt_existing_match(), es_to_sh(), extract_blind_sign_pub(), find_advertisable_hello(), find_stream(), find_target(), find_trees(), forward_reply(), GC_u2h(), GCT_handle_kx_auth(), GDS_helper_sign_path(), GDS_try_connect(), GDS_u_connect(), get_cadet(), get_context_from_member(), get_destination_key_from_ip(), get_fair_encryption_challenge(), get_file_handle(), get_gns_cont(), get_matching_bits(), get_member_session(), get_node_info(), get_store_contact(), get_update_information_directory(), get_url_parameter_copy(), GNUNET_b2s(), GNUNET_BLOCK_mingle_hash(), GNUNET_CONVERSATION_phone_create(), GNUNET_CRYPTO_blind_sign_keys_create_va(), GNUNET_CRYPTO_ecc_ecdh(), GNUNET_CRYPTO_ecdh_ecdsa(), GNUNET_CRYPTO_ecdh_eddsa(), GNUNET_CRYPTO_ecdsa_ecdh(), GNUNET_CRYPTO_eddsa_ecdh(), GNUNET_CRYPTO_edx25519_key_create_from_seed(), GNUNET_CRYPTO_rsa_public_key_hash(), GNUNET_DHT_verify_path(), 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_block(), GNUNET_GNSRECORD_query_from_public_key(), GNUNET_IDENTITY_ego_get_anonymous(), GNUNET_MESSENGER_create_room_key(), GNUNET_NETWORK_shorten_unixpath(), GNUNET_p2s(), GNUNET_p2s2(), GNUNET_TESTING_barrier_name_hash_(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TESTING_interpreter_get_command(), GNUNET_TESTING_interpreter_run_cmd_(), GNUNET_TUN_service_name_to_hash(), GSF_cadet_start_server(), handle_client_decrypt(), handle_core_connect(), handle_identity_update(), handle_identity_update(), handle_initiator_hello(), handle_initiator_hello_cont(), handle_put(), handle_query_message(), handle_regex_result(), hash_message(), hash_pkey_and_label(), header_iterator(), iface_proc(), init_socket(), init_socket(), insert_decrypt_element(), insert_round1_element(), iterate_initial_edge(), iterateBits(), join_room_run(), load_state(), login_cont(), lookup_diff(), lookup_rfn(), lookup_set(), lookup_task(), maint_child_death(), mq_init(), mq_init(), mq_init(), mq_init(), namestore_get(), notify_connect(), notify_srv_handle_message(), ns_lookup_result_cb(), output_vectors(), parse_credentials_basic_auth(), parse_credentials_post_body(), peer_destroy(), PEERSTORE_hash_key(), pending_reversal_timeout(), pending_reversal_timeout(), pid_change_cb(), pils_sign_address(), post_data_iter(), postgres_plugin_put(), process(), process_client_result(), process_kblock_for_unindex(), process_reply(), publicize_rm(), put_diff(), put_rfn(), put_set(), put_task(), queue(), queue_destroy(), queue_destroy(), REGEX_BLOCK_check_proof(), REGEX_BLOCK_get_key(), REGEX_INTERNAL_get_first_key(), remove_high_frequency_keywords(), remove_member_session(), remove_room_member_session(), remove_store_contact(), remove_stream(), reset_cadet(), restart_kx(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), schedule_next_hello(), schedule_transmit_search_request(), score_content(), select_store_contact_map(), send_initiator_hello(), send_kx_auth(), setup_filter(), sock_read(), sock_read(), sock_read(), sqlite_plugin_put(), start_address_validation(), start_intersection(), store_handle_encryption_key(), token_endpoint(), try_match_block(), try_open_exit(), try_top_down_reconstruction(), update_store_contact(), url_iterator(), and userinfo_endpoint().

◆ 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 295 of file crypto_hash.c.

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

References GNUNET_CRYPTO_hmac_raw(), and key.

Referenced by calc_message_hmac(), decrypt_secret_message(), dv_hmac(), encrypt_secret_message(), generate_initiator_finished(), generate_responder_finished(), RPS_sampler_elem_next(), t_ax_hmac_hash(), and t_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) error

Definition at line 169 of file crypto_hash_file.c.

{
  struct GNUNET_CRYPTO_FileHashContext *fhc;
 
  GNUNET_assert (blocksize > 0);
  GNUNET_assert (blocksize <= (SIZE_MAX - sizeof (*fhc)));
  fhc =
    GNUNET_malloc (sizeof(*fhc) + 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->filename);
    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;
}

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

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 103 of file crypto_hash.c.

{
  GNUNET_CRYPTO_random_block (mode, result, sizeof (*result));
}

References GNUNET_CRYPTO_random_block(), mode, and result.

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

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

Definition at line 111 of file crypto_hash.c.

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

References GNUNET_HashCode::bits, and result.

◆ 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

Definition at line 123 of file crypto_hash.c.

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

References GNUNET_HashCode::bits, delta, and result.

Referenced by convert_messenger_key_to_port().

Here is the caller graph for this function:

◆ 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

Definition at line 135 of file crypto_hash.c.

{
  const unsigned long long *lla = (const unsigned long long *) a;
  const unsigned long long *llb = (const unsigned long long *) b;
  unsigned long long *llr = (unsigned long long *) result;
 
  GNUNET_static_assert (8 == sizeof (unsigned long long));
  GNUNET_static_assert (0 == sizeof (*a) % sizeof (unsigned long long));
 
  for (int i = sizeof (*result) / sizeof (*llr) - 1; i>=0; i--)
    llr[i] = lla[i] ^ llb[i];
}

References GNUNET_static_assert, and result.

Referenced by determine_id(), filter_all(), filter_all(), filtered_map_initialization(), filtered_map_initialization(), find_bucket(), GDS_DATACACHE_handle_put(), get_context_from_member(), get_matching_bits(), initialize_map_unfiltered(), initialize_map_unfiltered(), iterator_bf_reduce(), iterator_bf_reduce(), process_sks_result(), and select_peer().

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 152 of file crypto_hash.c.

{
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CRYPTO_hkdf_gnunet (
                   skey,
                   sizeof(*skey),
                   "Hash key derivation",
                   strlen ("Hash key derivation"),
                   hc, sizeof(*hc)));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CRYPTO_hkdf_gnunet (
                   iv,
                   sizeof(*iv),
                   "Initialization vector derivation",
                   strlen ("Initialization vector derivation"),
                   hc, sizeof(*hc)));
}

References GNUNET_assert, GNUNET_CRYPTO_hkdf_gnunet, 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().

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.

Definition at line 219 of file crypto_hash.c.

{
  unsigned int *i1;
  unsigned int *i2;
 
  i1 = (unsigned int *) h1;
  i2 = (unsigned int *) h2;
  for (ssize_t 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;
}

Referenced by check_member_session_completion(), clear_linked_hash(), create_message_request(), decode_short_message(), decrypt_secret_message(), do_generate_pid(), element_cmp(), element_cmp(), element_cmp(), element_cmp(), find_closest(), find_linked_hash(), get_epoch_membership_member_hash(), get_epoch_membership_member_position(), get_epoch_previous_announcement(), get_epoch_previous_group(), get_store_message(), handle_access_message(), handle_client_join(), handle_core_connect(), handle_initiator_hello_cont(), is_epoch_previous_of_other(), it_update_epoch_member(), iterate_cancel_action_by(), op_get_element_iterator(), op_get_element_iterator(), propose_epoch_group(), put_store_message(), REGEX_BLOCK_check_proof(), remove_from_list_messages(), restart_kx(), RPS_sampler_elem_next(), select_store_contact_map(), send_epoch_group(), send_message_to_room(), and verify_message_by_key().

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.

Definition at line 241 of file crypto_hash.c.

{
  const unsigned long long *l1 = (const unsigned long long *) h1;
  const unsigned long long *l2 = (const unsigned long long *) h2;
  const unsigned long long *t = (const unsigned long long *) target;
 
  GNUNET_static_assert (0 == sizeof (*h1) % sizeof (*l1));
  for (size_t i = 0; i < sizeof(*h1) / sizeof(*l1); i++)
  {
    unsigned long long x1 = l1[i] ^ t[i];
    unsigned long long x2 = l2[i] ^ t[i];
 
    if (x1 > x2)
      return 1;
    if (x1 < x2)
      return -1;
  }
  return 0;
}

References GNUNET_static_assert, and t.

Referenced by GDS_am_closest_peer(), and select_peer().

Here is the caller graph for this function:

◆ GNUNET_CRYPTO_hkdf_extract()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf_extract	(	struct GNUNET_ShortHashCode *	prk,
		const void *	salt,
		size_t	salt_len,
		const void *	ikm,
		size_t	ikm_len
	)

HKDF-Extract using SHA256.

RFC 5869

Parameters

prk	the PRK
salt	salt
salt_len	length of xts
ikm	source key material
ikm_len	length of skm

Returns: GNUNET_YES on success

Definition at line 182 of file crypto_hkdf.c.

{
  crypto_auth_hmacsha256_state st;
  if (crypto_auth_hmacsha256_init (&st, xts, xts_len))
    return GNUNET_SYSERR;
  if (crypto_auth_hmacsha256_update (&st, skm, skm_len))
    return GNUNET_SYSERR;
  crypto_auth_hmacsha256_final (&st, (unsigned char*) prk);
  sodium_memzero (&st, sizeof st);
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_SYSERR, and st.

Referenced by derive_es_ets(), derive_hs(), derive_ms(), get_kid(), GNUNET_PILS_derive_pid(), and labeled_extract().

Here is the caller graph for this function:

◆ GNUNET_CRYPTO_hkdf_gnunet_v()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf_gnunet_v	(	void *	result,
		size_t	out_len,
		const void *	xts,
		size_t	xts_len,
		const void *	skm,
		size_t	skm_len,
		size_t	hkdf_args_count,
		const struct GNUNET_CRYPTO_KdfInputArgument	hkdf_args[hkdf_args_count]
	)

Derive key.

See GNUNET_CRYPTO_hkdf_gnunet

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
hkdf_args_count	size of the input argument array that follows
hkdf_args	array of struct GNUNET_CRYPTO_KdfInputArgument for context chunks

Returns: GNUNET_YES on success

◆ GNUNET_CRYPTO_hkdf_expand_v()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf_expand_v	(	void *	result,
		size_t	out_len,
		const struct GNUNET_ShortHashCode *	prk,
		size_t	hkdf_args_count,
		const struct GNUNET_CRYPTO_KdfInputArgument	hkdf_args[hkdf_args_count]
	)

HKDF-Expand using SHA256.

See GNUNET_CRYPTO_hkdf_expand

Parameters

result	buffer for the derived key, allocated by caller
out_len	desired length of the derived key
prk	pesudorandom key
hkdf_args_count	size of the input argument array that follows
hkdf_args	array of struct GNUNET_CRYPTO_KdfInputArgument for context chunks

Returns: GNUNET_YES on success

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ GNUNET_CRYPTO_hash_from_string

◆ GNUNET_CRYPTO_hkdf_gnunet

◆ GNUNET_CRYPTO_hkdf_expand

Function Documentation

◆ GNUNET_CRYPTO_crc8_n()

◆ GNUNET_CRYPTO_crc16_n()

◆ GNUNET_CRYPTO_crc32_n()

◆ GNUNET_CRYPTO_hash_to_enc()

◆ GNUNET_CRYPTO_hash_from_string2()

◆ GNUNET_CRYPTO_hash_distance_u32()

◆ GNUNET_CRYPTO_hash()

◆ GNUNET_CRYPTO_hmac()

◆ GNUNET_CRYPTO_hash_file()

◆ GNUNET_CRYPTO_hash_create_random()

◆ GNUNET_CRYPTO_hash_difference()

◆ GNUNET_CRYPTO_hash_sum()

◆ GNUNET_CRYPTO_hash_xor()

◆ GNUNET_CRYPTO_hash_to_aes_key()

◆ GNUNET_CRYPTO_hash_cmp()

◆ GNUNET_CRYPTO_hash_xorcmp()

◆ GNUNET_CRYPTO_hkdf_extract()

◆ GNUNET_CRYPTO_hkdf_gnunet_v()

◆ GNUNET_CRYPTO_hkdf_expand_v()