Why do they want an 'unsigned char*' and not just a normal string or 'char*'

Question

EDIT: After taking adivce I have rearranged the parameters & types. But the application crashes when I call the digest() function now? Any ideas whats going wrong?

const std::string message = "to be encrypted";
unsigned char* hashMessage;

SHA256::getInstance()->digest( message, hashMessage ); // crash occurs here, what am I doing wrong?
printf("AFTER: n"); //, hashMessage); // line never reached

I am using an open source implementation of the SHA256 algorithm in C++. My problem is understanding how to pass a unsigned char* version of my string so it can be hashed?

This is the function that takes a unsigned char* version of my string:

void SHA256::digest(const std::string &buf, unsigned char *dig) {
    init();
    update(reinterpret_cast<const unsigned char *>(buf.c_str()), static_cast<unsigned int>(buf.length()));
    final();
    digest(dig);
}

How can I convert my string(which I want hashed) to an unsigned char*?

The following code I have made causes a runtime error when I go to print out the string contents:

const std::string hashOutput;
char message[] = "to be encrypted";

printf("BEFORE: %s bb\n", hashOutput.c_str());
SHA256::getInstance()->digest( hashOutput, reinterpret_cast<unsigned char *>(message) );
printf("AFTER: %s\n", hashOutput.c_str()); // CRASH occurs here

PS: I have been looking at many implementations of SHA256 & they all take an unsigned char* as the message to be hashed. Why do they do that? Why not a char* or a string instead?

Answer 1

You have the parameters around the wrong way. Buf is the input (data to be hashed) and dig is the output digest ( the hash).

Furthermore, a hash is binary data. You will have to convert said binary data into some string representation prior to printing it to screen. Normally, people choose to use a hexadecimal string for this.

Answer 2

The reason that unsigned char is used is that it has guaranteed behaviours under bitwise operations, shifts, and overflow.

char , (when it corresponds to signed char ) does not give any of these guarantees, and so is far less useable for operations intended to act directly on the underlying bits in a string.

---

The answer to the question: "why does it crash?" is "you got lucky!". Your code has undefined behaviour. In short, you are writing through a pointer hashMessage that has never been initialised to point to any memory. A short investigation of the source code for the library that you are using reveals that it requires the digest pointer to point to a block of valid memory that is at least SHA256_DIGEST_SIZE char s long.

To fix this problem, all that you need to do is to make sure that the pointer that you pass in as the digest argument ( hashMessage ) is properly initialised, and points to a block of memory of sufficient size. In code:

const std::string message("to be encrypted");
unsigned char hashMessage[SHA256_DIGEST_SIZE];

SHA256::getInstance()->digest( message, hashMessage );

//hashMessage should now contain the hash of message.

Answer 3

I don't know how a SHA256 hash is produced but maybe it involves some sort of arithmetic that needs to be done on a unsigned data type.

Why does it matter? Get a char* from your string object by calling the c_str() method then cast to unsigned char* .