Online MD5 Hash Generator

I need to compare the MD5 hash of a specific value in my mockMvc response body to a header of the same request. I'm not sure how to do this given that there doesn't seem to be an easy way to get the content of a jsonPath or xPath matcher. I think something like this is the closest I've managed to get. I'm fairly sure I need to approach this from the header side since MD5 is not easily reversed.

mockMvc.perform(get(url)                .session(session)                .andExpect(header().string(ETAG,  convertToMD5(jsonPath("$.object.id"))));

Is there a way to do this, preferably without writing a custom Matcher?

I am updating the md5 to sha512 for DPM authorizenet- Please help me out -

I am not getting it work.

see code change -

while generating fingerprint for x_hp_hash -

from md5 -

if (function_exists('hash_hmac')) {return hash_hmac("md5", $api_login_id . "^" . $fp_sequence . "^" . $fp_timestamp . "^" . $amount . "^", $transaction_key); }return bin2hex(mhash(MHASH_MD5, $api_login_id . "^" . $fp_sequence . "^" . $fp_timestamp . "^" . $amount . "^", $transaction_key));

to sha512 -

$signature_key = hex2bin($signature_key);if (function_exists('hash_hmac')) {return hash_hmac("sha512", $api_login_id . "^" . $fp_sequence . "^" . $fp_timestamp . "^" . $amount . "^", $signature_key); }return bin2hex(mhash(MHASH_SHA512, $api_login_id . "^" . $fp_sequence . "^" . $fp_timestamp . "^" . $amount . "^", $signature_key));

While getting reponse and comparing the x_sha_hash value from md5 -

if(strtoupper(md5($this->md5_setting . $this->api_login_id . $this->transaction_id . $amount)) == $this->md5_hash){        //valid } else{        //not valid }

Changed to sha512 -

$this->signature_key = hex2bin($this->signature_key);$string = '^'.$this->api_login_id.'^'.$this->transaction_id.'^'.$amount.'^';if(strtoupper(HASH_HMAC('sha512', $string, $this->signature_key)) == $this->SHA2_Hash){  //valid} else{  //not valid}

What I am doing wrong?When validating the transaction at my end it is saying please check your md5 setting. It validates on the basis of last code shown in the snippet.

my signature Key = E284BDC12A45A7F5B0933A352EB1C3F25E91A3B92360693D94E4366190EF12E78F6CFE8601751F719DA7A72ABBA117BF0161F8A1DD894DADE3C56A838D8355AD

x_hp_hash submitting using the second code snippet (i.e sha512 fingerprint)x_hp_hash = b4c9e1878f88aa9c4f808761ed8ceee71ab117cc0f1297b2d850e28351f08fc52bd528a7538c832568c674a1d5095ead1a5383a626c9797587ab16bae76e45fb

after submitting getting in reponse -

X_SHA2_Hash - 19AB7947709CF6CB2B8415784EBD7669FCDE5D83B69EC8C716203806A3235308187668F5783F9CA0F1AE8A47808EDAB241025A8AF61A2FABC27FA6AAAEA8FFD8

generated hash code - 3E6427E67271B1F0732D3D95217D25EE4D7C4103C906A6CB70943498698157F48F7BECD5C7E5393CF2A489B464070A7778F15757385E8F29029CFC3F66256F05

using last snippet above.

so these are not equal so not a valid transaction.

I want to re-create the MyBB hashing process so I can use its database to authenticate users on a 3rd party app (written on C#).

MyBB uses:

md5(md5($salt).password)

My problem is that the result I get on C# is nowhere similar to the one MyBB gets.

What I've done on C#:

public string HashPass(string password, string salt){    MD5 md5 = new MD5CryptoServiceProvider();    byte[] saltHash =md5.ComputeHash(System.Text.Encoding.ASCII.GetBytes(salt));    string passwordAndSalt = password + System.Text.Encoding.ASCII.GetString(saltHash);    byte[] finalHash = md5.ComputeHash(System.Text.Encoding.ASCII.GetBytes(passwordAndSalt));    string final = System.Text.Encoding.ASCII.GetString(finalHash);    return final;}

The result I get from using that function for password "Test123" and salt "0fYR6mEE" (gathered from MyBB db) is: "??R?????s??" while the actual result should look like "VaHffsyzJeEa4dB3bbMWeUlJObAfN5I9rf1CuNRXCa6xPJTzXL".

Most likely I'm missing something obvious, sorry about that.

I've recently been attempting to recreate the MD5 algorithm in C++ in order to implement it, later, as part of a CUDA project for a class. I've read over various resources, including RFC1321, various example implementations (CUDA project #1, CUDA project #2, C implementation gist), the Wikipedia page, and another question here on SO on the same topic.

My code currently is the following:

#include <iostream>#include <sstream>#include <string>#include <cstring>using namespace std;#define MD5_INPUT_LENGTH 64// Unsigned character - 8 bitstypedef unsigned char uchar_8;// Unsigned int - 32 bitstypedef unsigned int uint_32;// Unsigned long - 64 bit (for lengths)typedef unsigned long uint_64;static const uint_32 T[64] = {  0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,  0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,  0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,  0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,  0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,  0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,  0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,  0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,  0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,  0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,  0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,  0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,  0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,  0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,  0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,  0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};// Magic values for initializationstatic const uint_32 A0 = 0x67452301;static const uint_32 B0 = 0xefcdab89;static const uint_32 C0 = 0x98badcfe;static const uint_32 D0 = 0x10325476;inline uint_32 F(uint_32 x, uint_32 y, uint_32 z) {  return ((x & y) | (~x & z));}inline uint_32 G(uint_32 x, uint_32 y, uint_32 z) {  return ((x & y) | (y & ~z));}inline uint_32 H(uint_32 x, uint_32 y, uint_32 z) {  return (x ^ y ^ z);}inline uint_32 I(uint_32 x, uint_32 y, uint_32 z) {  return (y ^ (x | ~z));}// Logical wrapping left shift handlinginline uint_32 shift(uint_32 x, uint_32 s) {  return ((x << s) | (x >> (32 - s)));}// Round 1 handlerinline void FF(uint_32 &a, uint_32 b, uint_32 c, uint_32 d, uint_32 x, uint_32 s, uint_32 t) {  a += F(b, c, d) + x + t;  a = shift(a, s) + b;}// Round 2 handlerinline void GG(uint_32 &a, uint_32 b, uint_32 c, uint_32 d, uint_32 x, uint_32 s, uint_32 t) {  a += G(b, c, d) + x + t;  a = shift(a, s) + b;}// Round 3 handlerinline void HH(uint_32 &a, uint_32 b, uint_32 c, uint_32 d, uint_32 x, uint_32 s, uint_32 t) {  a += H(b, c, d) + x + t;  a = shift(a, s) + b;}// Round 4 handlerinline void II(uint_32 &a, uint_32 b, uint_32 c, uint_32 d, uint_32 x, uint_32 s, uint_32 t) {  a += I(b, c, d) + x + t;  a = shift(a, s) + b;}uint_32 *md5Pad(char *charBuf, uint_64 len) {  // Number of characters in buffer * 8 mod 64  uint_64 newLen;  for (newLen = len * 8 + 1; newLen % 512 != 448; newLen++);  newLen /= 8;  // Initialize result buffer with null characters  uint_32 *buf = new uint_32[newLen + 64];  memset(buf, 0, newLen + 64);  // Copy bytes from characters into uint memory space, no conversion necessary  memcpy(buf, charBuf, len);  // Append terminating char  buf[len] = 0x80;  // Append length to buffer  uint_32 bitsLen = len * 8;  memcpy(buf + newLen, &bitsLen, 4);  return buf;}void MD5(uint_32 *outBuf, uint_32 *inBuf) {  uint_32 a, b, c, d;  const uint_32 a0 = 0x67452301;  const uint_32 b0 = 0xEFCDAB89;  const uint_32 c0 = 0x98BADCFE;  const uint_32 d0 = 0x10325476;  a = a0;  b = b0;  c = c0;  d = d0;  // Shift amounts 1st round  static const uchar_8 S11 =  7;  static const uchar_8 S12 = 12;  static const uchar_8 S13 = 17;  static const uchar_8 S14 = 22;  FF ( a, b, c, d, inBuf[ 0], S11, T[ 0]); /* 1 */  FF ( d, a, b, c, inBuf[ 1], S12, T[ 1]); /* 2 */  FF ( c, d, a, b, inBuf[ 2], S13, T[ 2]); /* 3 */  FF ( b, c, d, a, inBuf[ 3], S14, T[ 3]); /* 4 */  FF ( a, b, c, d, inBuf[ 4], S11, T[ 4]); /* 5 */  FF ( d, a, b, c, inBuf[ 5], S12, T[ 5]); /* 6 */  FF ( c, d, a, b, inBuf[ 6], S13, T[ 6]); /* 7 */  FF ( b, c, d, a, inBuf[ 7], S14, T[ 7]); /* 8 */  FF ( a, b, c, d, inBuf[ 8], S11, T[ 8]); /* 9 */  FF ( d, a, b, c, inBuf[ 9], S12, T[ 9]); /* 10 */  FF ( c, d, a, b, inBuf[10], S13, T[10]); /* 11 */  FF ( b, c, d, a, inBuf[11], S14, T[1]); /* 12 */   FF ( a, b, c, d, inBuf[12], S11, T[12]); /* 13 */  FF ( d, a, b, c, inBuf[13], S12, T[13]); /* 14 */  FF ( c, d, a, b, inBuf[14], S13, T[14]); /* 15 */  FF ( b, c, d, a, inBuf[15], S14, T[15]); /* 16 */  // Shift amounts 2nd round  static const uchar_8 S21 =  5;  static const uchar_8 S22 =  9;  static const uchar_8 S23 = 14;  static const uchar_8 S24 = 20;  GG ( a, b, c, d, inBuf[ 1], S21, T[16]); /* 17 */  GG ( d, a, b, c, inBuf[ 6], S22, T[17]); /* 18 */  GG ( c, d, a, b, inBuf[11], S23, T[18]); /* 19 */  GG ( b, c, d, a, inBuf[ 0], S24, T[19]); /* 20 */  GG ( a, b, c, d, inBuf[ 5], S21, T[20]); /* 21 */  GG ( d, a, b, c, inBuf[10], S22, T[21]); /* 22 */  GG ( c, d, a, b, inBuf[15], S23, T[22]); /* 23 */  GG ( b, c, d, a, inBuf[ 4], S24, T[23]); /* 24 */  GG ( a, b, c, d, inBuf[ 9], S21, T[24]); /* 25 */  GG ( d, a, b, c, inBuf[14], S22, T[25]); /* 26 */  GG ( c, d, a, b, inBuf[ 3], S23, T[26]); /* 27 */  GG ( b, c, d, a, inBuf[ 8], S24, T[27]); /* 28 */  GG ( a, b, c, d, inBuf[13], S21, T[28]); /* 29 */  GG ( d, a, b, c, inBuf[ 2], S22, T[29]); /* 30 */  GG ( c, d, a, b, inBuf[ 7], S23, T[30]); /* 31 */  GG ( b, c, d, a, inBuf[12], S24, T[31]); /* 32 */  // Shift amounts 3rd round  static const uchar_8 S31 =  4;  static const uchar_8 S32 = 11;  static const uchar_8 S33 = 16;  static const uchar_8 S34 = 23;  HH ( a, b, c, d, inBuf[ 5], S31, T[32]); /* 33 */  HH ( d, a, b, c, inBuf[ 8], S32, T[33]); /* 34 */  HH ( c, d, a, b, inBuf[11], S33, T[34]); /* 35 */  HH ( b, c, d, a, inBuf[14], S34, T[35]); /* 36 */  HH ( a, b, c, d, inBuf[ 1], S31, T[36]); /* 37 */  HH ( d, a, b, c, inBuf[ 4], S32, T[37]); /* 38 */  HH ( c, d, a, b, inBuf[ 7], S33, T[38]); /* 39 */  HH ( b, c, d, a, inBuf[10], S34, T[39]); /* 40 */  HH ( a, b, c, d, inBuf[13], S31, T[40]); /* 41 */  HH ( d, a, b, c, inBuf[ 0], S32, T[41]); /* 42 */  HH ( c, d, a, b, inBuf[ 3], S33, T[42]); /* 43 */  HH ( b, c, d, a, inBuf[ 6], S34, T[43]); /* 44 */  HH ( a, b, c, d, inBuf[ 9], S31, T[44]); /* 45 */  HH ( d, a, b, c, inBuf[12], S32, T[45]); /* 46 */  HH ( c, d, a, b, inBuf[15], S33, T[46]); /* 47 */  HH ( b, c, d, a, inBuf[ 2], S34, T[47]); /* 48 */  // Shift amounts 4th round  static const uchar_8 S41 =  6;  static const uchar_8 S42 = 10;  static const uchar_8 S43 = 15;  static const uchar_8 S44 = 21;  II ( a, b, c, d, inBuf[ 0], S41, T[48]); /* 49 */  II ( d, a, b, c, inBuf[ 7], S42, T[49]); /* 50 */  II ( c, d, a, b, inBuf[14], S43, T[50]); /* 51 */  II ( b, c, d, a, inBuf[ 5], S44, T[51]); /* 52 */  II ( a, b, c, d, inBuf[12], S41, T[52]); /* 53 */  II ( d, a, b, c, inBuf[ 3], S42, T[53]); /* 54 */  II ( c, d, a, b, inBuf[10], S43, T[54]); /* 55 */  II ( b, c, d, a, inBuf[ 1], S44, T[55]); /* 56 */  II ( a, b, c, d, inBuf[ 8], S41, T[56]); /* 57 */  II ( d, a, b, c, inBuf[15], S42, T[57]); /* 58 */  II ( c, d, a, b, inBuf[ 6], S43, T[58]); /* 59 */  II ( b, c, d, a, inBuf[13], S44, T[59]); /* 60 */  II ( a, b, c, d, inBuf[ 4], S41, T[60]); /* 61 */  II ( d, a, b, c, inBuf[11], S42, T[61]); /* 62 */  II ( c, d, a, b, inBuf[ 2], S43, T[62]); /* 63 */  II ( b, c, d, a, inBuf[ 9], S44, T[63]); /* 64 */  // Re-add initialization magic values  a += a0;  b += b0;  c += c0;  d += d0;  outBuf[0] = a;  outBuf[1] = b;  outBuf[2] = c;  outBuf[3] = d;  return;}string intToHexReverseEndian(uint_32 val) {  ostringstream ss;  ss << hex << ((val >>  0) & 0xFF);  ss << hex << ((val >>  8) & 0xFF);  ss << hex << ((val >> 16) & 0xFF);  ss << hex << ((val >> 24) & 0xFF);  return ss.str();}int main() {  char *srcStr = "";  uint_32 *padded = md5Pad(srcStr, strlen(srcStr));  uint_32 result[4] = {0};  MD5(result, padded);  uchar_8 digestChars[16] = {0};  memcpy(digestChars, result, 16);  cout << "Digest: "     << intToHexReverseEndian(result[0])    << intToHexReverseEndian(result[1])    << intToHexReverseEndian(result[2])    << intToHexReverseEndian(result[3])    << endl;  delete[] padded;  return 0;}

I have been unable to get it to produce the correct hashes and I am unsure why, primarily because the implementations I have seen and attempted to work with have all varied in different ways.

Part of my problem may be due to some of mixing and matching of C and C++ code I've done in my various attempts, but I believe it has more to do with the way I'm copying the char/unsigned int values around, switching between them, and potentially the little endian format.

Currently the output I am getting is Digest: 1aa849c0fde5f2bf548522832ab2d27, which is not the correct hash for an empty string (d41d8cd98f00b204e9800998ecf8427e). Does anyone know why, or where I should look to fix it?

I am using Digest::MD5 to compute MD5 of a data stream; namely a GZIPped file (or to be precise, 3000) that are much too large to fit in RAM. So I'm doing this:

 use Digest::MD5 qw(md5_base64); my ($filename) = @_;                # this is in a sub my $ctx = Digest::MD5 -> new; $openme = $filename;        # Usually, it's a plain file $openme = "gunzip -c '$filename' |" if ($filename =~ /\.gz$/); # is gz open (FILE, $openme); # gunzip to STDOUT binmode(FILE); $ctx -> addfile(*FILE);   # passing filehandle close(FILE);

This is a success. addfile neatly slurps in the output of gunzip and gives a correct MD5.

However, I would really, really like to know the size of the slurped data (gunzipped "file" in this case).

I could add an additional

  $size = 0 + `gunzip -c very/big-file.gz | wc -c`;

but that would involve reading the file twice.

Is there any way to extract the number of bytes slurped from Digest::MD5? I tried capturing the result: $result = $ctx -> addfile(*FILE); and doing Data::Dumper on both $result and $ctx, but nothing interesting emerged.

Edit: The files are often not gzipped. Added code to show what I really do.