Tukukkk

Most implementations of SHA-1 (even on Wikipedia) I came across are coded for big-endian runtimes. So I'm trying to implement my own version for my machine (little-endian).

I've followed the pseudo-code form Wikipedia and have the following code. I found a function that converts the byte ordering but still not getting the correct output.

#include<stdio.h>

#include<string.h>

#include<math.h>

#include<stdlib.h>



#define rotateleft(x,n) ((x<<n) | (x>>(32-n)))



unsigned int endian_reverse(unsigned int n)

{

    unsigned int m = 0;

    m |= n << 24;

    m |= ((n >> 8) << 24) >> 8;

    m |= ((n << 8) >> 24) << 8;

    m |= n >> 24;

    return m;

}



void SHA1(unsigned char * str1)

{

    unsigned long int h0,h1,h2,h3,h4,a,b,c,d,e,f,k,temp;



    h0 = 0x67452301;

    h1 = 0xEFCDAB89;

    h2 = 0x98BADCFE;

    h3 = 0x10325476;

    h4 = 0xC3D2E1F0;



    unsigned char * str;



    str = (unsigned char *)malloc(strlen((const char *)str1)+100);

    strcpy((char *)str,(const char *)str1);



    int current_length = strlen((const char *)str);

    int original_length = current_length;



    str[current_length] = 0x80;

    str[current_length + 1] = '';



    char ic = str[current_length];



    current_length++;

    int ib = current_length % 64;



    int i, j;



    if(ib<56)

        ib = 56-ib;

    else

        ib = 120 - ib;



    for(i=0;i < ib;i++)

    {

        str[current_length]=0x00;

        current_length++;

    }



    str[current_length + 1]='';



    for(i=0;i<6;i++)

    {

        str[current_length]=0x0;

        current_length++;

    }



    str[current_length] = (original_length * 8) / 0x100 ;

    current_length++;

    str[current_length] = (original_length * 8) % 0x100;

    current_length++;

    str[current_length+i]='';



    int number_of_chunks = current_length/64;

    unsigned long int word[80];



    for(i=0;i<number_of_chunks;i++)

    {

        for(j=0;j<16;j++)

        {

            word[j] = 

                str[i*64 + j*4 + 0] * 0x1000000 + str[i*64 + j*4 + 1] * 0x10000 + 

                str[i*64 + j*4 + 2] * 0x100 + str[i*64 + j*4 + 3];

        }

        for(j=16;j<80;j++)

        {

            word[j] = rotateleft((word[j-3] ^ word[j-8] ^ word[j-14] ^ word[j-16]),1);

        }

        a = h0;

        b = h1;

        c = h2;

        d = h3;

        e = h4;

        for(int m=0;m<80;m++)

        {

            if(m<=19)

            {

                f = (b & c) | ((~b) & d);

                k = 0x5A827999;

            }

            else if(m<=39)

            {

                f = b ^ c ^ d;

                k = 0x6ED9EBA1;

            }

            else if(m<=59)

            {

                f = (b & c) | (b & d) | (c & d);

                k = 0x8F1BBCDC;

            }

            else

            {

                f = b ^ c ^ d;

                k = 0xCA62C1D6;

            }

            temp = (rotateleft(a,5) + f + e + k + word[m]) & 0xFFFFFFFF;

            e = d;

            d = c;

            c = rotateleft(b,30);

            b = a;

            a = temp;



        }



        h0 = h0 + a;

        h1 = h1 + b;

        h2 = h2 + c;

        h3 = h3 + d;

        h4 = h4 + e;



    }



    h0 = endian_reverse(h0);

    h1 = endian_reverse(h1);

    h2 = endian_reverse(h2);

    h3 = endian_reverse(h3);

    h4 = endian_reverse(h4);



    printf("nn");

    printf("Hash: %x %x %x %x %x",h0, h1, h2, h3, h4);

    printf("nn");

}



int main()

{

    SHA1((unsigned char *)"abc");

    return 0;

}

SHA-1 ("abc"):

Resulting

Hash: f7370736 e388302f 15815610 1ccacd49 e7649bb6

Correct (actual)

Hash: a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d

Am I doing my endianness conversion correctly or in the correct spot?

Am I doing my endianness conversion correctly or in the correct spot?

Endianness conversion endian_reverse(() is incorrect when unsigned is not 32-bit.

Endianness conversion not used in correct spot. Endian conversion not needed.

Other issues exists.

Code is assuming unsigned long int is 32-bit. When unsigned long int is 64-bit, I can get the same answer as OP.

Save yourself time: There is no reason to use loose types here. Use uint32_t, uint8_t. For array sizing and string lengths use size_t. Avoid signed types and constants.

By changing unsigned long --> uint32_t and dropping h0 = endian_reverse(h0); ... h7 = endian_reverse(h7); I came up with

Hash: a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d

Other suggestions.

Multiple of 64

size in str = malloc(size) should be a multiple of 64

Stay within multiples of 64

str[current_length+i]=''; can write outside allocation.

Alternate size storing

Works for all size_t values up to 2^64-3 - 1.

  size_t current_length = ...



  // append length in bits

  uint64_t current_length_bits = current_length;

  current_length_bits *= 8;

  for (i = 8; i > 0; ) {

    i--;

    str[current_length + i] = (unsigned char) current_length_bits;

    current_length_bits >>= 8;

  }

  current_length += 8;