Hasher::hashStatus_t Hasher::hash(const string& filename, string& hash) {
unsigned rhashType;
switch( p_hashType ) {
case tth: rhashType = RHASH_TTH; break;
case md5: rhashType = RHASH_MD5; break;
case sha1: rhashType = RHASH_SHA1; break;
default:
LOG(logError) << "Hasher called with no hash algorithm selected";
return noHashSelected;
}
unsigned char digest[64];
int res = rhash_file(rhashType, filename.c_str(), digest);
if( res < 0 ) {
LOG(logError) << "LibRHash error: " << strerror(errno);
return hashError;
}
char output[130];
size_t length = 0;
if( p_hashType == tth )
length = rhash_print_bytes(output, digest, rhash_get_digest_size(rhashType), RHPR_BASE32);
else
length = rhash_print_bytes(output, digest, rhash_get_digest_size(rhashType), RHPR_HEX);
hash = string(output, length);
LOG(logDetailed) << "Calculated " << rhash_get_name(rhashType) << " hash of file " << filename << ": " << hash;
return hashSuccess;
}
/**
* Verify that calculated hash doesn't depend on message alignment.
*/
static void test_alignment(void)
{
int i, start, hash_id, alignment_size;
/* loop by sums */
for(i = 0, hash_id = 1; (hash_id & RHASH_ALL_HASHES); hash_id <<= 1, i++) {
char expected_hash[130];
assert(rhash_get_digest_size(hash_id) < (int)sizeof(expected_hash));
alignment_size = (hash_id & (RHASH_TTH | RHASH_TIGER | RHASH_WHIRLPOOL | RHASH_SHA512) ? 8 : 4);
/* start message with different alignment */
for(start = 0; start < alignment_size; start++) {
char message[30];
int j, msg_length = 11 + alignment_size;
/* fill the buffer fifth shifted letter sequence */
for(j = 0; j < msg_length; j++) message[start + j] = 'a' + j;
message[start + j] = 0;
if(start == 0) {
/* save original hash value */
strcpy(expected_hash, hash_message(hash_id, message + start, 0));
} else {
/* verify obtained hash value */
assert_hash(hash_id, message + start, expected_hash, 0);
}
}
}
}
/**
* Verify for all algorithms, that rhash_final() returns the same result as
* rhash_print().
*/
static void test_results_consistency(void)
{
const char * msg = "a";
size_t msg_size = strlen(msg);
size_t digest_size;
struct rhash_context *ctx;
unsigned char res1[70];
char res2[70];
unsigned i, hash_id;
for(i = 0, hash_id = 1; (hash_id & RHASH_ALL_HASHES); hash_id <<= 1, i++) {
digest_size = rhash_get_digest_size(hash_id);
assert(digest_size < 70);
ctx = rhash_init(hash_id);
#ifdef USE_BTIH_WITH_TEST_FILENAME
if((hash_id & RHASH_BTIH) != 0) {
unsigned long long total_size = msg_size;
rhash_transmit(RMSG_BT_ADD_FILE, ctx, RHASH_STR2UPTR("test.txt"), (rhash_uptr_t)&total_size);
}
#endif
rhash_update(ctx, msg, msg_size);
rhash_final(ctx, res1);
rhash_print(res2, ctx, hash_id, RHPR_RAW);
rhash_free(ctx);
if(memcmp(res1, res2, digest_size) != 0) {
log_message("failed: inconsistent %s(\"%s\") hash results\n", rhash_get_name(hash_id), msg);
}
}
}
/*
* Class: org_sf_rhash_Bindings
* Method: rhash_print
* Signature: (JI)J
*/
JNIEXPORT jlong JNICALL Java_org_sf_rhash_Bindings_rhash_1print
(JNIEnv *env, jclass clz, jlong context, jint hash_id) {
Digest obj = malloc(sizeof(DigestStruct));
obj->hash_len = rhash_get_digest_size(hash_id);
obj->hash_data = calloc(obj->hash_len, sizeof(unsigned char));
rhash_print((char*)obj->hash_data, TO_RHASH(context), hash_id, RHPR_RAW);
return TO_JLONG(obj);
}
/**
* Print verbose error on hash sums mismatch.
*
* @param info file information with path and its hash sums.
*/
static void print_verbose_error(struct file_info *info)
{
char actual[130], expected[130];
assert(HC_FAILED(info->hc.flags));
rsh_fprintf(rhash_data.out, _("ERROR"));
if (HC_WRONG_FILESIZE & info->hc.flags) {
sprintI64(actual, info->rctx->msg_size, 0);
sprintI64(expected, info->hc.file_size, 0);
rsh_fprintf(rhash_data.out, _(", size is %s should be %s"), actual, expected);
}
if (HC_WRONG_EMBCRC32 & info->hc.flags) {
rhash_print(expected, info->rctx, RHASH_CRC32, RHPR_UPPERCASE);
rsh_fprintf(rhash_data.out, _(", embedded CRC32 should be %s"), expected);
}
if (HC_WRONG_HASHES & info->hc.flags) {
int i;
unsigned reported = 0;
for (i = 0; i < info->hc.hashes_num; i++) {
hash_value *hv = &info->hc.hashes[i];
char *expected_hash = info->hc.data + hv->offset;
unsigned hid = hv->hash_id;
int pflags;
if ((info->hc.wrong_hashes & (1 << i)) == 0) continue;
assert(hid != 0);
/* if can't detect precise hash */
if ((hid & (hid - 1)) != 0) {
/* guess the hash id */
if (hid & opt.sum_flags) hid &= opt.sum_flags;
if (hid & ~info->hc.found_hash_ids) hid &= ~info->hc.found_hash_ids;
if (hid & ~reported) hid &= ~reported; /* avoiding repeating */
if (hid & REPORT_FIRST_MASK) hid &= REPORT_FIRST_MASK;
hid &= -(int)hid; /* take the lowest bit */
}
assert(hid != 0 && (hid & (hid - 1)) == 0); /* single bit only */
reported |= hid;
pflags = (hv->length == (rhash_get_digest_size(hid) * 2) ?
(RHPR_HEX | RHPR_UPPERCASE) : (RHPR_BASE32 | RHPR_UPPERCASE));
rhash_print(actual, info->rctx, hid, pflags);
rsh_fprintf(rhash_data.out, _(", %s is %s should be %s"),
rhash_get_name(hid), actual, expected_hash);
}
}
rsh_fprintf(rhash_data.out, "\n");
}
/*
* Class: org_sf_rhash_Bindings
* Method: rhash_msg
* Signature: (I[BII)J
*/
JNIEXPORT jlong JNICALL Java_org_sf_rhash_Bindings_rhash_1msg
(JNIEnv *env, jclass clz, jint hash_id, jbyteArray buf, jint ofs, jint len) {
// reading data
void* msg = malloc(len);
(*env)->GetByteArrayRegion(env, buf, ofs, len, msg);
// creating and populating Digest
Digest obj = malloc(sizeof(DigestStruct));
obj->hash_len = rhash_get_digest_size(hash_id);
obj->hash_data = calloc(obj->hash_len, sizeof(unsigned char));
rhash_msg(hash_id, msg, len, obj->hash_data);
//cleaning
free(msg);
//returning
return TO_JLONG(obj);
}
/*
* Class: org_sf_rhash_Bindings
* Method: rhash_get_digest_size
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_org_sf_rhash_Bindings_rhash_1get_1digest_1size
(JNIEnv *env, jclass clz, jint hash_id) {
return rhash_get_digest_size(hash_id);
}
