Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
amsn/amsn/utils/webcamsn/src/kidhash.c
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
276 lines (205 sloc)
6.11 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include <stdlib.h> | |
#include <string.h> | |
#include "kidhash.h" | |
#include "constants.h" | |
#include "glib_replacement.h" | |
const double append_multiplicator = 4.614703357219696e-7; | |
const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./"; | |
const int init_variable = 0x0FE0637B1; | |
int init_table[31]; | |
int init_table_size = 31; | |
int *init_table_ptr = NULL; | |
int *init_table_end = NULL; | |
int *init_table_idx2 = NULL; | |
int *init_table_idx1 = NULL; | |
int init_table_idx_diff = 3; | |
const int fixed_value_3 = 3; | |
int key[26]; | |
void crazy_algorithm(int *table,int *temp_data) { | |
unsigned int i, temp = 0; | |
// Initialize the 4 temp variables | |
int P = table[1], | |
PP = table[2], | |
PPP = table[3], | |
PPPP = table[0]; | |
// four loops made into one | |
for (i = 0; i < 16*4; i++) { | |
temp = PPPP + const_mult[i] * const_values[i]; // Common to all loops | |
if(i/16 == 0) temp += GUINT32_FROM_LE(temp_data[i]) + (PPP ^ (P & (PP ^ PPP))); // add this for first loop i =[0..15] | |
else if(i/16 == 1) temp += GUINT32_FROM_LE(temp_data[((i-16)*5 + 1)%16]) + (PP ^ (PPP & (P ^ PP))); // add for second i = [16..31] | |
else if(i/16 == 2) temp += GUINT32_FROM_LE(temp_data[((i-32)*3 + 5)%16]) + (P ^ (PP ^ PPP)); // add for second i = [31..47] | |
else if(i/16 == 3) temp += GUINT32_FROM_LE(temp_data[choose_data_idx[i-48]]) + (PP ^ ((PPP ^ 0xFFFFFFFF) | P)); // add for the last loop | |
PPPP = PPP; PPP = PP; PP = P; | |
P += (temp >> shifts_right[(i%4) + 4*(i/16)]) | (temp << shifts_left[(i%4) + 4*(i/16)]); // look for the shifts in the table | |
} | |
// store in the output variables | |
table[0] += PPPP; | |
table[1] += P; | |
table[2] += PP; | |
table[3] += PPP; | |
return; | |
} | |
int alter_table() { | |
int ret; | |
if (fixed_value_3 != 0 ) { | |
*init_table_idx2 = *init_table_idx1 + *init_table_idx2; | |
ret = *init_table_idx2 >> 1 & 0x7fffffff; | |
if (init_table_idx2 + 1 < init_table_end) { | |
if(init_table_idx1 + 1 >= init_table_end) | |
init_table_idx1 = init_table_ptr; | |
else | |
init_table_idx1++; | |
init_table_idx2++; | |
} else { | |
init_table_idx2 = init_table_ptr; | |
init_table_idx1++; | |
} | |
} else { | |
init_table_ptr[0] = init_table_ptr[0] % 0x1f31d * 0x41a7 - | |
init_table_ptr[0] / 0x1f31d * 0xb14; | |
if ( init_table_ptr[0] <= 0) | |
init_table_ptr[0] += 0x7fffffff; | |
init_table_ptr[0] &= 0x7fffffff; | |
ret = init_table_ptr[0]; | |
} | |
return ret; | |
} | |
void init(int value) { | |
int i = 0; | |
*init_table_ptr = value; | |
if(fixed_value_3) { | |
for (i = 1; i < init_table_size; i++) { | |
init_table_ptr[i] = init_table_ptr[i-1] % 0x1f31d * 0x41a7 - | |
init_table_ptr[i-1] / 0x1f31d * 0xb14; | |
if ( init_table_ptr[i] <= 0) | |
init_table_ptr[i] += 0x7fffffff; | |
} | |
init_table_idx1 = init_table_ptr; | |
init_table_idx2 = init_table_ptr + init_table_idx_diff; | |
for(i = init_table_size * 10; i > 0; i--) alter_table(); | |
} | |
return; | |
} | |
void set_result (int *table, char * temp_data, int * result) { | |
char * temp_data_ptr = temp_data; | |
int idx; | |
idx = (table[4] / 8) & 63; | |
temp_data_ptr = temp_data + idx; | |
*temp_data_ptr = 0x80; | |
temp_data_ptr++; | |
idx = 55 - idx; | |
if ( idx < 0) { | |
memset(temp_data_ptr, 0, idx + 8); | |
crazy_algorithm(table, (int *)temp_data); | |
memset(temp_data, 0, 56); | |
} else | |
memset(temp_data_ptr, 0, idx); | |
temp_data_ptr += idx; | |
// The last 2 dwords are size / 8 and a bool for if size > 64 | |
*((int *)temp_data_ptr) = GUINT32_TO_LE(table[4]); | |
temp_data_ptr+=4; | |
*((int *)temp_data_ptr) = GUINT32_TO_LE(table[5]); | |
crazy_algorithm(table, (int *)temp_data); | |
result[0] = table[0]; | |
result[1] = table[1]; | |
result[2] = table[2]; | |
result[3] = table[3]; | |
result[4] = 0; | |
} | |
void Hash(char * a, int key_size) { | |
int result[5], | |
table[] = {0x67452301, | |
0x0EFCDAB89, | |
0x98BADCFE, | |
0x10325476, | |
8*key_size, | |
key_size >> 29}; | |
char temp_data[64]; | |
int *key_ptr = key; | |
char *a_ptr = a; | |
int i, temp; | |
if(key_size >= 64) { | |
for(i = key_size / 64; i > 0 ; i--) { | |
memcpy(temp_data, key_ptr, 64); | |
crazy_algorithm(table, (int *)temp_data); | |
key_ptr += 16; | |
} | |
key_size &= 63; | |
} | |
memcpy(temp_data, key_ptr, key_size); | |
set_result(table, temp_data, result); | |
result[0] = GUINT32_TO_LE(result[0]); | |
result[1] = GUINT32_TO_LE(result[1]); | |
result[2] = GUINT32_TO_LE(result[2]); | |
result[3] = GUINT32_TO_LE(result[3]); | |
result[4] = GUINT32_TO_LE(result[4]); | |
for (i = 0 ; i < 18; i += 3) { | |
temp = (0x000000ff &((char *) result)[i]) << 16 | | |
(0x000000ff & ((char *) result)[i+1]) << 8 | | |
(0x000000ff & ((char *) result)[i+2]); | |
a_ptr[0] = alphabet[temp >> 6 >> 6 >> 6 & 0x3F]; | |
a_ptr[1] = alphabet[temp >> 6 >> 6 & 0x3F]; | |
a_ptr[2] = alphabet[temp >> 6 & 0x3F]; | |
a_ptr[3] = alphabet[temp & 0x3F]; | |
a_ptr+=4; | |
} | |
*(a_ptr - 2) = 0; | |
} | |
int MakeKidHash(char *a, int *a_size, int kid, char * sid) { | |
int i; | |
char * sid_ptr = sid; | |
char *key_ptr = (char *) key; | |
char *append_char; | |
char *append_ptr; | |
if(kid < 0 || kid > 100) return 0; | |
if (*a_size < 25) return 0; | |
memset(key, 0, 26 * sizeof(int)); | |
init_table_ptr = init_table; | |
init_table_idx1 = init_table_ptr; | |
init_table_idx2 = init_table_ptr + init_table_idx_diff; | |
init_table_end = init_table_ptr + init_table_size; | |
for (i = 0 ; i < 100; i++) { | |
if(*sid_ptr == 0) break; | |
*key_ptr = *sid_ptr; | |
key_ptr++; | |
sid_ptr++; | |
} | |
if (sid_ptr - sid + append_size > 100) return 0; | |
init(init_variable); | |
while(kid > 0) { | |
alter_table(); | |
kid--; | |
} | |
append_char = (char *) (key_append + (long) (alter_table() * append_multiplicator) * 4); | |
append_ptr = append_char; | |
for (i = 0 ; i < append_size; i++) { | |
#ifdef __BIG_ENDIAN__ | |
*key_ptr = append_char[3 - ((append_ptr - append_char)%4) + 4*((append_ptr - append_char)/4)]; | |
#else | |
*key_ptr = *append_ptr; | |
#endif | |
key_ptr++; | |
append_ptr++; | |
} | |
Hash(a, (int) (sid_ptr - sid) + append_size); | |
return 1; | |
} | |
int test () { | |
char sid[] = "sid=aD4ENXNY3Q"; | |
char sid2[] = "sid=KCSwrDFrVg"; | |
char a[30]; | |
int kid = 64; | |
int kid2 = 98; | |
int a_size = 30; | |
printf("\n"); | |
if (MakeKidHash(a, &a_size, kid2, sid2)) { | |
printf("Computed hash is : %s\n", a); | |
printf("Should be : hHQbVkZ/eApiRzPiTg6jyw\n\n\n"); | |
} | |
if(MakeKidHash(a, &a_size, kid, sid)) { | |
printf("Computed hash is : %s\n", a); | |
printf("Should be : HlyPs6/kiWhr0JxmMO1A4Q\n"); | |
} | |
printf("\n\n"); | |
return 0; | |
} |