_ed2k.c

filter: Statementstmt 53.5% 15 / 28 Branchbran 25.0% 4 / 16 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 43.1% 19 / 44 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« _tth.c ↑ Summary _rhash.c »
1 /* ed2k.c - an implementation of EDonkey 2000 Hash Algorithm.
2 *
3 * Copyright (c) 2006, Aleksey Kravchenko <rhash.admin@gmail.com>
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
9 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
10 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
11 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
12 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
13 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
14 * PERFORMANCE OF THIS SOFTWARE.
15 *
16 * This file implements eMule-compatible version of algorithm.
17 * Note that eDonkey and eMule ed2k hashes are different only for
18 * files containing exactly multiple of 9728000 bytes.
19 *
20 * The file data is divided into full chunks of 9500 KiB (9728000 bytes) plus
21 * a remainder chunk, and a separate 128-bit MD4 hash is computed for each.
22 * If the file length is an exact multiple of 9500 KiB, the remainder zero
23 * size chunk is still used at the end of the hash list. The ed2k hash is
24 * computed by concatenating the chunks' MD4 hashes in order and hashing the
25 * result using MD4. Although, if the file is composed of a single non-full
26 * chunk, its MD4 hash is returned with no further modifications.
27 *
28 * See http://en.wikipedia.org/wiki/EDonkey_network for algorithm description.
29 */
30  
31 #include <string.h>
32 #include "ed2k.h"
33  
34 /* each hashed file is divided into 9500 KiB sized chunks */
35 #define ED2K_CHUNK_SIZE 9728000
36  
37 /**
38 * Initialize context before calculating hash.
39 *
40 * @param ctx context to initialize
41 */
42 2 void rhash_ed2k_init(ed2k_ctx* ctx)
43 {
44 2 rhash_md4_init(&ctx->md4_context);
45 2 rhash_md4_init(&ctx->md4_context_inner);
46 2 ctx->not_emule = 0;
47 2 }
48  
49 /**
50 * Calculate message hash.
51 * Can be called repeatedly with chunks of the message to be hashed.
52 *
53 * @param ctx the algorithm context containing current hashing state
54 * @param msg message chunk
55 * @param size length of the message chunk
56 */
57 2 void rhash_ed2k_update(ed2k_ctx* ctx, const unsigned char* msg, size_t size)
58 {
59 unsigned char chunk_md4_hash[16];
60 2 unsigned blockleft = ED2K_CHUNK_SIZE - (unsigned)ctx->md4_context_inner.length;
61  
62 /* note: eMule-compatible algorithm hashes by md4_inner
63 * the messages which sizes are multiple of 9728000
64 * and then processes obtained hash by external md4 */
65  
66 2 ▶ while ( size >= blockleft )
Branch: 1 branch
BranchTrueFalseTotal
while ( size >= blockleft ) 0 2 2
67 {
68 0 ▶ if (size == blockleft && ctx->not_emule) break;
Branch: 2 branches
BranchTrueFalseTotal
if (size == blockleft && ctx->not_emule) break; 0 0 0
if (size == blockleft && ctx->not_emule) break; 0 0 0
69  
70 /* if internal ed2k chunk is full, then finalize it */
71 0 rhash_md4_update(&ctx->md4_context_inner, msg, blockleft);
72 0 msg += blockleft;
73 0 size -= blockleft;
74 0 blockleft = ED2K_CHUNK_SIZE;
75  
76 /* just finished an ed2k chunk, updating md4_external context */
77 0 rhash_md4_final(&ctx->md4_context_inner, chunk_md4_hash);
78 0 rhash_md4_update(&ctx->md4_context, chunk_md4_hash, 16);
79 0 rhash_md4_init(&ctx->md4_context_inner);
80 }
81  
82 2 ▶ if (size) {
Branch: 1 branch
BranchTrueFalseTotal
if (size) { 2 0 2
83 /* hash leftovers */
84 2 rhash_md4_update(&ctx->md4_context_inner, msg, size);
85 }
86 2 }
87  
88 /**
89 * Store calculated hash into the given array.
90 *
91 * @param ctx the algorithm context containing current hashing state
92 * @param result calculated hash in binary form
93 */
94 2 void rhash_ed2k_final(ed2k_ctx* ctx, unsigned char result[16])
95 {
96 /* check if hashed message size is greater or equal to ED2K_CHUNK_SIZE */
97 2 ▶ if ( ctx->md4_context.length ) {
Branch: 1 branch
BranchTrueFalseTotal
if ( ctx->md4_context.length ) { 0 2 2
98  
99 /* note: weird eMule algorithm always processes the inner
100 * md4 context, no matter if it contains data or is empty */
101  
102 /* if any data are left in the md4_context_inner */
103 0 ▶ if ( (size_t)ctx->md4_context_inner.length > 0 || !ctx->not_emule)
Branch: 2 branches
BranchTrueFalseTotal
if ( (size_t)ctx->md4_context_inner.length > 0 || !ctx->not_emule) 0 0 0
if ( (size_t)ctx->md4_context_inner.length > 0 || !ctx->not_emule) 0 0 0
104 {
105 /* emule algorithm processes aditional block, even if it's empty */
106 unsigned char md4_digest_inner[16];
107 0 rhash_md4_final(&ctx->md4_context_inner, md4_digest_inner);
108 0 rhash_md4_update(&ctx->md4_context, md4_digest_inner, 16);
109 }
110 /* first call final to flush md4 buffer and finalize the hash value */
111 0 rhash_md4_final(&ctx->md4_context, result);
112 /* store the calculated ed2k hash in the md4_context_inner.hash */
113 0 memcpy(&ctx->md4_context_inner.hash, &ctx->md4_context.hash, md4_hash_size);
114 } else {
115 /* return just the message MD4 hash */
116 2 ▶ if (result) rhash_md4_final(&ctx->md4_context_inner, result);
Branch: 1 branch
BranchTrueFalseTotal
if (result) rhash_md4_final(&ctx->md4_context_inner, result); 2 0 2
117 }
118 2 }
« _tth.c ↑ Summary _rhash.c »