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; }
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; }
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)); }
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; } }
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*)×tamp, 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; }
/* 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); }
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 ); }
/** * @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'; }
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; }
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; }
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; }
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()); }
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) }
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]); } }
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 }
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; }
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; }
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); } }
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 ); }
//------------------------------------------------------------------------------ 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(); }
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); }
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); }
/* * 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); }
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; }
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; }
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; }
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; }
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; }
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; }
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(); }