diff options
-rw-r--r-- | doc/man/gnunet-rsa.1 | 5 | ||||
-rw-r--r-- | src/datastore/datastore.h | 4 | ||||
-rw-r--r-- | src/exit/exit.h | 6 | ||||
-rw-r--r-- | src/fs/gnunet-service-fs.h | 2 | ||||
-rw-r--r-- | src/include/block_dns.h | 2 | ||||
-rw-r--r-- | src/include/gnunet_common.h | 8 | ||||
-rw-r--r-- | src/include/gnunet_crypto_lib.h | 99 | ||||
-rw-r--r-- | src/include/gnunet_strings_lib.h | 4 | ||||
-rw-r--r-- | src/util/crypto_hash.c | 202 | ||||
-rw-r--r-- | src/util/gnunet-rsa.c | 18 | ||||
-rw-r--r-- | src/util/strings.c | 16 | ||||
-rw-r--r-- | src/vpn/vpn.h | 2 |
12 files changed, 258 insertions, 110 deletions
diff --git a/doc/man/gnunet-rsa.1 b/doc/man/gnunet-rsa.1 index f3b1df3d3..46f24de1c 100644 --- a/doc/man/gnunet-rsa.1 +++ b/doc/man/gnunet-rsa.1 | |||
@@ -17,7 +17,10 @@ gnunet\-rsa \- manipulate GNUnet RSA key files | |||
17 | Print the corresponding public key to stdout. | 17 | Print the corresponding public key to stdout. |
18 | .B | 18 | .B |
19 | .IP "\-P, \-\-print-peer-identity" | 19 | .IP "\-P, \-\-print-peer-identity" |
20 | Print the corresponding peer identity (hash of the public key) to stdout. | 20 | Print the corresponding peer identity (hash of the public key) to stdout. This hash is used for the name of peers. |
21 | .B | ||
22 | .IP "\-s, \-\-print-short-identity" | ||
23 | Print the corresponding short hash (256-bit hash of the public key) to stdout. This hash is used for names in the zkey zone. | ||
21 | .B | 24 | .B |
22 | .IP "\-c FILENAME, \-\-config=FILENAME" | 25 | .IP "\-c FILENAME, \-\-config=FILENAME" |
23 | Use the configuration file FILENAME. | 26 | Use the configuration file FILENAME. |
diff --git a/src/datastore/datastore.h b/src/datastore/datastore.h index 1126027f8..c8b2c722b 100644 --- a/src/datastore/datastore.h +++ b/src/datastore/datastore.h | |||
@@ -130,7 +130,7 @@ struct GetMessage | |||
130 | * Desired key (optional). Check the "size" of the | 130 | * Desired key (optional). Check the "size" of the |
131 | * header to see if the key is actually present. | 131 | * header to see if the key is actually present. |
132 | */ | 132 | */ |
133 | GNUNET_HashCode key GNUNET_PACKED; | 133 | GNUNET_HashCode key; |
134 | 134 | ||
135 | }; | 135 | }; |
136 | 136 | ||
@@ -253,7 +253,7 @@ struct DataMessage | |||
253 | /** | 253 | /** |
254 | * Key under which the item can be found. | 254 | * Key under which the item can be found. |
255 | */ | 255 | */ |
256 | GNUNET_HashCode key GNUNET_PACKED; | 256 | GNUNET_HashCode key; |
257 | 257 | ||
258 | }; | 258 | }; |
259 | GNUNET_NETWORK_STRUCT_END | 259 | GNUNET_NETWORK_STRUCT_END |
diff --git a/src/exit/exit.h b/src/exit/exit.h index dcc50f1b3..90df26d7d 100644 --- a/src/exit/exit.h +++ b/src/exit/exit.h | |||
@@ -49,7 +49,7 @@ struct GNUNET_EXIT_TcpServiceStartMessage | |||
49 | /** | 49 | /** |
50 | * Identification for the desired service. | 50 | * Identification for the desired service. |
51 | */ | 51 | */ |
52 | GNUNET_HashCode service_descriptor GNUNET_PACKED; | 52 | GNUNET_HashCode service_descriptor; |
53 | 53 | ||
54 | /** | 54 | /** |
55 | * Skeleton of the TCP header to send. Port numbers are to | 55 | * Skeleton of the TCP header to send. Port numbers are to |
@@ -142,7 +142,7 @@ struct GNUNET_EXIT_UdpServiceMessage | |||
142 | /** | 142 | /** |
143 | * Identification for the desired service. | 143 | * Identification for the desired service. |
144 | */ | 144 | */ |
145 | GNUNET_HashCode service_descriptor GNUNET_PACKED; | 145 | GNUNET_HashCode service_descriptor; |
146 | 146 | ||
147 | /* followed by UDP payload */ | 147 | /* followed by UDP payload */ |
148 | }; | 148 | }; |
@@ -230,7 +230,7 @@ struct GNUNET_EXIT_IcmpServiceMessage | |||
230 | /** | 230 | /** |
231 | * Identification for the desired service. | 231 | * Identification for the desired service. |
232 | */ | 232 | */ |
233 | GNUNET_HashCode service_descriptor GNUNET_PACKED; | 233 | GNUNET_HashCode service_descriptor; |
234 | 234 | ||
235 | /** | 235 | /** |
236 | * ICMP header to use. | 236 | * ICMP header to use. |
diff --git a/src/fs/gnunet-service-fs.h b/src/fs/gnunet-service-fs.h index 5ea73ee28..0c796bf9c 100644 --- a/src/fs/gnunet-service-fs.h +++ b/src/fs/gnunet-service-fs.h | |||
@@ -129,7 +129,7 @@ struct GetMessage | |||
129 | * Hashcodes of the file(s) we're looking for. | 129 | * Hashcodes of the file(s) we're looking for. |
130 | * Details depend on the query type. | 130 | * Details depend on the query type. |
131 | */ | 131 | */ |
132 | GNUNET_HashCode query GNUNET_PACKED; | 132 | GNUNET_HashCode query; |
133 | 133 | ||
134 | /* this is followed by hash codes as specified in the "hash_bitmap"; | 134 | /* this is followed by hash codes as specified in the "hash_bitmap"; |
135 | * after that, an optional bloomfilter (with bits set for replies | 135 | * after that, an optional bloomfilter (with bits set for replies |
diff --git a/src/include/block_dns.h b/src/include/block_dns.h index 4c2f1a3f3..e047779c5 100644 --- a/src/include/block_dns.h +++ b/src/include/block_dns.h | |||
@@ -64,7 +64,7 @@ struct GNUNET_DNS_Record | |||
64 | * The descriptor for the service | 64 | * The descriptor for the service |
65 | * (a peer may provide more than one service) | 65 | * (a peer may provide more than one service) |
66 | */ | 66 | */ |
67 | GNUNET_HashCode service_descriptor GNUNET_PACKED; | 67 | GNUNET_HashCode service_descriptor; |
68 | 68 | ||
69 | /** | 69 | /** |
70 | * When does this record expire? | 70 | * When does this record expire? |
diff --git a/src/include/gnunet_common.h b/src/include/gnunet_common.h index f26d6bc98..141df1a5d 100644 --- a/src/include/gnunet_common.h +++ b/src/include/gnunet_common.h | |||
@@ -208,27 +208,25 @@ struct GNUNET_MessageHeader | |||
208 | uint16_t type GNUNET_PACKED; | 208 | uint16_t type GNUNET_PACKED; |
209 | 209 | ||
210 | }; | 210 | }; |
211 | GNUNET_NETWORK_STRUCT_END | 211 | |
212 | 212 | ||
213 | /** | 213 | /** |
214 | * @brief 512-bit hashcode | 214 | * @brief 512-bit hashcode |
215 | */ | 215 | */ |
216 | typedef struct | 216 | typedef struct GNUNET_HashCode |
217 | { | 217 | { |
218 | uint32_t bits[512 / 8 / sizeof (uint32_t)]; /* = 16 */ | 218 | uint32_t bits[512 / 8 / sizeof (uint32_t)]; /* = 16 */ |
219 | } | 219 | } |
220 | GNUNET_HashCode; | 220 | GNUNET_HashCode; |
221 | 221 | ||
222 | 222 | ||
223 | GNUNET_NETWORK_STRUCT_BEGIN | ||
224 | |||
225 | /** | 223 | /** |
226 | * The identity of the host (basically the SHA-512 hashcode of | 224 | * The identity of the host (basically the SHA-512 hashcode of |
227 | * it's public key). | 225 | * it's public key). |
228 | */ | 226 | */ |
229 | struct GNUNET_PeerIdentity | 227 | struct GNUNET_PeerIdentity |
230 | { | 228 | { |
231 | GNUNET_HashCode hashPubKey GNUNET_PACKED; | 229 | GNUNET_HashCode hashPubKey; |
232 | }; | 230 | }; |
233 | GNUNET_NETWORK_STRUCT_END | 231 | GNUNET_NETWORK_STRUCT_END |
234 | 232 | ||
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h index 6224546b9..8270c89dd 100644 --- a/src/include/gnunet_crypto_lib.h +++ b/src/include/gnunet_crypto_lib.h | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Christian Grothoff (and other contributing authors) | 3 | (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 5 | GNUnet is free software; you can redistribute it and/or modify |
6 | it under the terms of the GNU General Public License as published | 6 | it under the terms of the GNU General Public License as published |
@@ -138,6 +138,26 @@ struct GNUNET_CRYPTO_HashAsciiEncoded | |||
138 | 138 | ||
139 | 139 | ||
140 | 140 | ||
141 | |||
142 | /** | ||
143 | * @brief 256-bit hashcode | ||
144 | */ | ||
145 | struct GNUNET_CRYPTO_ShortHashCode | ||
146 | { | ||
147 | uint32_t bits[256 / 8 / sizeof (uint32_t)]; /* = 8 */ | ||
148 | }; | ||
149 | |||
150 | |||
151 | /** | ||
152 | * @brief 0-terminated ASCII encoding of a 'struct GNUNET_ShortHashCode'. | ||
153 | */ | ||
154 | struct GNUNET_CRYPTO_ShortHashAsciiEncoded | ||
155 | { | ||
156 | unsigned char short_encoding[53]; | ||
157 | }; | ||
158 | |||
159 | |||
160 | |||
141 | /** | 161 | /** |
142 | * @brief an RSA signature | 162 | * @brief an RSA signature |
143 | */ | 163 | */ |
@@ -433,7 +453,19 @@ GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block, | |||
433 | 453 | ||
434 | 454 | ||
435 | /** | 455 | /** |
436 | * Convert ASCII encoding back to GNUNET_CRYPTO_hash | 456 | * Convert short hash to ASCII encoding. |
457 | * | ||
458 | * @param block the hash code | ||
459 | * @param result where to store the encoding (struct GNUNET_CRYPTO_ShortHashAsciiEncoded can be | ||
460 | * safely cast to char*, a '\\0' termination is set). | ||
461 | */ | ||
462 | void | ||
463 | GNUNET_CRYPTO_short_hash_to_enc (const struct GNUNET_CRYPTO_ShortHashCode * block, | ||
464 | struct GNUNET_CRYPTO_ShortHashAsciiEncoded *result); | ||
465 | |||
466 | |||
467 | /** | ||
468 | * Convert ASCII encoding back to a 'GNUNET_HashCode' | ||
437 | * | 469 | * |
438 | * @param enc the encoding | 470 | * @param enc the encoding |
439 | * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing) | 471 | * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing) |
@@ -446,16 +478,41 @@ GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen, | |||
446 | 478 | ||
447 | 479 | ||
448 | /** | 480 | /** |
449 | * Convert ASCII encoding back to GNUNET_CRYPTO_hash | 481 | * Convert ASCII encoding back to a 'struct GNUNET_CRYPTO_ShortHash' |
482 | * | ||
450 | * @param enc the encoding | 483 | * @param enc the encoding |
484 | * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing) | ||
451 | * @param result where to store the GNUNET_CRYPTO_hash code | 485 | * @param result where to store the GNUNET_CRYPTO_hash code |
452 | * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding | 486 | * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding |
453 | */ | 487 | */ |
488 | int | ||
489 | GNUNET_CRYPTO_short_hash_from_string2 (const char *enc, size_t enclen, | ||
490 | struct GNUNET_CRYPTO_ShortHashCode * result); | ||
491 | |||
492 | |||
493 | /** | ||
494 | * Convert ASCII encoding back to GNUNET_HashCode | ||
495 | * | ||
496 | * @param enc the encoding | ||
497 | * @param result where to store the hash code | ||
498 | * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding | ||
499 | */ | ||
454 | #define GNUNET_CRYPTO_hash_from_string(enc, result) \ | 500 | #define GNUNET_CRYPTO_hash_from_string(enc, result) \ |
455 | GNUNET_CRYPTO_hash_from_string2 (enc, strlen(enc), result) | 501 | GNUNET_CRYPTO_hash_from_string2 (enc, strlen(enc), result) |
456 | 502 | ||
457 | 503 | ||
458 | /** | 504 | /** |
505 | * Convert ASCII encoding back to a 'struct GNUNET_CRYPTO_ShortHash' | ||
506 | * | ||
507 | * @param enc the encoding | ||
508 | * @param result where to store the GNUNET_CRYPTO_ShortHash | ||
509 | * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding | ||
510 | */ | ||
511 | #define GNUNET_CRYPTO_short_hash_from_string(enc, result) \ | ||
512 | GNUNET_CRYPTO_short_hash_from_string2 (enc, strlen(enc), result) | ||
513 | |||
514 | |||
515 | /** | ||
459 | * Compute the distance between 2 hashcodes. | 516 | * Compute the distance between 2 hashcodes. |
460 | * The computation must be fast, not involve | 517 | * The computation must be fast, not involve |
461 | * a.a or a.e (they're used elsewhere), and | 518 | * a.a or a.e (they're used elsewhere), and |
@@ -483,6 +540,42 @@ GNUNET_CRYPTO_hash (const void *block, size_t size, GNUNET_HashCode * ret); | |||
483 | 540 | ||
484 | 541 | ||
485 | /** | 542 | /** |
543 | * Compute short (256-bit) hash of a given block. | ||
544 | * | ||
545 | * @param block the data to hash | ||
546 | * @param size size of the block | ||
547 | * @param ret pointer to where to write the hashcode | ||
548 | */ | ||
549 | void | ||
550 | GNUNET_CRYPTO_short_hash (const void *block, size_t size, | ||
551 | struct GNUNET_CRYPTO_ShortHashCode * ret); | ||
552 | |||
553 | |||
554 | /** | ||
555 | * Double short (256-bit) hash to create a long hash. | ||
556 | * | ||
557 | * @param sh short hash to double | ||
558 | * @param dh where to store the (doubled) long hash (not really a hash) | ||
559 | */ | ||
560 | void | ||
561 | GNUNET_CRYPTO_short_hash_double (const struct GNUNET_CRYPTO_ShortHashCode *sh, | ||
562 | struct GNUNET_HashCode *dh); | ||
563 | |||
564 | |||
565 | /** | ||
566 | * Truncate doubled short hash back to a short hash. | ||
567 | * | ||
568 | * @param lh doubled short hash to reduce again | ||
569 | * @param sh where to store the short hash | ||
570 | * @return GNUNET_OK on success, GNUNET_SYSERR if this was not a | ||
571 | * doubled short hash | ||
572 | */ | ||
573 | int | ||
574 | GNUNET_CRYPTO_short_hash_from_truncation (const struct GNUNET_HashCode *dh, | ||
575 | struct GNUNET_CRYPTO_ShortHashCode *sh); | ||
576 | |||
577 | |||
578 | /** | ||
486 | * Calculate HMAC of a message (RFC 2104) | 579 | * Calculate HMAC of a message (RFC 2104) |
487 | * | 580 | * |
488 | * @param key secret key | 581 | * @param key secret key |
diff --git a/src/include/gnunet_strings_lib.h b/src/include/gnunet_strings_lib.h index 997ca7dd9..55b96fc2c 100644 --- a/src/include/gnunet_strings_lib.h +++ b/src/include/gnunet_strings_lib.h | |||
@@ -230,8 +230,8 @@ GNUNET_STRINGS_get_short_name (const char *filename); | |||
230 | * @return pointer to the next byte in 'out' or NULL on error. | 230 | * @return pointer to the next byte in 'out' or NULL on error. |
231 | */ | 231 | */ |
232 | char * | 232 | char * |
233 | GNUNET_STRINGS_data_to_string (unsigned char *data, size_t size, | 233 | GNUNET_STRINGS_data_to_string (const unsigned char *data, size_t size, |
234 | char *out, size_t out_size); | 234 | char *out, size_t out_size); |
235 | 235 | ||
236 | 236 | ||
237 | /** | 237 | /** |
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c index f89639045..aaf5175d7 100644 --- a/src/util/crypto_hash.c +++ b/src/util/crypto_hash.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009 Christian Grothoff (and other contributing authors) | 3 | (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 5 | GNUnet is free software; you can redistribute it and/or modify |
6 | it under the terms of the GNU General Public License as published | 6 | it under the terms of the GNU General Public License as published |
@@ -34,6 +34,7 @@ | |||
34 | #include "gnunet_common.h" | 34 | #include "gnunet_common.h" |
35 | #include "gnunet_crypto_lib.h" | 35 | #include "gnunet_crypto_lib.h" |
36 | #include "gnunet_disk_lib.h" | 36 | #include "gnunet_disk_lib.h" |
37 | #include "gnunet_strings_lib.h" | ||
37 | #include <gcrypt.h> | 38 | #include <gcrypt.h> |
38 | 39 | ||
39 | #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__) | 40 | #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__) |
@@ -55,6 +56,21 @@ GNUNET_CRYPTO_hash (const void *block, size_t size, GNUNET_HashCode * ret) | |||
55 | 56 | ||
56 | 57 | ||
57 | /** | 58 | /** |
59 | * Compute short (256-bit) hash of a given block. | ||
60 | * | ||
61 | * @param block the data to GNUNET_CRYPTO_hash, length is given as a second argument | ||
62 | * @param size the length of the data to GNUNET_CRYPTO_hash | ||
63 | * @param ret pointer to where to write the hashcode | ||
64 | */ | ||
65 | void | ||
66 | GNUNET_CRYPTO_short_hash (const void *block, size_t size, | ||
67 | struct GNUNET_CRYPTO_ShortHashCode * ret) | ||
68 | { | ||
69 | gcry_md_hash_buffer (GCRY_MD_SHA256, ret, block, size); | ||
70 | } | ||
71 | |||
72 | |||
73 | /** | ||
58 | * Context used when hashing a file. | 74 | * Context used when hashing a file. |
59 | */ | 75 | */ |
60 | struct GNUNET_CRYPTO_FileHashContext | 76 | struct GNUNET_CRYPTO_FileHashContext |
@@ -243,24 +259,6 @@ GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc) | |||
243 | 259 | ||
244 | /* ***************** binary-ASCII encoding *************** */ | 260 | /* ***************** binary-ASCII encoding *************** */ |
245 | 261 | ||
246 | /* FIXME: should use GNUNET_STRINGS_data_to_string and strings_to_data below!!! */ | ||
247 | |||
248 | /** | ||
249 | * Get the numeric value corresponding to a character. | ||
250 | * | ||
251 | * @param a a character | ||
252 | * @return corresponding numeric value | ||
253 | */ | ||
254 | static unsigned int | ||
255 | getValue__ (unsigned char a) | ||
256 | { | ||
257 | if ((a >= '0') && (a <= '9')) | ||
258 | return a - '0'; | ||
259 | if ((a >= 'A') && (a <= 'V')) | ||
260 | return (a - 'A' + 10); | ||
261 | return -1; | ||
262 | } | ||
263 | |||
264 | 262 | ||
265 | /** | 263 | /** |
266 | * Convert GNUNET_CRYPTO_hash to ASCII encoding. The ASCII encoding is rather | 264 | * Convert GNUNET_CRYPTO_hash to ASCII encoding. The ASCII encoding is rather |
@@ -277,88 +275,32 @@ void | |||
277 | GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block, | 275 | GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block, |
278 | struct GNUNET_CRYPTO_HashAsciiEncoded *result) | 276 | struct GNUNET_CRYPTO_HashAsciiEncoded *result) |
279 | { | 277 | { |
280 | /** | 278 | char *np; |
281 | * 32 characters for encoding (GNUNET_CRYPTO_hash => 32 characters) | 279 | |
282 | */ | 280 | np = GNUNET_STRINGS_data_to_string ((const unsigned char *) block, |
283 | static char *encTable__ = "0123456789ABCDEFGHIJKLMNOPQRSTUV"; | 281 | sizeof (struct GNUNET_HashCode), |
284 | unsigned int wpos; | 282 | (char*) result, |
285 | unsigned int rpos; | 283 | sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1); |
286 | unsigned int bits; | 284 | GNUNET_assert (NULL != np); |
287 | unsigned int vbit; | 285 | *np = '\0'; |
288 | |||
289 | GNUNET_assert (block != NULL); | ||
290 | GNUNET_assert (result != NULL); | ||
291 | vbit = 0; | ||
292 | wpos = 0; | ||
293 | rpos = 0; | ||
294 | bits = 0; | ||
295 | while ((rpos < sizeof (GNUNET_HashCode)) || (vbit > 0)) | ||
296 | { | ||
297 | if ((rpos < sizeof (GNUNET_HashCode)) && (vbit < 5)) | ||
298 | { | ||
299 | bits = (bits << 8) | ((unsigned char *) block)[rpos++]; /* eat 8 more bits */ | ||
300 | vbit += 8; | ||
301 | } | ||
302 | if (vbit < 5) | ||
303 | { | ||
304 | bits <<= (5 - vbit); /* zero-padding */ | ||
305 | GNUNET_assert (vbit == 2); /* padding by 3: 512+3 mod 5 == 0 */ | ||
306 | vbit = 5; | ||
307 | } | ||
308 | GNUNET_assert (wpos < sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1); | ||
309 | result->encoding[wpos++] = encTable__[(bits >> (vbit - 5)) & 31]; | ||
310 | vbit -= 5; | ||
311 | } | ||
312 | GNUNET_assert (wpos == sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1); | ||
313 | GNUNET_assert (vbit == 0); | ||
314 | result->encoding[wpos] = '\0'; | ||
315 | } | 286 | } |
316 | 287 | ||
317 | 288 | ||
318 | /** | 289 | /** |
319 | * Convert ASCII encoding back to GNUNET_CRYPTO_hash | 290 | * Convert ASCII encoding back to hash code. |
320 | * | 291 | * |
321 | * @param enc the encoding | 292 | * @param enc the encoding |
322 | * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing) | 293 | * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing) |
323 | * @param result where to store the GNUNET_CRYPTO_hash code | 294 | * @param result where to store the hash code |
324 | * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding | 295 | * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding |
325 | */ | 296 | */ |
326 | int | 297 | int |
327 | GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen, | 298 | GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen, |
328 | GNUNET_HashCode * result) | 299 | GNUNET_HashCode * result) |
329 | { | 300 | { |
330 | unsigned int rpos; | 301 | return GNUNET_STRINGS_string_to_data (enc, enclen, |
331 | unsigned int wpos; | 302 | (unsigned char*) result, |
332 | unsigned int bits; | 303 | sizeof (struct GNUNET_HashCode)); |
333 | unsigned int vbit; | ||
334 | int ret; | ||
335 | |||
336 | if (enclen != sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1) | ||
337 | return GNUNET_SYSERR; | ||
338 | |||
339 | vbit = 2; /* padding! */ | ||
340 | wpos = sizeof (GNUNET_HashCode); | ||
341 | rpos = sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1; | ||
342 | bits = (ret = getValue__ (enc[--rpos])) >> 3; | ||
343 | if (-1 == ret) | ||
344 | return GNUNET_SYSERR; | ||
345 | while (wpos > 0) | ||
346 | { | ||
347 | GNUNET_assert (rpos > 0); | ||
348 | bits = ((ret = getValue__ (enc[--rpos])) << vbit) | bits; | ||
349 | if (-1 == ret) | ||
350 | return GNUNET_SYSERR; | ||
351 | vbit += 5; | ||
352 | if (vbit >= 8) | ||
353 | { | ||
354 | ((unsigned char *) result)[--wpos] = (unsigned char) bits; | ||
355 | bits >>= 8; | ||
356 | vbit -= 8; | ||
357 | } | ||
358 | } | ||
359 | GNUNET_assert (rpos == 0); | ||
360 | GNUNET_assert (vbit == 0); | ||
361 | return GNUNET_OK; | ||
362 | } | 304 | } |
363 | 305 | ||
364 | 306 | ||
@@ -645,4 +587,88 @@ GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key, | |||
645 | } | 587 | } |
646 | 588 | ||
647 | 589 | ||
590 | |||
591 | /** | ||
592 | * Double short (256-bit) hash to create a long hash. | ||
593 | * | ||
594 | * @param sh short hash to double | ||
595 | * @param dh where to store the (doubled) long hash (not really a hash) | ||
596 | */ | ||
597 | void | ||
598 | GNUNET_CRYPTO_short_hash_double (const struct GNUNET_CRYPTO_ShortHashCode *sh, | ||
599 | struct GNUNET_HashCode *dh) | ||
600 | { | ||
601 | char *ptr; | ||
602 | |||
603 | ptr = (char*) dh; | ||
604 | memcpy (ptr, sh, sizeof (struct GNUNET_CRYPTO_ShortHashCode)); | ||
605 | memcpy (&ptr[sizeof (struct GNUNET_CRYPTO_ShortHashCode)], sh, sizeof (struct GNUNET_CRYPTO_ShortHashCode)); | ||
606 | } | ||
607 | |||
608 | |||
609 | /** | ||
610 | * Truncate doubled short hash back to a short hash. | ||
611 | * | ||
612 | * @param lh doubled short hash to reduce again | ||
613 | * @param sh where to store the short hash | ||
614 | * @return GNUNET_OK on success, GNUNET_SYSERR if this was not a | ||
615 | * doubled short hash | ||
616 | */ | ||
617 | int | ||
618 | GNUNET_CRYPTO_short_hash_from_truncation (const struct GNUNET_HashCode *dh, | ||
619 | struct GNUNET_CRYPTO_ShortHashCode *sh) | ||
620 | { | ||
621 | const struct GNUNET_CRYPTO_ShortHashCode *s; | ||
622 | |||
623 | s = (const struct GNUNET_CRYPTO_ShortHashCode *) dh; | ||
624 | if (0 != memcmp (&s[0], | ||
625 | &s[1], | ||
626 | sizeof (struct GNUNET_CRYPTO_ShortHashCode))) | ||
627 | return GNUNET_SYSERR; | ||
628 | *sh = *s; | ||
629 | return GNUNET_OK; | ||
630 | } | ||
631 | |||
632 | |||
633 | /** | ||
634 | * Convert ASCII encoding back to a 'struct GNUNET_CRYPTO_ShortHash' | ||
635 | * | ||
636 | * @param enc the encoding | ||
637 | * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing) | ||
638 | * @param result where to store the GNUNET_CRYPTO_hash code | ||
639 | * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding | ||
640 | */ | ||
641 | int | ||
642 | GNUNET_CRYPTO_short_hash_from_string2 (const char *enc, size_t enclen, | ||
643 | struct GNUNET_CRYPTO_ShortHashCode * result) | ||
644 | { | ||
645 | return GNUNET_STRINGS_string_to_data (enc, enclen, | ||
646 | (unsigned char*) result, | ||
647 | sizeof (struct GNUNET_CRYPTO_ShortHashCode)); | ||
648 | } | ||
649 | |||
650 | |||
651 | /** | ||
652 | * Convert short hash to ASCII encoding. | ||
653 | * | ||
654 | * @param block the hash code | ||
655 | * @param result where to store the encoding (struct GNUNET_CRYPTO_ShortHashAsciiEncoded can be | ||
656 | * safely cast to char*, a '\\0' termination is set). | ||
657 | */ | ||
658 | void | ||
659 | GNUNET_CRYPTO_short_hash_to_enc (const struct GNUNET_CRYPTO_ShortHashCode * block, | ||
660 | struct GNUNET_CRYPTO_ShortHashAsciiEncoded *result) | ||
661 | { | ||
662 | char *np; | ||
663 | |||
664 | np = GNUNET_STRINGS_data_to_string ((const unsigned char *) block, | ||
665 | sizeof (struct GNUNET_CRYPTO_ShortHashCode), | ||
666 | (char*) result, | ||
667 | sizeof (struct GNUNET_CRYPTO_ShortHashAsciiEncoded) - 1); | ||
668 | GNUNET_assert (NULL != np); | ||
669 | *np = '\0'; | ||
670 | } | ||
671 | |||
672 | |||
673 | |||
648 | /* end of crypto_hash.c */ | 674 | /* end of crypto_hash.c */ |
diff --git a/src/util/gnunet-rsa.c b/src/util/gnunet-rsa.c index bfd854e65..f3cd83a8b 100644 --- a/src/util/gnunet-rsa.c +++ b/src/util/gnunet-rsa.c | |||
@@ -37,6 +37,11 @@ static int print_public_key; | |||
37 | */ | 37 | */ |
38 | static int print_peer_identity; | 38 | static int print_peer_identity; |
39 | 39 | ||
40 | /** | ||
41 | * Flag for printing short hash of public key. | ||
42 | */ | ||
43 | static int print_short_identity; | ||
44 | |||
40 | 45 | ||
41 | /** | 46 | /** |
42 | * Main function that will be run by the scheduler. | 47 | * Main function that will be run by the scheduler. |
@@ -78,6 +83,16 @@ run (void *cls, char *const *args, const char *cfgfile, | |||
78 | GNUNET_CRYPTO_hash_to_enc (&pid.hashPubKey, &enc); | 83 | GNUNET_CRYPTO_hash_to_enc (&pid.hashPubKey, &enc); |
79 | fprintf (stdout, "%s\n", enc.encoding); | 84 | fprintf (stdout, "%s\n", enc.encoding); |
80 | } | 85 | } |
86 | if (print_short_identity) | ||
87 | { | ||
88 | struct GNUNET_CRYPTO_ShortHashAsciiEncoded enc; | ||
89 | struct GNUNET_CRYPTO_ShortHashCode sh; | ||
90 | |||
91 | GNUNET_CRYPTO_rsa_key_get_public (pk, &pub); | ||
92 | GNUNET_CRYPTO_short_hash (&pub, sizeof (pub), &sh); | ||
93 | GNUNET_CRYPTO_short_hash_to_enc (&sh, &enc); | ||
94 | fprintf (stdout, "%s\n", enc.short_encoding); | ||
95 | } | ||
81 | GNUNET_CRYPTO_rsa_key_free (pk); | 96 | GNUNET_CRYPTO_rsa_key_free (pk); |
82 | } | 97 | } |
83 | 98 | ||
@@ -99,6 +114,9 @@ main (int argc, char *const *argv) | |||
99 | { 'P', "print-peer-identity", NULL, | 114 | { 'P', "print-peer-identity", NULL, |
100 | gettext_noop ("print the hash of the public key in ASCII format"), | 115 | gettext_noop ("print the hash of the public key in ASCII format"), |
101 | 0, &GNUNET_GETOPT_set_one, &print_peer_identity }, | 116 | 0, &GNUNET_GETOPT_set_one, &print_peer_identity }, |
117 | { 's', "print-short-identity", NULL, | ||
118 | gettext_noop ("print the short hash of the public key in ASCII format"), | ||
119 | 0, &GNUNET_GETOPT_set_one, &print_short_identity }, | ||
102 | GNUNET_GETOPT_OPTION_END | 120 | GNUNET_GETOPT_OPTION_END |
103 | }; | 121 | }; |
104 | return (GNUNET_OK == | 122 | return (GNUNET_OK == |
diff --git a/src/util/strings.c b/src/util/strings.c index 2ed1a0da3..40968956e 100644 --- a/src/util/strings.c +++ b/src/util/strings.c | |||
@@ -643,10 +643,10 @@ getValue__ (unsigned char a) | |||
643 | * @return pointer to the next byte in 'out' or NULL on error. | 643 | * @return pointer to the next byte in 'out' or NULL on error. |
644 | */ | 644 | */ |
645 | char * | 645 | char * |
646 | GNUNET_STRINGS_data_to_string (unsigned char *data, size_t size, char *out, size_t out_size) | 646 | GNUNET_STRINGS_data_to_string (const unsigned char *data, size_t size, char *out, size_t out_size) |
647 | { | 647 | { |
648 | /** | 648 | /** |
649 | * 32 characters for encoding (GNUNET_CRYPTO_hash => 32 characters) | 649 | * 32 characters for encoding |
650 | */ | 650 | */ |
651 | static char *encTable__ = "0123456789ABCDEFGHIJKLMNOPQRSTUV"; | 651 | static char *encTable__ = "0123456789ABCDEFGHIJKLMNOPQRSTUV"; |
652 | unsigned int wpos; | 652 | unsigned int wpos; |
@@ -656,7 +656,11 @@ GNUNET_STRINGS_data_to_string (unsigned char *data, size_t size, char *out, size | |||
656 | 656 | ||
657 | GNUNET_assert (data != NULL); | 657 | GNUNET_assert (data != NULL); |
658 | GNUNET_assert (out != NULL); | 658 | GNUNET_assert (out != NULL); |
659 | GNUNET_assert (out_size >= (((size*8) + ((size*8) % 5)) % 5)); | 659 | if (out_size < (((size*8) + ((size*8) % 5)) % 5)) |
660 | { | ||
661 | GNUNET_break (0); | ||
662 | return NULL; | ||
663 | } | ||
660 | vbit = 0; | 664 | vbit = 0; |
661 | wpos = 0; | 665 | wpos = 0; |
662 | rpos = 0; | 666 | rpos = 0; |
@@ -675,12 +679,18 @@ GNUNET_STRINGS_data_to_string (unsigned char *data, size_t size, char *out, size | |||
675 | vbit = 5; | 679 | vbit = 5; |
676 | } | 680 | } |
677 | if (wpos >= out_size) | 681 | if (wpos >= out_size) |
682 | { | ||
683 | GNUNET_break (0); | ||
678 | return NULL; | 684 | return NULL; |
685 | } | ||
679 | out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31]; | 686 | out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31]; |
680 | vbit -= 5; | 687 | vbit -= 5; |
681 | } | 688 | } |
682 | if (wpos != out_size) | 689 | if (wpos != out_size) |
690 | { | ||
691 | GNUNET_break (0); | ||
683 | return NULL; | 692 | return NULL; |
693 | } | ||
684 | GNUNET_assert (vbit == 0); | 694 | GNUNET_assert (vbit == 0); |
685 | return &out[wpos]; | 695 | return &out[wpos]; |
686 | } | 696 | } |
diff --git a/src/vpn/vpn.h b/src/vpn/vpn.h index e937f5ef5..bec3a5b59 100644 --- a/src/vpn/vpn.h +++ b/src/vpn/vpn.h | |||
@@ -115,7 +115,7 @@ struct RedirectToServiceRequestMessage | |||
115 | /** | 115 | /** |
116 | * Service descriptor identifying the service. | 116 | * Service descriptor identifying the service. |
117 | */ | 117 | */ |
118 | GNUNET_HashCode service_descriptor GNUNET_PACKED; | 118 | GNUNET_HashCode service_descriptor; |
119 | 119 | ||
120 | /** | 120 | /** |
121 | * Unique ID to match a future response to this request. | 121 | * Unique ID to match a future response to this request. |