Erreur dans mon code SHA-1

string SHA1( string nomFichier ) {

    /* Obtention des Mi (512 bits soit 64 octets) */
    /*
     - 1 est ajouté à la fin de x
     - On ajoute des 0 à la fin de x pour que ||x|| = 512n − 64
     - ||x|| est écrite en base 2 sur 64 bits, qui sont rajoutés à la fin du mot ci-dessus
    */

    ifstream monFlux;
    monFlux.open( nomFichier.c_str() );
    if( monFlux ) {
        monFlux.seekg (0, ios::end);
        unsigned int length = monFlux.tellg(); /* ATTENTION: au-delà de 2^32 :'( */
        monFlux.seekg (0, ios::beg);

        /* 512 bits = 64 octets */
        /*  64 bits =  8 octets */
        int nbLectures = ( length+1 +8 )/64;
        if( ( length+1 +8 )%64 > 0 ) ++nbLectures;

        unsigned int h0 = 0x67452301; /* unsigned int: 32 bits */
        unsigned int h1 = 0xEFCDAB89; /* http://www.commentcamarche.net/contents/cpp/cpptype.php3 */
        unsigned int h2 = 0x98BADCFE;
        unsigned int h3 = 0x10325476;
        unsigned int h4 = 0xC3D2E1F0;

        for( int i=0 ; i!=nbLectures ; ++i ) {

            int tailleLecture = 64; /* 64 octets */
            if( i == nbLectures-1 ) tailleLecture = length%64;

            char* buffer = new char[tailleLecture];
            monFlux.read( buffer, tailleLecture );

            unsigned int M[16]; /* 512 bits / 32 bits */
            for( int j=0 ; j!=16 ; ++j ) { M[j] = 0; }
            for( int t=0 ; t!=64 ; ++t ) {
                if( t < tailleLecture ) {
                    unsigned char tmp = *(buffer+t);
                    M[ t/4 ] += ( tmp << 8*( 3 - (t%4) ) );
                } else if( t == tailleLecture ) /* On ajoute le char: % 1000 0000 ie 128 */
                    M[ t/4 ] += ( 128 << 8*( 3 - (t%4) ) );
                /* length: "64" bits soit 2*32, on les ajoute après */
                /* else rien, on ajoute des 0 */
                if( i == nbLectures-1 ) {
                    /*M[ 14 ] = 0; length fait en réalité 32 bits */
                    M[15] = length;
                }
            }
            free( buffer );

            /* Obtient les Wt */
            unsigned int W[80];
            for( int t=0 ; t!=16 ; ++t ) { W[t] = M[t]; }
            for( int t=16 ; t!=80 ; ++t ) { W[t] = ROL32( W[t-3] xor W[t-8] xor W[t-14] xor W[t-16], 1 );  }

            /* A, B, C, D, E */
            unsigned int A = h0;
            unsigned int B = h1;
            unsigned int C = h2;
            unsigned int D = h3;
            unsigned int E = h4;

            /* Boucle sur t... */
            for( int t=0 ; t!=80 ; ++t ) {
                /*
                T = S5(A) + (ft(B,C,D) + Kt) + E + Wt
                E = D
                D = C
                C = S30(B)
                B = A
                A = T
                */
                unsigned int tmp;
                /* 19/ (B &#8743; C) or (¬B &#8743; D) *//* 39/ B xor C xor D *//* 59/ (B &#8743; C) or (B &#8743; D) or (C &#8743; D) *//* B xor C xor D */
                if( t <= 19 )      tmp = ( (B & C) | ((~B) & D) )        + 0x5A827999;
                else if( t <= 39 ) tmp = ( B ^ C ^ D )                   + 0x6ED9EBA1;
                else if( t <= 59 ) tmp = ( (B & C) | (B & D) | (C & D) ) + 0x8F1BBCDC;
                else               tmp = ( B ^ C ^ D )                   + 0xCA62C1D6;

                unsigned int T = ROL32(A,5) + tmp + E + W[t];
                E = D;
                D = C;
                C = ROL32(B,30);
                B = A;
                A = T;
            }

            /* Ajouter A à H0, B à H1, C à H2, D à H3 et E à H4 */
            h0 += A;
            h1 += B;
            h2 += C;
            h3 += D;
            h4 += E;
        }

        monFlux.close();

        return hexa_of_valeurhachee( (unsigned int[]){h0,h1,h2,h3,h4} );
    } else return 0;
}

 unsigned int h0 = 0x01234567; //0x67452301; 
 unsigned int h1 = 0x89ABCDEF; //0xEFCDAB89; 
 unsigned int h2 = 0xFEDCBA98; //0x98BADCFE;
 unsigned int h3 = 0x76543210; //0x10325476;
 unsigned int h4 = 0xF0E1D2C3; //0xC3D2E1F0;


 if( t <= 19 )      tmp = ( (B & C) | ((~B) & D) )        + 0x9979825A; //+ 0x5A827999;
 else if( t <= 39 ) tmp = ( B ^ C ^ D )                   + 0xA1EBD96E; //+ 0x6ED9EBA1;
 else if( t <= 59 ) tmp = ( (B & C) | (B & D) | (C & D) ) + 0xDCBC1B8F; //+ 0x8F1BBCDC;
 else               tmp = ( B ^ C ^ D )                   + 0xD6C162CA; //+ 0xCA62C1D6;

string hexa_of_uint( unsigned int entier ) {
    string hexa = "";
    for( int i=0 ; i!=8 ; ++i ) { /* entier: 32 bits, hexa: 4bits */
        switch( entier%16 ) {
            case 0:  hexa = "0" + hexa; break;
            case 1:  hexa = "1" + hexa; break;
            case 2:  hexa = "2" + hexa; break;
            case 3:  hexa = "3" + hexa; break;
            case 4:  hexa = "4" + hexa; break;
            case 5:  hexa = "5" + hexa; break;
            case 6:  hexa = "6" + hexa; break;
            case 7:  hexa = "7" + hexa; break;
            case 8:  hexa = "8" + hexa; break;
            case 9:  hexa = "9" + hexa; break;
            case 10: hexa = "a" + hexa; break;
            case 11: hexa = "b" + hexa; break;
            case 12: hexa = "c" + hexa; break;
            case 13: hexa = "d" + hexa; break;
            case 14: hexa = "e" + hexa; break;
            case 15: hexa = "f" + hexa; break;
            default: hexa = "*" + hexa; break;
        }
        entier /= 16;
    }
    return hexa;
}

string hexa_of_valeurhachee( unsigned int* valeurhacheee ) {
    string hexa = "";
    for( int i=0 ; i!= 5 ; ++i ) { hexa += hexa_of_uint( *(valeurhacheee+i) ); }
    return hexa;
}

#define ROL32(x,b) (((x) << (b)) | ((x) >> (32 - (b))))