Esempio n. 1
0
static khint_t hash_key(key_data_t key) {
    int i = 0;
    khint_t hash;

    if (key.single) {
        unsigned char sig[12];

        memcpy(sig + i, &key.this_ref, 4);      i += 4;
        memcpy(sig + i, &key.this_coord, 4);    i += 4;
        memcpy(sig + i, &key.orientation, 4);   i += 4;

        hash = do_hash(sig, i);
    } else {
        unsigned char sig[24];

        memcpy(sig + i, &key.this_ref, 4);      i += 4;
        memcpy(sig + i, &key.this_coord, 4);    i += 4;
        memcpy(sig + i, &key.other_ref, 4);     i += 4;
        memcpy(sig + i, &key.other_coord, 4);   i += 4;
        memcpy(sig + i, &key.leftmost, 4);      i += 4;
        memcpy(sig + i, &key.orientation, 4);   i += 4;

        hash = do_hash(sig, i);
    }

    return hash;
}
Esempio n. 2
0
int
st_find_or_add(st_table *table, char *key, char ***slot)
{
    int hash_val;
    st_table_entry *newEntry, *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr, last);

    if (ptr == NULL) {
	if (table->num_entries / table->num_bins >= table->max_density) {
	    if (rehash(table) == ST_OUT_OF_MEM) {
		return ST_OUT_OF_MEM;
	    }
	    hash_val = do_hash(key, table);
	}
	newEntry = ABC_ALLOC(st_table_entry, 1);
	if (newEntry == NULL) {
	    return ST_OUT_OF_MEM;
	}
	newEntry->key = key;
	newEntry->record = (char *) 0;
	newEntry->next = table->bins[hash_val];
	table->bins[hash_val] = newEntry;
	table->num_entries++;
	if (slot != NULL) *slot = &newEntry->record;
	return 0;
    } else {
	if (slot != NULL) *slot = &ptr->record;
	return 1;
    }
}
Esempio n. 3
0
int
st_insert(st_table *table, const char *key, char *value)
{
    int hash_val;
    st_table_entry *newEntry;
    st_table_entry *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr, last);

    if (ptr == NULL) {
	if (table->num_entries/table->num_bins >= table->max_density) {
	    if (rehash(table) == ST_OUT_OF_MEM) {
		return ST_OUT_OF_MEM;
	    }
	    hash_val = do_hash(key, table);
	}
	newEntry = ABC_ALLOC(st_table_entry, 1);
	if (newEntry == NULL) {
	    return ST_OUT_OF_MEM;
	}
	newEntry->key = (char *)key;
	newEntry->record = value;
	newEntry->next = table->bins[hash_val];
	table->bins[hash_val] = newEntry;
	table->num_entries++;
	return 0;
    } else {
	ptr->record = value;
	return 1;
    }
}
Esempio n. 4
0
void undo( letter_t c, keyword_t i )
/**********************************/
{
    keyword_t index;
    unsigned first_weight;
    unsigned last_weight;

    /*
        every keyword that had a full hash value calculated
        because of the weight of the character specified
        must deregister its hash value position
    */
    first_weight = first_scale * weights[c];
    last_weight = last_scale * weights[c];
    for( ; i > 0; --i ) {
        if( first[i] == c ) {
            --done[i];
            if( done[i] == 1 ) {      // 2 -> 1 transition
                index = do_hash( hash[i] );
                used[index] = NULL_KEYWORD;
            }
            hash[i] -= first_weight;
        }
        if( last[i] == c ) {
            --done[i];
            if( done[i] == 1 ) {      // 2 -> 1 transition
                index = do_hash( hash[i] );
                used[index] = NULL_KEYWORD;
            }
            hash[i] -= last_weight;
        }
    }
}
Esempio n. 5
0
	extern int sha1_hash(t_hash * hashout, unsigned int size, void const * datain)
	{
		t_uint32              tmp[64 + 16];
		unsigned char const * data;
		unsigned int          inc;
		unsigned int          orgSize;

		if (!hashout || !*hashout)
		{
			eventlog(eventlog_level_error, __FUNCTION__, "got NULL hashout");
			return -1;
		}
		if (size > 0 && !datain)
		{
			eventlog(eventlog_level_error, __FUNCTION__, "got NULL datain with size=%u", size);
			return -1;
		}

		hash_init(hashout);
		orgSize = size;

		data = (const unsigned char*)datain;
		while (size > 0)
		{
			if (size >= 64)
				inc = 64;
			else
				inc = size;

			if (size >= 64)
			{
				hash_set_16(tmp, data, inc, do_sha1_hash);
				do_hash(hashout, tmp, do_sha1_hash);
			}
			else if (size > 55){

				hash_set_16(tmp, data, inc, do_sha1_hash);
				do_hash(hashout, tmp, do_sha1_hash);

				// now use blizz variant as we only wanna fill in zeros
				hash_set_16(tmp, data, 0, do_blizzard_hash);
				hash_set_length(tmp, orgSize);
				do_hash(hashout, tmp, do_sha1_hash);
			}
			else{
				hash_set_16(tmp, data, inc, do_sha1_hash);
				hash_set_length(tmp, orgSize);
				do_hash(hashout, tmp, do_sha1_hash);
			}

			data += inc;
			size -= inc;
		}

		return 0;
	}
Esempio n. 6
0
void dump_weights( unsigned first_index, unsigned last_index )
/************************************************************/
{
    int bad_mask_hash;
    unsigned mask;
    char *prt_c;
    letter_t c;
    keyword_t i;
    unsigned h;

    outfile = fopen( get_gh_filename( "weights" ), "w" );
    dump_common_defs( first_index, last_index );
    bad_mask_hash = 0;
    for( mask = 1; mask != 0; mask <<= 1 ) {
        if( mask >= hashsize ) {
            for( i = 1; i <= num_keywords; ++i ) {
                h = hash[i];
                h &= mask - 1;
                if( mask != hashsize ) {
                    if( h >= hashsize ) {
                        h -= hashsize;
                    }
                }
                if( h != do_hash(hash[i]) ) {
                    output( "  %s: %u+%u*%u+%u*%u=%u mod %u = %u (%u)\n",
                            tokens[i],
                            init_hash[i],
                            first_scale, weights[first[i]],
                            last_scale, weights[last[i]],
                            hash[i],
                            hashsize,
                            do_hash( hash[i] ),
                            h );
                    bad_mask_hash = 1;
                    //break;
                }
            }
            break;
        }
    }
    if( bad_mask_hash ) {
        output( "code will use '%%' operator\n" );
    } else {
        fprintf( outfile, "#define KEYWORD_HASH_MASK  0x%0x\n", mask - 1 );
        if( mask != hashsize ) {
            fprintf( outfile, "#define KEYWORD_HASH_EXTRA\n" );
        }
    }
    fputc( '\n', outfile );
    for( c = LETTER_MIN; c <= LETTER_MAX; ++c ) {
        prt_c = make_define( c );
        fprintf( outfile, "#define W_%s     ", prt_c );
        fprintf( outfile, "%2d\n", weights[c]);
    }
    fclose( outfile );
}
Esempio n. 7
0
UniqueID::UniqueID()
{
	time_t m_time;
	int m_pid;
	char userName[255];
	char hostName[255];
	int ip = 3434;



	time(&(m_time));
	UniqueID::basedata += m_time;
	

	m_pid = _getpid();

	strcpy(userName,getenv(ENVSTRING));


	WSADATA wsaData;

	if(WSAStartup(MAKEWORD( 2, 2),&wsaData) == 0)
	{
		gethostname(hostName,255);	

		HOSTENT * host = gethostbyname(hostName);
		memcpy((void*)&ip, host->h_addr, 4);
	}
	else
	{
		strcpy(hostName,"ERROR_SOCKET");
	}

#ifdef WIN32
	MEMORYSTATUS lpBuffer;   // memory status structure
	GlobalMemoryStatus(&lpBuffer);
	int paso = (lpBuffer.dwAvailVirtual >> 8) * GenRandom() + GenRandom();	
#else
	int paso = GenRandom() * GenRandom();
#endif WIN32


	char* temp = uid;
	sprintf(temp,"%04.4x-",m_pid);
	temp += 5;
	sprintf(temp,"%08.8x-",m_time);
	temp += 9;	
	sprintf(temp,"%08.8x",do_hash(userName) + ip);
	temp += 8;
	sprintf(temp,"%08.8x-",do_hash(hostName) + ip);
	temp += 9;
	sprintf(temp,"%08.8x",paso);

	UniqueID::basedata++;
}
Esempio n. 8
0
int os_uuid(lua_State* L)
{
	char uuid[38];
	unsigned char bytes[16];
	
	/* If a name argument is supplied, build the UUID from that. For speed we
	 * are using a simple DBJ2 hashing function; if this isn't sufficient we
	 * can switch to a full RFC 4122 §4.3 implementation later. */
	const char* name = luaL_optstring(L, 1, NULL);
	if (name != NULL)
	{
		add(bytes, 0, do_hash(name, 0));
		add(bytes, 4, do_hash(name, 'L'));
		add(bytes, 8, do_hash(name, 'u'));
		add(bytes, 12, do_hash(name, 'a'));
	}

	/* If no name is supplied, try to build one properly */	
	else
	{
#if PLATFORM_WINDOWS
		CoCreateGuid((GUID*)bytes);
#elif PLATFORM_OS2
		int i;
		for (i = 0; i < 16; i++)
			bytes[i] = (unsigned char)gethrtime();
#else
		int result;

		/* not sure how to get a UUID here, so I fake it */
		FILE* rnd = fopen("/dev/urandom", "rb");
		result = fread(bytes, 16, 1, rnd);
		fclose(rnd);
		if (!result)
		{
			return 0;
		}
#endif
	}

	sprintf(uuid, "%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
		bytes[0], bytes[1], bytes[2], bytes[3],
		bytes[4], bytes[5],
		bytes[6], bytes[7],
		bytes[8], bytes[9],
		bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]);

	lua_pushstring(L, uuid);
	return 1;
}
Esempio n. 9
0
boolean hash_ok( void )
/*********************/
{
    keyword_t i,j,h;

    for( i = 1; i <= num_keywords; ++i ) {
        h = do_hash( hash[i] );
        for( j = i + 1; j <= num_keywords; ++j ) {
            if( h == do_hash( hash[j] ) ) {
                return( FALSE );
            }
        }
    }
    return( TRUE );
}
Esempio n. 10
0
bool hash_ok( void )
/*********************/
{
    keyword_t i,j,h;

    for( i = 1; i <= num_keywords; ++i ) {
        h = do_hash( hash[i] );
        for( j = i + 1; j <= num_keywords; ++j ) {
            if( h == do_hash( hash[j] ) ) {
                return( false );
            }
        }
    }
    return( true );
}
Esempio n. 11
0
int
st_get_key(st_table *table, register st_data_t key, st_data_t *result)
{
    unsigned int hash_val, bin_pos;
    register st_table_entry *ptr;

    if (table->entries_packed) {
        int i;
        for (i = 0; i < table->num_entries; i++) {
            if ((st_data_t)table->bins[i*2] == key) {
                if (result !=0) *result = (st_data_t)table->bins[i*2];
                return 1;
            }
        }
        return 0;
    }

    hash_val = do_hash(key, table);
    FIND_ENTRY(table, ptr, hash_val, bin_pos);

    if (ptr == 0) {
	return 0;
    }
    else {
	if (result != 0)  *result = ptr->key;
	return 1;
    }
}
Esempio n. 12
0
int
st_lookup(st_table *table, register st_data_t key, st_data_t *value)
{
    unsigned int hash_val, bin_pos;
    register st_table_entry *ptr;

    if (table->entries_packed) {
        int i;
        for (i = 0; i < table->num_entries; i++) {
            if ((st_data_t)table->bins[i*2] == key) {
                if (value !=0) *value = (st_data_t)table->bins[i*2+1];
                return 1;
            }
        }
        return 0;
    }

    hash_val = do_hash(key, table);
    FIND_ENTRY(table, ptr, hash_val, bin_pos);

    if (ptr == 0) {
	return 0;
    }
    else {
	if (value != 0)  *value = ptr->record;
	return 1;
    }
}
Esempio n. 13
0
/*
 * Scans throught the section list, and if found
 * return it. Otherwise, return NULL.
 */
ConfigSection* Config::find_section(const char* section) {
	E_ASSERT(section != NULL);
	int slen = strlen(section);
	unsigned int hh = do_hash(section, slen);

	// check if we have cached section
	if (cached && cached->shash == hh && (strncmp(cached->sname, section, cached->snamelen) == 0)) {
#ifdef CONFIG_INTERNAL
		printf("Found %s cached\n", cached->sname);
#endif
		return cached;
	}

	SectionListIter it = section_list.begin(), it_end = section_list.end();
	for (; it != it_end; ++it) {
		ConfigSection *cs = *it;
		if (cs->shash == hh && (strncmp(cs->sname, section, cs->snamelen) == 0)) {
#ifdef CONFIG_INTERNAL
			printf("XXX found: %s\n", cs->sname);
#endif
			cached = cs;
			return cs;
		}
	}
	return NULL;
}
Esempio n. 14
0
/*
 * Add new key/value, but first check
 * do we alread have and key, so if
 * we do, just update value
 */
void ConfigSection::add_entry(const char* key, const char* value) {
	E_ASSERT(key != NULL);
	E_ASSERT(value != NULL);

	ConfigEntry* e = find_entry(key);
	if (!e) {
		e = new ConfigEntry;
		e->keylen = strlen(key);
		e->valuelen = strlen(value);
		e->key = strdup(key);
		e->value = strdup(value);
		// hash the key
		e->hash = do_hash(e->key, e->keylen);

		E_ASSERT(e->key != NULL);
		E_ASSERT(e->value != NULL);
#ifdef CONFIG_INTERNAL
		printf("Adding: |%s| = |%s| hash = %i section = %s\n", e->key, e->value, e->hash, sname);
#endif
		entry_list.push_back(e);
	} else {
#ifdef CONFIG_INTERNAL
		printf("!!! found duplicate for %s\n", e->key);
#endif
		free(e->value);
		e->valuelen = strlen(value);
		e->value = strdup(value);
		E_ASSERT(e->value != NULL);
	}
}
Esempio n. 15
0
/*
 * ConfigSection methods
 */
ConfigSection::ConfigSection(const char* n) {
	E_ASSERT(n != NULL);

	snamelen = strlen(n);
	sname = strdup(n);
	shash = do_hash(sname, snamelen);
}
Esempio n. 16
0
File: st.c Progetto: sho-h/ruby
int
st_insert2(register st_table *table, register st_data_t key, st_data_t value,
	   st_data_t (*func)(st_data_t))
{
    st_index_t hash_val;
    register st_index_t bin_pos;
    register st_table_entry *ptr;

    hash_val = do_hash(key, table);

    if (table->entries_packed) {
	st_index_t i = find_packed_index(table, hash_val, key);
	if (i < table->real_entries) {
	    PVAL_SET(table, i, value);
	    return 1;
	}
	key = (*func)(key);
	add_packed_direct(table, key, value, hash_val);
	return 0;
    }

    FIND_ENTRY(table, ptr, hash_val, bin_pos);

    if (ptr == 0) {
	key = (*func)(key);
	add_direct(table, key, value, hash_val, bin_pos);
	return 0;
    }
    else {
	ptr->record = value;
	return 1;
    }
}
Esempio n. 17
0
/*
 * Add new key/value, but first check
 * do we alread have and key, so if
 * we do, just update value
 */
void ConfigSection::add_entry(const char* key, const char* value) {
	E_ASSERT(key != NULL);
	E_ASSERT(value != NULL);

	ConfigEntry* e = find_entry(key);
	if (!e) {
		e = new ConfigEntry;
		e->keylen   = strlen(key);
		e->valuelen = strlen(value);
		e->key      = strdup(key);
		e->value    = strdup(value);
		e->hash     = do_hash(e->key, e->keylen);

		E_ASSERT(e->key != NULL);
		E_ASSERT(e->value != NULL);

		entry_list.push_back(e);
	} else {
		free(e->value);
		e->valuelen = strlen(value);
		e->value    = strdup(value);

		E_ASSERT(e->value != NULL);
	}
}
Esempio n. 18
0
int string_hash(lua_State* L)
{
	const char* str = luaL_checkstring(L, 1);
	int seed = (int)luaL_optinteger(L, 2, 0);
	lua_pushinteger(L, do_hash(str, seed));
	return 1;
}
Esempio n. 19
0
File: st.c Progetto: sho-h/ruby
int
st_get_key(st_table *table, register st_data_t key, st_data_t *result)
{
    st_index_t hash_val;
    register st_table_entry *ptr;

    hash_val = do_hash(key, table);

    if (table->entries_packed) {
	st_index_t i = find_packed_index(table, hash_val, key);
	if (i < table->real_entries) {
	    if (result != 0) *result = PKEY(table, i);
	    return 1;
	}
        return 0;
    }

    ptr = find_entry(table, key, hash_val, hash_pos(hash_val, table->num_bins));

    if (ptr == 0) {
	return 0;
    }
    else {
	if (result != 0)  *result = ptr->key;
	return 1;
    }
}
Esempio n. 20
0
File: st.c Progetto: sho-h/ruby
int
st_lookup(st_table *table, register st_data_t key, st_data_t *value)
{
    st_index_t hash_val;
    register st_table_entry *ptr;

    hash_val = do_hash(key, table);

    if (table->entries_packed) {
	st_index_t i = find_packed_index(table, hash_val, key);
	if (i < table->real_entries) {
	    if (value != 0) *value = PVAL(table, i);
	    return 1;
	}
        return 0;
    }

    ptr = find_entry(table, key, hash_val, hash_pos(hash_val, table->num_bins));

    if (ptr == 0) {
	return 0;
    }
    else {
	if (value != 0) *value = ptr->record;
	return 1;
    }
}
Esempio n. 21
0
int main(int argc, char **argv) {
	const char *algo = "md5,sha1"; /* default hashing algorithm */
	int c, rad = 0, quit = 0, bsize = 0;
	RIO *io;

	while ((c = getopt (argc, argv, "rva:s:b:Bhf:t:")) != -1) {
		switch (c) {
		case 'r':
			rad = 1;
			break;
		case 'a':
			algo = optarg;
			break;
		case 'B':
			incremental = 0;
			break;
		case 'b':
			bsize = (int)r_num_math (NULL, optarg);
			break;
		case 's':
			{
				ut64 algobit = r_hash_name_to_bits (algo);
				RHash *ctx = r_hash_new (R_TRUE, algobit);
				from = 0;
				to = strlen (optarg);
				do_hash_internal (ctx, //0, strlen (optarg),
					algobit, (const ut8*) optarg,
					strlen (optarg), 0, 1);
				r_hash_free (ctx);
				quit = R_TRUE;
			}
			break;
		case 'f':
			from = r_num_math (NULL, optarg);
			break;
		case 't':
			to = r_num_math (NULL, optarg);
			break;
		case 'v':
			printf ("rahash2 v"R2_VERSION"\n");
			return 0;
		case 'h':
			return do_help (0);
		}
	}

	if (quit)
		return 0;
	if (optind>=argc)
		return do_help (1);

	io = r_io_new ();
	if (!r_io_open (io, argv[optind], 0, 0)) {
		eprintf ("Cannot open '%s'\n", argv[optind]);
		return 1;
	}
	return do_hash (algo, io, bsize, rad);
}
Esempio n. 22
0
void hash_table_insert(HashTable *ht, char* key, size_t key_len, Var* value)
{

        /* size = 53 (0 .. 52 ), num_elements = 53 ( 0 .. 52 ); */
        /* how would num_elements be > than size ? */
        if(ht->num_elements > ht->size) {

                hash_table_do_resize(ht);

        }

        uint32_t hashed_value = do_hash(key, key_len);

        size_t hashed_index = hashed_value % ht->size;

        Bucket* b = ht->buckets[hashed_index];

        while(b != NULL) {

                /* Update the value if a key is found */

                if((b->hash == hashed_value) && (b->key_len == key_len) && (memcmp(b->key, key, key_len) == 0)) {

                        b->value = value;

                        return;

                }

                b = b->next;
        }

        b = malloc(sizeof(Bucket));

        if(b == NULL) {

                fprintf(stderr, "%s\n", strerror(errno));
                exit(1);

        }

        b->key = malloc(key_len + 1);

        memcpy(b->key, key, key_len + 1);

        b->key_len = key_len;

        b->hash = hashed_value;

        b->value = value;

        b->next = ht->buckets[hashed_index];

        ht->buckets[hashed_index] = b;

        ht->num_elements++;
}
Esempio n. 23
0
void
cocoa_st_add_direct(cocoa_st_table *table, cocoa_st_data_t key, cocoa_st_data_t value)
{
    unsigned int hash_val, bin_pos;

    hash_val = do_hash(key, table);
    bin_pos = hash_val % table->num_bins;
    ADD_DIRECT(table, key, value, hash_val, bin_pos);
}
Esempio n. 24
0
void
st_add_direct(st_table *table, const char *key, const void *value)
{
    unsigned int hash_val, bin_pos;

    hash_val = do_hash(key, table);
    bin_pos = hash_val % table->num_bins;
    ADD_DIRECT(table, key, value, hash_val, bin_pos);
}
Esempio n. 25
0
/**
 * TODO: We need to support more hash algs
 * @fekek: ECRYPTFS_MAX_KEY_BYTES bytes of allocated memory
 *
 * @passphrase A NULL-terminated char array
 *
 * @salt A salt
 *
 * @passphrase_sig An allocated char array into which the generated
 * signature is written; PASSWORD_SIG_SIZE bytes should be allocated
 *
 */
int
generate_passphrase_sig(char *passphrase_sig, char *fekek,
			char *salt, char *passphrase)
{
	char salt_and_passphrase[ECRYPTFS_MAX_PASSPHRASE_BYTES
				 + ECRYPTFS_SALT_SIZE];
	int passphrase_size;
#ifdef ENABLE_NSS
	int alg = SEC_OID_SHA512;
#else
	int alg = GCRY_MD_SHA512;
#endif /* #ifdef ENABLE_NSS */
	int dig_len = SHA512_DIGEST_LENGTH;
	char buf[SHA512_DIGEST_LENGTH];
	int hash_iterations = ECRYPTFS_DEFAULT_NUM_HASH_ITERATIONS;
	int rc = 0;

	passphrase_size = strlen(passphrase);
	if (passphrase_size > ECRYPTFS_MAX_PASSPHRASE_BYTES) {
		passphrase_sig = NULL;
		syslog(LOG_ERR, "Passphrase too large (%d bytes)\n",
		       passphrase_size);
		return -EINVAL;
	}
	memcpy(salt_and_passphrase, salt, ECRYPTFS_SALT_SIZE);
	memcpy((salt_and_passphrase + ECRYPTFS_SALT_SIZE), passphrase,
		passphrase_size);
	if ((rc = do_hash(salt_and_passphrase,
			  (ECRYPTFS_SALT_SIZE + passphrase_size), buf, alg))) {
		return rc;
	}
	hash_iterations--;
	while (hash_iterations--) {
		if ((rc = do_hash(buf, dig_len, buf, alg))) {
			return rc;
		}
	}
	memcpy(fekek, buf, ECRYPTFS_MAX_KEY_BYTES);
	if ((rc = do_hash(buf, dig_len, buf, alg))) {
		return rc;
	}
	to_hex(passphrase_sig, buf, ECRYPTFS_SIG_SIZE);
	return 0;
}
Esempio n. 26
0
BAREBOX_CMD_END

#endif /* CMD_CMD_SHA224SUM */

#ifdef CONFIG_CMD_SHA256SUM

static int do_sha256(int argc, char *argv[])
{
	return do_hash("sha256", argc, argv);
}
Esempio n. 27
0
BAREBOX_CMD_END

#endif /* CMD_CMD_SHA384SUM */

#ifdef CONFIG_CMD_SHA512SUM

static int do_sha512(int argc, char *argv[])
{
	return do_hash("sha512", argc, argv);
}
Esempio n. 28
0
BAREBOX_CMD_END

#endif /* CMD_CMD_MD5SUM */

#ifdef CONFIG_CMD_SHA1SUM

static int do_sha1(int argc, char *argv[])
{
	return do_hash("sha1", argc, argv);
}
Esempio n. 29
0
void init_ordered( void )
/***********************/
{
    keyword_t i, j;

    for( i = 1; i <= num_keywords; ++i ) {
        j = do_hash( hash[i] );
        ordered[j + 1] = i;
    }
}
Esempio n. 30
0
bool PHPBB3Password::check_hash(string password, string hash) {
	if (hash.length() == 34){
		if (do_hash(password, hash).compare(hash) == 0) return true;
		return false;
	}
	else {
		if (md5(password).compare(hash) == 0) return true;
		return false;
	}
}