00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include "polarssl/config.h"
00027
00028 #if defined(POLARSSL_ASN1_PARSE_C)
00029
00030 #include "polarssl/asn1.h"
00031
00032 #if defined(POLARSSL_BIGNUM_C)
00033 #include "polarssl/bignum.h"
00034 #endif
00035
00036 #if defined(POLARSSL_MEMORY_C)
00037 #include "polarssl/memory.h"
00038 #else
00039 #define polarssl_malloc malloc
00040 #define polarssl_free free
00041 #endif
00042
00043 #include <string.h>
00044 #include <stdlib.h>
00045
00046
00047
00048
00049 int asn1_get_len( unsigned char **p,
00050 const unsigned char *end,
00051 size_t *len )
00052 {
00053 if( ( end - *p ) < 1 )
00054 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00055
00056 if( ( **p & 0x80 ) == 0 )
00057 *len = *(*p)++;
00058 else
00059 {
00060 switch( **p & 0x7F )
00061 {
00062 case 1:
00063 if( ( end - *p ) < 2 )
00064 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00065
00066 *len = (*p)[1];
00067 (*p) += 2;
00068 break;
00069
00070 case 2:
00071 if( ( end - *p ) < 3 )
00072 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00073
00074 *len = ( (*p)[1] << 8 ) | (*p)[2];
00075 (*p) += 3;
00076 break;
00077
00078 case 3:
00079 if( ( end - *p ) < 4 )
00080 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00081
00082 *len = ( (*p)[1] << 16 ) | ( (*p)[2] << 8 ) | (*p)[3];
00083 (*p) += 4;
00084 break;
00085
00086 case 4:
00087 if( ( end - *p ) < 5 )
00088 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00089
00090 *len = ( (*p)[1] << 24 ) | ( (*p)[2] << 16 ) | ( (*p)[3] << 8 ) | (*p)[4];
00091 (*p) += 5;
00092 break;
00093
00094 default:
00095 return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
00096 }
00097 }
00098
00099 if( *len > (size_t) ( end - *p ) )
00100 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00101
00102 return( 0 );
00103 }
00104
00105 int asn1_get_tag( unsigned char **p,
00106 const unsigned char *end,
00107 size_t *len, int tag )
00108 {
00109 if( ( end - *p ) < 1 )
00110 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00111
00112 if( **p != tag )
00113 return( POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
00114
00115 (*p)++;
00116
00117 return( asn1_get_len( p, end, len ) );
00118 }
00119
00120 int asn1_get_bool( unsigned char **p,
00121 const unsigned char *end,
00122 int *val )
00123 {
00124 int ret;
00125 size_t len;
00126
00127 if( ( ret = asn1_get_tag( p, end, &len, ASN1_BOOLEAN ) ) != 0 )
00128 return( ret );
00129
00130 if( len != 1 )
00131 return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
00132
00133 *val = ( **p != 0 ) ? 1 : 0;
00134 (*p)++;
00135
00136 return( 0 );
00137 }
00138
00139 int asn1_get_int( unsigned char **p,
00140 const unsigned char *end,
00141 int *val )
00142 {
00143 int ret;
00144 size_t len;
00145
00146 if( ( ret = asn1_get_tag( p, end, &len, ASN1_INTEGER ) ) != 0 )
00147 return( ret );
00148
00149 if( len > sizeof( int ) || ( **p & 0x80 ) != 0 )
00150 return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
00151
00152 *val = 0;
00153
00154 while( len-- > 0 )
00155 {
00156 *val = ( *val << 8 ) | **p;
00157 (*p)++;
00158 }
00159
00160 return( 0 );
00161 }
00162
00163 #if defined(POLARSSL_BIGNUM_C)
00164 int asn1_get_mpi( unsigned char **p,
00165 const unsigned char *end,
00166 mpi *X )
00167 {
00168 int ret;
00169 size_t len;
00170
00171 if( ( ret = asn1_get_tag( p, end, &len, ASN1_INTEGER ) ) != 0 )
00172 return( ret );
00173
00174 ret = mpi_read_binary( X, *p, len );
00175
00176 *p += len;
00177
00178 return( ret );
00179 }
00180 #endif
00181
00182 int asn1_get_bitstring( unsigned char **p, const unsigned char *end,
00183 asn1_bitstring *bs)
00184 {
00185 int ret;
00186
00187
00188 if( ( ret = asn1_get_tag( p, end, &bs->len, ASN1_BIT_STRING ) ) != 0 )
00189 return( ret );
00190
00191
00192 if ( bs->len < 1 )
00193 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00194 bs->len -= 1;
00195
00196
00197 bs->unused_bits = **p;
00198 if( bs->unused_bits > 7 )
00199 return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
00200 (*p)++;
00201
00202
00203 bs->p = *p;
00204 *p += bs->len;
00205
00206 if( *p != end )
00207 return( POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
00208
00209 return 0;
00210 }
00211
00212
00213
00214
00215 int asn1_get_bitstring_null( unsigned char **p, const unsigned char *end,
00216 size_t *len )
00217 {
00218 int ret;
00219
00220 if( ( ret = asn1_get_tag( p, end, len, ASN1_BIT_STRING ) ) != 0 )
00221 return( ret );
00222
00223 if( (*len)-- < 2 || *(*p)++ != 0 )
00224 return( POLARSSL_ERR_ASN1_INVALID_DATA );
00225
00226 return( 0 );
00227 }
00228
00229
00230
00231
00232
00233
00234 int asn1_get_sequence_of( unsigned char **p,
00235 const unsigned char *end,
00236 asn1_sequence *cur,
00237 int tag)
00238 {
00239 int ret;
00240 size_t len;
00241 asn1_buf *buf;
00242
00243
00244 if( ( ret = asn1_get_tag( p, end, &len,
00245 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
00246 return( ret );
00247
00248 if( *p + len != end )
00249 return( POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
00250
00251 while( *p < end )
00252 {
00253 buf = &(cur->buf);
00254 buf->tag = **p;
00255
00256 if( ( ret = asn1_get_tag( p, end, &buf->len, tag ) ) != 0 )
00257 return( ret );
00258
00259 buf->p = *p;
00260 *p += buf->len;
00261
00262
00263 if (*p < end)
00264 {
00265 cur->next = (asn1_sequence *) polarssl_malloc(
00266 sizeof( asn1_sequence ) );
00267
00268 if( cur->next == NULL )
00269 return( POLARSSL_ERR_ASN1_MALLOC_FAILED );
00270
00271 cur = cur->next;
00272 }
00273 }
00274
00275
00276 cur->next = NULL;
00277
00278 if( *p != end )
00279 return( POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
00280
00281 return( 0 );
00282 }
00283
00284 int asn1_get_alg( unsigned char **p,
00285 const unsigned char *end,
00286 asn1_buf *alg, asn1_buf *params )
00287 {
00288 int ret;
00289 size_t len;
00290
00291 if( ( ret = asn1_get_tag( p, end, &len,
00292 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
00293 return( ret );
00294
00295 if( ( end - *p ) < 1 )
00296 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
00297
00298 alg->tag = **p;
00299 end = *p + len;
00300
00301 if( ( ret = asn1_get_tag( p, end, &alg->len, ASN1_OID ) ) != 0 )
00302 return( ret );
00303
00304 alg->p = *p;
00305 *p += alg->len;
00306
00307 if( *p == end )
00308 {
00309 memset( params, 0, sizeof(asn1_buf) );
00310 return( 0 );
00311 }
00312
00313 params->tag = **p;
00314 (*p)++;
00315
00316 if( ( ret = asn1_get_len( p, end, ¶ms->len ) ) != 0 )
00317 return( ret );
00318
00319 params->p = *p;
00320 *p += params->len;
00321
00322 if( *p != end )
00323 return( POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
00324
00325 return( 0 );
00326 }
00327
00328 int asn1_get_alg_null( unsigned char **p,
00329 const unsigned char *end,
00330 asn1_buf *alg )
00331 {
00332 int ret;
00333 asn1_buf params;
00334
00335 memset( ¶ms, 0, sizeof(asn1_buf) );
00336
00337 if( ( ret = asn1_get_alg( p, end, alg, ¶ms ) ) != 0 )
00338 return( ret );
00339
00340 if( ( params.tag != ASN1_NULL && params.tag != 0 ) || params.len != 0 )
00341 return( POLARSSL_ERR_ASN1_INVALID_DATA );
00342
00343 return( 0 );
00344 }
00345
00346 void asn1_free_named_data( asn1_named_data *cur )
00347 {
00348 if( cur == NULL )
00349 return;
00350
00351 polarssl_free( cur->oid.p );
00352 polarssl_free( cur->val.p );
00353
00354 memset( cur, 0, sizeof( asn1_named_data ) );
00355 }
00356
00357 void asn1_free_named_data_list( asn1_named_data **head )
00358 {
00359 asn1_named_data *cur;
00360
00361 while( ( cur = *head ) != NULL )
00362 {
00363 *head = cur->next;
00364 asn1_free_named_data( cur );
00365 polarssl_free( cur );
00366 }
00367 }
00368
00369 asn1_named_data *asn1_find_named_data( asn1_named_data *list,
00370 const char *oid, size_t len )
00371 {
00372 while( list != NULL )
00373 {
00374 if( list->oid.len == len &&
00375 memcmp( list->oid.p, oid, len ) == 0 )
00376 {
00377 break;
00378 }
00379
00380 list = list->next;
00381 }
00382
00383 return( list );
00384 }
00385
00386 #endif