[proxmark3-svn] / common / mbedtls / sha1.c

/*
 *  FIPS-180-1 compliant SHA-1 implementation
 *
 *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
 *  SPDX-License-Identifier: GPL-2.0
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 *  This file is part of mbed TLS (https://tls.mbed.org)
 */
/*
 *  The SHA-1 standard was published by NIST in 1993.
 *
 *  http://www.itl.nist.gov/fipspubs/fip180-1.htm
 */

#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
#include MBEDTLS_CONFIG_FILE
#endif

#if defined(MBEDTLS_SHA1_C)

#include "mbedtls/sha1.h"
#include "mbedtls/platform_util.h"

#include <string.h>

#if defined(MBEDTLS_SELF_TEST)
#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
#define mbedtls_printf printf
#endif /* MBEDTLS_PLATFORM_C */
#endif /* MBEDTLS_SELF_TEST */

#if !defined(MBEDTLS_SHA1_ALT)

/*
 * 32-bit integer manipulation macros (big endian)
 */
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i)                            \
{                                                       \
    (n) = ( (uint32_t) (b)[(i)    ] << 24 )             \
        | ( (uint32_t) (b)[(i) + 1] << 16 )             \
        | ( (uint32_t) (b)[(i) + 2] <<  8 )             \
        | ( (uint32_t) (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

void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
{
    memset( ctx, 0, sizeof( mbedtls_sha1_context ) );
}

void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
{
    if( ctx == NULL )
        return;

    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
}

void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
                         const mbedtls_sha1_context *src )
{
    *dst = *src;
}

/*
 * SHA-1 context setup
 */
int mbedtls_sha1_starts_ret( mbedtls_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;

    return( 0 );
}

#if !defined(MBEDTLS_DEPRECATED_REMOVED)
void mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
{
    mbedtls_sha1_starts_ret( ctx );
}
#endif

#if !defined(MBEDTLS_SHA1_PROCESS_ALT)
int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
                                   const unsigned char data[64] )
{
    uint32_t 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;

    return( 0 );
}

#if !defined(MBEDTLS_DEPRECATED_REMOVED)
void mbedtls_sha1_process( mbedtls_sha1_context *ctx,
                           const unsigned char data[64] )
{
    mbedtls_internal_sha1_process( ctx, data );
}
#endif
#endif /* !MBEDTLS_SHA1_PROCESS_ALT */

/*
 * SHA-1 process buffer
 */
int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx,
                             const unsigned char *input,
                             size_t ilen )
{
    int ret;
    size_t fill;
    uint32_t left;

    if( ilen == 0 )
        return( 0 );

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

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

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

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

        if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
            return( ret );

        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
        if( ( ret = mbedtls_internal_sha1_process( ctx, input ) ) != 0 )
            return( ret );

        input += 64;
        ilen  -= 64;
    }

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

    return( 0 );
}

#if !defined(MBEDTLS_DEPRECATED_REMOVED)
void mbedtls_sha1_update( mbedtls_sha1_context *ctx,
                          const unsigned char *input,
                          size_t ilen )
{
    mbedtls_sha1_update_ret( ctx, input, ilen );
}
#endif

/*
 * SHA-1 final digest
 */
int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx,
                             unsigned char output[20] )
{
    int ret;
    uint32_t used;
    uint32_t high, low;

    /*
     * Add padding: 0x80 then 0x00 until 8 bytes remain for the length
     */
    used = ctx->total[0] & 0x3F;

    ctx->buffer[used++] = 0x80;

    if( used <= 56 )
    {
        /* Enough room for padding + length in current block */
        memset( ctx->buffer + used, 0, 56 - used );
    }
    else
    {
        /* We'll need an extra block */
        memset( ctx->buffer + used, 0, 64 - used );

        if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
            return( ret );

        memset( ctx->buffer, 0, 56 );
    }

    /*
     * Add message length
     */
    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );

    PUT_UINT32_BE( high, ctx->buffer, 56 );
    PUT_UINT32_BE( low,  ctx->buffer, 60 );

    if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
        return( ret );

    /*
     * Output final state
     */
    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 );

    return( 0 );
}

#if !defined(MBEDTLS_DEPRECATED_REMOVED)
void mbedtls_sha1_finish( mbedtls_sha1_context *ctx,
                          unsigned char output[20] )
{
    mbedtls_sha1_finish_ret( ctx, output );
}
#endif

#endif /* !MBEDTLS_SHA1_ALT */

/*
 * output = SHA-1( input buffer )
 */
int mbedtls_sha1_ret( const unsigned char *input,
                      size_t ilen,
                      unsigned char output[20] )
{
    int ret;
    mbedtls_sha1_context ctx;

    mbedtls_sha1_init( &ctx );

    if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
        goto exit;

    if( ( ret = mbedtls_sha1_update_ret( &ctx, input, ilen ) ) != 0 )
        goto exit;

    if( ( ret = mbedtls_sha1_finish_ret( &ctx, output ) ) != 0 )
        goto exit;

exit:
    mbedtls_sha1_free( &ctx );

    return( ret );
}

#if !defined(MBEDTLS_DEPRECATED_REMOVED)
void mbedtls_sha1( const unsigned char *input,
                   size_t ilen,
                   unsigned char output[20] )
{
    mbedtls_sha1_ret( input, ilen, output );
}
#endif

#if defined(MBEDTLS_SELF_TEST)
/*
 * FIPS-180-1 test vectors
 */
static const unsigned char sha1_test_buf[3][57] =
{
    { "abc" },
    { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
    { "" }
};

static const size_t sha1_test_buflen[3] =
{
    3, 56, 1000
};

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 mbedtls_sha1_self_test( int verbose )
{
    int i, j, buflen, ret = 0;
    unsigned char buf[1024];
    unsigned char sha1sum[20];
    mbedtls_sha1_context ctx;

    mbedtls_sha1_init( &ctx );

    /*
     * SHA-1
     */
    for( i = 0; i < 3; i++ )
    {
        if( verbose != 0 )
            mbedtls_printf( "  SHA-1 test #%d: ", i + 1 );

        if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
            goto fail;

        if( i == 2 )
        {
            memset( buf, 'a', buflen = 1000 );

            for( j = 0; j < 1000; j++ )
            {
                ret = mbedtls_sha1_update_ret( &ctx, buf, buflen );
                if( ret != 0 )
                    goto fail;
            }
        }
        else
        {
            ret = mbedtls_sha1_update_ret( &ctx, sha1_test_buf[i],
                                           sha1_test_buflen[i] );
            if( ret != 0 )
                goto fail;
        }

        if( ( ret = mbedtls_sha1_finish_ret( &ctx, sha1sum ) ) != 0 )
            goto fail;

        if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
        {
            ret = 1;
            goto fail;
        }

        if( verbose != 0 )
            mbedtls_printf( "passed\n" );
    }

    if( verbose != 0 )
        mbedtls_printf( "\n" );

    goto exit;

fail:
    if( verbose != 0 )
        mbedtls_printf( "failed\n" );

exit:
    mbedtls_sha1_free( &ctx );

    return( ret );
}

#endif /* MBEDTLS_SELF_TEST */

#endif /* MBEDTLS_SHA1_C */
Commit	Line	Data
1c4c0b06	1	/*
	2	* FIPS-180-1 compliant SHA-1 implementation
	3	*
700d8687 OM	4	* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
700d8687 OM	5	* SPDX-License-Identifier: GPL-2.0
1c4c0b06	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program 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
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License along
	18	* with this program; if not, write to the Free Software Foundation, Inc.,
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
700d8687 OM	20	*
700d8687 OM	21	* This file is part of mbed TLS (https://tls.mbed.org)
1c4c0b06	22	*/
	23	/*
	24	* The SHA-1 standard was published by NIST in 1993.
	25	*
	26	* http://www.itl.nist.gov/fipspubs/fip180-1.htm
	27	*/
	28
700d8687 OM	29	#if !defined(MBEDTLS_CONFIG_FILE)
	30	#include "mbedtls/config.h"
	31	#else
	32	#include MBEDTLS_CONFIG_FILE
	33	#endif
	34
	35	#if defined(MBEDTLS_SHA1_C)
1c4c0b06	36
700d8687 OM	37	#include "mbedtls/sha1.h"
700d8687 OM	38	#include "mbedtls/platform_util.h"
1c4c0b06	39
700d8687	40	#include <string.h>
1c4c0b06	41
700d8687 OM	42	#if defined(MBEDTLS_SELF_TEST)
	43	#if defined(MBEDTLS_PLATFORM_C)
	44	#include "mbedtls/platform.h"
	45	#else
1c4c0b06	46	#include <stdio.h>
700d8687 OM	47	#define mbedtls_printf printf
	48	#endif /* MBEDTLS_PLATFORM_C */
	49	#endif /* MBEDTLS_SELF_TEST */
1c4c0b06	50
700d8687	51	#if !defined(MBEDTLS_SHA1_ALT)
1c4c0b06	52
	53	/*
	54	* 32-bit integer manipulation macros (big endian)
	55	*/
	56	#ifndef GET_UINT32_BE
	57	#define GET_UINT32_BE(n,b,i) \
	58	{ \
	59	(n) = ( (uint32_t) (b)[(i) ] << 24 ) \
	60	\| ( (uint32_t) (b)[(i) + 1] << 16 ) \
	61	\| ( (uint32_t) (b)[(i) + 2] << 8 ) \
	62	\| ( (uint32_t) (b)[(i) + 3] ); \
	63	}
	64	#endif
	65
	66	#ifndef PUT_UINT32_BE
	67	#define PUT_UINT32_BE(n,b,i) \
	68	{ \
	69	(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
	70	(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
	71	(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
	72	(b)[(i) + 3] = (unsigned char) ( (n) ); \
	73	}
	74	#endif
	75
700d8687 OM	76	void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
	77	{
	78	memset( ctx, 0, sizeof( mbedtls_sha1_context ) );
	79	}
	80
	81	void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
	82	{
	83	if( ctx == NULL )
	84	return;
	85
	86	mbedtls_platform_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
	87	}
	88
	89	void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
	90	const mbedtls_sha1_context *src )
	91	{
	92	dst = src;
	93	}
	94
1c4c0b06	95	/*
	96	* SHA-1 context setup
	97	*/
700d8687	98	int mbedtls_sha1_starts_ret( mbedtls_sha1_context *ctx )
1c4c0b06	99	{
	100	ctx->total[0] = 0;
	101	ctx->total[1] = 0;
	102
	103	ctx->state[0] = 0x67452301;
	104	ctx->state[1] = 0xEFCDAB89;
	105	ctx->state[2] = 0x98BADCFE;
	106	ctx->state[3] = 0x10325476;
	107	ctx->state[4] = 0xC3D2E1F0;
700d8687 OM	108
700d8687 OM	109	return( 0 );
1c4c0b06	110	}
1c4c0b06	111
700d8687 OM	112	#if !defined(MBEDTLS_DEPRECATED_REMOVED)
	113	void mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
	114	{
	115	mbedtls_sha1_starts_ret( ctx );
	116	}
	117	#endif
	118
	119	#if !defined(MBEDTLS_SHA1_PROCESS_ALT)
	120	int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
	121	const unsigned char data[64] )
1c4c0b06	122	{
	123	uint32_t temp, W[16], A, B, C, D, E;
	124
	125	GET_UINT32_BE( W[ 0], data, 0 );
	126	GET_UINT32_BE( W[ 1], data, 4 );
	127	GET_UINT32_BE( W[ 2], data, 8 );
	128	GET_UINT32_BE( W[ 3], data, 12 );
	129	GET_UINT32_BE( W[ 4], data, 16 );
	130	GET_UINT32_BE( W[ 5], data, 20 );
	131	GET_UINT32_BE( W[ 6], data, 24 );
	132	GET_UINT32_BE( W[ 7], data, 28 );
	133	GET_UINT32_BE( W[ 8], data, 32 );
	134	GET_UINT32_BE( W[ 9], data, 36 );
	135	GET_UINT32_BE( W[10], data, 40 );
	136	GET_UINT32_BE( W[11], data, 44 );
	137	GET_UINT32_BE( W[12], data, 48 );
	138	GET_UINT32_BE( W[13], data, 52 );
	139	GET_UINT32_BE( W[14], data, 56 );
	140	GET_UINT32_BE( W[15], data, 60 );
	141
	142	#define S(x,n) ((x << n) \| ((x & 0xFFFFFFFF) >> (32 - n)))
	143
	144	#define R(t) \
	145	( \
700d8687 OM	146	temp = W[( t - 3 ) & 0x0F] ^ W[( t - 8 ) & 0x0F] ^ \
700d8687 OM	147	W[( t - 14 ) & 0x0F] ^ W[ t & 0x0F], \
1c4c0b06	148	( W[t & 0x0F] = S(temp,1) ) \
	149	)
	150
	151	#define P(a,b,c,d,e,x) \
	152	{ \
	153	e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \
	154	}
	155
	156	A = ctx->state[0];
	157	B = ctx->state[1];
	158	C = ctx->state[2];
	159	D = ctx->state[3];
	160	E = ctx->state[4];
	161
	162	#define F(x,y,z) (z ^ (x & (y ^ z)))
	163	#define K 0x5A827999
	164
	165	P( A, B, C, D, E, W[0] );
	166	P( E, A, B, C, D, W[1] );
	167	P( D, E, A, B, C, W[2] );
	168	P( C, D, E, A, B, W[3] );
	169	P( B, C, D, E, A, W[4] );
	170	P( A, B, C, D, E, W[5] );
	171	P( E, A, B, C, D, W[6] );
	172	P( D, E, A, B, C, W[7] );
	173	P( C, D, E, A, B, W[8] );
	174	P( B, C, D, E, A, W[9] );
	175	P( A, B, C, D, E, W[10] );
	176	P( E, A, B, C, D, W[11] );
	177	P( D, E, A, B, C, W[12] );
	178	P( C, D, E, A, B, W[13] );
	179	P( B, C, D, E, A, W[14] );
	180	P( A, B, C, D, E, W[15] );
	181	P( E, A, B, C, D, R(16) );
	182	P( D, E, A, B, C, R(17) );
	183	P( C, D, E, A, B, R(18) );
	184	P( B, C, D, E, A, R(19) );
	185
	186	#undef K
	187	#undef F
	188
	189	#define F(x,y,z) (x ^ y ^ z)
	190	#define K 0x6ED9EBA1
	191
	192	P( A, B, C, D, E, R(20) );
	193	P( E, A, B, C, D, R(21) );
	194	P( D, E, A, B, C, R(22) );
	195	P( C, D, E, A, B, R(23) );
	196	P( B, C, D, E, A, R(24) );
	197	P( A, B, C, D, E, R(25) );
	198	P( E, A, B, C, D, R(26) );
	199	P( D, E, A, B, C, R(27) );
	200	P( C, D, E, A, B, R(28) );
	201	P( B, C, D, E, A, R(29) );
	202	P( A, B, C, D, E, R(30) );
	203	P( E, A, B, C, D, R(31) );
	204	P( D, E, A, B, C, R(32) );
	205	P( C, D, E, A, B, R(33) );
	206	P( B, C, D, E, A, R(34) );
	207	P( A, B, C, D, E, R(35) );
	208	P( E, A, B, C, D, R(36) );
	209	P( D, E, A, B, C, R(37) );
	210	P( C, D, E, A, B, R(38) );
	211	P( B, C, D, E, A, R(39) );
212
213	#undef K
214	#undef F
215
216	#define F(x,y,z) ((x & y) \| (z & (x \| y)))
217	#define K 0x8F1BBCDC
218
219	P( A, B, C, D, E, R(40) );
220	P( E, A, B, C, D, R(41) );
221	P( D, E, A, B, C, R(42) );
222	P( C, D, E, A, B, R(43) );
223	P( B, C, D, E, A, R(44) );
224	P( A, B, C, D, E, R(45) );
225	P( E, A, B, C, D, R(46) );
226	P( D, E, A, B, C, R(47) );
227	P( C, D, E, A, B, R(48) );
228	P( B, C, D, E, A, R(49) );
229	P( A, B, C, D, E, R(50) );
230	P( E, A, B, C, D, R(51) );
231	P( D, E, A, B, C, R(52) );
232	P( C, D, E, A, B, R(53) );
233	P( B, C, D, E, A, R(54) );
234	P( A, B, C, D, E, R(55) );
235	P( E, A, B, C, D, R(56) );
236	P( D, E, A, B, C, R(57) );
237	P( C, D, E, A, B, R(58) );
238	P( B, C, D, E, A, R(59) );
239
240	#undef K
241	#undef F
242
243	#define F(x,y,z) (x ^ y ^ z)
244	#define K 0xCA62C1D6
245
246	P( A, B, C, D, E, R(60) );
247	P( E, A, B, C, D, R(61) );
248	P( D, E, A, B, C, R(62) );
249	P( C, D, E, A, B, R(63) );
250	P( B, C, D, E, A, R(64) );
251	P( A, B, C, D, E, R(65) );
252	P( E, A, B, C, D, R(66) );
253	P( D, E, A, B, C, R(67) );
254	P( C, D, E, A, B, R(68) );
255	P( B, C, D, E, A, R(69) );
256	P( A, B, C, D, E, R(70) );
257	P( E, A, B, C, D, R(71) );
258	P( D, E, A, B, C, R(72) );
259	P( C, D, E, A, B, R(73) );
260	P( B, C, D, E, A, R(74) );
261	P( A, B, C, D, E, R(75) );
262	P( E, A, B, C, D, R(76) );
263	P( D, E, A, B, C, R(77) );
264	P( C, D, E, A, B, R(78) );
265	P( B, C, D, E, A, R(79) );
266
267	#undef K
268	#undef F
269
270	ctx->state[0] += A;
271	ctx->state[1] += B;
272	ctx->state[2] += C;
273	ctx->state[3] += D;
274	ctx->state[4] += E;
700d8687 OM	275
	276	return( 0 );
	277	}
	278
	279	#if !defined(MBEDTLS_DEPRECATED_REMOVED)
	280	void mbedtls_sha1_process( mbedtls_sha1_context *ctx,
	281	const unsigned char data[64] )
	282	{
	283	mbedtls_internal_sha1_process( ctx, data );
1c4c0b06	284	}
700d8687 OM	285	#endif
700d8687 OM	286	#endif /* !MBEDTLS_SHA1_PROCESS_ALT */
1c4c0b06	287
	288	/*
	289	* SHA-1 process buffer
	290	*/
700d8687 OM	291	int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx,
	292	const unsigned char *input,
	293	size_t ilen )
1c4c0b06	294	{
700d8687	295	int ret;
1c4c0b06	296	size_t fill;
	297	uint32_t left;
	298
700d8687 OM	299	if( ilen == 0 )
700d8687 OM	300	return( 0 );
1c4c0b06	301
	302	left = ctx->total[0] & 0x3F;
	303	fill = 64 - left;
	304
	305	ctx->total[0] += (uint32_t) ilen;
	306	ctx->total[0] &= 0xFFFFFFFF;
	307
	308	if( ctx->total[0] < (uint32_t) ilen )
	309	ctx->total[1]++;
	310
	311	if( left && ilen >= fill )
	312	{
	313	memcpy( (void *) (ctx->buffer + left), input, fill );
700d8687 OM	314
	315	if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
	316	return( ret );
	317
1c4c0b06	318	input += fill;
	319	ilen -= fill;
	320	left = 0;
	321	}
	322
	323	while( ilen >= 64 )
	324	{
700d8687 OM	325	if( ( ret = mbedtls_internal_sha1_process( ctx, input ) ) != 0 )
	326	return( ret );
	327
1c4c0b06	328	input += 64;
	329	ilen -= 64;
	330	}
	331
	332	if( ilen > 0 )
	333	memcpy( (void *) (ctx->buffer + left), input, ilen );
700d8687 OM	334
700d8687 OM	335	return( 0 );
1c4c0b06	336	}
1c4c0b06	337
700d8687 OM	338	#if !defined(MBEDTLS_DEPRECATED_REMOVED)
	339	void mbedtls_sha1_update( mbedtls_sha1_context *ctx,
	340	const unsigned char *input,
	341	size_t ilen )
1c4c0b06	342	{
700d8687 OM	343	mbedtls_sha1_update_ret( ctx, input, ilen );
	344	}
	345	#endif
1c4c0b06	346
	347	/*
	348	* SHA-1 final digest
	349	*/
700d8687 OM	350	int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx,
700d8687 OM	351	unsigned char output[20] )
1c4c0b06	352	{
700d8687 OM	353	int ret;
700d8687 OM	354	uint32_t used;
1c4c0b06	355	uint32_t high, low;
1c4c0b06	356
700d8687 OM	357	/*
	358	* Add padding: 0x80 then 0x00 until 8 bytes remain for the length
	359	*/
	360	used = ctx->total[0] & 0x3F;
	361
	362	ctx->buffer[used++] = 0x80;
	363
	364	if( used <= 56 )
	365	{
	366	/* Enough room for padding + length in current block */
	367	memset( ctx->buffer + used, 0, 56 - used );
	368	}
	369	else
	370	{
	371	/* We'll need an extra block */
	372	memset( ctx->buffer + used, 0, 64 - used );
	373
	374	if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
	375	return( ret );
	376
	377	memset( ctx->buffer, 0, 56 );
	378	}
	379
	380	/*
	381	* Add message length
	382	*/
1c4c0b06	383	high = ( ctx->total[0] >> 29 )
	384	\| ( ctx->total[1] << 3 );
	385	low = ( ctx->total[0] << 3 );
	386
700d8687 OM	387	PUT_UINT32_BE( high, ctx->buffer, 56 );
700d8687 OM	388	PUT_UINT32_BE( low, ctx->buffer, 60 );
1c4c0b06	389
700d8687 OM	390	if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
700d8687 OM	391	return( ret );
1c4c0b06	392
700d8687 OM	393	/*
	394	* Output final state
	395	*/
1c4c0b06	396	PUT_UINT32_BE( ctx->state[0], output, 0 );
	397	PUT_UINT32_BE( ctx->state[1], output, 4 );
	398	PUT_UINT32_BE( ctx->state[2], output, 8 );
	399	PUT_UINT32_BE( ctx->state[3], output, 12 );
	400	PUT_UINT32_BE( ctx->state[4], output, 16 );
1c4c0b06	401
700d8687	402	return( 0 );
1c4c0b06	403	}
1c4c0b06	404
700d8687 OM	405	#if !defined(MBEDTLS_DEPRECATED_REMOVED)
	406	void mbedtls_sha1_finish( mbedtls_sha1_context *ctx,
	407	unsigned char output[20] )
1c4c0b06	408	{
700d8687	409	mbedtls_sha1_finish_ret( ctx, output );
1c4c0b06	410	}
700d8687 OM	411	#endif
	412
	413	#endif /* !MBEDTLS_SHA1_ALT */
1c4c0b06	414
1c4c0b06	415	/*
700d8687	416	* output = SHA-1( input buffer )
1c4c0b06	417	*/
700d8687 OM	418	int mbedtls_sha1_ret( const unsigned char *input,
	419	size_t ilen,
	420	unsigned char output[20] )
1c4c0b06	421	{
700d8687 OM	422	int ret;
700d8687 OM	423	mbedtls_sha1_context ctx;
1c4c0b06	424
700d8687	425	mbedtls_sha1_init( &ctx );
1c4c0b06	426
700d8687 OM	427	if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
700d8687 OM	428	goto exit;
1c4c0b06	429
700d8687 OM	430	if( ( ret = mbedtls_sha1_update_ret( &ctx, input, ilen ) ) != 0 )
700d8687 OM	431	goto exit;
1c4c0b06	432
700d8687 OM	433	if( ( ret = mbedtls_sha1_finish_ret( &ctx, output ) ) != 0 )
700d8687 OM	434	goto exit;
1c4c0b06	435
700d8687 OM	436	exit:
700d8687 OM	437	mbedtls_sha1_free( &ctx );
1c4c0b06	438
700d8687	439	return( ret );
1c4c0b06	440	}
1c4c0b06	441
700d8687 OM	442	#if !defined(MBEDTLS_DEPRECATED_REMOVED)
	443	void mbedtls_sha1( const unsigned char *input,
	444	size_t ilen,
	445	unsigned char output[20] )
1c4c0b06	446	{
700d8687	447	mbedtls_sha1_ret( input, ilen, output );
1c4c0b06	448	}
700d8687	449	#endif
1c4c0b06	450
700d8687	451	#if defined(MBEDTLS_SELF_TEST)
1c4c0b06	452	/*
	453	* FIPS-180-1 test vectors
	454	*/
700d8687	455	static const unsigned char sha1_test_buf[3][57] =
1c4c0b06	456	{
	457	{ "abc" },
	458	{ "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
	459	{ "" }
	460	};
	461
700d8687	462	static const size_t sha1_test_buflen[3] =
1c4c0b06	463	{
	464	3, 56, 1000
	465	};
	466
	467	static const unsigned char sha1_test_sum[3][20] =
	468	{
	469	{ 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
	470	0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
	471	{ 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
	472	0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
	473	{ 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
	474	0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
	475	};
	476
1c4c0b06	477	/*
	478	* Checkup routine
	479	*/
700d8687	480	int mbedtls_sha1_self_test( int verbose )
1c4c0b06	481	{
700d8687	482	int i, j, buflen, ret = 0;
1c4c0b06	483	unsigned char buf[1024];
1c4c0b06	484	unsigned char sha1sum[20];
700d8687 OM	485	mbedtls_sha1_context ctx;
	486
	487	mbedtls_sha1_init( &ctx );
1c4c0b06	488
1c4c0b06	489	/*
	490	* SHA-1
	491	*/
	492	for( i = 0; i < 3; i++ )
	493	{
	494	if( verbose != 0 )
700d8687	495	mbedtls_printf( " SHA-1 test #%d: ", i + 1 );
1c4c0b06	496
700d8687 OM	497	if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
700d8687 OM	498	goto fail;
1c4c0b06	499
	500	if( i == 2 )
	501	{
	502	memset( buf, 'a', buflen = 1000 );
	503
	504	for( j = 0; j < 1000; j++ )
700d8687 OM	505	{
	506	ret = mbedtls_sha1_update_ret( &ctx, buf, buflen );
	507	if( ret != 0 )
	508	goto fail;
	509	}
1c4c0b06	510	}
1c4c0b06	511	else
700d8687 OM	512	{
	513	ret = mbedtls_sha1_update_ret( &ctx, sha1_test_buf[i],
	514	sha1_test_buflen[i] );
	515	if( ret != 0 )
	516	goto fail;
	517	}
1c4c0b06	518
700d8687 OM	519	if( ( ret = mbedtls_sha1_finish_ret( &ctx, sha1sum ) ) != 0 )
700d8687 OM	520	goto fail;
1c4c0b06	521
	522	if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
	523	{
700d8687 OM	524	ret = 1;
700d8687 OM	525	goto fail;
1c4c0b06	526	}
	527
	528	if( verbose != 0 )
700d8687	529	mbedtls_printf( "passed\n" );
1c4c0b06	530	}
	531
	532	if( verbose != 0 )
700d8687	533	mbedtls_printf( "\n" );
1c4c0b06	534
700d8687	535	goto exit;
1c4c0b06	536
700d8687	537	fail:
1c4c0b06	538	if( verbose != 0 )
700d8687	539	mbedtls_printf( "failed\n" );
1c4c0b06	540
700d8687 OM	541	exit:
	542	mbedtls_sha1_free( &ctx );
	543
	544	return( ret );
1c4c0b06	545	}
1c4c0b06	546
700d8687	547	#endif /* MBEDTLS_SELF_TEST */
1c4c0b06	548
700d8687	549	#endif /* MBEDTLS_SHA1_C */