uint64_t mix_hashed_nums(uint8_t *hashed_nums, const uint8_t *unhashedData, size_t unhashed_sz,
uint8_t **mixed_hash, uint8_t *hash_digest)
{
uint32_t i, index = 0;
const uint32_t hashed_nums_len = SHA256_LEN;
uint64_t count;
uint8_t tmp_val, tmp_array[SHA256_LEN + 2];
//initialize the class for the extend hash
Extend_Array new_hash;
Extend_Array_init(&new_hash);
//set the first hash length in the temp array to all 0xff
memset(tmp_array, 0xff, SHA256_LEN);
//set the last two bytes to \000
*(tmp_array + SHA256_LEN) = *(tmp_array + SHA256_LEN + 1) = 0;
for(count = 0;; count++)
{
//+1 to keeps a 0 value of *(hashed_nums + index) moving on
i = hex_char_to_int(*(hashed_nums + index)) + 1;
index += i;
//if we hit the end of the hash, rehash it
if(index >= hashed_nums_len)
{
index = index % hashed_nums_len;
sha256_to_str(hashed_nums, hashed_nums_len, hashed_nums, hash_digest); //rescramble
}
tmp_val = *(hashed_nums + index);
join_to_array(tmp_array, tmp_val); //plop tmp_val at the end of tmp_array
sha256_to_str(tmp_array, SHA256_LEN + 1, tmp_array, hash_digest);
//extend the expanded hash to the array
extend_array(&new_hash, count * SHA256_LEN, tmp_array, SHA256_LEN, false);
//check if the last value of hashed_nums is the same as the last value in tmp_array
if(index == hashed_nums_len - 1)
if(tmp_val == *(tmp_array + SHA256_LEN - 1))
{
//add to count since we extended the array, but break will exit the for loop and count
// will not get incremenented by the for loop
count++;
break;
}
}
//extend the unhashed data to the end and add the \000 to the end
extend_array(&new_hash, count * SHA256_LEN, (unsigned char*)unhashedData, unhashed_sz, true);
//assign the address of new_hash's array to mixed_hash
*mixed_hash = new_hash.array;
return count * SHA256_LEN + unhashed_sz;
}
bool dcrypt(const uint8_t *data, size_t data_sz, uint8_t *hash_digest, u32int *hashRet, int num_iter)
{
uint8_t hashed_nums[SHA256_LEN + 1], *mix_hash;
bool allocDigest = false;
bool completed = false;
if(!hash_digest)
{
hash_digest = alloca(DCRYPT_DIGEST_LENGTH);
allocDigest = true;
}
sha256_to_str(data, data_sz, hashed_nums, hash_digest);
//mix the hashes up, magority of the time takes here
uint64 mix_hash_len = mix_hashed_nums(hashed_nums, data, data_sz, &mix_hash, hash_digest, num_iter, &completed);
//apply the final hash to the output
if (completed) sha256((const uint8_t*)mix_hash, mix_hash_len, hashRet);
free(mix_hash);
//sucess
return completed;
}
void dcrypt(const uint8_t *data, size_t data_sz, uint8_t *hash_digest, uint32_t *hashRet)
{
uint8_t hashed_nums[SHA256_LEN + 1], *mix_hash;
bool allocDigest = false;
if(!hash_digest)
{
hash_digest = (uint8_t*)malloc(DCRYPT_DIGEST_LENGTH);
allocDigest = true;
}
sha256_to_str(data, data_sz, hashed_nums, hash_digest);
//mix the hashes up, magority of the time takes here
uint64_t mix_hash_len = mix_hashed_nums(hashed_nums, data, data_sz, &mix_hash, hash_digest);
//apply the final hash to the output
sha256((const uint8_t*)mix_hash, mix_hash_len, hashRet);
free(mix_hash);
if(allocDigest)
free(hash_digest);
//sucess
return;
}
bool dcrypt_fast(u8int *data, size_t data_sz,uint32_t*md)
{
#define MAX_INC 16
unsigned char hash_buffer[SHA256_LEN*MAX_INC+SHA256_LEN*4+80+1];
unsigned char index_buffer[SHA256_LEN+1];
unsigned char *tmp_array = hash_buffer;
unsigned int index = 0;
unsigned char tmp_val;
SHA256_CTX hash;
SHA256_Init(&hash);
digest_to_skiplist((u8int *)md,index_buffer);
int steps = 0,index_test=index;
while(1)
{
index_test += index_buffer[index_test]+1;
if(index_test >= SHA256_LEN) return 0;
if(index_test == SHA256_LEN - 1) break;
steps++;
}
if(steps >= MAX_INC) return 0;/**/
memset(tmp_array, 0xff, SHA256_LEN); //set the first hash length in the temp array to all 0xff'
memset(tmp_array + SHA256_LEN, 0x00, 2); //set the last bytes to \000
int count = 0;
if(tmp_array_1 && hash_1) // copy pre-calulated internal hashes
{
index += index_buffer[index]+1;
unsigned int offset_1 = index_buffer[index];
if(tmp_array_2 && hash_2) // depth 2
{
index += index_buffer[index]+1;
unsigned int offset_2 = offset_1*16+index_buffer[index];
if(tmp_array_3 && hash_3) // depth 3
{
index += index_buffer[index]+1;
unsigned int offset_3 = offset_2*16+index_buffer[index];
if(tmp_array_4 && hash_4) // depth 4
{
index += index_buffer[index]+1;
unsigned int offset_4 = offset_3*16+index_buffer[index];
if(tmp_array_5 && hash_5) // depth 5
{
index += index_buffer[index]+1;
unsigned int offset_5 = offset_4*16+index_buffer[index];
// depth 6?
memcpy(tmp_array,&tmp_array_5[item_size*offset_5],SHA256_LEN);
memcpy(&hash,&hash_5[offset_5],sizeof(SHA256_CTX));
}
else
{
memcpy(tmp_array,&tmp_array_4[item_size*offset_4],SHA256_LEN);
memcpy(&hash,&hash_4[offset_4],sizeof(SHA256_CTX));
}
}
else
{
memcpy(tmp_array,&tmp_array_3[item_size*offset_3],SHA256_LEN);
memcpy(&hash,&hash_3[offset_3],sizeof(SHA256_CTX));
}
}
else
{
memcpy(tmp_array,&tmp_array_2[item_size*offset_2],SHA256_LEN);
memcpy(&hash,&hash_2[offset_2],sizeof(SHA256_CTX));
}
}
else {
memcpy(tmp_array,&tmp_array_1[item_size*offset_1],SHA256_LEN);
memcpy(&hash,&hash_1[offset_1],sizeof(SHA256_CTX));
}
}
do
{
index += index_buffer[index]+1;
if(index >= SHA256_LEN) return 0;
tmp_val = hex_digits[index_buffer[index]];
tmp_array[SHA256_LEN] = tmp_val; //set end of tmp_array to tmp_val
sha256_to_str(tmp_array, SHA256_LEN + 1, tmp_array+SHA256_LEN,(u8int *)md);
count++;
tmp_array += SHA256_LEN;
}
while ((index != SHA256_LEN - 1) || (tmp_val != tmp_array[SHA256_LEN - 1] ));
SHA256_Update(&hash,hash_buffer+SHA256_LEN,SHA256_LEN*count);
SHA256_Update(&hash,data,data_sz);
SHA256_Final((u8int *)md, &hash);
return 1;
}
void init_hashtable_values()
{
printf("Pre-computing dcrypt internal hash values.\n");
SHA256_CTX hash;
SHA256_Init(&hash);
unsigned char md[32];
if(tmp_array_1 && hash_1)
{
for(int x1 = 0; x1 < 16; x1++)
{
unsigned int offset_1 = x1;
uint8_t * ta1 = &tmp_array_1[item_size*x1];
memset(ta1, 0xff, SHA256_LEN);
ta1[SHA256_LEN] = hex_digits[x1];
sha256_to_str(ta1, SHA256_LEN + 1, ta1,md);
SHA256_CTX *current_hash = &hash_1[x1];
memcpy(current_hash,&hash,sizeof(SHA256_CTX));
SHA256_Update(current_hash,ta1,SHA256_LEN);
if(tmp_array_2 && hash_2)
{
for(int x2 = 0; x2 < 16; x2++)
{
unsigned int offset_2 = offset_1*16+x2;
uint8_t * ta2 = &tmp_array_2[item_size*offset_2];
memcpy(ta2,ta1,SHA256_LEN);
ta2[SHA256_LEN] = hex_digits[x2];
sha256_to_str(ta2, SHA256_LEN + 1, ta2,md);
memcpy(&hash_2[offset_2],&hash_1[offset_1],sizeof(SHA256_CTX));
SHA256_Update(&hash_2[offset_2],ta2,SHA256_LEN);
if(tmp_array_3 && hash_3)
{
for(int x3 = 0; x3 < 16; x3++)
{
unsigned int offset_3 = offset_2*16+x3;
uint8_t * ta3 = &tmp_array_3[item_size*offset_3];
memcpy(ta3,ta2,SHA256_LEN);
ta3[SHA256_LEN] = hex_digits[x3];
sha256_to_str(ta3, SHA256_LEN + 1, ta3,md);
memcpy(&hash_3[offset_3],&hash_2[offset_2],sizeof(SHA256_CTX));
SHA256_Update(&hash_3[offset_3],ta3,SHA256_LEN);
if(tmp_array_4 && hash_4)
{
for(int x4 = 0; x4 < 16; x4++)
{
unsigned int offset_4 = offset_3*16+x4;
uint8_t * ta4 = &tmp_array_4[item_size*offset_4];
memcpy(ta4,ta3,SHA256_LEN);
ta4[SHA256_LEN] = hex_digits[x4];
sha256_to_str(ta4, SHA256_LEN + 1, ta4,md);
memcpy(&hash_4[offset_4],&hash_3[offset_3],sizeof(SHA256_CTX));
SHA256_Update(&hash_4[offset_4],ta4,SHA256_LEN);
if(tmp_array_5 && hash_5)
{
for(int x5 = 0; x5 < 16; x5++)
{
unsigned int offset_5 = offset_4*16+x5;
uint8_t * ta5 = &tmp_array_5[item_size*offset_5];
memcpy(ta5,ta4,SHA256_LEN);
ta5[SHA256_LEN] = hex_digits[x5];
sha256_to_str(ta5, SHA256_LEN + 1, ta5,md);
memcpy(&hash_5[offset_5],&hash_4[offset_4],sizeof(SHA256_CTX));
SHA256_Update(&hash_5[offset_5],ta5,SHA256_LEN);
}
}
}
}
}
}
}
}
}
}
printf("Ready to rumble.\n");
}
