コード例 #1
0
ファイル: md5_hash.cpp プロジェクト: him-28/tracethreat-mat
        uint64_t md5_hash(const unsigned char *s, const unsigned int len)
        {
            md5_state_t state;
            md5_byte_t digest[16];

            md5_init(&state);
            md5_append(&state, (const md5_byte_t *)s, len);
            md5_finish(&state, digest);

            uint64_t *p = reinterpret_cast<uint64_t *>(digest);
            uint64_t hash = *p;

            return hash;
        }
コード例 #2
0
ファイル: md5_file.cpp プロジェクト: AltroCoin/altrocoin
int md5_block(const unsigned char* data, int nbytes, char* output) {
    unsigned char binout[16];
    int i;

    md5_state_t state;
    md5_init(&state);
    md5_append(&state, data, nbytes);
    md5_finish(&state, binout);
    for (i=0; i<16; i++) {
        sprintf(output+2*i, "%02x", binout[i]);
    }
    output[32] = 0;
    return 0;
}
コード例 #3
0
ファイル: utils.cpp プロジェクト: DINKIN/mongo
static BSONObj native_hex_md5(const BSONObj& args, void* data) {
    uassert(10261,
            "hex_md5 takes a single string argument -- hex_md5(string)",
            args.nFields() == 1 && args.firstElement().type() == String);
    const char* s = args.firstElement().valuestrsafe();

    md5digest d;
    md5_state_t st;
    md5_init(&st);
    md5_append(&st, (const md5_byte_t*)s, strlen(s));
    md5_finish(&st, d);

    return BSON("" << digestToString(d));
}
コード例 #4
0
ファイル: upload.c プロジェクト: Undrizzle/apps
int checkFile(void)
{
	md5_state_t state;
	md5_byte_t md5Tag[16] = {0};
	md5_byte_t md5Clc[16] = {0};
	//struct MD5Context md5c;
	
	if( imageLen < 80 )
	{
		do_upload_finnal();
		return BOOL_FALSE;
	}
	if( imagePtr == NULL )
	{
		do_upload_finnal();
		return BOOL_FALSE;
	}
	memcpy(md5Tag, imagePtr+64, 16);

	printf("boardapi_checkCpuEndian = %s\n", boardapi_checkCpuEndian()?"little-endian":"big-endian");
	
	//MD5Init( &md5c );
	//MD5Update( &md5c, imagePtr+80, imageLen-80 );
	//MD5Final( md5Clc, &md5c );

	md5_init(&state);
	md5_append(&state, (const md5_byte_t *)(imagePtr+80), (imageLen-80));
	md5_finish(&state, md5Clc);	

	printf("MD5 SRC:\n");
	dumpHex((unsigned char *)md5Tag, 16);
	printf("MD5 CLC:\n");
	dumpHex((unsigned char *)md5Clc, 16);

	if( memcmp(md5Tag, md5Clc, 16) == 0 )
	{
		if( CMM_SUCCESS != extract_file("/var/tmp/wec9720ek.tar.bz2", imagePtr+80, imageLen-80) )
		{
			do_upload_finnal();
			return BOOL_FALSE;
		}
		return BOOL_TRUE;
	}
	else
	{
		do_upload_finnal();
		return BOOL_FALSE;
	}    
}
コード例 #5
0
ファイル: network_server.cpp プロジェクト: CytraL/HClient
bool CNetServer::Open(NETADDR BindAddr, CNetBan *pNetBan, int MaxClients, int MaxClientsPerIP, int Flags)
{
	// zero out the whole structure
	mem_zero(this, sizeof(*this));

	// open socket
	m_Socket = net_udp_create(BindAddr);
	if(!m_Socket.type)
		return false;

	m_pNetBan = pNetBan;

	// clamp clients
	m_MaxClients = MaxClients;
	if(m_MaxClients > NET_MAX_CLIENTS)
		m_MaxClients = NET_MAX_CLIENTS;
	if(m_MaxClients < 1)
		m_MaxClients = 1;

	m_MaxClientsPerIP = MaxClientsPerIP;

	IOHANDLE urandom = io_open("/dev/urandom", IOFLAG_READ);
	if (urandom) {
		io_read(urandom, m_SecurityTokenSeed, sizeof(m_SecurityTokenSeed));
		io_close(urandom);
	}
	else
	{
		dbg_msg("security", "/dev/urandom is not available. using sv_rcon_password for security token seed, make sure you have a long password!");
		str_copy(m_SecurityTokenSeed, g_Config.m_SvRconPassword, sizeof(m_SecurityTokenSeed));
		long timestamp = time_get();
		md5_state_t md5;
		md5_byte_t digest[16];
		// do over 9000 rounds of md5 on the rcon password, to make it harder to recover the password from the token values
		for (int i = 0; i < 1000000; i++)
		{
			md5_init(&md5);
			md5_append(&md5, (unsigned char*)m_SecurityTokenSeed, sizeof(m_SecurityTokenSeed));
			md5_append(&md5, (unsigned char*)&timestamp, sizeof(timestamp));
			md5_finish(&md5, digest);
			mem_copy(m_SecurityTokenSeed, digest, sizeof(m_SecurityTokenSeed) < sizeof(digest) ? sizeof(m_SecurityTokenSeed) : sizeof(digest));
		}
	}

	for(int i = 0; i < NET_MAX_CLIENTS; i++)
		m_aSlots[i].m_Connection.Init(m_Socket, true);

	return true;
}
コード例 #6
0
/* Generate HMAC-MD5 intermediate Hash */
static void sa_hmac_md5_get_pad(const u8 *key, u16 key_sz, u32 *ipad, u32 *opad)
{
	u8 k_ipad[MD5_MESSAGE_BYTES];
	u8 k_opad[MD5_MESSAGE_BYTES];
	int i;

	for (i = 0; i < key_sz; i++) {
		k_ipad[i] = key[i] ^ 0x36;
		k_opad[i] = key[i] ^ 0x5c;
	}
	/* Instead of XOR with 0 */
	for (; i < SHA_MESSAGE_BYTES; i++) {
		k_ipad[i] = 0x36;
		k_opad[i] = 0x5c;
	}

	/* SHA-1 on k_ipad */
	md5_init(ipad);
	md5_transform(ipad, (u32 *)k_ipad);

	/* SHA-1 on k_opad */
	md5_init(opad);
	md5_transform(ipad, (u32 *)k_opad);
}
コード例 #7
0
ファイル: auth_helpers.cpp プロジェクト: drandalltaylor/mongo
 std::string createPasswordDigest(const StringData& username,
                                  const StringData& clearTextPassword) {
     md5digest d;
     {
         md5_state_t st;
         md5_init(&st);
         md5_append(&st, (const md5_byte_t *) username.rawData(), username.size());
         md5_append(&st, (const md5_byte_t *) ":mongo:", 7 );
         md5_append(&st,
                    (const md5_byte_t *) clearTextPassword.rawData(),
                    clearTextPassword.size());
         md5_finish(&st, d);
     }
     return digestToString( d );
 }
コード例 #8
0
ファイル: mpdscrob.c プロジェクト: technosaurus/donky
/**
 * @brief Get the md5 hash of a string.
 *
 * @param str String to motha effin hash (this will also be the storage, so
 *            make sure it is at least 32 + 1 bytes long.)
 */
static void scrob_md5(char *str)
{
        md5_state_t state;
        md5_byte_t digest[16];
        int i;

        md5_init(&state);
        md5_append(&state, (const md5_byte_t *) str, strlen(str));
        md5_finish(&state, digest);

        for (i = 0; i < 16; i++)
                sprintf(str + i * 2, "%02x", digest[i]);

        str[32] = '\0';
}
コード例 #9
0
ファイル: md5.c プロジェクト: raidenawkward/recite
char* get_md5_str(const char* str) {
	int length = strlen(str);
	char* buf = (char*)malloc(sizeof(char)*length);
	unsigned char* ret = (unsigned char*)malloc(sizeof(unsigned char)*LEN_MD5_STR);
	memset(ret,0x00,LEN_MD5_STR);
	strcpy(buf,str);
	void *ptr = create_md5_ctx();
    md5_init(ptr);
	md5_update(ptr, buf, length);

	md5_final(ptr, ret);
	release_md5_ctx(ptr);
	//free(buf);
	return ret;
}
コード例 #10
0
ファイル: funcsm.cpp プロジェクト: bduck/livecode
Exec_stat MCMD5Digest::eval(MCExecPoint &ep)
{
	if (source->eval(ep) != ES_NORMAL)
	{
		MCeerror->add(EE_MD5DIGEST_BADSOURCE, line, pos);
		return ES_ERROR;
	}
	md5_state_t state;
	md5_byte_t digest[16];
	md5_init(&state);
	md5_append(&state, (const md5_byte_t *)ep.getsvalue().getstring(), ep.getsvalue().getlength());
	md5_finish(&state, digest);
	ep.copysvalue((char *)digest, 16);
	return ES_NORMAL;
}
コード例 #11
0
ファイル: Misc.cpp プロジェクト: vinceplusplus/z3D
		mbs					gen_md5(const void* array_byte, size_t bytes)
		{
			mbs md5;

			md5_state_t state;
			md5_byte_t digest[16];

			md5_init(&state);
			md5_append(&state, (const md5_byte_t*)array_byte, (int)bytes);
			md5_finish(&state, digest);

			for(int i = 0; i < 16; ++i)
				md5 += FORMATA("%02x", (int)digest[i]);
			return md5;
		}
コード例 #12
0
ファイル: MongoUtils.cpp プロジェクト: strogo/robomongo
        QString buildPasswordHash(const QString &username, const QString &password)
        {
            QString sum = username + ":mongo:" + password;
            QByteArray bytes = sum.toUtf8();
            const char * s = bytes.constData();

            mongo::md5digest d;
            md5_state_t st;
            md5_init(&st);
            md5_append( &st , (const md5_byte_t*)s , strlen( s ) );
            md5_finish(&st, d);

            std::string hash = mongo::digestToString(d);
            return QString::fromUtf8(hash.c_str(), hash.size());
        }
コード例 #13
0
inline bool ff_media_packet_impl::is_valid() const
{
#if defined(DT_VALIDATE_PACKET) && (DT_VALIDATE_PACKET == 1)
    md5_byte_t currentMD5[16];
    md5_state_t md5State;
    md5_init(&md5State);
    md5_append(&md5State, m_AVPacket->data, m_AVPacket->size);
    md5_finish(&md5State, currentMD5);
    bool valid = CheckMD5(currentMD5);
    DT_ALL_ASSERT(valid);
    return valid;
#else // defined(DT_VALIDATE_PACKET) && (DT_VALIDATE_PACKET == 1)
    return m_Valid;
#endif // defined(DT_VALIDATE_PACKET) && (DT_VALIDATE_PACKET == 1)
}
コード例 #14
0
ファイル: geoipupdate.c プロジェクト: Psiphon-Inc/geoipupdate
void md5hex_license_ipaddr(geoipupdate_s * gu, const char *client_ipaddr,
                           char *new_digest_str)
{
    unsigned char digest[16];
    MD5_CONTEXT context;
    md5_init(&context);
    md5_write(&context, (unsigned char *)gu->license.license_key,
              strlen(gu->license.license_key));
    md5_write(&context, (unsigned char *)client_ipaddr, strlen(client_ipaddr));
    md5_final(&context);
    memcpy(digest, context.buf, 16);
    for (int i = 0; i < 16; i++) {
        snprintf(&new_digest_str[2 * i], 3, "%02x", digest[i]);
    }
}
コード例 #15
0
ファイル: kex.c プロジェクト: BackupTheBerlios/libssh-svn
static void build_session_id1(SSH_SESSION *session, STRING *servern, 
        STRING *hostn){
    MD5CTX md5=md5_init();
#ifdef DEBUG_CRYPTO
    ssh_print_hexa("host modulus",hostn->string,string_len(hostn));
    ssh_print_hexa("server modulus",servern->string,string_len(servern));
#endif
    md5_update(md5,hostn->string,string_len(hostn));
    md5_update(md5,servern->string,string_len(servern));
    md5_update(md5,session->server_kex.cookie,8);
    md5_final(session->next_crypto->session_id,md5);
#ifdef DEBUG_CRYPTO
    ssh_print_hexa("session_id",session->next_crypto->session_id,MD5_DIGEST_LEN);
#endif
}
コード例 #16
0
ファイル: osppeer.c プロジェクト: caiboyang/CS
 char *calculate_MD5_CODE(char fn[])
{
			/*start calculate MD5 for file*/
		md5_state_t * state =NULL;
		FILE *temp =NULL;
		unsigned int tmp_size;//file size for temp;
		unsigned char *tmp_buf = NULL;//buffer to hold file content
		size_t r;//return read file result
		char *MD5_CODE = NULL;

		//initilize
		state = (md5_state_t *)malloc(sizeof(md5_state_t));
		MD5_CODE = (char*) malloc(MD5_TEXT_DIGEST_SIZE+1);
		MD5_CODE[MD5_TEXT_DIGEST_SIZE] = '\0';
		temp = fopen (fn, "rb" );
		if ( temp == NULL) 
        {
        	fputs ("Error occur while open file",stderr); 
        	exit (1);
        }
        //aquire size
        fseek (temp , 0 , SEEK_END);
    	tmp_size = ftell (temp);
    	rewind (temp);

        tmp_buf = (unsigned char*) malloc (sizeof(char)*tmp_size);
        if (tmp_buf == NULL) 
        {
        	fputs ("Allocation Error",stderr); 
        	exit (2);
        }
    	//reading file
    	r = fread (tmp_buf,1,tmp_size,temp);
    	if (r != tmp_size) 
    	{
    		fputs ("Error occur while open file",stderr); exit (3);
    	}

    	//Obtain MD5
    	md5_init(state);
   		md5_append(state, tmp_buf , tmp_size);
    	md5_finish_text(state, MD5_CODE, 1);    
    	
    	//Clean
    	fclose (temp);
    	free(tmp_buf);
    	return MD5_CODE;
}
コード例 #17
0
ファイル: http.c プロジェクト: ezotrank/monit-src
static int check_request_checksum(Socket_T socket, int content_length, char *checksum, int hashtype) {
        int n, keylength = 0;
        MD_T result, hash;
        md5_context_t ctx_md5;
        sha1_context_t ctx_sha1;
        char buf[READ_SIZE];

        if (content_length <= 0) {
                DEBUG("HTTP warning: Response does not contain a valid Content-Length -- cannot compute checksum\n");
                return TRUE;
        }

        switch (hashtype) {
                case HASH_MD5:
                        md5_init(&ctx_md5);
                        while (content_length > 0) {
                                if ((n = socket_read(socket, buf, content_length > sizeof(buf) ? sizeof(buf) : content_length)) < 0)
                                        break;
                                md5_append(&ctx_md5, (const md5_byte_t *)buf, n);
                                content_length -= n;
                        }
                        md5_finish(&ctx_md5, (md5_byte_t *)hash);
                        keylength = 16; /* Raw key bytes not string chars! */
                        break;
                case HASH_SHA1:
                        sha1_init(&ctx_sha1);
                        while (content_length > 0) {
                                if ((n = socket_read(socket, buf, content_length > sizeof(buf) ? sizeof(buf) : content_length)) < 0)
                                        break;
                                sha1_append(&ctx_sha1, (md5_byte_t *)buf, n);
                                content_length -= n;
                        }
                        sha1_finish(&ctx_sha1, (md5_byte_t *)hash);
                        keylength = 20; /* Raw key bytes not string chars! */
                        break;
                default:
                        socket_setError(socket, "HTTP checksum error: Unknown hash type\n");
                        return FALSE;
        }

        if (strncasecmp(Util_digest2Bytes((unsigned char *)hash, keylength, result), checksum, keylength * 2) != 0) {
                socket_setError(socket, "HTTP checksum error: Document checksum mismatch\n");
                return FALSE;
        } else {
                DEBUG("HTTP: Succeeded testing document checksum\n");
        }
        return TRUE;
}
コード例 #18
0
ファイル: check_md5.c プロジェクト: AaronVanGeffen/bitlbee
static void check_sums(int l)
{
	int i;

	for (i = 0; tests[i].str; i++) {
		md5_byte_t sum[16];
		tcase_fn_start(tests[i].str, __FILE__, __LINE__);
		md5_state_t state;

		md5_init(&state);
		md5_append(&state, (const md5_byte_t *) tests[i].str, strlen(tests[i].str));
		md5_finish(&state, sum);

		fail_if(memcmp(tests[i].expected, sum, 16) != 0, "%s failed", tests[i].str);
	}
}
コード例 #19
0
ファイル: growl.c プロジェクト: kissthink/GNTPCom
void growl_append_md5( unsigned char *const data , const int data_length , const char *const password )
{
    md5_state_t state;
    md5_byte_t  md5tmp[20];

	memset(md5tmp, 0, sizeof(md5tmp));
    md5_init(&state);
    md5_append(&state, (const md5_byte_t *)data, data_length);
	if(password != NULL)
	{
        md5_append(&state, (const md5_byte_t *)password, strlen(password));
	}
    md5_finish(&state, md5tmp);

	memcpy( data + data_length , md5tmp , 16 );
}
コード例 #20
0
ファイル: md5.cpp プロジェクト: krichter722/zeroballistics
//------------------------------------------------------------------------------
std::string hashString(const std::string & in)
{
    md5_state_t state;
    md5_byte_t digest[16];
    
    md5_init(&state);
    md5_append(&state, (const md5_byte_t*)in.c_str(), in.size());
    md5_finish(&state, digest);

    std::ostringstream str;
    for (unsigned i=0; i<16; ++i)
    {
        str << std::setfill('0') << std::setw(2) << std::hex << (unsigned)digest[i];
    }
    return str.str();    
}
コード例 #21
0
ファイル: smf_core.c プロジェクト: spmfilter/spmfilter
char *smf_core_md5sum(const char *data) {
    md5_state_t state;
    md5_byte_t digest[16];
    int offset = 0;
    char *hex = (char *)calloc(16*2+1,sizeof(char));

    md5_init(&state);
    md5_append(&state, (const md5_byte_t *)data, strlen(data));
    md5_finish(&state, digest);

    for(offset=0; offset<16; offset++) {
        sprintf(hex + offset * 2, "%02x", digest[offset]);
    }

    return(hex);
}
コード例 #22
0
ファイル: ntlm-encrypt.c プロジェクト: via/dovecot-clouddb
void
ntlmssp2_response(const unsigned char *hash,
                  const unsigned char *server_challenge,
                  const unsigned char *client_challenge,
                  unsigned char response[NTLMSSP_RESPONSE_SIZE])
{
    struct md5_context ctx;
    unsigned char session_hash[MD5_RESULTLEN];

    md5_init(&ctx);
    md5_update(&ctx, server_challenge, NTLMSSP_CHALLENGE_SIZE);
    md5_update(&ctx, client_challenge, NTLMSSP_CHALLENGE_SIZE);
    md5_final(&ctx, session_hash);

    ntlmssp_v1_response(hash, session_hash, response);
}
コード例 #23
0
/*
 * The result buffer has to be 16 bytes.
 */
void clMD5Compute(ClUint8T *data, ClUint32T size, ClUint8T result[16])
{
    md5_state_t ctx;
    if(!byte_order)
    {
        /*
         * set endian-ness
         */
        static const int w = 1;
        if( *(const md5_byte_t*)&w) byte_order = -1; /*little endian*/
        else byte_order = 1;
    }
    md5_init(&ctx);
    md5_append(&ctx, (const md5_byte_t*)data, size);
    md5_finish(&ctx, (md5_byte_t*)result);
}
コード例 #24
0
ファイル: pwcrypt.cpp プロジェクト: aidan-g/opennx
wxString
md5sum(const wxString &s)
{
    md5_state_t state;
    md5_byte_t digest[16];

    md5_init(&state);
    const wxWX2MBbuf buf = wxConvCurrent->cWX2MB(s);
    const char *cc = wx_static_cast(const char*, buf);
    md5_append(&state, wx_reinterpret_cast(const md5_byte_t *, cc), s.Length());
    md5_finish(&state, digest);
    wxString ret;
    for (int i = 0; i < 16; i++)
        ret << wxString::Format(wxT("%02x"), digest[i]);
    return ret;
}
コード例 #25
0
ファイル: md5.c プロジェクト: fluyy/fluyy_code
int md5_string(const char *str){

	CONTEXT cxt;
	unsigned char buf[16];
	int i;

	md5_init(&cxt);
	md5_update(&cxt,(unsigned char *)str,strlen(str));
	md5_final(&cxt,buf);
                                  	
	for(i=0;i<16;i++)            
		printf("%02x",buf[i]);
	printf("\n");
	
	return 0;
}
コード例 #26
0
ファイル: main.c プロジェクト: nmav/cspim-ku
int main(void)
{
unsigned char string[256];
struct md5_ctx ctx;
unsigned int size;
int ret;

#ifdef REPEAT
	do {
#else
	print_string("This is the emulated program. Will try to calculate MD5...\n");
#endif


	md5_init(&ctx);

	/* pass the string address above */
#ifdef TEST
#define STR "A long text to hash, and hash, and hash and hash..."
	size = sizeof(STR)-1;
	memcpy(string, STR, size);

	md5_update(&ctx, size, string);
	md5_digest(&ctx, 16, string);

	return 0;
#else
	ret = SYSCALL2(USER_SYSCALL(1), (unsigned int)string, sizeof(string));
	if (ret > 0) {
		size = ret;
		md5_update(&ctx, size, string);
		md5_digest(&ctx, 16, string);

#ifndef REPEAT
		ret = SYSCALL2(USER_SYSCALL(2), (unsigned int)string, 16);
		if (ret == 0)
			return 0;
#endif
	}
#endif	

#ifdef REPEAT
	} while(SYSCALL1(USER_SYSCALL(0),0)==0);
#endif

	return 1;
}
コード例 #27
0
INT64_T cfs_basic_md5(const char *path, unsigned char digest[16])
{
	int fd;
	INT64_T result;
	struct chirp_stat info;

	result = cfs->stat(path, &info);
	if(result < 0)
		return result;

	if(S_ISDIR(info.cst_mode)) {
		errno = EISDIR;
		return -1;
	}

	fd = cfs->open(path, O_RDONLY, 0);
	if(fd >= 0) {
		char buffer[65536];
		INT64_T ractual;
		INT64_T total = 0;
		INT64_T length = info.cst_size;
		md5_context_t ctx;

		md5_init(&ctx);

		while(length > 0) {
			INT64_T chunk = MIN((int) sizeof(buffer), length);

			ractual = cfs->pread(fd, buffer, chunk, total);
			if(ractual <= 0)
				break;

			md5_update(&ctx, (unsigned char *) buffer, ractual);

			length -= ractual;
			total += ractual;
		}
		result = 0;
		cfs->close(fd);
		md5_final(digest, &ctx);
	} else {
		result = -1;
	}

	return result;
}
コード例 #28
0
ファイル: test.c プロジェクト: BillGrim/AudioKit
int sp_test_create(sp_test **t, uint32_t bufsize)
{
    uint32_t i;
    *t = malloc(sizeof(sp_test));
    sp_test *tp = *t;

    SPFLOAT *buf = malloc(sizeof(SPFLOAT) * bufsize);
    for(i = 0; i < bufsize; i++) tp->buf = 0;

    tp->buf = buf;
    tp->size = bufsize;
    tp->pos = 0;
    md5_init(&tp->state);
    tp->md5string[32] = '\0';
    tp->md5 = tp->md5string;
    return SP_OK;
}
コード例 #29
0
ファイル: larlib.c プロジェクト: 8devices/carambola2-luci
int larlib_md5( lua_State *L )
{
	int i;
	char md5[16], md5_hex[33];
	const char *data = luaL_checkstring( L, 1 );
	md5_state_t state;

	md5_init(&state);
	md5_append(&state, (const md5_byte_t *)data, strlen(data));
	md5_finish(&state, (md5_byte_t *)md5);

	for( i = 0; i < 16; i++ )
		sprintf(&md5_hex[i*2], "%02x", (unsigned char)md5[i]);

	lua_pushstring(L, md5_hex);
	return 1;
}
コード例 #30
0
ファイル: md5.cpp プロジェクト: JohnnyonFlame/odamex
std::string MD5SUM(const void *in, size_t size)
{
	md5_state_t state;
	md5_init(&state);

	md5_append(&state, (const unsigned char *)in, size);

	md5_byte_t digest[16];
	md5_finish(&state, digest);

	std::stringstream hash;

	for(int i = 0; i < 16; i++)
		hash << std::setw(2) << std::setfill('0') << std::hex << std::uppercase << (short)digest[i];

	return hash.str();
}