PolarSSL v1.1.4
md.c
Go to the documentation of this file.
00001 
00030 #include "polarssl/config.h"
00031 
00032 #if defined(POLARSSL_MD_C)
00033 
00034 #include "polarssl/md.h"
00035 #include "polarssl/md_wrap.h"
00036 
00037 #include <stdlib.h>
00038 
00039 #if defined _MSC_VER && !defined strcasecmp
00040 #define strcasecmp _stricmp
00041 #endif
00042 
00043 static const int supported_digests[] = {
00044 
00045 #if defined(POLARSSL_MD2_C)
00046         POLARSSL_MD_MD2,
00047 #endif
00048 
00049 #if defined(POLARSSL_MD4_C)
00050         POLARSSL_MD_MD4,
00051 #endif
00052 
00053 #if defined(POLARSSL_MD5_C)
00054         POLARSSL_MD_MD5,
00055 #endif
00056 
00057 #if defined(POLARSSL_SHA1_C)
00058         POLARSSL_MD_SHA1,
00059 #endif
00060 
00061 #if defined(POLARSSL_SHA2_C)
00062         POLARSSL_MD_SHA224,
00063         POLARSSL_MD_SHA256,
00064 #endif
00065 
00066 #if defined(POLARSSL_SHA4_C)
00067         POLARSSL_MD_SHA384,
00068         POLARSSL_MD_SHA512,
00069 #endif
00070 
00071         0
00072 };
00073 
00074 const int *md_list( void )
00075 {
00076     return supported_digests;
00077 }
00078 
00079 const md_info_t *md_info_from_string( const char *md_name )
00080 {
00081     if( NULL == md_name )
00082         return NULL;
00083 
00084     /* Get the appropriate digest information */
00085 #if defined(POLARSSL_MD2_C)
00086     if( !strcasecmp( "MD2", md_name ) )
00087         return md_info_from_type( POLARSSL_MD_MD2 );
00088 #endif
00089 #if defined(POLARSSL_MD4_C)
00090     if( !strcasecmp( "MD4", md_name ) )
00091         return md_info_from_type( POLARSSL_MD_MD4 );
00092 #endif
00093 #if defined(POLARSSL_MD5_C)
00094     if( !strcasecmp( "MD5", md_name ) )
00095         return md_info_from_type( POLARSSL_MD_MD5 );
00096 #endif
00097 #if defined(POLARSSL_SHA1_C)
00098     if( !strcasecmp( "SHA1", md_name ) || !strcasecmp( "SHA", md_name ) )
00099         return md_info_from_type( POLARSSL_MD_SHA1 );
00100 #endif
00101 #if defined(POLARSSL_SHA2_C)
00102     if( !strcasecmp( "SHA224", md_name ) )
00103         return md_info_from_type( POLARSSL_MD_SHA224 );
00104     if( !strcasecmp( "SHA256", md_name ) )
00105         return md_info_from_type( POLARSSL_MD_SHA256 );
00106 #endif
00107 #if defined(POLARSSL_SHA4_C)
00108     if( !strcasecmp( "SHA384", md_name ) )
00109         return md_info_from_type( POLARSSL_MD_SHA384 );
00110     if( !strcasecmp( "SHA512", md_name ) )
00111         return md_info_from_type( POLARSSL_MD_SHA512 );
00112 #endif
00113     return NULL;
00114 }
00115 
00116 const md_info_t *md_info_from_type( md_type_t md_type )
00117 {
00118     switch( md_type )
00119     {
00120 #if defined(POLARSSL_MD2_C)
00121         case POLARSSL_MD_MD2:
00122             return &md2_info;
00123 #endif
00124 #if defined(POLARSSL_MD4_C)
00125         case POLARSSL_MD_MD4:
00126             return &md4_info;
00127 #endif
00128 #if defined(POLARSSL_MD5_C)
00129         case POLARSSL_MD_MD5:
00130             return &md5_info;
00131 #endif
00132 #if defined(POLARSSL_SHA1_C)
00133         case POLARSSL_MD_SHA1:
00134             return &sha1_info;
00135 #endif
00136 #if defined(POLARSSL_SHA2_C)
00137         case POLARSSL_MD_SHA224:
00138             return &sha224_info;
00139         case POLARSSL_MD_SHA256:
00140             return &sha256_info;
00141 #endif
00142 #if defined(POLARSSL_SHA4_C)
00143         case POLARSSL_MD_SHA384:
00144             return &sha384_info;
00145         case POLARSSL_MD_SHA512:
00146             return &sha512_info;
00147 #endif
00148         default:
00149             return NULL;
00150     }
00151 }
00152 
00153 int md_init_ctx( md_context_t *ctx, const md_info_t *md_info )
00154 {
00155     if( md_info == NULL || ctx == NULL )
00156         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00157 
00158     memset( ctx, 0, sizeof( md_context_t ) );
00159 
00160     if( ( ctx->md_ctx = md_info->ctx_alloc_func() ) == NULL )
00161         return POLARSSL_ERR_MD_ALLOC_FAILED;
00162 
00163     ctx->md_info = md_info;
00164 
00165     md_info->starts_func( ctx->md_ctx );
00166 
00167     return 0;
00168 }
00169 
00170 int md_free_ctx( md_context_t *ctx )
00171 {
00172     if( ctx == NULL || ctx->md_info == NULL )
00173         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00174 
00175     ctx->md_info->ctx_free_func( ctx->md_ctx );
00176     ctx->md_ctx = NULL;
00177 
00178     return 0;
00179 }
00180 
00181 int md_starts( md_context_t *ctx )
00182 {
00183     if( ctx == NULL || ctx->md_info == NULL )
00184         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00185 
00186     ctx->md_info->starts_func( ctx->md_ctx );
00187 
00188     return 0;
00189 }
00190 
00191 int md_update( md_context_t *ctx, const unsigned char *input, size_t ilen )
00192 {
00193     if( ctx == NULL || ctx->md_info == NULL )
00194         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00195 
00196     ctx->md_info->update_func( ctx->md_ctx, input, ilen );
00197 
00198     return 0;
00199 }
00200 
00201 int md_finish( md_context_t *ctx, unsigned char *output )
00202 {
00203     if( ctx == NULL || ctx->md_info == NULL )
00204         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00205 
00206     ctx->md_info->finish_func( ctx->md_ctx, output );
00207 
00208     return 0;
00209 }
00210 
00211 int md( const md_info_t *md_info, const unsigned char *input, size_t ilen,
00212             unsigned char *output )
00213 {
00214     if ( md_info == NULL )
00215         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00216 
00217     md_info->digest_func( input, ilen, output );
00218 
00219     return 0;
00220 }
00221 
00222 int md_file( const md_info_t *md_info, const char *path, unsigned char *output )
00223 {
00224 #if defined(POLARSSL_FS_IO)
00225     int ret;
00226 #endif
00227 
00228     if( md_info == NULL )
00229         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00230 
00231 #if defined(POLARSSL_FS_IO)
00232     ret = md_info->file_func( path, output );
00233     if( ret != 0 )
00234         return( POLARSSL_ERR_MD_FILE_IO_ERROR + ret );
00235 
00236     return( ret );
00237 #else
00238     ((void) path);
00239     ((void) output);
00240 
00241     return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00242 #endif
00243 }
00244 
00245 int md_hmac_starts( md_context_t *ctx, const unsigned char *key, size_t keylen )
00246 {
00247     if( ctx == NULL || ctx->md_info == NULL )
00248         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00249 
00250     ctx->md_info->hmac_starts_func( ctx->md_ctx, key, keylen);
00251 
00252     return 0;
00253 }
00254 
00255 int md_hmac_update( md_context_t *ctx, const unsigned char *input, size_t ilen )
00256 {
00257     if( ctx == NULL || ctx->md_info == NULL )
00258         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00259 
00260     ctx->md_info->hmac_update_func( ctx->md_ctx, input, ilen );
00261 
00262     return 0;
00263 }
00264 
00265 int md_hmac_finish( md_context_t *ctx, unsigned char *output)
00266 {
00267     if( ctx == NULL || ctx->md_info == NULL )
00268         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00269 
00270     ctx->md_info->hmac_finish_func( ctx->md_ctx, output);
00271 
00272     return 0;
00273 }
00274 
00275 int md_hmac_reset( md_context_t *ctx )
00276 {
00277     if( ctx == NULL || ctx->md_info == NULL )
00278         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00279 
00280     ctx->md_info->hmac_reset_func( ctx->md_ctx);
00281 
00282     return 0;
00283 }
00284 
00285 int md_hmac( const md_info_t *md_info, const unsigned char *key, size_t keylen,
00286                 const unsigned char *input, size_t ilen,
00287                 unsigned char *output )
00288 {
00289     if( md_info == NULL )
00290         return POLARSSL_ERR_MD_BAD_INPUT_DATA;
00291 
00292     md_info->hmac_func( key, keylen, input, ilen, output );
00293 
00294     return 0;
00295 }
00296 
00297 #endif