| /* rhash.c - implementation of LibRHash library calls |
| * |
| * Copyright (c) 2008, Aleksey Kravchenko <rhash.admin@gmail.com> |
| * |
| * Permission to use, copy, modify, and/or distribute this software for any |
| * purpose with or without fee is hereby granted. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH |
| * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
| * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, |
| * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM |
| * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE |
| * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| * PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| /* modifier for Windows DLL */ |
| #if (defined(_WIN32) || defined(__CYGWIN__)) && defined(RHASH_EXPORTS) |
| # define RHASH_API __declspec(dllexport) |
| #endif |
| |
| /* macros for large file support, must be defined before any include file */ |
| #define _LARGEFILE_SOURCE |
| #define _LARGEFILE64_SOURCE |
| #define _FILE_OFFSET_BITS 64 |
| |
| #include "ustd.h" /* Need this first within CMake. */ |
| |
| #include "rhash.h" |
| #include "algorithms.h" |
| #include "byte_order.h" |
| #include "hex.h" |
| #include "util.h" |
| #include <assert.h> |
| #include <errno.h> |
| #include <stdlib.h> |
| #include <stddef.h> |
| #include <string.h> |
| |
| #define STATE_ACTIVE 0xb01dbabe |
| #define STATE_STOPPED 0xdeadbeef |
| #define STATE_DELETED 0xdecea5ed |
| #define IS_BAD_STATE(s) ((s) != STATE_ACTIVE && (s) != STATE_STOPPED) |
| #define RCTX_AUTO_FINAL 0x1 |
| #define RCTX_FINALIZED 0x2 |
| #define RCTX_FINALIZED_MASK (RCTX_AUTO_FINAL | RCTX_FINALIZED) |
| #define RHPR_FORMAT (RHPR_RAW | RHPR_HEX | RHPR_BASE32 | RHPR_BASE64) |
| #define RHPR_MODIFIER (RHPR_UPPERCASE | RHPR_URLENCODE | RHPR_REVERSE) |
| |
| #define HAS_ZERO_OR_ONE_BIT(id) (((id) & ((id) - 1)) == 0) |
| #define IS_VALID_HASH_MASK(bitmask) ((bitmask) != 0 && ((bitmask) & ~RHASH_ALL_HASHES) == 0) |
| #define IS_VALID_HASH_ID(id) (IS_VALID_HASH_MASK(id) && HAS_ZERO_OR_ONE_BIT(id)) |
| |
| /* each hash function context must be aligned to DEFAULT_ALIGNMENT bytes */ |
| #define GET_CTX_ALIGNED(size) ALIGN_SIZE_BY((size), DEFAULT_ALIGNMENT) |
| #define GET_EXPORT_ALIGNED(size) ALIGN_SIZE_BY((size), 8) |
| |
| RHASH_API void rhash_library_init(void) |
| { |
| rhash_init_algorithms(RHASH_ALL_HASHES); |
| #ifdef USE_OPENSSL |
| rhash_plug_openssl(); |
| #endif |
| } |
| |
| RHASH_API int rhash_count(void) |
| { |
| return rhash_info_size; |
| } |
| |
| /* LOW-LEVEL LIBRHASH INTERFACE */ |
| |
| /** |
| * Allocate and initialize RHash context for calculating a single or multiple hash functions. |
| * The context after usage must be freed by calling rhash_free(). |
| * |
| * @param count the size of the hash_ids array, the count must be greater than zero |
| * @param hash_ids array of identifiers of hash functions. Each element must |
| * be an identifier of one hash function |
| * @param need_init initialize context for each hash function |
| * @return initialized rhash context, NULL on fail with error code stored in errno |
| */ |
| static rhash_context_ext* rhash_alloc_multi(size_t count, const unsigned hash_ids[], int need_init) |
| { |
| struct rhash_hash_info* info; /* hash algorithm information */ |
| rhash_context_ext* rctx = NULL; /* allocated rhash context */ |
| const size_t header_size = GET_CTX_ALIGNED(sizeof(rhash_context_ext) + sizeof(rhash_vector_item) * count); |
| size_t ctx_size_sum = 0; /* size of hash contexts to store in rctx */ |
| size_t i; |
| char* phash_ctx; |
| unsigned hash_bitmask = 0; |
| |
| if (count < 1) { |
| errno = EINVAL; |
| return NULL; |
| } |
| for (i = 0; i < count; i++) { |
| unsigned hash_index; |
| if (!IS_VALID_HASH_ID(hash_ids[i])) { |
| errno = EINVAL; |
| return NULL; |
| } |
| hash_bitmask |= hash_ids[i]; |
| hash_index = rhash_ctz(hash_ids[i]); |
| assert(hash_index < RHASH_HASH_COUNT); /* correct until extended hash_ids are supported */ |
| info = &rhash_info_table[hash_index]; |
| |
| /* align context sizes and sum up */ |
| ctx_size_sum += GET_CTX_ALIGNED(info->context_size); |
| } |
| |
| /* allocate rhash context with enough memory to store contexts of all selected hash functions */ |
| rctx = (rhash_context_ext*)rhash_aligned_alloc(DEFAULT_ALIGNMENT, header_size + ctx_size_sum); |
| if (rctx == NULL) |
| return NULL; |
| |
| /* initialize common fields of the rhash context */ |
| memset(rctx, 0, header_size); |
| rctx->rc.hash_id = hash_bitmask; |
| rctx->flags = RCTX_AUTO_FINAL; /* turn on auto-final by default */ |
| rctx->state = STATE_ACTIVE; |
| rctx->hash_vector_size = count; |
| |
| /* calculate aligned pointer >= (&rctx->vector[count]) */ |
| phash_ctx = (char*)rctx + header_size; |
| assert(phash_ctx >= (char*)&rctx->vector[count]); |
| assert(phash_ctx < ((char*)&rctx->vector[count] + DEFAULT_ALIGNMENT)); |
| |
| for (i = 0; i < count; i++) { |
| unsigned hash_index = rhash_ctz(hash_ids[i]); |
| info = &rhash_info_table[hash_index]; |
| assert(info->context_size > 0); |
| assert(info->init != NULL); |
| assert(IS_PTR_ALIGNED_BY(phash_ctx, DEFAULT_ALIGNMENT)); /* hash context is aligned */ |
| |
| rctx->vector[i].hash_info = info; |
| rctx->vector[i].context = phash_ctx; |
| |
| #if 0 |
| /* BTIH initialization is a bit complicated, so store the context pointer for later usage */ |
| if ((hash_ids[i] & RHASH_BTIH) != 0) |
| rctx->bt_ctx = phash_ctx; |
| #endif |
| phash_ctx += GET_CTX_ALIGNED(info->context_size); |
| |
| /* initialize the i-th hash context */ |
| if (need_init) |
| info->init(rctx->vector[i].context); |
| } |
| return rctx; |
| } |
| |
| RHASH_API rhash rhash_init_multi(size_t count, const unsigned hash_ids[]) |
| { |
| rhash_context_ext* ectx = rhash_alloc_multi(count, hash_ids, 1); |
| return &ectx->rc; /* return initialized rhash context */ |
| } |
| |
| RHASH_API rhash rhash_init(unsigned hash_id) |
| { |
| if (!IS_VALID_HASH_MASK(hash_id)) { |
| errno = EINVAL; |
| return NULL; |
| } |
| if (HAS_ZERO_OR_ONE_BIT(hash_id)) { |
| return rhash_init_multi(1, &hash_id); |
| } else { |
| /* handle the depricated case, when hash_id is a bitwise union of several hash function identifiers */ |
| size_t count; |
| unsigned hash_ids[32]; |
| unsigned id = hash_id & -hash_id; /* get the trailing bit */ |
| for (count = 0; id <= hash_id; id = id << 1) { |
| assert(id != 0); |
| if (hash_id & id) |
| hash_ids[count++] = id; |
| } |
| assert(count > 1); |
| return rhash_init_multi(count, hash_ids); |
| } |
| } |
| |
| void rhash_free(rhash ctx) |
| { |
| rhash_context_ext* const ectx = (rhash_context_ext*)ctx; |
| unsigned i; |
| |
| if (ctx == 0) return; |
| ectx->state = STATE_DELETED; /* mark memory block as being removed */ |
| |
| /* clean the hash functions, which require additional clean up */ |
| for (i = 0; i < ectx->hash_vector_size; i++) { |
| struct rhash_hash_info* info = ectx->vector[i].hash_info; |
| if (info->cleanup != 0) { |
| info->cleanup(ectx->vector[i].context); |
| } |
| } |
| rhash_aligned_free(ectx); |
| } |
| |
| RHASH_API void rhash_reset(rhash ctx) |
| { |
| rhash_context_ext* const ectx = (rhash_context_ext*)ctx; |
| unsigned i; |
| |
| assert(ectx->hash_vector_size > 0); |
| assert(ectx->hash_vector_size <= RHASH_HASH_COUNT); |
| ectx->state = STATE_ACTIVE; /* re-activate the structure */ |
| |
| /* re-initialize every hash in a loop */ |
| for (i = 0; i < ectx->hash_vector_size; i++) { |
| struct rhash_hash_info* info = ectx->vector[i].hash_info; |
| if (info->cleanup != 0) { |
| info->cleanup(ectx->vector[i].context); |
| } |
| |
| assert(info->init != NULL); |
| info->init(ectx->vector[i].context); |
| } |
| ectx->flags &= ~RCTX_FINALIZED; /* clear finalized state */ |
| } |
| |
| RHASH_API int rhash_update(rhash ctx, const void* message, size_t length) |
| { |
| rhash_context_ext* const ectx = (rhash_context_ext*)ctx; |
| unsigned i; |
| |
| assert(ectx->hash_vector_size <= RHASH_HASH_COUNT); |
| if (ectx->state != STATE_ACTIVE) return 0; /* do nothing if canceled */ |
| |
| ctx->msg_size += length; |
| |
| /* call update method for every algorithm */ |
| for (i = 0; i < ectx->hash_vector_size; i++) { |
| struct rhash_hash_info* info = ectx->vector[i].hash_info; |
| assert(info->update != 0); |
| info->update(ectx->vector[i].context, message, length); |
| } |
| return 0; /* no error processing at the moment */ |
| } |
| |
| RHASH_API int rhash_final(rhash ctx, unsigned char* first_result) |
| { |
| unsigned i = 0; |
| unsigned char buffer[130]; |
| unsigned char* out = (first_result ? first_result : buffer); |
| rhash_context_ext* const ectx = (rhash_context_ext*)ctx; |
| assert(ectx->hash_vector_size <= RHASH_HASH_COUNT); |
| |
| /* skip final call if already finalized and auto-final is on */ |
| if ((ectx->flags & RCTX_FINALIZED_MASK) == |
| (RCTX_AUTO_FINAL | RCTX_FINALIZED)) return 0; |
| |
| /* call final method for every algorithm */ |
| for (i = 0; i < ectx->hash_vector_size; i++) { |
| struct rhash_hash_info* info = ectx->vector[i].hash_info; |
| assert(info->final != 0); |
| assert(info->info->digest_size < sizeof(buffer)); |
| info->final(ectx->vector[i].context, out); |
| out = buffer; |
| } |
| ectx->flags |= RCTX_FINALIZED; |
| return 0; /* no error processing at the moment */ |
| } |
| |
| /** |
| * Header block for rhash context import/export. |
| */ |
| typedef struct export_header |
| { |
| uint32_t state; |
| uint16_t hash_vector_size; |
| uint16_t flags; |
| uint64_t msg_size; |
| } export_header; |
| |
| /** |
| * Process export error. Returns 0 and set errno to EINVAL. |
| * |
| * @return NULL |
| */ |
| static size_t export_error_einval(void) |
| { |
| errno = EINVAL; |
| return 0; |
| } |
| |
| /** |
| * Process import error. Returns NULL and set errno to EINVAL. |
| * |
| * @return NULL |
| */ |
| static rhash import_error_einval(void) |
| { |
| errno = EINVAL; |
| return NULL; |
| } |
| |
| RHASH_API size_t rhash_export(rhash ctx, void* out, size_t size) |
| { |
| #if !defined(NO_IMPORT_EXPORT) |
| size_t export_size; |
| size_t i; |
| rhash_context_ext* const ectx = (rhash_context_ext*)ctx; |
| export_header* header = (export_header*)out; |
| unsigned* hash_ids = NULL; |
| if (!ctx || (out && size < sizeof(export_header)) || IS_BAD_STATE(ectx->state)) |
| return export_error_einval(); |
| export_size = sizeof(export_header) + sizeof(unsigned) * ectx->hash_vector_size; |
| if (out != NULL) { |
| memset(out, 0, size); |
| header->state = ectx->state; |
| header->hash_vector_size = (uint16_t)(ectx->hash_vector_size); |
| header->flags = (uint16_t)(ectx->flags); |
| header->msg_size = ctx->msg_size; |
| hash_ids = (unsigned*)(void*)(header + 1); |
| } |
| for (i = 0; i < ectx->hash_vector_size; i++) { |
| void* src_context = ectx->vector[i].context; |
| struct rhash_hash_info* hash_info = ectx->vector[i].hash_info; |
| unsigned is_special = (hash_info->info->flags & F_SPCEXP); |
| size_t item_size; |
| if (out != NULL) { |
| if (size <= export_size) |
| return export_error_einval(); |
| hash_ids[i] = hash_info->info->hash_id; |
| if (is_special) { |
| char* dst_item; |
| size_t left_size; |
| export_size = GET_EXPORT_ALIGNED(export_size); |
| dst_item = (char*)out + export_size; |
| left_size = size - export_size; |
| item_size = rhash_export_alg(hash_info->info->hash_id, |
| src_context, dst_item, left_size); |
| if (!item_size) |
| return export_error_einval(); |
| } else { |
| char* dst_item = (char*)out + export_size; |
| item_size = hash_info->context_size; |
| if (size < (export_size + item_size)) |
| return export_error_einval(); |
| memcpy(dst_item, src_context, item_size); |
| } |
| } else { |
| if (is_special) { |
| export_size = GET_EXPORT_ALIGNED(export_size); |
| item_size = rhash_export_alg( |
| hash_info->info->hash_id, src_context, NULL, 0); |
| } else |
| item_size = hash_info->context_size; |
| } |
| export_size += item_size; |
| } |
| if (export_size < size) |
| return export_error_einval(); |
| return export_size; |
| #else |
| return export_error_einval(); |
| #endif /* !defined(NO_IMPORT_EXPORT) */ |
| } |
| |
| RHASH_API rhash rhash_import(const void* in, size_t size) |
| { |
| #if !defined(NO_IMPORT_EXPORT) |
| const export_header* header = (const export_header*)in; |
| size_t i; |
| size_t imported_size; |
| const unsigned* hash_ids; |
| const char* src_item; |
| rhash_context_ext* ectx; |
| if (!header || IS_BAD_STATE(header->state) || size < sizeof(export_header)) |
| return import_error_einval(); |
| imported_size = sizeof(export_header) + sizeof(unsigned) * header->hash_vector_size; |
| if (!header->hash_vector_size || size < imported_size) |
| return import_error_einval(); |
| hash_ids = (const unsigned*)(const void*)(header + 1); |
| ectx = (rhash_context_ext*)rhash_alloc_multi(header->hash_vector_size, hash_ids, 0); |
| if (!ectx) |
| return NULL; /* errno must be set by the previous function */ |
| ectx->state = header->state; |
| ectx->hash_vector_size = header->hash_vector_size; |
| ectx->flags = header->flags; |
| ectx->rc.msg_size = header->msg_size; |
| for (i = 0; i < ectx->hash_vector_size; i++) { |
| void* dst_context = ectx->vector[i].context; |
| struct rhash_hash_info* hash_info = ectx->vector[i].hash_info; |
| unsigned is_special = (hash_info->info->flags & F_SPCEXP); |
| size_t item_size; |
| |
| if (is_special) { |
| size_t left_size; |
| imported_size = GET_EXPORT_ALIGNED(imported_size); |
| src_item = (const char*)in + imported_size; |
| left_size = size - imported_size; |
| assert(size >= imported_size); |
| item_size = rhash_import_alg(hash_ids[i], dst_context, src_item, left_size); |
| imported_size += item_size; |
| if (!item_size || size < imported_size) { |
| ectx->hash_vector_size = i + 1; /* clean only initialized contextes */ |
| rhash_free(&ectx->rc); |
| return import_error_einval(); |
| } |
| } else { |
| src_item = (const char*)in + imported_size; |
| item_size = hash_info->context_size; |
| imported_size += item_size; |
| if (size < imported_size) { |
| ectx->hash_vector_size = i + 1; |
| rhash_free(&ectx->rc); |
| return import_error_einval(); |
| } |
| memcpy(dst_context, src_item, item_size); |
| } |
| } |
| return &ectx->rc; |
| #else |
| return import_error_einval(); |
| #endif /* !defined(NO_IMPORT_EXPORT) */ |
| } |
| |
| /** |
| * Store digest for given hash_id. |
| * If hash_id is zero, function stores digest for a hash with the lowest id found in the context. |
| * For nonzero hash_id the context must contain it, otherwise function silently does nothing. |
| * |
| * @param ctx rhash context |
| * @param hash_id id of hash to retrieve or zero for hash with the lowest available id |
| * @param result buffer to put the hash into |
| */ |
| static void rhash_put_digest(rhash ctx, unsigned hash_id, unsigned char* result) |
| { |
| rhash_context_ext* const ectx = (rhash_context_ext*)ctx; |
| unsigned i; |
| rhash_vector_item* item; |
| struct rhash_hash_info* info; |
| unsigned char* digest; |
| |
| assert(ectx); |
| assert(ectx->hash_vector_size > 0 && ectx->hash_vector_size <= RHASH_HASH_COUNT); |
| |
| /* finalize context if not yet finalized and auto-final is on */ |
| if ((ectx->flags & RCTX_FINALIZED_MASK) == RCTX_AUTO_FINAL) { |
| rhash_final(ctx, NULL); |
| } |
| |
| if (hash_id == 0) { |
| item = &ectx->vector[0]; /* get the first hash */ |
| info = item->hash_info; |
| } else { |
| for (i = 0;; i++) { |
| if (i >= ectx->hash_vector_size) { |
| return; /* hash_id not found, do nothing */ |
| } |
| item = &ectx->vector[i]; |
| info = item->hash_info; |
| if (info->info->hash_id == hash_id) break; |
| } |
| } |
| digest = ((unsigned char*)item->context + info->digest_diff); |
| if (info->info->flags & F_SWAP32) { |
| assert((info->info->digest_size & 3) == 0); |
| /* NB: the next call is correct only for multiple of 4 byte size */ |
| rhash_swap_copy_str_to_u32(result, 0, digest, info->info->digest_size); |
| } else if (info->info->flags & F_SWAP64) { |
| rhash_swap_copy_u64_to_str(result, digest, info->info->digest_size); |
| } else { |
| memcpy(result, digest, info->info->digest_size); |
| } |
| } |
| |
| RHASH_API void rhash_set_callback(rhash ctx, rhash_callback_t callback, void* callback_data) |
| { |
| ((rhash_context_ext*)ctx)->callback = callback; |
| ((rhash_context_ext*)ctx)->callback_data = callback_data; |
| } |
| |
| /* HIGH-LEVEL LIBRHASH INTERFACE */ |
| |
| RHASH_API int rhash_msg(unsigned hash_id, const void* message, size_t length, unsigned char* result) |
| { |
| rhash ctx; |
| hash_id &= RHASH_ALL_HASHES; |
| ctx = rhash_init(hash_id); |
| if (ctx == NULL) return -1; |
| rhash_update(ctx, message, length); |
| rhash_final(ctx, result); |
| rhash_free(ctx); |
| return 0; |
| } |
| |
| RHASH_API int rhash_file_update(rhash ctx, FILE* fd) |
| { |
| rhash_context_ext* const ectx = (rhash_context_ext*)ctx; |
| const size_t block_size = 8192; |
| unsigned char* buffer; |
| size_t length = 0; |
| int res = 0; |
| if (ectx->state != STATE_ACTIVE) |
| return 0; /* do nothing if canceled */ |
| if (ctx == NULL) { |
| errno = EINVAL; |
| return -1; |
| } |
| buffer = (unsigned char*)rhash_aligned_alloc(DEFAULT_ALIGNMENT, block_size); |
| if (!buffer) |
| return -1; /* errno is set to ENOMEM according to UNIX 98 */ |
| |
| while (!feof(fd)) { |
| if (ectx->state != STATE_ACTIVE) |
| break; /* stop if canceled */ |
| length = fread(buffer, 1, block_size, fd); |
| |
| if (ferror(fd)) { |
| res = -1; /* note: errno contains error code */ |
| break; |
| } else if (length) { |
| rhash_update(ctx, buffer, length); |
| |
| if (ectx->callback) { |
| ((rhash_callback_t)ectx->callback)(ectx->callback_data, ectx->rc.msg_size); |
| } |
| } |
| } |
| rhash_aligned_free(buffer); |
| return res; |
| } |
| |
| #ifdef _WIN32 |
| # define FOPEN_MODE "rbS" |
| #else |
| # define FOPEN_MODE "rb" |
| #endif |
| |
| RHASH_API int rhash_file(unsigned hash_id, const char* filepath, unsigned char* result) |
| { |
| FILE* fd; |
| rhash ctx; |
| int res; |
| |
| hash_id &= RHASH_ALL_HASHES; |
| if (hash_id == 0) { |
| errno = EINVAL; |
| return -1; |
| } |
| |
| fd = fopen(filepath, FOPEN_MODE); |
| if (!fd) |
| return -1; |
| |
| ctx = rhash_init(hash_id); |
| if (!ctx) { |
| fclose(fd); |
| return -1; |
| } |
| res = rhash_file_update(ctx, fd); /* hash the file */ |
| fclose(fd); |
| if (res >= 0) |
| rhash_final(ctx, result); |
| rhash_free(ctx); |
| return res; |
| } |
| |
| #ifdef _WIN32 /* windows only function */ |
| #include <share.h> |
| |
| RHASH_API int rhash_wfile(unsigned hash_id, const wchar_t* filepath, unsigned char* result) |
| { |
| FILE* fd; |
| rhash ctx; |
| int res; |
| |
| hash_id &= RHASH_ALL_HASHES; |
| if (hash_id == 0) { |
| errno = EINVAL; |
| return -1; |
| } |
| |
| fd = _wfsopen(filepath, L"rbS", _SH_DENYWR); |
| if (!fd) |
| return -1; |
| |
| ctx = rhash_init(hash_id); |
| if (!ctx) { |
| fclose(fd); |
| return -1; |
| } |
| res = rhash_file_update(ctx, fd); /* hash the file */ |
| fclose(fd); |
| if (res >= 0) |
| rhash_final(ctx, result); |
| rhash_free(ctx); |
| return res; |
| } |
| #endif |
| |
| /* RHash information functions */ |
| |
| #if 0 |
| RHASH_API int rhash_is_base32(unsigned hash_id) |
| { |
| /* fast method is just to test a bit-mask */ |
| return ((hash_id & (RHASH_TTH | RHASH_AICH)) != 0); |
| } |
| #endif |
| |
| RHASH_API int rhash_get_digest_size(unsigned hash_id) |
| { |
| hash_id &= RHASH_ALL_HASHES; |
| if (hash_id == 0 || (hash_id & (hash_id - 1)) != 0) return -1; |
| return (int)rhash_info_table[rhash_ctz(hash_id)].info->digest_size; |
| } |
| |
| RHASH_API int rhash_get_hash_length(unsigned hash_id) |
| { |
| const rhash_info* info = rhash_info_by_id(hash_id); |
| return (int)(info ? (info->flags & F_BS32 ? |
| BASE32_LENGTH(info->digest_size) : info->digest_size * 2) : 0); |
| } |
| |
| RHASH_API const char* rhash_get_name(unsigned hash_id) |
| { |
| const rhash_info* info = rhash_info_by_id(hash_id); |
| return (info ? info->name : 0); |
| } |
| |
| RHASH_API const char* rhash_get_magnet_name(unsigned hash_id) |
| { |
| const rhash_info* info = rhash_info_by_id(hash_id); |
| return (info ? info->magnet_name : 0); |
| } |
| |
| #if 0 |
| static size_t rhash_get_magnet_url_size(const char* filepath, |
| rhash context, unsigned hash_mask, int flags) |
| { |
| size_t size = 0; /* count terminating '\0' */ |
| unsigned bit, hash = context->hash_id & hash_mask; |
| |
| /* RHPR_NO_MAGNET, RHPR_FILESIZE */ |
| if ((flags & RHPR_NO_MAGNET) == 0) { |
| size += 8; |
| } |
| |
| if ((flags & RHPR_FILESIZE) != 0) { |
| uint64_t num = context->msg_size; |
| |
| size += 4; |
| if (num == 0) size++; |
| else { |
| for (; num; num /= 10, size++); |
| } |
| } |
| |
| if (filepath) { |
| size += 4 + rhash_urlencode(NULL, filepath, strlen(filepath), 0); |
| } |
| |
| /* loop through hash values */ |
| for (bit = hash & -(int)hash; bit <= hash; bit <<= 1) { |
| const char* name; |
| if ((bit & hash) == 0) continue; |
| if ((name = rhash_get_magnet_name(bit)) == 0) continue; |
| |
| size += (7 + 2) + strlen(name); |
| size += rhash_print(NULL, context, bit, |
| (bit & RHASH_SHA1 ? RHPR_BASE32 : 0)); |
| } |
| |
| return size; |
| } |
| |
| RHASH_API size_t rhash_print_magnet(char* output, const char* filepath, |
| rhash context, unsigned hash_mask, int flags) |
| { |
| int i; |
| const char* begin = output; |
| |
| if (output == NULL) |
| return rhash_get_magnet_url_size(filepath, context, hash_mask, flags); |
| |
| /* RHPR_NO_MAGNET, RHPR_FILESIZE */ |
| if ((flags & RHPR_NO_MAGNET) == 0) { |
| strcpy(output, "magnet:?"); |
| output += 8; |
| } |
| |
| if ((flags & RHPR_FILESIZE) != 0) { |
| strcpy(output, "xl="); |
| output += 3; |
| output += rhash_sprintI64(output, context->msg_size); |
| *(output++) = '&'; |
| } |
| |
| flags &= RHPR_UPPERCASE; |
| if (filepath) { |
| strcpy(output, "dn="); |
| output += 3; |
| output += rhash_urlencode(output, filepath, strlen(filepath), flags); |
| *(output++) = '&'; |
| } |
| |
| for (i = 0; i < 2; i++) { |
| unsigned bit; |
| unsigned hash = context->hash_id & hash_mask; |
| hash = (i == 0 ? hash & (RHASH_ED2K | RHASH_AICH) |
| : hash & ~(RHASH_ED2K | RHASH_AICH)); |
| if (!hash) continue; |
| |
| /* loop through hash values */ |
| for (bit = hash & -(int)hash; bit <= hash; bit <<= 1) { |
| const char* name; |
| if ((bit & hash) == 0) continue; |
| if (!(name = rhash_get_magnet_name(bit))) continue; |
| |
| strcpy(output, "xt=urn:"); |
| output += 7; |
| strcpy(output, name); |
| output += strlen(name); |
| *(output++) = ':'; |
| output += rhash_print(output, context, bit, |
| (bit & RHASH_SHA1 ? flags | RHPR_BASE32 : flags)); |
| *(output++) = '&'; |
| } |
| } |
| output[-1] = '\0'; /* terminate the line */ |
| |
| return (output - begin); |
| } |
| |
| |
| /* HASH SUM OUTPUT INTERFACE */ |
| |
| size_t rhash_print_bytes(char* output, const unsigned char* bytes, size_t size, int flags) |
| { |
| size_t result_length; |
| int upper_case = (flags & RHPR_UPPERCASE); |
| int format = (flags & ~RHPR_MODIFIER); |
| |
| switch (format) { |
| case RHPR_HEX: |
| result_length = size * 2; |
| rhash_byte_to_hex(output, bytes, size, upper_case); |
| break; |
| case RHPR_BASE32: |
| result_length = BASE32_LENGTH(size); |
| rhash_byte_to_base32(output, bytes, size, upper_case); |
| break; |
| case RHPR_BASE64: |
| result_length = rhash_base64_url_encoded_helper(output, bytes, size, (flags & RHPR_URLENCODE), upper_case); |
| break; |
| default: |
| if (flags & RHPR_URLENCODE) { |
| result_length = rhash_urlencode(output, (char*)bytes, size, upper_case); |
| } else { |
| memcpy(output, bytes, size); |
| result_length = size; |
| } |
| break; |
| } |
| return result_length; |
| } |
| |
| RHASH_API size_t rhash_print(char* output, rhash context, unsigned hash_id, int flags) |
| { |
| const rhash_info* info; |
| unsigned char digest[80]; |
| size_t digest_size; |
| |
| info = (hash_id != 0 ? rhash_info_by_id(hash_id) : |
| ((rhash_context_ext*)context)->vector[0].hash_info->info); |
| |
| if (info == NULL) return 0; |
| digest_size = info->digest_size; |
| assert(digest_size <= 64); |
| |
| flags &= (RHPR_FORMAT | RHPR_MODIFIER); |
| if ((flags & RHPR_FORMAT) == 0) { |
| /* use default format if not specified by flags */ |
| flags |= (info->flags & RHASH_INFO_BASE32 ? RHPR_BASE32 : RHPR_HEX); |
| } |
| |
| if (output == NULL) { |
| size_t multiplier = (flags & RHPR_URLENCODE ? 3 : 1); |
| switch (flags & RHPR_FORMAT) { |
| case RHPR_HEX: |
| return (digest_size * 2); |
| case RHPR_BASE32: |
| return BASE32_LENGTH(digest_size); |
| case RHPR_BASE64: |
| return BASE64_LENGTH(digest_size) * multiplier; |
| default: |
| return digest_size * multiplier; |
| } |
| } |
| |
| /* note: use info->hash_id, cause hash_id can be 0 */ |
| rhash_put_digest(context, info->hash_id, digest); |
| |
| if ((flags & ~RHPR_UPPERCASE) == (RHPR_REVERSE | RHPR_HEX)) { |
| /* reverse the digest */ |
| unsigned char* p = digest; |
| unsigned char* r = digest + digest_size - 1; |
| char tmp; |
| for (; p < r; p++, r--) { |
| tmp = *p; |
| *p = *r; |
| *r = tmp; |
| } |
| } |
| |
| return rhash_print_bytes(output, digest, digest_size, flags); |
| } |
| |
| #if (defined(_WIN32) || defined(__CYGWIN__)) && defined(RHASH_EXPORTS) |
| #include <windows.h> |
| BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID reserved); |
| BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID reserved) |
| { |
| (void)hModule; |
| (void)reserved; |
| switch (reason) { |
| case DLL_PROCESS_ATTACH: |
| rhash_library_init(); |
| break; |
| case DLL_PROCESS_DETACH: |
| /*rhash_library_free();*/ |
| case DLL_THREAD_ATTACH: |
| case DLL_THREAD_DETACH: |
| break; |
| } |
| return TRUE; |
| } |
| #endif |
| |
| #define PVOID2UPTR(p) ((rhash_uptr_t)(((char*)(p)) + 0)) |
| |
| RHASH_API rhash_uptr_t rhash_transmit(unsigned msg_id, void* dst, rhash_uptr_t ldata, rhash_uptr_t rdata) |
| { |
| /* for messages working with rhash context */ |
| rhash_context_ext* const ctx = (rhash_context_ext*)dst; |
| (void)rdata; |
| |
| switch (msg_id) { |
| case RMSG_GET_CONTEXT: |
| { |
| unsigned i; |
| for (i = 0; i < ctx->hash_vector_size; i++) { |
| struct rhash_hash_info* info = ctx->vector[i].hash_info; |
| if (info->info->hash_id == (unsigned)ldata) |
| return PVOID2UPTR(ctx->vector[i].context); |
| } |
| return (rhash_uptr_t)0; |
| } |
| |
| case RMSG_CANCEL: |
| /* mark rhash context as canceled, in a multithreaded program */ |
| atomic_compare_and_swap(&ctx->state, STATE_ACTIVE, STATE_STOPPED); |
| return 0; |
| |
| case RMSG_IS_CANCELED: |
| return (ctx->state == STATE_STOPPED); |
| |
| case RMSG_GET_FINALIZED: |
| return ((ctx->flags & RCTX_FINALIZED) != 0); |
| case RMSG_SET_AUTOFINAL: |
| ctx->flags &= ~RCTX_AUTO_FINAL; |
| if (ldata) ctx->flags |= RCTX_AUTO_FINAL; |
| break; |
| |
| /* OpenSSL related messages */ |
| #ifdef USE_OPENSSL |
| case RMSG_SET_OPENSSL_MASK: |
| rhash_openssl_hash_mask = (unsigned)ldata; |
| break; |
| case RMSG_GET_OPENSSL_MASK: |
| return rhash_openssl_hash_mask; |
| #endif |
| case RMSG_GET_OPENSSL_SUPPORTED_MASK: |
| return rhash_get_openssl_supported_hash_mask(); |
| case RMSG_GET_OPENSSL_AVAILABLE_MASK: |
| return rhash_get_openssl_available_hash_mask(); |
| |
| case RMSG_GET_LIBRHASH_VERSION: |
| return RHASH_XVERSION; |
| |
| default: |
| return RHASH_ERROR; /* unknown message */ |
| } |
| return 0; |
| } |
| #endif |