GNUnet 0.26.2-98-gb402d9955
 
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_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_hkdf_gnunet (
158 skey,
159 sizeof(*skey),
160 "Hash key derivation",
161 strlen ("Hash key derivation"),
162 hc, sizeof(*hc)));
163 GNUNET_assert (GNUNET_YES ==
164 GNUNET_CRYPTO_hkdf_gnunet (
165 iv,
166 sizeof(*iv),
167 "Initialization vector derivation",
168 strlen ("Initialization vector derivation"),
169 hc, sizeof(*hc)));
170}
171
172
173unsigned int
174GNUNET_CRYPTO_hash_count_leading_zeros (const struct GNUNET_HashCode *h)
175{
176 const unsigned long long *llp = (const unsigned long long *) h;
177 unsigned int ret = 0;
178 unsigned int i;
179
180 GNUNET_static_assert (8 == sizeof (unsigned long long));
181 GNUNET_static_assert (0 == sizeof (*h) % sizeof (unsigned long long));
182 for (i = 0; i<sizeof (*h) / sizeof (*llp); i++)
183 {
184 if (0LLU != llp[i])
185 break;
186 ret += sizeof (*llp) * 8;
187 }
188 if (ret == 8 * sizeof (*h))
189 return ret;
190 ret += __builtin_clzll (GNUNET_ntohll ((uint64_t) llp[i]));
191 return ret;
192}
193
194
195unsigned int
196GNUNET_CRYPTO_hash_count_tailing_zeros (const struct GNUNET_HashCode *h)
197{
198 const unsigned long long *llp = (const unsigned long long *) h;
199 unsigned int ret = 0;
200 int i;
201
202 GNUNET_static_assert (8 == sizeof (unsigned long long));
203 GNUNET_static_assert (0 == sizeof (*h) % sizeof (unsigned long long));
204 for (i = sizeof (*h) / sizeof (*llp) - 1; i>=0; i--)
205 {
206 if (0LLU != llp[i])
207 break;
208 ret += sizeof (*llp) * 8;
209 }
210 if (ret == 8 * sizeof (*h))
211 return ret;
212 ret += __builtin_ctzll (GNUNET_ntohll ((uint64_t) llp[i]));
213 return ret;
214}
215
216
217int
218GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
219 const struct GNUNET_HashCode *h2)
220{
221 unsigned int *i1;
222 unsigned int *i2;
223
224 i1 = (unsigned int *) h1;
225 i2 = (unsigned int *) h2;
226 for (ssize_t i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1;
227 i >= 0;
228 i--)
229 {
230 if (i1[i] > i2[i])
231 return 1;
232 if (i1[i] < i2[i])
233 return -1;
234 }
235 return 0;
236}
237
238
239int
240GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode *h1,
241 const struct GNUNET_HashCode *h2,
242 const struct GNUNET_HashCode *target)
243{
244 const unsigned long long *l1 = (const unsigned long long *) h1;
245 const unsigned long long *l2 = (const unsigned long long *) h2;
246 const unsigned long long *t = (const unsigned long long *) target;
247
248 GNUNET_static_assert (0 == sizeof (*h1) % sizeof (*l1));
249 for (size_t i = 0; i < sizeof(*h1) / sizeof(*l1); i++)
250 {
251 unsigned long long x1 = l1[i] ^ t[i];
252 unsigned long long x2 = l2[i] ^ t[i];
253
254 if (x1 > x2)
255 return 1;
256 if (x1 < x2)
257 return -1;
258 }
259 return 0;
260}
261
262
263void
264GNUNET_CRYPTO_hmac_raw (const void *key, size_t key_len,
265 const void *plaintext, size_t plaintext_len,
266 struct GNUNET_HashCode *hmac)
267{
268 static int once;
269 static gcry_md_hd_t md;
270 const unsigned char *mc;
271
272 if (! once)
273 {
274 once = 1;
275 GNUNET_assert (GPG_ERR_NO_ERROR ==
276 gcry_md_open (&md,
277 GCRY_MD_SHA512,
278 GCRY_MD_FLAG_HMAC));
279 }
280 else
281 {
282 gcry_md_reset (md);
283 }
284 GNUNET_assert (GPG_ERR_NO_ERROR ==
285 gcry_md_setkey (md, key, key_len));
286 gcry_md_write (md, plaintext, plaintext_len);
287 mc = gcry_md_read (md, GCRY_MD_SHA512);
288 GNUNET_assert (NULL != mc);
289 GNUNET_memcpy (hmac->bits, mc, sizeof(hmac->bits));
290}
291
292
293void
294GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key,
295 const void *plaintext, size_t plaintext_len,
296 struct GNUNET_HashCode *hmac)
297{
298 GNUNET_CRYPTO_hmac_raw ((void *) key->key, sizeof(key->key),
299 plaintext, plaintext_len,
300 hmac);
301}
302
303
304struct GNUNET_HashContext
305{
309 gcry_md_hd_t hd;
310};
311
312
313struct GNUNET_HashContext *
314GNUNET_CRYPTO_hash_context_start ()
315{
316 struct GNUNET_HashContext *hc;
317
318 BENCHMARK_START (hash_context_start);
319 hc = GNUNET_new (struct GNUNET_HashContext);
320 GNUNET_assert (0 ==
321 gcry_md_open (&hc->hd,
322 GCRY_MD_SHA512,
323 0));
324 BENCHMARK_END (hash_context_start);
325 return hc;
326}
327
328
329void
330GNUNET_CRYPTO_hash_context_read (struct GNUNET_HashContext *hc,
331 const void *buf,
332 size_t size)
333{
334 BENCHMARK_START (hash_context_read);
335 gcry_md_write (hc->hd, buf, size);
336 BENCHMARK_END (hash_context_read);
337}
338
339
340struct GNUNET_HashContext *
341GNUNET_CRYPTO_hash_context_copy (const struct GNUNET_HashContext *hc)
342{
343 struct GNUNET_HashContext *cp;
344
345 cp = GNUNET_new (struct GNUNET_HashContext);
346 GNUNET_assert (0 ==
347 gcry_md_copy (&cp->hd,
348 hc->hd));
349 return cp;
350}
351
352
353void
354GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc,
355 struct GNUNET_HashCode *r_hash)
356{
357 const void *res = gcry_md_read (hc->hd, 0);
358
359 BENCHMARK_START (hash_context_finish);
360
361 GNUNET_assert (NULL != res);
362 if (NULL != r_hash)
363 GNUNET_memcpy (r_hash,
364 res,
365 sizeof(struct GNUNET_HashCode));
366 GNUNET_CRYPTO_hash_context_abort (hc);
367 BENCHMARK_END (hash_context_finish);
368}
369
370
371void
372GNUNET_CRYPTO_hash_context_abort (struct GNUNET_HashContext *hc)
373{
374 gcry_md_close (hc->hd);
375 GNUNET_free (hc);
376}
377
378
379/* 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
mode
static enum @52 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:295
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:241
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_hkdf_gnunet
#define GNUNET_CRYPTO_hkdf_gnunet(result, out_len, xts, xts_len, skm, skm_len,...)
A peculiar HKDF instantiation that tried to mimic Truncated NMAC.
Definition gnunet_crypto_lib.h:1449
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:219
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_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:175
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:331
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:342
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_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:373
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:355
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:197
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:315
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:265
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:578
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:567
GNUNET_CRYPTO_SymmetricSessionKey
type for session keys
Definition gnunet_crypto_lib.h:535
GNUNET_HashCode
A 512-bit hashcode.
Definition gnunet_common.h:287
GNUNET_HashContext
Definition crypto_hash.c:306
GNUNET_HashContext::hd
gcry_md_hd_t hd
Internal state of the hash function.
Definition crypto_hash.c:310