OpenSSL MD5 gives a different hash every time

Question

I'm trying to create a certain modular code using OpenSSL's EVP API for MD5 by passing the EVP_MD object within functions as shown below.

#include <stdio.h>
#include <string.h>
#include <openssl/evp.h>

EVP_MD* md5_digest_init() {
  OpenSSL_add_all_digests();
  EVP_MD *md = EVP_get_digestbyname("MD5");
  if(!md) {
     printf("Unable to init MD5 digest\n");
     exit(1);
   }
  return md;
}

unsigned char *md5_digest_process(EVP_MD* md, unsigned char *input_text) {
    EVP_MD_CTX mdctx;
    unsigned char hash[EVP_MAX_MD_SIZE];
    int hash_len;
    EVP_MD_CTX_init(&mdctx);
    EVP_DigestInit_ex(&mdctx, md, NULL);
    EVP_DigestUpdate(&mdctx, input_text, strlen(input_text)+1);
    EVP_DigestFinal_ex(&mdctx, hash, &hash_len);
    EVP_MD_CTX_cleanup(&mdctx);
    return hash;
}

int main() {
  EVP_MD *md;
  md = md5_digest_init();
  unsigned char* res;
  res = md5_digest_process(md, "foobar");
  printf("%02x", res);
  return 0;
}

The problem is that on executing the code every time, I obtain a different hash value for the same text.

Such as

585c64a0
554454a0
5f75a4a0, etc

MD5 is deterministic and such an issue should not exist. Any reason why such as error exists? Also, the passing of the EVP_MD object within functions is important to me.

EDIT:

Replacing the final printf with the following code

for(int i = 0; i < 16; ++i)
    printf("%02x", res[i]);

I get the following output.

b4000000000000000100000000000000

However, this stays the same for all executions. But I'm guessing that this hash isn't right.

you're returning a reference to a local variable... then you're printing it as an hex integer... — Jean-François Fabre, Jun 20 '17 at 20:32
`printf("%02x", res);` ? Are you sure you are actually getting the output from the code presented? Do you know, MD5 hash is 16 byte long? — Eugene Sh., Jun 20 '17 at 20:34
@EugeneSh. I'm aware of that, however for this example I wanted to avoid a `for` loop and just check for initial patterns. — saruftw, Jun 20 '17 at 20:38
Apparently you cannot, unless you make openssl to output the hash as a printable string. Or if you want to print first few bytes, you need to dereference the pointer. But as @Jean-FrançoisFabre mentioned, this pointer is invalid as it is pointing to a variable which does not exist anymore. — Eugene Sh., Jun 20 '17 at 20:39
Also see [EVP Message Digests](https://wiki.openssl.org/index.php/EVP_Message_Digests) on the OpenSSL wiki. — jww, Jun 20 '17 at 20:41
https://stackoverflow.com/questions/6441218/can-a-local-variables-memory-be-accessed-outside-its-scope — Dark Falcon, Jun 20 '17 at 20:44

Remy Lebeau · Accepted Answer · 2017-06-20T21:07:04.707

As stated in comments, md5_digest_process() is returning a pointer to a local variable that goes out of scope when the function exits, leaving the pointer dangling as it is left pointing to invalid memory.

But that doesn't matter to your issue, because you are printing the memory address that the pointer is pointing at, not the data that it is pointing at. So your printed output is displaying whatever random memory address the local hash variable existed at when the function was called. That is why you are seeing inconsistent values in your output. As stated in comments, you need to dereference the pointer in order to print the data that is being pointed at.

If you want to return a pointer to memory that outlives the function, you have to allocate the memory dynamically:

unsigned char* md5_digest_process(EVP_MD* md, unsigned char *input_text, int *hash_len) {
    unsigned char *hash = (unsigned char *) malloc(EVP_MAX_MD_SIZE);
    if (!hash) return NULL;
    EVP_MD_CTX mdctx;
    EVP_MD_CTX_init(&mdctx);
    EVP_DigestInit_ex(&mdctx, md, NULL);
    EVP_DigestUpdate(&mdctx, input_text, strlen(input_text)+1);
    EVP_DigestFinal_ex(&mdctx, hash, hash_len);
    EVP_MD_CTX_cleanup(&mdctx);
    return hash;
}

int main() {
  EVP_MD *md = md5_digest_init();
  int hash_len = 0;
  unsigned char* res = md5_digest_process(md, "foobar", &hash_len);
  if (res) {
    for(int i = 0; i < hash_len; ++i) {
      printf("%02x", res[i]);
    }
    free(res)
  }
  return 0;
}

Otherwise, the caller will have to allocate the memory and pass it into the function to fill in:

int md5_digest_process(EVP_MD* md, unsigned char *input_text, unsigned char* hash) {
    EVP_MD_CTX mdctx;
    int hash_len = 0;
    EVP_MD_CTX_init(&mdctx);
    EVP_DigestInit_ex(&mdctx, md, NULL);
    EVP_DigestUpdate(&mdctx, input_text, strlen(input_text)+1);
    EVP_DigestFinal_ex(&mdctx, hash, &hash_len);
    EVP_MD_CTX_cleanup(&mdctx);
    return hash_len;
}

int main() {
  EVP_MD *md = md5_digest_init();
  unsigned char hash[EVP_MAX_MD_SIZE];
  int hash_len = md5_digest_process(md, "foobar", hash);
  for(int i = 0; i < hash_len; ++i) {
    printf("%02x", res[i]);
  }
  return 0;
}

Thanks for the clear explanation! So it was the dangling pointer after all? — saruftw, Jun 20 '17 at 20:57
@saruftw: that is only part of it. There is another aspect to your issue. I have updated my answer. — Remy Lebeau, Jun 20 '17 at 21:05

score 2 · Answer 2 · answered Jun 20 '17 at 20:49

I think you are close. I would probably change md5_digest_process to:

/* md_digest is declared as unsigned char md_digest[EVP_MAX_MD_SIZE] */
unsigned int md5_digest_process(EVP_MD* md, unsigned char *input_text, unsigned int input_len, unsigned char* md_digest)
{
    int hash_len;
    EVP_MD_CTX mdctx;

    EVP_MD_CTX_init(&mdctx);
    EVP_DigestInit_ex(&mdctx, md, NULL);
    EVP_DigestUpdate(&mdctx, input_text, input_len);
    EVP_DigestFinal_ex(&mdctx, md_digest, &hash_len);
    EVP_MD_CTX_cleanup(&mdctx);
    return hash_len;
}

Then, print md_digest with:

int main()
{
  EVP_MD *md;
  unsigned char hash[EVP_MAX_MD_SIZE];
  unsigned int hash_len;

  md = md5_digest_init();
  hash_len = md5_digest_process(md, "foobar", 6, hash);

  for(unsigned int i=0; i<hash_len; i++)
      printf("%02x", hash[i]);
  printf("\n");

  return 0;
}

You should also add some error checking.

It would make more sense to use `size_t` for `input_len`. So you also avoid truncations and other errors (`EVP_DigestUpdate()` also use size_t) — 12431234123412341234123, Jun 20 '17 at 21:35

OpenSSL MD5 gives a different hash every time

2 Answers2