GNUnet 0.26.2-1-g232dc9ef2
 
Loading...
Searching...
No Matches
Data Structures | Macros | Functions
crypto_hash.c File Reference

SHA-512 GNUNET_CRYPTO_hash() related functions. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "benchmark.h"
#include <gcrypt.h>
Include dependency graph for crypto_hash.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_HashContext
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "util-crypto-hash", __VA_ARGS__)
 
#define LOG_STRERROR_FILE(kind, syscall, filename)
 

Functions

void GNUNET_CRYPTO_hash (const void *block, size_t size, struct GNUNET_HashCode *ret)
 Compute hash of a given block.
 
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'.
 
unsigned int 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_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.
 
unsigned int GNUNET_CRYPTO_hash_count_leading_zeros (const struct GNUNET_HashCode *h)
 Count the number of leading 0 bits in h.
 
unsigned int GNUNET_CRYPTO_hash_count_tailing_zeros (const struct GNUNET_HashCode *h)
 Count the number of tailing 0 bits in h.
 
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).
 
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.
 
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.
 
void GNUNET_CRYPTO_hmac_raw (const void *key, size_t key_len, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
 Calculate HMAC of a message (RFC 2104) TODO: Shouldn't this be the standard hmac function and the above be renamed?
 
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_HashContext * GNUNET_CRYPTO_hash_context_start ()
 Start incremental hashing operation.
 
void GNUNET_CRYPTO_hash_context_read (struct GNUNET_HashContext *hc, const void *buf, size_t size)
 Add data to be hashed.
 
struct GNUNET_HashContext * GNUNET_CRYPTO_hash_context_copy (const struct GNUNET_HashContext *hc)
 Make a copy of the hash computation.
 
void GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc, struct GNUNET_HashCode *r_hash)
 Finish the hash computation.
 
void GNUNET_CRYPTO_hash_context_abort (struct GNUNET_HashContext *hc)
 Abort hashing, do not bother calculating final result.
 

Detailed Description

SHA-512 GNUNET_CRYPTO_hash() related functions.

Author
Christian Grothoff

Definition in file crypto_hash.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "util-crypto-hash", __VA_ARGS__)

Definition at line 32 of file crypto_hash.c.

◆ LOG_STRERROR_FILE

#define LOG_STRERROR_FILE (   kind,
  syscall,
  filename 
)
Value:
GNUNET_log_from_strerror_file (kind, \
"util-crypto-hash", \
syscall, \
filename)
filename
static char * filename
Definition gnunet-download.c:52
GNUNET_log_from_strerror_file
#define GNUNET_log_from_strerror_file(level, component, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
Definition gnunet_common.h:1146

Definition at line 34 of file crypto_hash.c.

43{
44 BENCHMARK_START (hash);
45 gcry_md_hash_buffer (GCRY_MD_SHA512, ret, block, size);
46 BENCHMARK_END (hash);
47}
48
49
50/* ***************** binary-ASCII encoding *************** */
51
52
53void
54GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block,
55 struct GNUNET_CRYPTO_HashAsciiEncoded *result)
56{
57 char *np;
58
59 np = GNUNET_STRINGS_data_to_string ((const unsigned char *) block,
60 sizeof(struct GNUNET_HashCode),
61 (char *) result,
62 sizeof(struct
63 GNUNET_CRYPTO_HashAsciiEncoded)
64 - 1);
65 GNUNET_assert (NULL != np);
66 *np = '\0';
67}
68
69
70enum GNUNET_GenericReturnValue
71GNUNET_CRYPTO_hash_from_string2 (const char *enc,
72 size_t enclen,
73 struct GNUNET_HashCode *result)
74{
75 enum GNUNET_GenericReturnValue ret;
76 char *up_ptr;
77
78 up_ptr = GNUNET_STRINGS_utf8_toupper (enc);
79 if (NULL == up_ptr)
80 return GNUNET_SYSERR;
81 ret = GNUNET_STRINGS_string_to_data (up_ptr,
82 strlen (up_ptr),
83 (unsigned char *) result,
84 sizeof(struct GNUNET_HashCode));
85 GNUNET_free (up_ptr);
86 return ret;
87}
88
89
90unsigned int
91GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode *a,
92 const struct GNUNET_HashCode *b)
93{
94 unsigned int x1 = (a->bits[1] - b->bits[1]) >> 16;
95 unsigned int x2 = (b->bits[1] - a->bits[1]) >> 16;
96
97 return(x1 * x2);
98}
99
100
101void
102GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
103 struct GNUNET_HashCode *result)
104{
105 GNUNET_CRYPTO_random_block (mode, result, sizeof (*result));
106}
107
108
109void
110GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode *a,
111 const struct GNUNET_HashCode *b,
112 struct GNUNET_HashCode *result)
113{
114 for (ssize_t i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1;
115 i >= 0;
116 i--)
117 result->bits[i] = b->bits[i] - a->bits[i];
118}
119
120
121void
122GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode *a,
123 const struct GNUNET_HashCode *delta, struct
124 GNUNET_HashCode *result)
125{
126 for (ssize_t i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1;
127 i >= 0;
128 i--)
129 result->bits[i] = delta->bits[i] + a->bits[i];
130}
131
132
133void
134GNUNET_CRYPTO_hash_xor (const struct GNUNET_HashCode *a,
135 const struct GNUNET_HashCode *b,
136 struct GNUNET_HashCode *result)
137{
138 const unsigned long long *lla = (const unsigned long long *) a;
139 const unsigned long long *llb = (const unsigned long long *) b;
140 unsigned long long *llr = (unsigned long long *) result;
141
142 GNUNET_static_assert (8 == sizeof (unsigned long long));
143 GNUNET_static_assert (0 == sizeof (*a) % sizeof (unsigned long long));
144
145 for (int i = sizeof (*result) / sizeof (*llr) - 1; i>=0; i--)
146 llr[i] = lla[i] ^ llb[i];
147}
148
149
150void
151GNUNET_CRYPTO_hash_to_aes_key (
152 const struct GNUNET_HashCode *hc,
153 struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
154 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
155{
156 GNUNET_assert (GNUNET_YES ==
157 GNUNET_CRYPTO_kdf (
158 skey,
159 sizeof(*skey),
160 "Hash key derivation",
161 strlen ("Hash key derivation"),
162 hc, sizeof(*hc),
163 NULL, 0));
164 GNUNET_assert (GNUNET_YES ==
165 GNUNET_CRYPTO_kdf (
166 iv,
167 sizeof(*iv),
168 "Initialization vector derivation",
169 strlen ("Initialization vector derivation"),
170 hc, sizeof(*hc),
171 NULL, 0));
172}
173
174
175unsigned int
176GNUNET_CRYPTO_hash_count_leading_zeros (const struct GNUNET_HashCode *h)
177{
178 const unsigned long long *llp = (const unsigned long long *) h;
179 unsigned int ret = 0;
180 unsigned int i;
181
182 GNUNET_static_assert (8 == sizeof (unsigned long long));
183 GNUNET_static_assert (0 == sizeof (*h) % sizeof (unsigned long long));
184 for (i = 0; i<sizeof (*h) / sizeof (*llp); i++)
185 {
186 if (0LLU != llp[i])
187 break;
188 ret += sizeof (*llp) * 8;
189 }
190 if (ret == 8 * sizeof (*h))
191 return ret;
192 ret += __builtin_clzll (GNUNET_ntohll ((uint64_t) llp[i]));
193 return ret;
194}
195
196
197unsigned int
198GNUNET_CRYPTO_hash_count_tailing_zeros (const struct GNUNET_HashCode *h)
199{
200 const unsigned long long *llp = (const unsigned long long *) h;
201 unsigned int ret = 0;
202 int i;
203
204 GNUNET_static_assert (8 == sizeof (unsigned long long));
205 GNUNET_static_assert (0 == sizeof (*h) % sizeof (unsigned long long));
206 for (i = sizeof (*h) / sizeof (*llp) - 1; i>=0; i--)
207 {
208 if (0LLU != llp[i])
209 break;
210 ret += sizeof (*llp) * 8;
211 }
212 if (ret == 8 * sizeof (*h))
213 return ret;
214 ret += __builtin_ctzll (GNUNET_ntohll ((uint64_t) llp[i]));
215 return ret;
216}
217
218
219int
220GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
221 const struct GNUNET_HashCode *h2)
222{
223 unsigned int *i1;
224 unsigned int *i2;
225
226 i1 = (unsigned int *) h1;
227 i2 = (unsigned int *) h2;
228 for (ssize_t i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1;
229 i >= 0;
230 i--)
231 {
232 if (i1[i] > i2[i])
233 return 1;
234 if (i1[i] < i2[i])
235 return -1;
236 }
237 return 0;
238}
239
240
241int
242GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode *h1,
243 const struct GNUNET_HashCode *h2,
244 const struct GNUNET_HashCode *target)
245{
246 const unsigned long long *l1 = (const unsigned long long *) h1;
247 const unsigned long long *l2 = (const unsigned long long *) h2;
248 const unsigned long long *t = (const unsigned long long *) target;
249
250 GNUNET_static_assert (0 == sizeof (*h1) % sizeof (*l1));
251 for (size_t i = 0; i < sizeof(*h1) / sizeof(*l1); i++)
252 {
253 unsigned long long x1 = l1[i] ^ t[i];
254 unsigned long long x2 = l2[i] ^ t[i];
255
256 if (x1 > x2)
257 return 1;
258 if (x1 < x2)
259 return -1;
260 }
261 return 0;
262}
263
264
265void
266GNUNET_CRYPTO_hmac_derive_key (
267 struct GNUNET_CRYPTO_AuthKey *key,
268 const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
269 const void *salt, size_t salt_len,
270 ...)
271{
272 va_list argp;
273
274 va_start (argp,
275 salt_len);
276 GNUNET_CRYPTO_hmac_derive_key_v (key,
277 rkey,
278 salt, salt_len,
279 argp);
280 va_end (argp);
281}
282
283
284void
285GNUNET_CRYPTO_hmac_derive_key_v (
286 struct GNUNET_CRYPTO_AuthKey *key,
287 const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
288 const void *salt, size_t salt_len,
289 va_list argp)
290{
291 GNUNET_CRYPTO_kdf_v (key->key, sizeof(key->key),
292 salt, salt_len,
293 rkey, sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey),
294 argp);
295}
296
297
298void
299GNUNET_CRYPTO_hmac_raw (const void *key, size_t key_len,
300 const void *plaintext, size_t plaintext_len,
301 struct GNUNET_HashCode *hmac)
302{
303 static int once;
304 static gcry_md_hd_t md;
305 const unsigned char *mc;
306
307 if (! once)
308 {
309 once = 1;
310 GNUNET_assert (GPG_ERR_NO_ERROR ==
311 gcry_md_open (&md,
312 GCRY_MD_SHA512,
313 GCRY_MD_FLAG_HMAC));
314 }
315 else
316 {
317 gcry_md_reset (md);
318 }
319 GNUNET_assert (GPG_ERR_NO_ERROR ==
320 gcry_md_setkey (md, key, key_len));
321 gcry_md_write (md, plaintext, plaintext_len);
322 mc = gcry_md_read (md, GCRY_MD_SHA512);
323 GNUNET_assert (NULL != mc);
324 GNUNET_memcpy (hmac->bits, mc, sizeof(hmac->bits));
325}
326
327
328void
329GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key,
330 const void *plaintext, size_t plaintext_len,
331 struct GNUNET_HashCode *hmac)
332{
333 GNUNET_CRYPTO_hmac_raw ((void *) key->key, sizeof(key->key),
334 plaintext, plaintext_len,
335 hmac);
336}
337
338
339struct GNUNET_HashContext
340{
344 gcry_md_hd_t hd;
345};
346
347
348struct GNUNET_HashContext *
349GNUNET_CRYPTO_hash_context_start ()
350{
351 struct GNUNET_HashContext *hc;
352
353 BENCHMARK_START (hash_context_start);
354 hc = GNUNET_new (struct GNUNET_HashContext);
355 GNUNET_assert (0 ==
356 gcry_md_open (&hc->hd,
357 GCRY_MD_SHA512,
358 0));
359 BENCHMARK_END (hash_context_start);
360 return hc;
361}
362
363
364void
365GNUNET_CRYPTO_hash_context_read (struct GNUNET_HashContext *hc,
366 const void *buf,
367 size_t size)
368{
369 BENCHMARK_START (hash_context_read);
370 gcry_md_write (hc->hd, buf, size);
371 BENCHMARK_END (hash_context_read);
372}
373
374
375struct GNUNET_HashContext *
376GNUNET_CRYPTO_hash_context_copy (const struct GNUNET_HashContext *hc)
377{
378 struct GNUNET_HashContext *cp;
379
380 cp = GNUNET_new (struct GNUNET_HashContext);
381 GNUNET_assert (0 ==
382 gcry_md_copy (&cp->hd,
383 hc->hd));
384 return cp;
385}
386
387
388void
389GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc,
390 struct GNUNET_HashCode *r_hash)
391{
392 const void *res = gcry_md_read (hc->hd, 0);
393
394 BENCHMARK_START (hash_context_finish);
395
396 GNUNET_assert (NULL != res);
397 if (NULL != r_hash)
398 GNUNET_memcpy (r_hash,
399 res,
400 sizeof(struct GNUNET_HashCode));
401 GNUNET_CRYPTO_hash_context_abort (hc);
402 BENCHMARK_END (hash_context_finish);
403}
404
405
406void
407GNUNET_CRYPTO_hash_context_abort (struct GNUNET_HashContext *hc)
408{
409 gcry_md_close (hc->hd);
410 GNUNET_free (hc);
411}
412
413
414/* end of crypto_hash.c */
BENCHMARK_START
#define BENCHMARK_START(opname)
Definition benchmark.h:57
BENCHMARK_END
#define BENCHMARK_END(opname)
Definition benchmark.h:58
h
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition gnunet-arm.c:98
ret
static int ret
Final status code.
Definition gnunet-arm.c:93
key
struct GNUNET_HashCode key
The key used in the DHT.
Definition gnunet-dht-put.c:37
enc
static OpusEncoder * enc
OPUS encoder.
Definition gnunet-helper-audio-record.c:206
t
static struct GNUNET_SCHEDULER_Task * t
Main task.
Definition gnunet-namestore-zonefile.c:302
res
static char * res
Currently read line or NULL on EOF.
Definition gnunet-namestore-zonefile.c:256
once
static int once
Option -i.
Definition gnunet-pils.c:39
mc
static struct GNUNET_TESTBED_Controller * mc
Handle to the master controller.
Definition gnunet-regex-profiler.c:200
result
static int result
Global testing status.
Definition gnunet-regex-profiler.c:240
salt
static struct GNUNET_CRYPTO_PowSalt salt
Salt for PoW calculations.
Definition gnunet-scrypt.c:34
mode
static enum @49 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
GNUNET_CRYPTO_random_block
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
Definition crypto_random.c:133
GNUNET_CRYPTO_Quality
GNUNET_CRYPTO_Quality
Desired quality level for random numbers.
Definition gnunet_crypto_lib.h:86
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
Definition crypto_hash.c:111
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.
Definition crypto_hash.c:55
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.
Definition crypto_hash.c:103
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)
Definition crypto_hash.c:330
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
Definition crypto_hash.c:123
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
Definition crypto_hash.c:135
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).
Definition crypto_hash.c:243
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.
Definition crypto_hash.c:286
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'.
Definition crypto_hash.c:72
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.
Definition crypto_hash.c:221
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.
Definition crypto_hash.c:92
GNUNET_CRYPTO_kdf
enum GNUNET_GenericReturnValue 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.
Definition crypto_kdf.c:62
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.
Definition crypto_hash.c:267
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.
Definition crypto_hash.c:152
GNUNET_CRYPTO_hash_count_leading_zeros
unsigned int GNUNET_CRYPTO_hash_count_leading_zeros(const struct GNUNET_HashCode *h)
Count the number of leading 0 bits in h.
Definition crypto_hash.c:177
GNUNET_CRYPTO_hash_context_read
void GNUNET_CRYPTO_hash_context_read(struct GNUNET_HashContext *hc, const void *buf, size_t size)
Add data to be hashed.
Definition crypto_hash.c:366
GNUNET_CRYPTO_hash_context_copy
struct GNUNET_HashContext * GNUNET_CRYPTO_hash_context_copy(const struct GNUNET_HashContext *hc)
Make a copy of the hash computation.
Definition crypto_hash.c:377
GNUNET_ntohll
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition common_endian.c:54
GNUNET_CRYPTO_kdf_v
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_kdf_v(void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len, va_list argp)
Derive key.
Definition crypto_kdf.c:38
GNUNET_CRYPTO_hash_context_abort
void GNUNET_CRYPTO_hash_context_abort(struct GNUNET_HashContext *hc)
Abort hashing, do not bother calculating final result.
Definition crypto_hash.c:408
GNUNET_CRYPTO_hash_context_finish
void GNUNET_CRYPTO_hash_context_finish(struct GNUNET_HashContext *hc, struct GNUNET_HashCode *r_hash)
Finish the hash computation.
Definition crypto_hash.c:390
GNUNET_memcpy
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Definition gnunet_common.h:1320
GNUNET_CRYPTO_hash_count_tailing_zeros
unsigned int GNUNET_CRYPTO_hash_count_tailing_zeros(const struct GNUNET_HashCode *h)
Count the number of tailing 0 bits in h.
Definition crypto_hash.c:199
GNUNET_GenericReturnValue
GNUNET_GenericReturnValue
Named constants for return values.
Definition gnunet_common.h:111
GNUNET_CRYPTO_hash_context_start
struct GNUNET_HashContext * GNUNET_CRYPTO_hash_context_start()
Start incremental hashing operation.
Definition crypto_hash.c:350
GNUNET_CRYPTO_hmac_raw
void GNUNET_CRYPTO_hmac_raw(const void *key, size_t key_len, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104) TODO: Shouldn't this be the standard hmac function and the abo...
Definition crypto_hash.c:300
GNUNET_static_assert
#define GNUNET_static_assert(cond)
Assertion to be checked (if supported by C compiler) at compile time, otherwise checked at runtime an...
Definition gnunet_common.h:1036
GNUNET_HashCode::bits
uint32_t bits[512/8/sizeof(uint32_t)]
Definition gnunet_common.h:288
GNUNET_YES
@ GNUNET_YES
Definition gnunet_common.h:116
GNUNET_SYSERR
@ GNUNET_SYSERR
Definition gnunet_common.h:112
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition gnunet_common.h:960
GNUNET_new
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition gnunet_common.h:1240
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition gnunet_common.h:1415
GNUNET_STRINGS_data_to_string
char * GNUNET_STRINGS_data_to_string(const void *data, size_t size, char *out, size_t out_size)
Convert binary data to ASCII encoding using CrockfordBase32.
Definition strings.c:757
GNUNET_STRINGS_utf8_toupper
char * GNUNET_STRINGS_utf8_toupper(const char *input)
Convert the utf-8 input string to upper case.
Definition strings.c:500
GNUNET_STRINGS_string_to_data
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition strings.c:837
size
static unsigned int size
Size of the "table".
Definition peer.c:68
delta
static struct GNUNET_TIME_Relative delta
Definition speedup.c:36
GNUNET_CRYPTO_AuthKey
type for (message) authentication keys
Definition gnunet_crypto_lib.h:567
GNUNET_CRYPTO_HashAsciiEncoded
0-terminated ASCII encoding of a struct GNUNET_HashCode.
Definition gnunet_crypto_lib.h:128
GNUNET_CRYPTO_SymmetricInitializationVector
IV for sym cipher.
Definition gnunet_crypto_lib.h:556
GNUNET_CRYPTO_SymmetricSessionKey
type for session keys
Definition gnunet_crypto_lib.h:524
GNUNET_HashCode
A 512-bit hashcode.
Definition gnunet_common.h:287
GNUNET_HashContext
Definition crypto_hash.c:341
GNUNET_HashContext::hd
gcry_md_hd_t hd
Internal state of the hash function.
Definition crypto_hash.c:345