char * md5_identity(void *data, int len) { unsigned char hash[16]; char* result; int ptr,i; result = (char*)malloc(sizeof(char)*512); memset(result, 0, sizeof(result)); MD5_CTX ctx; MD5_Init(&ctx); MD5_Update(&ctx,(char*)data,len); MD5_Final(hash,&ctx); ptr = 0; for(i=0;i<16;i++) { ptr += sprintf(result+ptr, "%02x", hash[i]); } return result; }
ClientWardenModule* WardenWin::GetModuleForClient() { ClientWardenModule *mod = new ClientWardenModule; uint32 length = sizeof(Module.Module); // data assign mod->CompressedSize = length; mod->CompressedData = new uint8[length]; memcpy(mod->CompressedData, Module.Module, length); memcpy(mod->Key, Module.ModuleKey, 16); // md5 hash MD5_CTX ctx; MD5_Init(&ctx); MD5_Update(&ctx, mod->CompressedData, length); MD5_Final((uint8*)&mod->Id, &ctx); return mod; }
ClientWardenModule *WardenMac::GetModuleForClient(WorldSession *session) { ClientWardenModule *mod = new ClientWardenModule; uint32 len = sizeof(Module_0DBBF209A27B1E279A9FEC5C168A15F7_Data); // data assign mod->CompressedSize = len; mod->CompressedData = new uint8[len]; memcpy(mod->CompressedData, Module_0DBBF209A27B1E279A9FEC5C168A15F7_Data, len); memcpy(mod->Key, Module_0DBBF209A27B1E279A9FEC5C168A15F7_Key, 16); // md5 hash MD5_CTX ctx; MD5_Init(&ctx); MD5_Update(&ctx, mod->CompressedData, len); MD5_Final((uint8*)&mod->ID, &ctx); return mod; }
string md5sum(const char * str, int len) { int n; MD5_CTX ctx; char buf[SLICECAP]; unsigned char out[MD5_DIGEST_LENGTH]; string md5str; MD5_Init(&ctx); MD5_Update(&ctx, str, len); MD5_Final(out, &ctx); for(n = 0; n< MD5_DIGEST_LENGTH; n++) { snprintf(buf, SLICECAP, "%02x", out[n]); md5str += buf; } return md5str; }
// computes an RSA-MD5 signature over 'buf' using 'priv_key' // signature data is returned is 'sig_buf' which should be at least // SIGNATURE_LEN bytes in size. // Method returns 0 on success. int get_signature(char *buf, unsigned int buf_size, RSA *priv_key, unsigned char *sig_buf, unsigned int *sig_len) { unsigned char digest[16]; unsigned int digest_len = 16; MD5_CTX md5; MD5_Init(&md5); MD5_Update(&md5, (unsigned char*)buf, buf_size); MD5_Final(digest, &md5); int ret_val = RSA_sign(NID_md5, digest, digest_len, sig_buf, sig_len, priv_key); if(!ret_val) { unsigned long e = ERR_get_error(); DPRINTF(DEBUG_ERROR,"RSA_sign error: %s", ERR_error_string(e, buf)); return 1; } return 0; }
/* * Selects the cipher, and keys if by computing the MD5 checksum of the * passphrase and using the resulting 16 bytes as the key. */ int cipher_set_key_string(struct sshcipher_ctx *cc, struct sshcipher *cipher, const char *pphrase, int do_encrypt) { MD5_CTX md; u_char digest[16]; int ret = SSH_ERR_LIBCRYPTO_ERROR; if (MD5_Init(&md) != 1 || MD5_Update(&md, (const u_char *)pphrase, strlen(pphrase)) != 1 || MD5_Final(digest, &md) != 1) goto out; ret = cipher_init(cc, cipher, digest, 16, NULL, 0, do_encrypt); out: memset(digest, 0, sizeof(digest)); memset(&md, 0, sizeof(md)); return ret; }
//Return value is on the heap. char* md5(const char *filename) { //Open the input file. FILE *in_file = fopen(filename, "rb"); if (!in_file) { printf ("%s can't be opened.\n", filename); return NULL; } //Initialise the md5 function. MD5_CTX md_context; MD5_Init (&md_context); //Read in the data from the file and feed it to the md5 function. int bytes; unsigned char data[1024]; while ((bytes = fread(data, 1, 1024, in_file)) != 0) { MD5_Update(&md_context, data, bytes); } //Recieve the final md5 value inside c. unsigned char c[MD5_DIGEST_LENGTH]; MD5_Final(c,&md_context); //Allocate memory for the return value. char tmp[2]; char *hash = malloc((MD5_DIGEST_LENGTH * 2) + 1); //Format the md5 digits as chars. for (int i = 0; i < MD5_DIGEST_LENGTH; i++) { sprintf(tmp, "%02x", c[i]); memcpy(hash+(i*2), tmp, 2); } hash[MD5_DIGEST_LENGTH*2] = '\0'; fclose (in_file); return hash; }
int ssl3_PRF( const u_char* secret, uint32_t secret_len, const u_char* random1, uint32_t random1_len, const u_char* random2, uint32_t random2_len, u_char* out, uint32_t out_len ) { MD5_CTX md5; SHA_CTX sha; u_char buf[20]; uint32_t off; u_char i; if( !out ) return NM_ERROR( DSSL_E_INVALID_PARAMETER ); for( off=0, i = 1; off < out_len; off+=16, ++i ) { u_char md5_buf[16]; uint32_t cnt; uint32_t j; MD5_Init(&md5); SHA1_Init(&sha); /* salt: A, BB, CCC, ... */ for( j=0; j < i; j++ ) buf[j]='A' + (i-1); SHA1_Update( &sha, buf, i ); if( secret ) SHA1_Update( &sha, secret, secret_len ); SHA1_Update( &sha, random1, random1_len ); SHA1_Update( &sha, random2, random2_len ); SHA1_Final( buf, &sha ); MD5_Update( &md5, secret, secret_len ); MD5_Update( &md5, buf, 20 ); MD5_Final( md5_buf, &md5 ); cnt = out_len - off < 16 ? out_len - off : 16; memcpy( out + off, md5_buf, cnt ); } return DSSL_RC_OK; }
/* * Computes the proper response to a RSA challenge, and sends the response to * the server. */ static void respond_to_rsa_challenge(struct ssh *ssh, BIGNUM * challenge, RSA * prv) { u_char buf[32], response[16]; MD5_CTX md; int r, len; /* Decrypt the challenge using the private key. */ /* XXX think about Bleichenbacher, too */ if ((r = rsa_private_decrypt(challenge, challenge, prv)) != 0) { ssh_packet_disconnect(ssh, "%s: rsa_private_decrypt: %s", __func__, ssh_err(r)); } /* Compute the response. */ /* The response is MD5 of decrypted challenge plus session id. */ len = BN_num_bytes(challenge); if (len <= 0 || (u_int)len > sizeof(buf)) ssh_packet_disconnect(ssh, "respond_to_rsa_challenge: bad challenge length %d", len); memset(buf, 0, sizeof(buf)); BN_bn2bin(challenge, buf + sizeof(buf) - len); MD5_Init(&md); MD5_Update(&md, buf, 32); MD5_Update(&md, session_id, 16); MD5_Final(response, &md); debug("Sending response to host key RSA challenge."); /* Send the response back to the server. */ if ((r = sshpkt_start(ssh, SSH_CMSG_AUTH_RSA_RESPONSE)) != 0 || (r = sshpkt_put(ssh, &response, sizeof(response))) != 0 || (r = sshpkt_send(ssh)) != 0) fatal("%s: %s", __func__, ssh_err(r)); ssh_packet_write_wait(ssh); memset(buf, 0, sizeof(buf)); memset(response, 0, sizeof(response)); memset(&md, 0, sizeof(md)); }
void md5(FILE * f) { MD5_CTX ctx; unsigned char tab[MD5_DIGEST_LENGTH]; MD5_Init(&ctx); unsigned char bufor[size]; int read; while (!feof(f)) { read = fread(bufor, 1, size, f); MD5_Update(&ctx, bufor, read); } MD5_Final(tab, &ctx); int i; for (i = 0; i < MD5_DIGEST_LENGTH; i++) printf("%02x", tab[i]); printf("\n"); }
bool Checksum::get_final(struct_file* file) { if ( file == NULL ) return false; if ( SHA1_Final(sha1, &sha1_ctx) == 0 || MD5_Final(md5, &md5_ctx) == 0 ) { // error ! return false; } file->sha1.clear(); for ( int i = 0 ; i < SHA_DIGEST_LENGTH ; ++i ) { file->sha1.append(QString::number(sha1[i], 16)); } // FIXME: the MD5 sum is wrong:w file->md5.clear(); for ( int i = 0 ; i < MD5_DIGEST_LENGTH ; ++i ) { file->md5.append(QString::number(md5[i], 16)); } return true; }
// Function which calculates MD5 for comparison with Response Authenticator void GetSubscriberMD5(BYTE subResponseAuth[MD5_DIGEST_LENGTH], RADIUS_PACKET *aaaData, SUBSCRIBER *sub) { int i, j; BYTE hash[MAX_ARGUMENT_LENGTH]; MD5_CTX context; // Init MD5 MD5_Init(&context); // Create string to be hashed and execute MD5 hashing bzero(hash, MAX_ARGUMENT_LENGTH); hash[0] = aaaData->code; hash[1] = aaaData->identifier; memcpy(hash + 2, (unsigned char *)&aaaData->length, 2); memcpy(hash + 4, sub->aaaAuthenticator, 16); memcpy(hash + 20, aaaData->options, htons(aaaData->length) - RADIUS_HEADER_LENGTH); memcpy(hash + ntohs(aaaData->length), Radius_secret, strlen(Radius_secret)); MD5_Update (&context, hash, ntohs(aaaData->length) + strlen(Radius_secret)); MD5_Final (subResponseAuth, &context); return; }
// Password is did_u_really_reverse_me int verify_password(char *pass) { MD5_CTX c; unsigned char digest[16] = { 0x87, 0xe0, 0xbe, 0x2f, 0x4f, 0x39, 0x86, 0x29, 0x5d, 0x86, 0xe3, 0x27, 0xaf, 0x53, 0xee, 0xd2 }; unsigned char pass_digest[16]; int i; MD5_Init(&c); MD5_Update(&c, pass, strlen(pass)); MD5_Final(pass_digest, &c); for (i = 0; i < 16; i++) { if (digest[i] != pass_digest[i]) { return -1; } } return 0; }
unsigned char * Condor_MD_MAC::computeOnce(unsigned char * buffer, unsigned long length, KeyInfo * key) { #ifdef HAVE_EXT_OPENSSL unsigned char * md = (unsigned char *) malloc(MAC_SIZE); MD5_CTX context; MD5_Init(&context); MD5_Update(&context, key->getKeyData(), key->getKeyLength()); MD5_Update(&context, buffer, length); MD5_Final(md, &context); return md; #else return NULL; #endif }
void generate_data( dcp_info_t * info ) { // init static random generator srand(STATIC_SEED); MD5_CTX ctx; int idx; for( idx=0; idx<info->nbuffer; ++idx) { MD5_Init(&ctx); uintptr_t ptr = (uintptr_t) info->buffer[idx]; uintptr_t ptr_e = (uintptr_t)info->buffer[idx] + (uintptr_t)info->size[idx]; while ( ptr < ptr_e ) { unsigned int rui = (unsigned int) rand(); int init_size = ( (ptr_e - ptr) > UI_UNIT ) ? UI_UNIT : ptr_e-ptr; memcpy((void*)ptr, &rui, init_size); MD5_Update( &ctx, (void*)ptr, init_size); ptr += init_size; } assert( ptr == ptr_e ); MD5_Final(info->hash[idx], &ctx); } }
void compute_session_id(u_char session_id[16], u_char cookie[8], BIGNUM* host_key_n, BIGNUM* session_key_n) { u_int host_key_bytes = BN_num_bytes(host_key_n); u_int session_key_bytes = BN_num_bytes(session_key_n); u_int bytes = host_key_bytes + session_key_bytes; u_char *buf = xmalloc(bytes); MD5_CTX md; BN_bn2bin(host_key_n, buf); BN_bn2bin(session_key_n, buf + host_key_bytes); MD5_Init(&md); MD5_Update(&md, buf, bytes); MD5_Update(&md, cookie, 8); MD5_Final(session_id, &md); memset(buf, 0, bytes); xfree(buf); }
static int crypt_all(int *pcount, struct db_salt *salt) { int count = *pcount; int index = 0; #ifdef _OPENMP #pragma omp parallel for #endif #if defined(_OPENMP) || MAX_KEYS_PER_CRYPT > 1 for (index = 0; index < count; index++) #endif { unsigned char hash[16]; MD5_CTX ctx; MD5_Init(&ctx); MD5_Update(&ctx, saved_key[index], strlen(saved_key[index])); MD5_Final(hash, &ctx); hex_encode(hash, 16, (unsigned char*)crypt_out[index]); } return count; }
int stun_produce_integrity_key_str(u08bits *uname, u08bits *realm, u08bits *upwd, u08bits *key) { MD5_CTX ctx; size_t ulen = strlen((s08bits*)uname); size_t rlen = strlen((s08bits*)realm); size_t plen = strlen((s08bits*)upwd); u08bits *str = (u08bits*)malloc(ulen+1+rlen+1+plen+1); strcpy((s08bits*)str,(s08bits*)uname); str[ulen]=':'; strcpy((s08bits*)str+ulen+1,(s08bits*)realm); str[ulen+1+rlen]=':'; strcpy((s08bits*)str+ulen+1+rlen+1,(s08bits*)upwd); MD5_Init(&ctx); MD5_Update(&ctx,str,ulen+1+rlen+1+plen); MD5_Final(key,&ctx); free(str); return 0; }
int gen_md5(headers_t *headers, char *target) { unsigned long key1 = parse_hixie76_key(headers->key1); unsigned long key2 = parse_hixie76_key(headers->key2); char *key3 = headers->key3; MD5_CTX c; char in[HIXIE_MD5_DIGEST_LENGTH] = { key1 >> 24, key1 >> 16, key1 >> 8, key1, key2 >> 24, key2 >> 16, key2 >> 8, key2, key3[0], key3[1], key3[2], key3[3], key3[4], key3[5], key3[6], key3[7] }; MD5_Init(&c); MD5_Update(&c, (void *)in, sizeof in); MD5_Final((void *)target, &c); target[HIXIE_MD5_DIGEST_LENGTH] = '\0'; return 1; }
/* * Computes the proper response to a RSA challenge, and sends the response to * the server. */ static void respond_to_rsa_challenge(BIGNUM * challenge, RSA * prv) { u_char buf[32], response[16]; MD5_CTX md; int i, len; /* Decrypt the challenge using the private key. */ /* XXX think about Bleichenbacher, too */ if (rsa_private_decrypt(challenge, challenge, prv) <= 0) packet_disconnect( "respond_to_rsa_challenge: rsa_private_decrypt failed"); /* Compute the response. */ /* The response is MD5 of decrypted challenge plus session id. */ len = BN_num_bytes(challenge); if (len <= 0 || len > sizeof(buf)) packet_disconnect( "respond_to_rsa_challenge: bad challenge length %d", len); memset(buf, 0, sizeof(buf)); BN_bn2bin(challenge, buf + sizeof(buf) - len); MD5_Init(&md); MD5_Update(&md, buf, 32); MD5_Update(&md, session_id, 16); MD5_Final(response, &md); debug("Sending response to host key RSA challenge."); /* Send the response back to the server. */ packet_start(SSH_CMSG_AUTH_RSA_RESPONSE); for (i = 0; i < 16; i++) packet_put_char(response[i]); packet_send(); packet_write_wait(); memset(buf, 0, sizeof(buf)); memset(response, 0, sizeof(response)); memset(&md, 0, sizeof(md)); }
static int get_full_cksum(struct file *f, FILE **fp) { size_t s=0; MD5_CTX md5; static char buf[FULL_CHUNK]; unsigned char checksum[MD5_DIGEST_LENGTH+1]; if(*fp) fseek(*fp, 0, SEEK_SET); else if(!(*fp=open_file(f))) { f->full_cksum=0; return 0; } if(!MD5_Init(&md5)) { logp("MD5_Init() failed\n"); return -1; } while((s=fread(buf, 1, FULL_CHUNK, *fp))>0) { if(!MD5_Update(&md5, buf, s)) { logp("MD5_Update() failed\n"); return -1; } if(s<FULL_CHUNK) break; } if(!MD5_Final(checksum, &md5)) { logp("MD5_Final() failed\n"); return -1; } memcpy(&(f->full_cksum), checksum, sizeof(unsigned)); return 0; }
void md5String(const char* input1, const char* input2, char** out) { int i; buffer* b = buffer_init(); unsigned char signature[16]; MD5_CTX ctx; MD5_Init(&ctx); if(input1){ //Cdbg(1, "input1 %s", input1); MD5_Update(&ctx, input1, strlen(input1)); } if(input2){ //Cdbg(1, "input2 %s", input2); MD5_Update(&ctx, input2, strlen(input2)); } MD5_Final(signature, &ctx); char tempstring[2]; for(i=0; i<16; i++){ int x = signature[i]/16; sprintf(tempstring, "%x", x); buffer_append_string(b, tempstring); int y = signature[i]%16; sprintf(tempstring, "%x", y); buffer_append_string(b, tempstring); } //Cdbg(1, "result %s", b->ptr); int len = b->used + 1; *out = (char*)malloc(len); memset(*out, '\0', len); strcpy(*out, b->ptr); buffer_free(b); }
char* str2md5(const char* str, int length) { int n; MD5_CTX c; unsigned char digest[16]; char* out = (char*)malloc(33); MD5_Init(&c); while (length > 0) { if (length > 512) MD5_Update(&c, str, 512); else MD5_Update(&c, str, length); length -= 512; str += 512; } MD5_Final(digest, &c); for (n = 0; n < 16; ++n) snprintf(&(out[n * 2]), 16 * 2, "%02x", (unsigned int)digest[n]); return out; }
/* Function to generate key from the passphrase entered by the user */ unsigned char * md5_key_generate(char * a, int len) { MD5_CTX c; unsigned char *digest=(unsigned char*)malloc(16); MD5_Init(&c); while(len>0){ if(len>512){ MD5_Update(&c,a,512); } else{ MD5_Update(&c,a,len); } len-=512; a+=512; } MD5_Final(digest,&c); return digest; }
void doit (void) { MD5_CTX c; unsigned char md[MD5_DIGEST_LENGTH]; if (!gnutls_check_version (LIBGNUTLS_VERSION)) success ("gnutls_check_version ERROR\n"); MD5_Init (&c); MD5_Update (&c, "abc", 3); MD5_Final (&(md[0]), &c); if (memcmp (md, "\x90\x01\x50\x98\x3c\xd2\x4f\xb0" "\xd6\x96\x3f\x7d\x28\xe1\x7f\x72", sizeof (md)) != 0) { hexprint (md, sizeof (md)); fail ("MD5 failure\n"); } else success ("MD5 OK\n"); }
u_int res_nrandomid(res_state statp) { struct timeval now; u_int16_t u16; MD5_CTX ctx; u_char *rnd = statp->_rnd == NULL ? srnd : statp->_rnd; gettimeofday(&now, NULL); u16 = (u_int16_t) (now.tv_sec ^ now.tv_usec); memcpy(rnd + 14, &u16, 2); #ifndef HAVE_MD5 MD5_Init(&ctx); MD5_Update(&ctx, rnd, 16); MD5_Final(rnd, &ctx); #else MD5Init(&ctx); MD5Update(&ctx, rnd, 16); MD5Final(rnd, &ctx); #endif memcpy(&u16, rnd + 14, 2); return ((u_int) u16); }
static int crypt_all(int *pcount, struct db_salt *salt) { const int count = *pcount; int index = 0; #ifdef _OPENMP #pragma omp parallel for for (index = 0; index < count; index++) #endif { // hash is compressor(md5(password)) MD5_CTX ctx; unsigned char *out = (unsigned char*)crypt_out[index]; unsigned char hash[16]; MD5_Init(&ctx); MD5_Update(&ctx, saved_key[index], saved_len[index]); MD5_Final(hash, &ctx); compressor(hash, out); } return count; }
unsigned char* samHive::generateHashedBootKey(unsigned char* bootKey) { unsigned char aqwerty[] = "!@#$%^&*()qwertyUIOPAzxcvbnmQQQQQQQQQQQQ)(*@&%"; unsigned char anum[] = "0123456789012345678901234567890123456789"; MD5_CTX md5Context; unsigned char md5Hash[0x10]; RC4_KEY rc4Key; unsigned char* hashedBootKey = new unsigned char[0x20]; unsigned char* fValue = this->getGlobalFValue(); MD5_Init(&md5Context); MD5_Update(&md5Context, &fValue[0x70], 0x10); MD5_Update(&md5Context, aqwerty, 0x2f); MD5_Update(&md5Context, bootKey, 0x10); MD5_Update(&md5Context, anum, 0x29); MD5_Final(md5Hash, &md5Context); RC4_set_key(&rc4Key, 0x10, md5Hash); RC4(&rc4Key, 0x20, &fValue[0x80], hashedBootKey); return hashedBootKey; }
char *check_validity( const char *certPath, const char *origFile, unsigned char *signature, char* caPath ) { MD5_CTX md5CTX; int rbytes; unsigned char md5_md[MD5_DIGEST_LENGTH], rbuf[2048]; SSL_load_error_strings(); SSL_library_init(); if (!is_file(origFile)) { return NULL; } FILE* of = boinc_fopen(origFile, "r"); if (!of) return NULL; MD5_Init(&md5CTX); while (0 != (rbytes = (int)fread(rbuf, 1, sizeof(rbuf), of))) { MD5_Update(&md5CTX, rbuf, rbytes); } MD5_Final(md5_md, &md5CTX); fclose(of); DIRREF dir = dir_open(certPath); char file[MAXPATHLEN]; while (!dir_scan(file, dir, sizeof(file))) { char fpath[MAXPATHLEN]; snprintf(fpath, sizeof(fpath), "%s/%s", certPath, file); // TODO : replace '128' if (check_validity_of_cert(fpath, md5_md, signature, 128, caPath)) { dir_close(dir); return strdup(fpath); } } dir_close(dir); return NULL; }
int check_fmhdr(char *b, ssize_t len) { if (gV > 1) puts("check_fmhdr"); MD5_CTX context; frm_t *buf = (frm_t *) b; unsigned char cmp_digest[0x10] = {0}, hdr_digest[0x10]; unsigned char cmp_signature[0x20] = {0}, hdr_signature[0x20]; unsigned char cmp_randseq[0x10] = {0}, hdr_randseq[0x10]; memcpy(hdr_signature, buf->h.fm_signature, sizeof(hdr_signature)); memset(buf->h.fm_signature, 0, 0x20); memcpy(hdr_digest, buf->h.fm_digest, sizeof(hdr_digest)); memset(buf->h.fm_digest, 0, 0x10); MD5_Init(&context); // Compute hash MD5_Update(&context, buf, len); MD5_Final(cmp_digest, &context); memcpy(hdr_randseq, buf->h.fm_randseq, sizeof(hdr_randseq)); memset(buf->h.fm_randseq, 0, sizeof(buf->h.fm_randseq)); nsdigest(cmp_randseq, (char *)buf, len); // Compute digest memcpy(buf->h.fm_randseq, cmp_randseq, sizeof(buf->h.fm_randseq)); memcpy(buf->h.fm_digest, cmp_digest, sizeof(buf->h.fm_digest)); memcpy(buf->h.fm_signature, cmp_signature, sizeof(buf->h.fm_signature)); if (memcmp(cmp_digest, hdr_digest, sizeof(hdr_digest))) { puts("Header digest error"); print_digest(cmp_digest); print_digest(hdr_digest); return -1; } if (memcmp(cmp_randseq, hdr_randseq, sizeof(hdr_randseq))) { puts("Header randseq error"); print_digest_x(cmp_randseq, 0x20); print_digest_x(hdr_randseq, 0x20); return -1; } puts ("Header OK!"); return 0; }