Thread: addition modulo 2^32 with unsigned ints (integer constant too large)

Hello all,

I have recently started to implement the SHA-256 checksum algorithm in C as an education exercise. I was moving along quite well until I reached the point where I needed to perform addition modulo 2^32 on a number of 32-bit words.

Basically, I am storing these 32-bit chunks and I need to perform this addition modulo 2^32 as stated in the specification.

The code:

Code:

#define BOUND 0x100000000    /* 2^32 */

unsigned int schedule[blocks][64];

...
unsigned int temp = (F4(schedule[i][j-2]) + schedule[i][j-7]) % BOUND;
temp = (temp + ((F3(schedule[i][j-15]) + schedule[i][j-16]) % BOUND)) % BOUND;

schedule[i][j] = temp;

The compiler prints the following warning for the code using the modulus operator:

sha_256.c:246: warning: integer constant is too large for ‘long’ type

F3 and F4 are functions defined by the specification which rotate and shift the bits of a 32-bit word. I know I am supposed to be storing this into 32-bits, but if I mod 2^32 apparently this won't work.

Can someone help me see what I am not understanding with the specification and/or my code? I suppose theoretically I could be summing (2^32-1) or a similarly large number, but that would just cause problems when i store the value. I am not sure exactly why this is a problem.

Thanks for looking!

(hopefully I explained everything enough, if not, let me know as I am sure you will)

And more to the point, if you are using 32-bit unsigned integers, you are doing arithmetic modulo 2^32 anyway (since overflow of unsigned is guaranteed to work that way).

The warning is coming from the fact that a "plain old number" in the text of your program must be an int, so the literal "0x100000000" in your code must be an int, but it doesn't fit. To force the compiler to treat it as a long long, you must make it "0x100000000LL". Of course, it doesn't matter here, since we don't need it anyway, but for future reference.

Thanks for the replies though! However, I wish I would have realized what I was doing myself!

EDIT: Good info! Thanks again!

Code:

  unsigned long long temp = 256 % BOUND;

  printf("sizeof(unsigned long long) = %d\n", sizeof(unsigned long long));
  printf("result: %lld\n", temp);

%lld is for signed long longs. Use %llu is for unsigned long longs.

sizeof returns size_t. To print that in C99, use %zu. In C89, cast to unsigned long and use %lu.

A postfix of ULL to integer literals makes an unsigned long long.

Well, I actually got the program working after my blunders. Learned quite a bit in the process.

At first I thought debugging the program was going to be a nightmare, but then one simple fix gave me the correct hash values. I had to use htonl() to force big-endian storage of the data.

Thanks a lot for the tips though!