[J-u-boot.git] / lib_generic / sha1.c

/*
 *  Heiko Schocher, DENX Software Engineering, [email protected].
 *  based on:
 *  FIPS-180-1 compliant SHA-1 implementation
 *
 *  Copyright (C) 2003-2006  Christophe Devine
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License, version 2.1 as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *  MA  02110-1301  USA
 */
/*
 *  The SHA-1 standard was published by NIST in 1993.
 *
 *  http://www.itl.nist.gov/fipspubs/fip180-1.htm
 */

#ifndef _CRT_SECURE_NO_DEPRECATE
#define _CRT_SECURE_NO_DEPRECATE 1
#endif

#include <linux/string.h>
#include "sha1.h"

/*
 * 32-bit integer manipulation macros (big endian)
 */
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i)                            \
{                                                       \
    (n) = ( (unsigned long) (b)[(i)    ] << 24 )        \
        | ( (unsigned long) (b)[(i) + 1] << 16 )        \
        | ( (unsigned long) (b)[(i) + 2] <<  8 )        \
        | ( (unsigned long) (b)[(i) + 3]       );       \
}
#endif
#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i)                            \
{                                                       \
    (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
    (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
    (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
    (b)[(i) + 3] = (unsigned char) ( (n)       );       \
}
#endif

/*
 * SHA-1 context setup
 */
void sha1_starts( sha1_context *ctx )
{
    ctx->total[0] = 0;
    ctx->total[1] = 0;

    ctx->state[0] = 0x67452301;
    ctx->state[1] = 0xEFCDAB89;
    ctx->state[2] = 0x98BADCFE;
    ctx->state[3] = 0x10325476;
    ctx->state[4] = 0xC3D2E1F0;
}

static void sha1_process( sha1_context *ctx, unsigned char data[64] )
{
    unsigned long temp, W[16], A, B, C, D, E;

    GET_UINT32_BE( W[0],  data,  0 );
    GET_UINT32_BE( W[1],  data,  4 );
    GET_UINT32_BE( W[2],  data,  8 );
    GET_UINT32_BE( W[3],  data, 12 );
    GET_UINT32_BE( W[4],  data, 16 );
    GET_UINT32_BE( W[5],  data, 20 );
    GET_UINT32_BE( W[6],  data, 24 );
    GET_UINT32_BE( W[7],  data, 28 );
    GET_UINT32_BE( W[8],  data, 32 );
    GET_UINT32_BE( W[9],  data, 36 );
    GET_UINT32_BE( W[10], data, 40 );
    GET_UINT32_BE( W[11], data, 44 );
    GET_UINT32_BE( W[12], data, 48 );
    GET_UINT32_BE( W[13], data, 52 );
    GET_UINT32_BE( W[14], data, 56 );
    GET_UINT32_BE( W[15], data, 60 );

#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))

#define R(t)                                            \
(                                                       \
    temp = W[(t -  3) & 0x0F] ^ W[(t - 8) & 0x0F] ^     \
           W[(t - 14) & 0x0F] ^ W[ t      & 0x0F],      \
    ( W[t & 0x0F] = S(temp,1) )                         \
)

#define P(a,b,c,d,e,x)                                  \
{                                                       \
    e += S(a,5) + F(b,c,d) + K + x; b = S(b,30);        \
}

    A = ctx->state[0];
    B = ctx->state[1];
    C = ctx->state[2];
    D = ctx->state[3];
    E = ctx->state[4];

#define F(x,y,z) (z ^ (x & (y ^ z)))
#define K 0x5A827999

    P( A, B, C, D, E, W[0]  );
    P( E, A, B, C, D, W[1]  );
    P( D, E, A, B, C, W[2]  );
    P( C, D, E, A, B, W[3]  );
    P( B, C, D, E, A, W[4]  );
    P( A, B, C, D, E, W[5]  );
    P( E, A, B, C, D, W[6]  );
    P( D, E, A, B, C, W[7]  );
    P( C, D, E, A, B, W[8]  );
    P( B, C, D, E, A, W[9]  );
    P( A, B, C, D, E, W[10] );
    P( E, A, B, C, D, W[11] );
    P( D, E, A, B, C, W[12] );
    P( C, D, E, A, B, W[13] );
    P( B, C, D, E, A, W[14] );
    P( A, B, C, D, E, W[15] );
    P( E, A, B, C, D, R(16) );
    P( D, E, A, B, C, R(17) );
    P( C, D, E, A, B, R(18) );
    P( B, C, D, E, A, R(19) );

#undef K
#undef F

#define F(x,y,z) (x ^ y ^ z)
#define K 0x6ED9EBA1

    P( A, B, C, D, E, R(20) );
    P( E, A, B, C, D, R(21) );
    P( D, E, A, B, C, R(22) );
    P( C, D, E, A, B, R(23) );
    P( B, C, D, E, A, R(24) );
    P( A, B, C, D, E, R(25) );
    P( E, A, B, C, D, R(26) );
    P( D, E, A, B, C, R(27) );
    P( C, D, E, A, B, R(28) );
    P( B, C, D, E, A, R(29) );
    P( A, B, C, D, E, R(30) );
    P( E, A, B, C, D, R(31) );
    P( D, E, A, B, C, R(32) );
    P( C, D, E, A, B, R(33) );
    P( B, C, D, E, A, R(34) );
    P( A, B, C, D, E, R(35) );
    P( E, A, B, C, D, R(36) );
    P( D, E, A, B, C, R(37) );
    P( C, D, E, A, B, R(38) );
    P( B, C, D, E, A, R(39) );

#undef K
#undef F

#define F(x,y,z) ((x & y) | (z & (x | y)))
#define K 0x8F1BBCDC

    P( A, B, C, D, E, R(40) );
    P( E, A, B, C, D, R(41) );
    P( D, E, A, B, C, R(42) );
    P( C, D, E, A, B, R(43) );
    P( B, C, D, E, A, R(44) );
    P( A, B, C, D, E, R(45) );
    P( E, A, B, C, D, R(46) );
    P( D, E, A, B, C, R(47) );
    P( C, D, E, A, B, R(48) );
    P( B, C, D, E, A, R(49) );
    P( A, B, C, D, E, R(50) );
    P( E, A, B, C, D, R(51) );
    P( D, E, A, B, C, R(52) );
    P( C, D, E, A, B, R(53) );
    P( B, C, D, E, A, R(54) );
    P( A, B, C, D, E, R(55) );
    P( E, A, B, C, D, R(56) );
    P( D, E, A, B, C, R(57) );
    P( C, D, E, A, B, R(58) );
    P( B, C, D, E, A, R(59) );

#undef K
#undef F

#define F(x,y,z) (x ^ y ^ z)
#define K 0xCA62C1D6

    P( A, B, C, D, E, R(60) );
    P( E, A, B, C, D, R(61) );
    P( D, E, A, B, C, R(62) );
    P( C, D, E, A, B, R(63) );
    P( B, C, D, E, A, R(64) );
    P( A, B, C, D, E, R(65) );
    P( E, A, B, C, D, R(66) );
    P( D, E, A, B, C, R(67) );
    P( C, D, E, A, B, R(68) );
    P( B, C, D, E, A, R(69) );
    P( A, B, C, D, E, R(70) );
    P( E, A, B, C, D, R(71) );
    P( D, E, A, B, C, R(72) );
    P( C, D, E, A, B, R(73) );
    P( B, C, D, E, A, R(74) );
    P( A, B, C, D, E, R(75) );
    P( E, A, B, C, D, R(76) );
    P( D, E, A, B, C, R(77) );
    P( C, D, E, A, B, R(78) );
    P( B, C, D, E, A, R(79) );

#undef K
#undef F

    ctx->state[0] += A;
    ctx->state[1] += B;
    ctx->state[2] += C;
    ctx->state[3] += D;
    ctx->state[4] += E;
}

/*
 * SHA-1 process buffer
 */
void sha1_update( sha1_context *ctx, unsigned char *input, int ilen )
{
    int fill;
    unsigned long left;

    if( ilen <= 0 )
        return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if( ctx->total[0] < (unsigned long) ilen )
        ctx->total[1]++;

    if( left && ilen >= fill )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, fill );
        sha1_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
        sha1_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }

    if( ilen > 0 )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, ilen );
    }
}

static const unsigned char sha1_padding[64] =
{
 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

/*
 * SHA-1 final digest
 */
void sha1_finish( sha1_context *ctx, unsigned char output[20] )
{
    unsigned long last, padn;
    unsigned long high, low;
    unsigned char msglen[8];

    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );

    PUT_UINT32_BE( high, msglen, 0 );
    PUT_UINT32_BE( low,  msglen, 4 );

    last = ctx->total[0] & 0x3F;
    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

    sha1_update( ctx, (unsigned char *) sha1_padding, padn );
    sha1_update( ctx, msglen, 8 );

    PUT_UINT32_BE( ctx->state[0], output,  0 );
    PUT_UINT32_BE( ctx->state[1], output,  4 );
    PUT_UINT32_BE( ctx->state[2], output,  8 );
    PUT_UINT32_BE( ctx->state[3], output, 12 );
    PUT_UINT32_BE( ctx->state[4], output, 16 );
}

/*
 * Output = SHA-1( input buffer )
 */
void sha1_csum( unsigned char *input, int ilen,
                unsigned char output[20] )
{
    sha1_context ctx;

    sha1_starts( &ctx );
    sha1_update( &ctx, input, ilen );
    sha1_finish( &ctx, output );
}

/*
 * Output = HMAC-SHA-1( input buffer, hmac key )
 */
void sha1_hmac( unsigned char *key, int keylen,
                unsigned char *input, int ilen,
                unsigned char output[20] )
{
    int i;
    sha1_context ctx;
    unsigned char k_ipad[64];
    unsigned char k_opad[64];
    unsigned char tmpbuf[20];

    memset( k_ipad, 0x36, 64 );
    memset( k_opad, 0x5C, 64 );

    for( i = 0; i < keylen; i++ )
    {
        if( i >= 64 ) break;

        k_ipad[i] ^= key[i];
        k_opad[i] ^= key[i];
    }

    sha1_starts( &ctx );
    sha1_update( &ctx, k_ipad, 64 );
    sha1_update( &ctx, input, ilen );
    sha1_finish( &ctx, tmpbuf );

    sha1_starts( &ctx );
    sha1_update( &ctx, k_opad, 64 );
    sha1_update( &ctx, tmpbuf, 20 );
    sha1_finish( &ctx, output );

    memset( k_ipad, 0, 64 );
    memset( k_opad, 0, 64 );
    memset( tmpbuf, 0, 20 );
    memset( &ctx, 0, sizeof( sha1_context ) );
}

static const char _sha1_src[] = "_sha1_src";

#ifdef SELF_TEST
/*
 * FIPS-180-1 test vectors
 */
static const char sha1_test_str[3][57] = 
{
    { "abc" },
    { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
    { "" }
};

static const unsigned char sha1_test_sum[3][20] =
{
    { 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
      0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
    { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
      0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
    { 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
      0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
};

/*
 * Checkup routine
 */
int sha1_self_test( void )
{
    int i, j;
    unsigned char buf[1000];
    unsigned char sha1sum[20];
    sha1_context ctx;

    for( i = 0; i < 3; i++ )
    {
        printf( "  SHA-1 test #%d: ", i + 1 );

        sha1_starts( &ctx );

        if( i < 2 )
            sha1_update( &ctx, (unsigned char *) sha1_test_str[i],
                         strlen( sha1_test_str[i] ) );
        else
        {
            memset( buf, 'a', 1000 );
            for( j = 0; j < 1000; j++ )
                sha1_update( &ctx, buf, 1000 );
        }

        sha1_finish( &ctx, sha1sum );

        if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
        {
            printf( "failed\n" );
            return( 1 );
        }

        printf( "passed\n" );
    }

    printf( "\n" );
    return( 0 );
}
#else
int sha1_self_test( void )
{
    return( 0 );
}
#endif
Commit	Line	Data
566a494f HS	1	/*
	2	* Heiko Schocher, DENX Software Engineering, [email protected].
	3	* based on:
	4	* FIPS-180-1 compliant SHA-1 implementation
	5	*
	6	* Copyright (C) 2003-2006 Christophe Devine
	7	*
	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License, version 2.1 as published by the Free Software Foundation.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with this library; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
	20	* MA 02110-1301 USA
	21	*/
	22	/*
	23	* The SHA-1 standard was published by NIST in 1993.
	24	*
	25	* http://www.itl.nist.gov/fipspubs/fip180-1.htm
	26	*/
	27
	28	#ifndef _CRT_SECURE_NO_DEPRECATE
	29	#define _CRT_SECURE_NO_DEPRECATE 1
	30	#endif
	31
	32	#include <linux/string.h>
	33	#include "sha1.h"
	34
	35	/*
	36	* 32-bit integer manipulation macros (big endian)
	37	*/
	38	#ifndef GET_UINT32_BE
	39	#define GET_UINT32_BE(n,b,i) \
	40	{ \
	41	(n) = ( (unsigned long) (b)[(i) ] << 24 ) \
	42	\| ( (unsigned long) (b)[(i) + 1] << 16 ) \
	43	\| ( (unsigned long) (b)[(i) + 2] << 8 ) \
	44	\| ( (unsigned long) (b)[(i) + 3] ); \
	45	}
	46	#endif
	47	#ifndef PUT_UINT32_BE
	48	#define PUT_UINT32_BE(n,b,i) \
	49	{ \
	50	(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
	51	(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
	52	(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
	53	(b)[(i) + 3] = (unsigned char) ( (n) ); \
	54	}
	55	#endif
	56
	57	/*
	58	* SHA-1 context setup
	59	*/
	60	void sha1_starts( sha1_context *ctx )
	61	{
	62	ctx->total[0] = 0;
	63	ctx->total[1] = 0;
	64
65	ctx->state[0] = 0x67452301;
66	ctx->state[1] = 0xEFCDAB89;
67	ctx->state[2] = 0x98BADCFE;
68	ctx->state[3] = 0x10325476;
69	ctx->state[4] = 0xC3D2E1F0;
70	}
71
72	static void sha1_process( sha1_context *ctx, unsigned char data[64] )
73	{
74	unsigned long temp, W[16], A, B, C, D, E;
75
76	GET_UINT32_BE( W[0], data, 0 );
77	GET_UINT32_BE( W[1], data, 4 );
78	GET_UINT32_BE( W[2], data, 8 );
79	GET_UINT32_BE( W[3], data, 12 );
80	GET_UINT32_BE( W[4], data, 16 );
81	GET_UINT32_BE( W[5], data, 20 );
82	GET_UINT32_BE( W[6], data, 24 );
83	GET_UINT32_BE( W[7], data, 28 );
84	GET_UINT32_BE( W[8], data, 32 );
85	GET_UINT32_BE( W[9], data, 36 );
86	GET_UINT32_BE( W[10], data, 40 );
87	GET_UINT32_BE( W[11], data, 44 );
88	GET_UINT32_BE( W[12], data, 48 );
89	GET_UINT32_BE( W[13], data, 52 );
90	GET_UINT32_BE( W[14], data, 56 );
91	GET_UINT32_BE( W[15], data, 60 );
92
93	#define S(x,n) ((x << n) \| ((x & 0xFFFFFFFF) >> (32 - n)))
94
95	#define R(t) \
96	( \
97	temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \
98	W[(t - 14) & 0x0F] ^ W[ t & 0x0F], \
99	( W[t & 0x0F] = S(temp,1) ) \
100	)
101
102	#define P(a,b,c,d,e,x) \
103	{ \
104	e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \
105	}
106
107	A = ctx->state[0];
108	B = ctx->state[1];
109	C = ctx->state[2];
110	D = ctx->state[3];
111	E = ctx->state[4];
112
113	#define F(x,y,z) (z ^ (x & (y ^ z)))
114	#define K 0x5A827999
115
116	P( A, B, C, D, E, W[0] );
117	P( E, A, B, C, D, W[1] );
118	P( D, E, A, B, C, W[2] );
119	P( C, D, E, A, B, W[3] );
120	P( B, C, D, E, A, W[4] );
121	P( A, B, C, D, E, W[5] );
122	P( E, A, B, C, D, W[6] );
123	P( D, E, A, B, C, W[7] );
124	P( C, D, E, A, B, W[8] );
125	P( B, C, D, E, A, W[9] );
126	P( A, B, C, D, E, W[10] );
127	P( E, A, B, C, D, W[11] );
128	P( D, E, A, B, C, W[12] );
129	P( C, D, E, A, B, W[13] );
130	P( B, C, D, E, A, W[14] );
131	P( A, B, C, D, E, W[15] );
132	P( E, A, B, C, D, R(16) );
133	P( D, E, A, B, C, R(17) );
134	P( C, D, E, A, B, R(18) );
135	P( B, C, D, E, A, R(19) );
136
137	#undef K
138	#undef F
139
140	#define F(x,y,z) (x ^ y ^ z)
141	#define K 0x6ED9EBA1
142
143	P( A, B, C, D, E, R(20) );
144	P( E, A, B, C, D, R(21) );
145	P( D, E, A, B, C, R(22) );
146	P( C, D, E, A, B, R(23) );
147	P( B, C, D, E, A, R(24) );
148	P( A, B, C, D, E, R(25) );
149	P( E, A, B, C, D, R(26) );
150	P( D, E, A, B, C, R(27) );
151	P( C, D, E, A, B, R(28) );
152	P( B, C, D, E, A, R(29) );
153	P( A, B, C, D, E, R(30) );
154	P( E, A, B, C, D, R(31) );
155	P( D, E, A, B, C, R(32) );
156	P( C, D, E, A, B, R(33) );
157	P( B, C, D, E, A, R(34) );
158	P( A, B, C, D, E, R(35) );
159	P( E, A, B, C, D, R(36) );
160	P( D, E, A, B, C, R(37) );
161	P( C, D, E, A, B, R(38) );
162	P( B, C, D, E, A, R(39) );
163
164	#undef K
165	#undef F
166
167	#define F(x,y,z) ((x & y) \| (z & (x \| y)))
168	#define K 0x8F1BBCDC
169
170	P( A, B, C, D, E, R(40) );
171	P( E, A, B, C, D, R(41) );
172	P( D, E, A, B, C, R(42) );
173	P( C, D, E, A, B, R(43) );
174	P( B, C, D, E, A, R(44) );
175	P( A, B, C, D, E, R(45) );
176	P( E, A, B, C, D, R(46) );
177	P( D, E, A, B, C, R(47) );
178	P( C, D, E, A, B, R(48) );
179	P( B, C, D, E, A, R(49) );
180	P( A, B, C, D, E, R(50) );
181	P( E, A, B, C, D, R(51) );
182	P( D, E, A, B, C, R(52) );
183	P( C, D, E, A, B, R(53) );
184	P( B, C, D, E, A, R(54) );
185	P( A, B, C, D, E, R(55) );
186	P( E, A, B, C, D, R(56) );
187	P( D, E, A, B, C, R(57) );
188	P( C, D, E, A, B, R(58) );
189	P( B, C, D, E, A, R(59) );
190
191	#undef K
192	#undef F
193
194	#define F(x,y,z) (x ^ y ^ z)
195	#define K 0xCA62C1D6
196
197	P( A, B, C, D, E, R(60) );
198	P( E, A, B, C, D, R(61) );
199	P( D, E, A, B, C, R(62) );
200	P( C, D, E, A, B, R(63) );
201	P( B, C, D, E, A, R(64) );
202	P( A, B, C, D, E, R(65) );
203	P( E, A, B, C, D, R(66) );
204	P( D, E, A, B, C, R(67) );
205	P( C, D, E, A, B, R(68) );
206	P( B, C, D, E, A, R(69) );
207	P( A, B, C, D, E, R(70) );
208	P( E, A, B, C, D, R(71) );
209	P( D, E, A, B, C, R(72) );
210	P( C, D, E, A, B, R(73) );
211	P( B, C, D, E, A, R(74) );
212	P( A, B, C, D, E, R(75) );
213	P( E, A, B, C, D, R(76) );
214	P( D, E, A, B, C, R(77) );
215	P( C, D, E, A, B, R(78) );
216	P( B, C, D, E, A, R(79) );
217
218	#undef K
219	#undef F
220
221	ctx->state[0] += A;
222	ctx->state[1] += B;
223	ctx->state[2] += C;
224	ctx->state[3] += D;
225	ctx->state[4] += E;
226	}
227
228	/*
229	* SHA-1 process buffer
230	*/
231	void sha1_update( sha1_context ctx, unsigned char input, int ilen )
232	{
233	int fill;
234	unsigned long left;
235
236	if( ilen <= 0 )
237	return;
238
239	left = ctx->total[0] & 0x3F;
240	fill = 64 - left;
241
242	ctx->total[0] += ilen;
243	ctx->total[0] &= 0xFFFFFFFF;
244
245	if( ctx->total[0] < (unsigned long) ilen )
246	ctx->total[1]++;
247
248	if( left && ilen >= fill )
249	{
250	memcpy( (void *) (ctx->buffer + left),
251	(void *) input, fill );
252	sha1_process( ctx, ctx->buffer );
253	input += fill;
254	ilen -= fill;
255	left = 0;
256	}
257
258	while( ilen >= 64 )
259	{
260	sha1_process( ctx, input );
261	input += 64;
262	ilen -= 64;
263	}
264
265	if( ilen > 0 )
266	{
267	memcpy( (void *) (ctx->buffer + left),
268	(void *) input, ilen );
269	}
270	}
271
272	static const unsigned char sha1_padding[64] =
273	{
274	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
275	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
276	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
277	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
278	};
279
280	/*
281	* SHA-1 final digest
282	*/
283	void sha1_finish( sha1_context *ctx, unsigned char output[20] )
284	{
285	unsigned long last, padn;
286	unsigned long high, low;
287	unsigned char msglen[8];
288
289	high = ( ctx->total[0] >> 29 )
290	\| ( ctx->total[1] << 3 );
291	low = ( ctx->total[0] << 3 );
292
293	PUT_UINT32_BE( high, msglen, 0 );
294	PUT_UINT32_BE( low, msglen, 4 );
295
296	last = ctx->total[0] & 0x3F;
297	padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
298
299	sha1_update( ctx, (unsigned char *) sha1_padding, padn );
300	sha1_update( ctx, msglen, 8 );
301
302	PUT_UINT32_BE( ctx->state[0], output, 0 );
303	PUT_UINT32_BE( ctx->state[1], output, 4 );
304	PUT_UINT32_BE( ctx->state[2], output, 8 );
305	PUT_UINT32_BE( ctx->state[3], output, 12 );
306	PUT_UINT32_BE( ctx->state[4], output, 16 );
307	}
308
309	/*
310	* Output = SHA-1( input buffer )
311	*/
312	void sha1_csum( unsigned char *input, int ilen,
313	unsigned char output[20] )
314	{
315	sha1_context ctx;
316
317	sha1_starts( &ctx );
318	sha1_update( &ctx, input, ilen );
319	sha1_finish( &ctx, output );
320	}
321
322	/*
323	* Output = HMAC-SHA-1( input buffer, hmac key )
324	*/
325	void sha1_hmac( unsigned char *key, int keylen,
326	unsigned char *input, int ilen,
327	unsigned char output[20] )
328	{
329	int i;
330	sha1_context ctx;
331	unsigned char k_ipad[64];
332	unsigned char k_opad[64];
333	unsigned char tmpbuf[20];
334
335	memset( k_ipad, 0x36, 64 );
336	memset( k_opad, 0x5C, 64 );
337
338	for( i = 0; i < keylen; i++ )
339	{
340	if( i >= 64 ) break;
341
342	k_ipad[i] ^= key[i];
343	k_opad[i] ^= key[i];
344	}
345
346	sha1_starts( &ctx );
347	sha1_update( &ctx, k_ipad, 64 );
348	sha1_update( &ctx, input, ilen );
349	sha1_finish( &ctx, tmpbuf );
350
351	sha1_starts( &ctx );
352	sha1_update( &ctx, k_opad, 64 );
353	sha1_update( &ctx, tmpbuf, 20 );
354	sha1_finish( &ctx, output );
355
356	memset( k_ipad, 0, 64 );
357	memset( k_opad, 0, 64 );
358	memset( tmpbuf, 0, 20 );
359	memset( &ctx, 0, sizeof( sha1_context ) );
360	}
361
362	static const char _sha1_src[] = "_sha1_src";
363
364	#ifdef SELF_TEST
365	/*
366	* FIPS-180-1 test vectors
367	*/
368	static const char sha1_test_str[3][57] =
369	{
370	{ "abc" },
371	{ "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
372	{ "" }
373	};
374
375	static const unsigned char sha1_test_sum[3][20] =
376	{
377	{ 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
378	0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
379	{ 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
380	0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
381	{ 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
382	0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
383	};
384
385	/*
386	* Checkup routine
387	*/
388	int sha1_self_test( void )
389	{
390	int i, j;
391	unsigned char buf[1000];
392	unsigned char sha1sum[20];
393	sha1_context ctx;
394
395	for( i = 0; i < 3; i++ )
396	{
397	printf( " SHA-1 test #%d: ", i + 1 );
398
399	sha1_starts( &ctx );
400
401	if( i < 2 )
402	sha1_update( &ctx, (unsigned char *) sha1_test_str[i],
403	strlen( sha1_test_str[i] ) );
404	else
405	{
406	memset( buf, 'a', 1000 );
407	for( j = 0; j < 1000; j++ )
408	sha1_update( &ctx, buf, 1000 );
409	}
410
411	sha1_finish( &ctx, sha1sum );
412
413	if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
414	{
415	printf( "failed\n" );
416	return( 1 );
417	}
418
419	printf( "passed\n" );
420	}
421
422	printf( "\n" );
423	return( 0 );
424	}
425	#else
426	int sha1_self_test( void )
427	{
428	return( 0 );
429	}
430	#endif