recasting a unsigned char array to an unsigned long array

Question

Ok, I'm using a raw SHA1 hash to seed a Mersenne Twister pseudo-random number generator the generator gives me the option to seed either with an unsigned long or a array of unsigned longs

the SHA1 class I'm using gives me the hash as a 20 byte array of unsigned chars

I figured I could recast this array of chars to an array of longs to get a working seed but how can I know how long the resulting array of longs is?

example code:

CSHA1 sha1;
sha1.Update((unsigned char*)key, size_key);
sha1.Final();
unsigned char* hash;
sha1.GetHash(hash);

// Seed the random with the key
MTRand mt((unsigned long*)hash, <size of array of longs>);

I'm hoping that there is no data loss (as in no bytes are dropped off) as I need this to remain cryptography secure

score 1 · Answer 1 · answered Oct 23 '12 at 01:47

1

You can use len_of_chars * sizeof(char) / sizeof(long), where len_of_chars is presumably 20.

answered Oct 23 '12 at 01:47

Lily Ballard

182,031
33
381
347

@aib: Sure, but it makes it more obvious what you're doing if you leave it in there. The compiler will evaluate the expression into a constant anyway. – Lily Ballard Oct 23 '12 at 02:28

Gene · Accepted Answer · 2012-10-23T02:36:45.543

You can say

sizeof(unsigned long) / sizeof(unsigned char)

to get the number of octets in a long.

However there are two potential problems with simply casting.

First, the array of chars might not be properly aligned. On some processors this can cause a trap. On others it just slows execution.

Second, you're asking for byte order problems if the program must work the same way on different architecutures.

You can solve both problems by copying the bytes into an array of longs explicitly. Untested code:

const int bytes_per_long = sizeof(unsigned long) / sizeof(unsigned char);
unsigned long hash_copy[key_length_in_bytes / bytes_per_long];
int i_hash = 0;
for (int i_copy = 0; i_copy < sizeof hash_copy / sizeof hash_copy[0]; i_copy++) {
  unsigned long b = 0;
  for (int i_byte = 0; i_byte < bytes_per_long; i_byte++)
    b = (b << 8) | hash[i_hash++];
  hash_copy[i_copy] = b;
}
// Now use hash_copy.

You're right. Thanks. I had an explicit word copy (which I just replaced) and deleted it. It's been a long day. — Gene, Oct 23 '12 at 02:39

aib · Answer 3 · 2012-10-23T02:40:10.940

Your library seems to assume 32-bit unsigned longs, so there's no [more] harm in you doing the same. In fact, I'd go as far to assume 8-bit unsigned chars and perhaps even unpadded, little-endian representations for both. So you could use a simple cast (though I'd use a reinterpret_cast), or maybe @Gene's memcpy sample for alignment.

Portable code*, however, should use <cstdint>, the uint#_t types therein and piecewise, by-value copying for conversion:

uint32_t littleEndianInt8sToInt32(uint8_t bytes[4]) {
    return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
}

...and better names. Sorry, it's getting late here :)

*: Though, of course, stdint itself isn't very portable (>= C++11) and the exact-width types aren't guaranteed to be in it. Ironic.

Not relevant to the question, but supplements the answer: [Portable C++ 03 Exact Width Types](http://stackoverflow.com/questions/1481733/portable-c-03-exact-width-types) — aib, Oct 23 '12 at 02:43

recasting a unsigned char array to an unsigned long array

3 Answers3