mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-11-30 21:24:19 +01:00
e47b34bdc8
New padding checking is unbiased on correct or incorrect padding and has no branch prediction timing differences. The additional MAC checks further straighten out the timing differences.
584 lines
16 KiB
C
584 lines
16 KiB
C
/*
|
|
* RFC 1321 compliant MD5 implementation
|
|
*
|
|
* Copyright (C) 2006-2010, Brainspark B.V.
|
|
*
|
|
* This file is part of PolarSSL (http://www.polarssl.org)
|
|
* Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* 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.
|
|
*/
|
|
/*
|
|
* The MD5 algorithm was designed by Ron Rivest in 1991.
|
|
*
|
|
* http://www.ietf.org/rfc/rfc1321.txt
|
|
*/
|
|
|
|
#include "polarssl/config.h"
|
|
|
|
#if defined(POLARSSL_MD5_C)
|
|
|
|
#include "polarssl/md5.h"
|
|
|
|
#if defined(POLARSSL_FS_IO) || defined(POLARSSL_SELF_TEST)
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/*
|
|
* 32-bit integer manipulation macros (little endian)
|
|
*/
|
|
#ifndef GET_UINT32_LE
|
|
#define GET_UINT32_LE(n,b,i) \
|
|
{ \
|
|
(n) = ( (uint32_t) (b)[(i) ] ) \
|
|
| ( (uint32_t) (b)[(i) + 1] << 8 ) \
|
|
| ( (uint32_t) (b)[(i) + 2] << 16 ) \
|
|
| ( (uint32_t) (b)[(i) + 3] << 24 ); \
|
|
}
|
|
#endif
|
|
|
|
#ifndef PUT_UINT32_LE
|
|
#define PUT_UINT32_LE(n,b,i) \
|
|
{ \
|
|
(b)[(i) ] = (unsigned char) ( (n) ); \
|
|
(b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \
|
|
(b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \
|
|
(b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* MD5 context setup
|
|
*/
|
|
void md5_starts( md5_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;
|
|
}
|
|
|
|
void md5_process( md5_context *ctx, const unsigned char data[64] )
|
|
{
|
|
uint32_t X[16], A, B, C, D;
|
|
|
|
GET_UINT32_LE( X[ 0], data, 0 );
|
|
GET_UINT32_LE( X[ 1], data, 4 );
|
|
GET_UINT32_LE( X[ 2], data, 8 );
|
|
GET_UINT32_LE( X[ 3], data, 12 );
|
|
GET_UINT32_LE( X[ 4], data, 16 );
|
|
GET_UINT32_LE( X[ 5], data, 20 );
|
|
GET_UINT32_LE( X[ 6], data, 24 );
|
|
GET_UINT32_LE( X[ 7], data, 28 );
|
|
GET_UINT32_LE( X[ 8], data, 32 );
|
|
GET_UINT32_LE( X[ 9], data, 36 );
|
|
GET_UINT32_LE( X[10], data, 40 );
|
|
GET_UINT32_LE( X[11], data, 44 );
|
|
GET_UINT32_LE( X[12], data, 48 );
|
|
GET_UINT32_LE( X[13], data, 52 );
|
|
GET_UINT32_LE( X[14], data, 56 );
|
|
GET_UINT32_LE( X[15], data, 60 );
|
|
|
|
#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
|
|
|
|
#define P(a,b,c,d,k,s,t) \
|
|
{ \
|
|
a += F(b,c,d) + X[k] + t; a = S(a,s) + b; \
|
|
}
|
|
|
|
A = ctx->state[0];
|
|
B = ctx->state[1];
|
|
C = ctx->state[2];
|
|
D = ctx->state[3];
|
|
|
|
#define F(x,y,z) (z ^ (x & (y ^ z)))
|
|
|
|
P( A, B, C, D, 0, 7, 0xD76AA478 );
|
|
P( D, A, B, C, 1, 12, 0xE8C7B756 );
|
|
P( C, D, A, B, 2, 17, 0x242070DB );
|
|
P( B, C, D, A, 3, 22, 0xC1BDCEEE );
|
|
P( A, B, C, D, 4, 7, 0xF57C0FAF );
|
|
P( D, A, B, C, 5, 12, 0x4787C62A );
|
|
P( C, D, A, B, 6, 17, 0xA8304613 );
|
|
P( B, C, D, A, 7, 22, 0xFD469501 );
|
|
P( A, B, C, D, 8, 7, 0x698098D8 );
|
|
P( D, A, B, C, 9, 12, 0x8B44F7AF );
|
|
P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
|
|
P( B, C, D, A, 11, 22, 0x895CD7BE );
|
|
P( A, B, C, D, 12, 7, 0x6B901122 );
|
|
P( D, A, B, C, 13, 12, 0xFD987193 );
|
|
P( C, D, A, B, 14, 17, 0xA679438E );
|
|
P( B, C, D, A, 15, 22, 0x49B40821 );
|
|
|
|
#undef F
|
|
|
|
#define F(x,y,z) (y ^ (z & (x ^ y)))
|
|
|
|
P( A, B, C, D, 1, 5, 0xF61E2562 );
|
|
P( D, A, B, C, 6, 9, 0xC040B340 );
|
|
P( C, D, A, B, 11, 14, 0x265E5A51 );
|
|
P( B, C, D, A, 0, 20, 0xE9B6C7AA );
|
|
P( A, B, C, D, 5, 5, 0xD62F105D );
|
|
P( D, A, B, C, 10, 9, 0x02441453 );
|
|
P( C, D, A, B, 15, 14, 0xD8A1E681 );
|
|
P( B, C, D, A, 4, 20, 0xE7D3FBC8 );
|
|
P( A, B, C, D, 9, 5, 0x21E1CDE6 );
|
|
P( D, A, B, C, 14, 9, 0xC33707D6 );
|
|
P( C, D, A, B, 3, 14, 0xF4D50D87 );
|
|
P( B, C, D, A, 8, 20, 0x455A14ED );
|
|
P( A, B, C, D, 13, 5, 0xA9E3E905 );
|
|
P( D, A, B, C, 2, 9, 0xFCEFA3F8 );
|
|
P( C, D, A, B, 7, 14, 0x676F02D9 );
|
|
P( B, C, D, A, 12, 20, 0x8D2A4C8A );
|
|
|
|
#undef F
|
|
|
|
#define F(x,y,z) (x ^ y ^ z)
|
|
|
|
P( A, B, C, D, 5, 4, 0xFFFA3942 );
|
|
P( D, A, B, C, 8, 11, 0x8771F681 );
|
|
P( C, D, A, B, 11, 16, 0x6D9D6122 );
|
|
P( B, C, D, A, 14, 23, 0xFDE5380C );
|
|
P( A, B, C, D, 1, 4, 0xA4BEEA44 );
|
|
P( D, A, B, C, 4, 11, 0x4BDECFA9 );
|
|
P( C, D, A, B, 7, 16, 0xF6BB4B60 );
|
|
P( B, C, D, A, 10, 23, 0xBEBFBC70 );
|
|
P( A, B, C, D, 13, 4, 0x289B7EC6 );
|
|
P( D, A, B, C, 0, 11, 0xEAA127FA );
|
|
P( C, D, A, B, 3, 16, 0xD4EF3085 );
|
|
P( B, C, D, A, 6, 23, 0x04881D05 );
|
|
P( A, B, C, D, 9, 4, 0xD9D4D039 );
|
|
P( D, A, B, C, 12, 11, 0xE6DB99E5 );
|
|
P( C, D, A, B, 15, 16, 0x1FA27CF8 );
|
|
P( B, C, D, A, 2, 23, 0xC4AC5665 );
|
|
|
|
#undef F
|
|
|
|
#define F(x,y,z) (y ^ (x | ~z))
|
|
|
|
P( A, B, C, D, 0, 6, 0xF4292244 );
|
|
P( D, A, B, C, 7, 10, 0x432AFF97 );
|
|
P( C, D, A, B, 14, 15, 0xAB9423A7 );
|
|
P( B, C, D, A, 5, 21, 0xFC93A039 );
|
|
P( A, B, C, D, 12, 6, 0x655B59C3 );
|
|
P( D, A, B, C, 3, 10, 0x8F0CCC92 );
|
|
P( C, D, A, B, 10, 15, 0xFFEFF47D );
|
|
P( B, C, D, A, 1, 21, 0x85845DD1 );
|
|
P( A, B, C, D, 8, 6, 0x6FA87E4F );
|
|
P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
|
|
P( C, D, A, B, 6, 15, 0xA3014314 );
|
|
P( B, C, D, A, 13, 21, 0x4E0811A1 );
|
|
P( A, B, C, D, 4, 6, 0xF7537E82 );
|
|
P( D, A, B, C, 11, 10, 0xBD3AF235 );
|
|
P( C, D, A, B, 2, 15, 0x2AD7D2BB );
|
|
P( B, C, D, A, 9, 21, 0xEB86D391 );
|
|
|
|
#undef F
|
|
|
|
ctx->state[0] += A;
|
|
ctx->state[1] += B;
|
|
ctx->state[2] += C;
|
|
ctx->state[3] += D;
|
|
}
|
|
|
|
/*
|
|
* MD5 process buffer
|
|
*/
|
|
void md5_update( md5_context *ctx, const unsigned char *input, size_t ilen )
|
|
{
|
|
size_t fill;
|
|
uint32_t left;
|
|
|
|
if( ilen <= 0 )
|
|
return;
|
|
|
|
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),
|
|
(void *) input, fill );
|
|
md5_process( ctx, ctx->buffer );
|
|
input += fill;
|
|
ilen -= fill;
|
|
left = 0;
|
|
}
|
|
|
|
while( ilen >= 64 )
|
|
{
|
|
md5_process( ctx, input );
|
|
input += 64;
|
|
ilen -= 64;
|
|
}
|
|
|
|
if( ilen > 0 )
|
|
{
|
|
memcpy( (void *) (ctx->buffer + left),
|
|
(void *) input, ilen );
|
|
}
|
|
}
|
|
|
|
static const unsigned char md5_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
|
|
};
|
|
|
|
/*
|
|
* MD5 final digest
|
|
*/
|
|
void md5_finish( md5_context *ctx, unsigned char output[16] )
|
|
{
|
|
uint32_t last, padn;
|
|
uint32_t high, low;
|
|
unsigned char msglen[8];
|
|
|
|
high = ( ctx->total[0] >> 29 )
|
|
| ( ctx->total[1] << 3 );
|
|
low = ( ctx->total[0] << 3 );
|
|
|
|
PUT_UINT32_LE( low, msglen, 0 );
|
|
PUT_UINT32_LE( high, msglen, 4 );
|
|
|
|
last = ctx->total[0] & 0x3F;
|
|
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
|
|
|
|
md5_update( ctx, (unsigned char *) md5_padding, padn );
|
|
md5_update( ctx, msglen, 8 );
|
|
|
|
PUT_UINT32_LE( ctx->state[0], output, 0 );
|
|
PUT_UINT32_LE( ctx->state[1], output, 4 );
|
|
PUT_UINT32_LE( ctx->state[2], output, 8 );
|
|
PUT_UINT32_LE( ctx->state[3], output, 12 );
|
|
}
|
|
|
|
/*
|
|
* output = MD5( input buffer )
|
|
*/
|
|
void md5( const unsigned char *input, size_t ilen, unsigned char output[16] )
|
|
{
|
|
md5_context ctx;
|
|
|
|
md5_starts( &ctx );
|
|
md5_update( &ctx, input, ilen );
|
|
md5_finish( &ctx, output );
|
|
|
|
memset( &ctx, 0, sizeof( md5_context ) );
|
|
}
|
|
|
|
#if defined(POLARSSL_FS_IO)
|
|
/*
|
|
* output = MD5( file contents )
|
|
*/
|
|
int md5_file( const char *path, unsigned char output[16] )
|
|
{
|
|
FILE *f;
|
|
size_t n;
|
|
md5_context ctx;
|
|
unsigned char buf[1024];
|
|
|
|
if( ( f = fopen( path, "rb" ) ) == NULL )
|
|
return( POLARSSL_ERR_MD5_FILE_IO_ERROR );
|
|
|
|
md5_starts( &ctx );
|
|
|
|
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
|
|
md5_update( &ctx, buf, n );
|
|
|
|
md5_finish( &ctx, output );
|
|
|
|
memset( &ctx, 0, sizeof( md5_context ) );
|
|
|
|
if( ferror( f ) != 0 )
|
|
{
|
|
fclose( f );
|
|
return( POLARSSL_ERR_MD5_FILE_IO_ERROR );
|
|
}
|
|
|
|
fclose( f );
|
|
return( 0 );
|
|
}
|
|
#endif /* POLARSSL_FS_IO */
|
|
|
|
/*
|
|
* MD5 HMAC context setup
|
|
*/
|
|
void md5_hmac_starts( md5_context *ctx, const unsigned char *key, size_t keylen )
|
|
{
|
|
size_t i;
|
|
unsigned char sum[16];
|
|
|
|
if( keylen > 64 )
|
|
{
|
|
md5( key, keylen, sum );
|
|
keylen = 16;
|
|
key = sum;
|
|
}
|
|
|
|
memset( ctx->ipad, 0x36, 64 );
|
|
memset( ctx->opad, 0x5C, 64 );
|
|
|
|
for( i = 0; i < keylen; i++ )
|
|
{
|
|
ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
|
|
ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
|
|
}
|
|
|
|
md5_starts( ctx );
|
|
md5_update( ctx, ctx->ipad, 64 );
|
|
|
|
memset( sum, 0, sizeof( sum ) );
|
|
}
|
|
|
|
/*
|
|
* MD5 HMAC process buffer
|
|
*/
|
|
void md5_hmac_update( md5_context *ctx, const unsigned char *input, size_t ilen )
|
|
{
|
|
md5_update( ctx, input, ilen );
|
|
}
|
|
|
|
/*
|
|
* MD5 HMAC final digest
|
|
*/
|
|
void md5_hmac_finish( md5_context *ctx, unsigned char output[16] )
|
|
{
|
|
unsigned char tmpbuf[16];
|
|
|
|
md5_finish( ctx, tmpbuf );
|
|
md5_starts( ctx );
|
|
md5_update( ctx, ctx->opad, 64 );
|
|
md5_update( ctx, tmpbuf, 16 );
|
|
md5_finish( ctx, output );
|
|
|
|
memset( tmpbuf, 0, sizeof( tmpbuf ) );
|
|
}
|
|
|
|
/*
|
|
* MD5 HMAC context reset
|
|
*/
|
|
void md5_hmac_reset( md5_context *ctx )
|
|
{
|
|
md5_starts( ctx );
|
|
md5_update( ctx, ctx->ipad, 64 );
|
|
}
|
|
|
|
/*
|
|
* output = HMAC-MD5( hmac key, input buffer )
|
|
*/
|
|
void md5_hmac( const unsigned char *key, size_t keylen,
|
|
const unsigned char *input, size_t ilen,
|
|
unsigned char output[16] )
|
|
{
|
|
md5_context ctx;
|
|
|
|
md5_hmac_starts( &ctx, key, keylen );
|
|
md5_hmac_update( &ctx, input, ilen );
|
|
md5_hmac_finish( &ctx, output );
|
|
|
|
memset( &ctx, 0, sizeof( md5_context ) );
|
|
}
|
|
|
|
#if defined(POLARSSL_SELF_TEST)
|
|
/*
|
|
* RFC 1321 test vectors
|
|
*/
|
|
static unsigned char md5_test_buf[7][81] =
|
|
{
|
|
{ "" },
|
|
{ "a" },
|
|
{ "abc" },
|
|
{ "message digest" },
|
|
{ "abcdefghijklmnopqrstuvwxyz" },
|
|
{ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" },
|
|
{ "12345678901234567890123456789012345678901234567890123456789012" \
|
|
"345678901234567890" }
|
|
};
|
|
|
|
static const int md5_test_buflen[7] =
|
|
{
|
|
0, 1, 3, 14, 26, 62, 80
|
|
};
|
|
|
|
static const unsigned char md5_test_sum[7][16] =
|
|
{
|
|
{ 0xD4, 0x1D, 0x8C, 0xD9, 0x8F, 0x00, 0xB2, 0x04,
|
|
0xE9, 0x80, 0x09, 0x98, 0xEC, 0xF8, 0x42, 0x7E },
|
|
{ 0x0C, 0xC1, 0x75, 0xB9, 0xC0, 0xF1, 0xB6, 0xA8,
|
|
0x31, 0xC3, 0x99, 0xE2, 0x69, 0x77, 0x26, 0x61 },
|
|
{ 0x90, 0x01, 0x50, 0x98, 0x3C, 0xD2, 0x4F, 0xB0,
|
|
0xD6, 0x96, 0x3F, 0x7D, 0x28, 0xE1, 0x7F, 0x72 },
|
|
{ 0xF9, 0x6B, 0x69, 0x7D, 0x7C, 0xB7, 0x93, 0x8D,
|
|
0x52, 0x5A, 0x2F, 0x31, 0xAA, 0xF1, 0x61, 0xD0 },
|
|
{ 0xC3, 0xFC, 0xD3, 0xD7, 0x61, 0x92, 0xE4, 0x00,
|
|
0x7D, 0xFB, 0x49, 0x6C, 0xCA, 0x67, 0xE1, 0x3B },
|
|
{ 0xD1, 0x74, 0xAB, 0x98, 0xD2, 0x77, 0xD9, 0xF5,
|
|
0xA5, 0x61, 0x1C, 0x2C, 0x9F, 0x41, 0x9D, 0x9F },
|
|
{ 0x57, 0xED, 0xF4, 0xA2, 0x2B, 0xE3, 0xC9, 0x55,
|
|
0xAC, 0x49, 0xDA, 0x2E, 0x21, 0x07, 0xB6, 0x7A }
|
|
};
|
|
|
|
/*
|
|
* RFC 2202 test vectors
|
|
*/
|
|
static unsigned char md5_hmac_test_key[7][26] =
|
|
{
|
|
{ "\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B" },
|
|
{ "Jefe" },
|
|
{ "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA" },
|
|
{ "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10"
|
|
"\x11\x12\x13\x14\x15\x16\x17\x18\x19" },
|
|
{ "\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C" },
|
|
{ "" }, /* 0xAA 80 times */
|
|
{ "" }
|
|
};
|
|
|
|
static const int md5_hmac_test_keylen[7] =
|
|
{
|
|
16, 4, 16, 25, 16, 80, 80
|
|
};
|
|
|
|
static unsigned char md5_hmac_test_buf[7][74] =
|
|
{
|
|
{ "Hi There" },
|
|
{ "what do ya want for nothing?" },
|
|
{ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
|
|
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
|
|
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
|
|
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
|
|
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" },
|
|
{ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
|
|
"\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
|
|
"\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
|
|
"\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
|
|
"\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD" },
|
|
{ "Test With Truncation" },
|
|
{ "Test Using Larger Than Block-Size Key - Hash Key First" },
|
|
{ "Test Using Larger Than Block-Size Key and Larger"
|
|
" Than One Block-Size Data" }
|
|
};
|
|
|
|
static const int md5_hmac_test_buflen[7] =
|
|
{
|
|
8, 28, 50, 50, 20, 54, 73
|
|
};
|
|
|
|
static const unsigned char md5_hmac_test_sum[7][16] =
|
|
{
|
|
{ 0x92, 0x94, 0x72, 0x7A, 0x36, 0x38, 0xBB, 0x1C,
|
|
0x13, 0xF4, 0x8E, 0xF8, 0x15, 0x8B, 0xFC, 0x9D },
|
|
{ 0x75, 0x0C, 0x78, 0x3E, 0x6A, 0xB0, 0xB5, 0x03,
|
|
0xEA, 0xA8, 0x6E, 0x31, 0x0A, 0x5D, 0xB7, 0x38 },
|
|
{ 0x56, 0xBE, 0x34, 0x52, 0x1D, 0x14, 0x4C, 0x88,
|
|
0xDB, 0xB8, 0xC7, 0x33, 0xF0, 0xE8, 0xB3, 0xF6 },
|
|
{ 0x69, 0x7E, 0xAF, 0x0A, 0xCA, 0x3A, 0x3A, 0xEA,
|
|
0x3A, 0x75, 0x16, 0x47, 0x46, 0xFF, 0xAA, 0x79 },
|
|
{ 0x56, 0x46, 0x1E, 0xF2, 0x34, 0x2E, 0xDC, 0x00,
|
|
0xF9, 0xBA, 0xB9, 0x95 },
|
|
{ 0x6B, 0x1A, 0xB7, 0xFE, 0x4B, 0xD7, 0xBF, 0x8F,
|
|
0x0B, 0x62, 0xE6, 0xCE, 0x61, 0xB9, 0xD0, 0xCD },
|
|
{ 0x6F, 0x63, 0x0F, 0xAD, 0x67, 0xCD, 0xA0, 0xEE,
|
|
0x1F, 0xB1, 0xF5, 0x62, 0xDB, 0x3A, 0xA5, 0x3E }
|
|
};
|
|
|
|
/*
|
|
* Checkup routine
|
|
*/
|
|
int md5_self_test( int verbose )
|
|
{
|
|
int i, buflen;
|
|
unsigned char buf[1024];
|
|
unsigned char md5sum[16];
|
|
md5_context ctx;
|
|
|
|
for( i = 0; i < 7; i++ )
|
|
{
|
|
if( verbose != 0 )
|
|
printf( " MD5 test #%d: ", i + 1 );
|
|
|
|
md5( md5_test_buf[i], md5_test_buflen[i], md5sum );
|
|
|
|
if( memcmp( md5sum, md5_test_sum[i], 16 ) != 0 )
|
|
{
|
|
if( verbose != 0 )
|
|
printf( "failed\n" );
|
|
|
|
return( 1 );
|
|
}
|
|
|
|
if( verbose != 0 )
|
|
printf( "passed\n" );
|
|
}
|
|
|
|
if( verbose != 0 )
|
|
printf( "\n" );
|
|
|
|
for( i = 0; i < 7; i++ )
|
|
{
|
|
if( verbose != 0 )
|
|
printf( " HMAC-MD5 test #%d: ", i + 1 );
|
|
|
|
if( i == 5 || i == 6 )
|
|
{
|
|
memset( buf, '\xAA', buflen = 80 );
|
|
md5_hmac_starts( &ctx, buf, buflen );
|
|
}
|
|
else
|
|
md5_hmac_starts( &ctx, md5_hmac_test_key[i],
|
|
md5_hmac_test_keylen[i] );
|
|
|
|
md5_hmac_update( &ctx, md5_hmac_test_buf[i],
|
|
md5_hmac_test_buflen[i] );
|
|
|
|
md5_hmac_finish( &ctx, md5sum );
|
|
|
|
buflen = ( i == 4 ) ? 12 : 16;
|
|
|
|
if( memcmp( md5sum, md5_hmac_test_sum[i], buflen ) != 0 )
|
|
{
|
|
if( verbose != 0 )
|
|
printf( "failed\n" );
|
|
|
|
return( 1 );
|
|
}
|
|
|
|
if( verbose != 0 )
|
|
printf( "passed\n" );
|
|
}
|
|
|
|
if( verbose != 0 )
|
|
printf( "\n" );
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|