md2.c

00001 /*
00002  *  RFC 1115/1319 compliant MD2 implementation
00003  *
00004  *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
00005  *  SPDX-License-Identifier: Apache-2.0
00006  *
00007  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
00008  *  not use this file except in compliance with the License.
00009  *  You may obtain a copy of the License at
00010  *
00011  *  http://www.apache.org/licenses/LICENSE-2.0
00012  *
00013  *  Unless required by applicable law or agreed to in writing, software
00014  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
00015  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00016  *  See the License for the specific language governing permissions and
00017  *  limitations under the License.
00018  *
00019  *  This file is part of mbed TLS (https://tls.mbed.org)
00020  */
00021 /*
00022  *  The MD2 algorithm was designed by Ron Rivest in 1989.
00023  *
00024  *  http://www.ietf.org/rfc/rfc1115.txt
00025  *  http://www.ietf.org/rfc/rfc1319.txt
00026  */
00027 
00028 #if !defined(MBEDTLS_CONFIG_FILE)
00029 #include "mbedtls/config.h"
00030 #else
00031 #include MBEDTLS_CONFIG_FILE
00032 #endif
00033 
00034 #if defined(MBEDTLS_MD2_C)
00035 
00036 #include "mbedtls/md2.h"
00037 #include "mbedtls/platform_util.h"
00038 
00039 #include <string.h>
00040 
00041 #if defined(MBEDTLS_SELF_TEST)
00042 #if defined(MBEDTLS_PLATFORM_C)
00043 #include "mbedtls/platform.h"
00044 #else
00045 #include <stdio.h>
00046 #define mbedtls_printf printf
00047 #endif /* MBEDTLS_PLATFORM_C */
00048 #endif /* MBEDTLS_SELF_TEST */
00049 
00050 #if !defined(MBEDTLS_MD2_ALT)
00051 
00052 static const unsigned char PI_SUBST[256] =
00053 {
00054     0x29, 0x2E, 0x43, 0xC9, 0xA2, 0xD8, 0x7C, 0x01, 0x3D, 0x36,
00055     0x54, 0xA1, 0xEC, 0xF0, 0x06, 0x13, 0x62, 0xA7, 0x05, 0xF3,
00056     0xC0, 0xC7, 0x73, 0x8C, 0x98, 0x93, 0x2B, 0xD9, 0xBC, 0x4C,
00057     0x82, 0xCA, 0x1E, 0x9B, 0x57, 0x3C, 0xFD, 0xD4, 0xE0, 0x16,
00058     0x67, 0x42, 0x6F, 0x18, 0x8A, 0x17, 0xE5, 0x12, 0xBE, 0x4E,
00059     0xC4, 0xD6, 0xDA, 0x9E, 0xDE, 0x49, 0xA0, 0xFB, 0xF5, 0x8E,
00060     0xBB, 0x2F, 0xEE, 0x7A, 0xA9, 0x68, 0x79, 0x91, 0x15, 0xB2,
00061     0x07, 0x3F, 0x94, 0xC2, 0x10, 0x89, 0x0B, 0x22, 0x5F, 0x21,
00062     0x80, 0x7F, 0x5D, 0x9A, 0x5A, 0x90, 0x32, 0x27, 0x35, 0x3E,
00063     0xCC, 0xE7, 0xBF, 0xF7, 0x97, 0x03, 0xFF, 0x19, 0x30, 0xB3,
00064     0x48, 0xA5, 0xB5, 0xD1, 0xD7, 0x5E, 0x92, 0x2A, 0xAC, 0x56,
00065     0xAA, 0xC6, 0x4F, 0xB8, 0x38, 0xD2, 0x96, 0xA4, 0x7D, 0xB6,
00066     0x76, 0xFC, 0x6B, 0xE2, 0x9C, 0x74, 0x04, 0xF1, 0x45, 0x9D,
00067     0x70, 0x59, 0x64, 0x71, 0x87, 0x20, 0x86, 0x5B, 0xCF, 0x65,
00068     0xE6, 0x2D, 0xA8, 0x02, 0x1B, 0x60, 0x25, 0xAD, 0xAE, 0xB0,
00069     0xB9, 0xF6, 0x1C, 0x46, 0x61, 0x69, 0x34, 0x40, 0x7E, 0x0F,
00070     0x55, 0x47, 0xA3, 0x23, 0xDD, 0x51, 0xAF, 0x3A, 0xC3, 0x5C,
00071     0xF9, 0xCE, 0xBA, 0xC5, 0xEA, 0x26, 0x2C, 0x53, 0x0D, 0x6E,
00072     0x85, 0x28, 0x84, 0x09, 0xD3, 0xDF, 0xCD, 0xF4, 0x41, 0x81,
00073     0x4D, 0x52, 0x6A, 0xDC, 0x37, 0xC8, 0x6C, 0xC1, 0xAB, 0xFA,
00074     0x24, 0xE1, 0x7B, 0x08, 0x0C, 0xBD, 0xB1, 0x4A, 0x78, 0x88,
00075     0x95, 0x8B, 0xE3, 0x63, 0xE8, 0x6D, 0xE9, 0xCB, 0xD5, 0xFE,
00076     0x3B, 0x00, 0x1D, 0x39, 0xF2, 0xEF, 0xB7, 0x0E, 0x66, 0x58,
00077     0xD0, 0xE4, 0xA6, 0x77, 0x72, 0xF8, 0xEB, 0x75, 0x4B, 0x0A,
00078     0x31, 0x44, 0x50, 0xB4, 0x8F, 0xED, 0x1F, 0x1A, 0xDB, 0x99,
00079     0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14
00080 };
00081 
00082 void mbedtls_md2_init( mbedtls_md2_context *ctx )
00083 {
00084     memset( ctx, 0, sizeof( mbedtls_md2_context ) );
00085 }
00086 
00087 void mbedtls_md2_free( mbedtls_md2_context *ctx )
00088 {
00089     if( ctx == NULL )
00090         return;
00091 
00092     mbedtls_platform_zeroize( ctx, sizeof( mbedtls_md2_context ) );
00093 }
00094 
00095 void mbedtls_md2_clone( mbedtls_md2_context *dst,
00096                         const mbedtls_md2_context *src )
00097 {
00098     *dst = *src;
00099 }
00100 
00101 /*
00102  * MD2 context setup
00103  */
00104 int mbedtls_md2_starts_ret( mbedtls_md2_context *ctx )
00105 {
00106     memset( ctx->cksum , 0, 16 );
00107     memset( ctx->state , 0, 46 );
00108     memset( ctx->buffer , 0, 16 );
00109     ctx->left  = 0;
00110 
00111     return( 0 );
00112 }
00113 
00114 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00115 void mbedtls_md2_starts( mbedtls_md2_context *ctx )
00116 {
00117     mbedtls_md2_starts_ret( ctx );
00118 }
00119 #endif
00120 
00121 #if !defined(MBEDTLS_MD2_PROCESS_ALT)
00122 int mbedtls_internal_md2_process( mbedtls_md2_context *ctx )
00123 {
00124     int i, j;
00125     unsigned char t = 0;
00126 
00127     for( i = 0; i < 16; i++ )
00128     {
00129         ctx->state [i + 16] = ctx->buffer [i];
00130         ctx->state [i + 32] =
00131             (unsigned char)( ctx->buffer [i] ^ ctx->state [i]);
00132     }
00133 
00134     for( i = 0; i < 18; i++ )
00135     {
00136         for( j = 0; j < 48; j++ )
00137         {
00138             ctx->state [j] = (unsigned char)
00139                ( ctx->state [j] ^ PI_SUBST[t] );
00140             t  = ctx->state [j];
00141         }
00142 
00143         t = (unsigned char)( t + i );
00144     }
00145 
00146     t = ctx->cksum [15];
00147 
00148     for( i = 0; i < 16; i++ )
00149     {
00150         ctx->cksum [i] = (unsigned char)
00151            ( ctx->cksum [i] ^ PI_SUBST[ctx->buffer [i] ^ t] );
00152         t  = ctx->cksum [i];
00153     }
00154 
00155     return( 0 );
00156 }
00157 
00158 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00159 void mbedtls_md2_process( mbedtls_md2_context *ctx )
00160 {
00161     mbedtls_internal_md2_process( ctx );
00162 }
00163 #endif
00164 #endif /* !MBEDTLS_MD2_PROCESS_ALT */
00165 
00166 /*
00167  * MD2 process buffer
00168  */
00169 int mbedtls_md2_update_ret( mbedtls_md2_context *ctx,
00170                             const unsigned char *input,
00171                             size_t ilen )
00172 {
00173     int ret;
00174     size_t fill;
00175 
00176     while( ilen > 0 )
00177     {
00178         if( ilen > 16 - ctx->left  )
00179             fill = 16 - ctx->left ;
00180         else
00181             fill = ilen;
00182 
00183         memcpy( ctx->buffer  + ctx->left , input, fill );
00184 
00185         ctx->left  += fill;
00186         input += fill;
00187         ilen  -= fill;
00188 
00189         if( ctx->left  == 16 )
00190         {
00191             ctx->left  = 0;
00192             if( ( ret = mbedtls_internal_md2_process( ctx ) ) != 0 )
00193                 return( ret );
00194         }
00195     }
00196 
00197     return( 0 );
00198 }
00199 
00200 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00201 void mbedtls_md2_update( mbedtls_md2_context *ctx,
00202                          const unsigned char *input,
00203                          size_t ilen )
00204 {
00205     mbedtls_md2_update_ret( ctx, input, ilen );
00206 }
00207 #endif
00208 
00209 /*
00210  * MD2 final digest
00211  */
00212 int mbedtls_md2_finish_ret( mbedtls_md2_context *ctx,
00213                             unsigned char output[16] )
00214 {
00215     int ret;
00216     size_t i;
00217     unsigned char x;
00218 
00219     x = (unsigned char)( 16 - ctx->left  );
00220 
00221     for( i = ctx->left ; i < 16; i++ )
00222         ctx->buffer [i] = x;
00223 
00224     if( ( ret = mbedtls_internal_md2_process( ctx ) ) != 0 )
00225         return( ret );
00226 
00227     memcpy( ctx->buffer , ctx->cksum , 16 );
00228     if( ( ret = mbedtls_internal_md2_process( ctx ) ) != 0 )
00229         return( ret );
00230 
00231     memcpy( output, ctx->state , 16 );
00232 
00233     return( 0 );
00234 }
00235 
00236 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00237 void mbedtls_md2_finish( mbedtls_md2_context *ctx,
00238                          unsigned char output[16] )
00239 {
00240     mbedtls_md2_finish_ret( ctx, output );
00241 }
00242 #endif
00243 
00244 #endif /* !MBEDTLS_MD2_ALT */
00245 
00246 /*
00247  * output = MD2( input buffer )
00248  */
00249 int mbedtls_md2_ret( const unsigned char *input,
00250                      size_t ilen,
00251                      unsigned char output[16] )
00252 {
00253     int ret;
00254     mbedtls_md2_context ctx;
00255 
00256     mbedtls_md2_init( &ctx );
00257 
00258     if( ( ret = mbedtls_md2_starts_ret( &ctx ) ) != 0 )
00259         goto exit;
00260 
00261     if( ( ret = mbedtls_md2_update_ret( &ctx, input, ilen ) ) != 0 )
00262         goto exit;
00263 
00264     if( ( ret = mbedtls_md2_finish_ret( &ctx, output ) ) != 0 )
00265         goto exit;
00266 
00267 exit:
00268     mbedtls_md2_free( &ctx );
00269 
00270     return( ret );
00271 }
00272 
00273 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00274 void mbedtls_md2( const unsigned char *input,
00275                   size_t ilen,
00276                   unsigned char output[16] )
00277 {
00278     mbedtls_md2_ret( input, ilen, output );
00279 }
00280 #endif
00281 
00282 #if defined(MBEDTLS_SELF_TEST)
00283 
00284 /*
00285  * RFC 1319 test vectors
00286  */
00287 static const unsigned char md2_test_str[7][81] =
00288 {
00289     { "" },
00290     { "a" },
00291     { "abc" },
00292     { "message digest" },
00293     { "abcdefghijklmnopqrstuvwxyz" },
00294     { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" },
00295     { "12345678901234567890123456789012345678901234567890123456789012"
00296       "345678901234567890" }
00297 };
00298 
00299 static const size_t md2_test_strlen[7] =
00300 {
00301     0, 1, 3, 14, 26, 62, 80
00302 };
00303 
00304 static const unsigned char md2_test_sum[7][16] =
00305 {
00306     { 0x83, 0x50, 0xE5, 0xA3, 0xE2, 0x4C, 0x15, 0x3D,
00307       0xF2, 0x27, 0x5C, 0x9F, 0x80, 0x69, 0x27, 0x73 },
00308     { 0x32, 0xEC, 0x01, 0xEC, 0x4A, 0x6D, 0xAC, 0x72,
00309       0xC0, 0xAB, 0x96, 0xFB, 0x34, 0xC0, 0xB5, 0xD1 },
00310     { 0xDA, 0x85, 0x3B, 0x0D, 0x3F, 0x88, 0xD9, 0x9B,
00311       0x30, 0x28, 0x3A, 0x69, 0xE6, 0xDE, 0xD6, 0xBB },
00312     { 0xAB, 0x4F, 0x49, 0x6B, 0xFB, 0x2A, 0x53, 0x0B,
00313       0x21, 0x9F, 0xF3, 0x30, 0x31, 0xFE, 0x06, 0xB0 },
00314     { 0x4E, 0x8D, 0xDF, 0xF3, 0x65, 0x02, 0x92, 0xAB,
00315       0x5A, 0x41, 0x08, 0xC3, 0xAA, 0x47, 0x94, 0x0B },
00316     { 0xDA, 0x33, 0xDE, 0xF2, 0xA4, 0x2D, 0xF1, 0x39,
00317       0x75, 0x35, 0x28, 0x46, 0xC3, 0x03, 0x38, 0xCD },
00318     { 0xD5, 0x97, 0x6F, 0x79, 0xD8, 0x3D, 0x3A, 0x0D,
00319       0xC9, 0x80, 0x6C, 0x3C, 0x66, 0xF3, 0xEF, 0xD8 }
00320 };
00321 
00322 /*
00323  * Checkup routine
00324  */
00325 int mbedtls_md2_self_test( int verbose )
00326 {
00327     int i, ret = 0;
00328     unsigned char md2sum[16];
00329 
00330     for( i = 0; i < 7; i++ )
00331     {
00332         if( verbose != 0 )
00333             mbedtls_printf( "  MD2 test #%d: ", i + 1 );
00334 
00335         ret = mbedtls_md2_ret( md2_test_str[i], md2_test_strlen[i], md2sum );
00336         if( ret != 0 )
00337             goto fail;
00338 
00339         if( memcmp( md2sum, md2_test_sum[i], 16 ) != 0 )
00340         {
00341             ret = 1;
00342             goto fail;
00343         }
00344 
00345         if( verbose != 0 )
00346             mbedtls_printf( "passed\n" );
00347     }
00348 
00349     if( verbose != 0 )
00350         mbedtls_printf( "\n" );
00351 
00352     return( 0 );
00353 
00354 fail:
00355     if( verbose != 0 )
00356         mbedtls_printf( "failed\n" );
00357 
00358     return( ret );
00359 }
00360 
00361 #endif /* MBEDTLS_SELF_TEST */
00362 
00363 #endif /* MBEDTLS_MD2_C */