Macros | Typedefs | Functions
di_ops.h File Reference
#include "orconfig.h"
#include "lib/cc/torint.h"

Go to the source code of this file.


#define tor_memneq(a, b, sz)   (!tor_memeq((a),(b),(sz)))
#define fast_memcmp(a, b, c)   (memcmp((a),(b),(c)))
#define fast_memeq(a, b, c)   (0==memcmp((a),(b),(c)))
#define fast_memneq(a, b, c)   (0!=memcmp((a),(b),(c)))
#define dimap_free(map, free_fn)


typedef struct di_digest256_map_t di_digest256_map_t
typedef void(* dimap_free_fn) (void *)


int tor_memcmp (const void *a, const void *b, size_t sz)
int tor_memeq (const void *a, const void *b, size_t sz)
int safe_mem_is_zero (const void *mem, size_t sz)
void dimap_free_ (di_digest256_map_t *map, dimap_free_fn free_fn)
void dimap_add_entry (di_digest256_map_t **map, const uint8_t *key, void *val)
void * dimap_search (const di_digest256_map_t *map, const uint8_t *key, void *dflt_val)
int select_array_member_cumulative_timei (const uint64_t *entries, int n_entries, uint64_t total, uint64_t rand_val)

Detailed Description

Headers for di_ops.c.

Definition in file di_ops.h.

Macro Definition Documentation

◆ dimap_free

#define dimap_free (   map,
do { \
dimap_free_((map), (free_fn)); \
(map) = NULL; \
} while (0)

Definition at line 41 of file di_ops.h.

◆ fast_memcmp

#define fast_memcmp (   a,
)    (memcmp((a),(b),(c)))

Alias for the platform's memcmp() function. This function is not data-independent: we define this alias so that we can mark cases where we are deliberately using a data-dependent memcmp() implementation.

Definition at line 26 of file di_ops.h.

Typedef Documentation

◆ di_digest256_map_t

A type for a map from DIGEST256_LEN-byte blobs to void*, such that data lookups take an amount of time proportional only to the size of the map, and not to the position or presence of the item in the map.

Not efficient for large maps!

Definition at line 37 of file di_ops.h.

Function Documentation

◆ dimap_add_entry()

void dimap_add_entry ( di_digest256_map_t **  map,
const uint8_t *  key,
void *  val 

Adjust the map at *map, adding an entry for key -> val, where key is a DIGEST256_LEN-byte key.

The caller MUST NOT add a key that already appears in the map.

Definition at line 173 of file di_ops.c.

References dimap_search().

Referenced by construct_ntor_key_map().

◆ dimap_free_()

void dimap_free_ ( di_digest256_map_t map,
dimap_free_fn  free_fn 

Release all storage held in map, calling free_fn on each value as we go.

Definition at line 156 of file di_ops.c.

◆ dimap_search()

void* dimap_search ( const di_digest256_map_t map,
const uint8_t *  key,
void *  dflt_val 

Search the map at map for an entry whose key is key (a DIGEST256_LEN-byte key) returning the corresponding value if we found one, and returning dflt_val if the key wasn't found.

This operation takes an amount of time dependent only on the length of map, not on the position or presence of key within map.

Definition at line 197 of file di_ops.c.

References tor_memeq().

Referenced by dimap_add_entry().

◆ safe_mem_is_zero()

int safe_mem_is_zero ( const void *  mem,
size_t  sz 

Return true iff the sz bytes at mem are all zero. Runs in time independent of the contents of mem.

Definition at line 221 of file di_ops.c.

Referenced by curve25519_public_key_is_ok(), ed25519_public_key_is_zero(), tor_digest256_is_zero(), and tor_digest_is_zero().

◆ select_array_member_cumulative_timei()

int select_array_member_cumulative_timei ( const uint64_t *  entries,
int  n_entries,
uint64_t  total,
uint64_t  rand_val 

Given an array of list of n_entries uint64_t values, whose sum is total, find the first i such that the total of all elements 0...i is greater than rand_val.

Try to perform this operation in a constant-time way.

Definition at line 256 of file di_ops.c.

References gt_i64_timei().

Referenced by choose_array_element_by_weight().

◆ tor_memcmp()

int tor_memcmp ( const void *  a,
const void *  b,
size_t  len 

Timing-safe version of memcmp. As memcmp, compare the sz bytes at a with the sz bytes at b, and return less than 0 if the bytes at a lexically precede those at b, 0 if the byte ranges are equal, and greater than zero if the bytes at a lexically follow those at b.

This implementation differs from memcmp in that its timing behavior is not data-dependent: it should return in the same amount of time regardless of the contents of a and b.

Note that if all you care about is equality, this implementation is overkill: it would be better to use tor_memeq() or tor_memneq().

Definition at line 31 of file di_ops.c.

Referenced by compare_digest_to_routerstatus_entry(), compare_digest_to_vote_routerstatus_entry(), compare_digests256_(), compare_digests_(), and crypto_pk_cmp_keys().

◆ tor_memeq()

int tor_memeq ( const void *  a,
const void *  b,
size_t  sz