git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/mbedtls/library/x509_crl.c

   1 /*\r
   2  *  X.509 Certidicate Revocation List (CRL) parsing\r
   3  *\r
   4  *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved\r
   5  *  SPDX-License-Identifier: Apache-2.0\r
   6  *\r
   7  *  Licensed under the Apache License, Version 2.0 (the "License"); you may\r
   8  *  not use this file except in compliance with the License.\r
   9  *  You may obtain a copy of the License at\r
  10  *\r
  11  *  http://www.apache.org/licenses/LICENSE-2.0\r
  12  *\r
  13  *  Unless required by applicable law or agreed to in writing, software\r
  14  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r
  15  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  *  See the License for the specific language governing permissions and\r
  17  *  limitations under the License.\r
  18  *\r
  19  *  This file is part of mbed TLS (https://tls.mbed.org)\r
  20  */\r
  21 /*\r
  22  *  The ITU-T X.509 standard defines a certificate format for PKI.\r
  23  *\r
  24  *  http://www.ietf.org/rfc/rfc5280.txt (Certificates and CRLs)\r
  25  *  http://www.ietf.org/rfc/rfc3279.txt (Alg IDs for CRLs)\r
  26  *  http://www.ietf.org/rfc/rfc2986.txt (CSRs, aka PKCS#10)\r
  27  *\r
  28  *  http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf\r
  29  *  http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf\r
  30  */\r
  31 \r
  32 #if !defined(MBEDTLS_CONFIG_FILE)\r
  33 #include "mbedtls/config.h"\r
  34 #else\r
  35 #include MBEDTLS_CONFIG_FILE\r
  36 #endif\r
  37 \r
  38 #if defined(MBEDTLS_X509_CRL_PARSE_C)\r
  39 \r
  40 #include "mbedtls/x509_crl.h"\r
  41 #include "mbedtls/oid.h"\r
  42 #include "mbedtls/platform_util.h"\r
  43 \r
  44 #include <string.h>\r
  45 \r
  46 #if defined(MBEDTLS_PEM_PARSE_C)\r
  47 #include "mbedtls/pem.h"\r
  48 #endif\r
  49 \r
  50 #if defined(MBEDTLS_PLATFORM_C)\r
  51 #include "mbedtls/platform.h"\r
  52 #else\r
  53 #include <stdlib.h>\r
  54 #include <stdio.h>\r
  55 #define mbedtls_free       free\r
  56 #define mbedtls_calloc    calloc\r
  57 #define mbedtls_snprintf   snprintf\r
  58 #endif\r
  59 \r
  60 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)\r
  61 #include <windows.h>\r
  62 #else\r
  63 #include <time.h>\r
  64 #endif\r
  65 \r
  66 #if defined(MBEDTLS_FS_IO) || defined(EFIX64) || defined(EFI32)\r
  67 #include <stdio.h>\r
  68 #endif\r
  69 \r
  70 /*\r
  71  *  Version  ::=  INTEGER  {  v1(0), v2(1)  }\r
  72  */\r
  73 static int x509_crl_get_version( unsigned char **p,\r
  74                              const unsigned char *end,\r
  75                              int *ver )\r
  76 {\r
  77     int ret;\r
  78 \r
  79     if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )\r
  80     {\r
  81         if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )\r
  82         {\r
  83             *ver = 0;\r
  84             return( 0 );\r
  85         }\r
  86 \r
  87         return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );\r
  88     }\r
  89 \r
  90     return( 0 );\r
  91 }\r
  92 \r
  93 /*\r
  94  * X.509 CRL v2 extensions\r
  95  *\r
  96  * We currently don't parse any extension's content, but we do check that the\r
  97  * list of extensions is well-formed and abort on critical extensions (that\r
  98  * are unsupported as we don't support any extension so far)\r
  99  */\r
 100 static int x509_get_crl_ext( unsigned char **p,\r
 101                              const unsigned char *end,\r
 102                              mbedtls_x509_buf *ext )\r
 103 {\r
 104     int ret;\r
 105 \r
 106     /*\r
 107      * crlExtensions           [0]  EXPLICIT Extensions OPTIONAL\r
 108      *                              -- if present, version MUST be v2\r
 109      */\r
 110     if( ( ret = mbedtls_x509_get_ext( p, end, ext, 0 ) ) != 0 )\r
 111     {\r
 112         if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )\r
 113             return( 0 );\r
 114 \r
 115         return( ret );\r
 116     }\r
 117 \r
 118     while( *p < end )\r
 119     {\r
 120         /*\r
 121          * Extension  ::=  SEQUENCE  {\r
 122          *      extnID      OBJECT IDENTIFIER,\r
 123          *      critical    BOOLEAN DEFAULT FALSE,\r
 124          *      extnValue   OCTET STRING  }\r
 125          */\r
 126         int is_critical = 0;\r
 127         const unsigned char *end_ext_data;\r
 128         size_t len;\r
 129 \r
 130         /* Get enclosing sequence tag */\r
 131         if( ( ret = mbedtls_asn1_get_tag( p, end, &len,\r
 132                 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 133             return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );\r
 134 \r
 135         end_ext_data = *p + len;\r
 136 \r
 137         /* Get OID (currently ignored) */\r
 138         if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &len,\r
 139                                           MBEDTLS_ASN1_OID ) ) != 0 )\r
 140         {\r
 141             return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );\r
 142         }\r
 143         *p += len;\r
 144 \r
 145         /* Get optional critical */\r
 146         if( ( ret = mbedtls_asn1_get_bool( p, end_ext_data,\r
 147                                            &is_critical ) ) != 0 &&\r
 148             ( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )\r
 149         {\r
 150             return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );\r
 151         }\r
 152 \r
 153         /* Data should be octet string type */\r
 154         if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &len,\r
 155                 MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )\r
 156             return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );\r
 157 \r
 158         /* Ignore data so far and just check its length */\r
 159         *p += len;\r
 160         if( *p != end_ext_data )\r
 161             return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +\r
 162                     MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 163 \r
 164         /* Abort on (unsupported) critical extensions */\r
 165         if( is_critical )\r
 166             return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +\r
 167                     MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );\r
 168     }\r
 169 \r
 170     if( *p != end )\r
 171         return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +\r
 172                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 173 \r
 174     return( 0 );\r
 175 }\r
 176 \r
 177 /*\r
 178  * X.509 CRL v2 entry extensions (no extensions parsed yet.)\r
 179  */\r
 180 static int x509_get_crl_entry_ext( unsigned char **p,\r
 181                              const unsigned char *end,\r
 182                              mbedtls_x509_buf *ext )\r
 183 {\r
 184     int ret;\r
 185     size_t len = 0;\r
 186 \r
 187     /* OPTIONAL */\r
 188     if( end <= *p )\r
 189         return( 0 );\r
 190 \r
 191     ext->tag = **p;\r
 192     ext->p = *p;\r
 193 \r
 194     /*\r
 195      * Get CRL-entry extension sequence header\r
 196      * crlEntryExtensions      Extensions OPTIONAL  -- if present, MUST be v2\r
 197      */\r
 198     if( ( ret = mbedtls_asn1_get_tag( p, end, &ext->len,\r
 199             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 200     {\r
 201         if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )\r
 202         {\r
 203             ext->p = NULL;\r
 204             return( 0 );\r
 205         }\r
 206         return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );\r
 207     }\r
 208 \r
 209     end = *p + ext->len;\r
 210 \r
 211     if( end != *p + ext->len )\r
 212         return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +\r
 213                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 214 \r
 215     while( *p < end )\r
 216     {\r
 217         if( ( ret = mbedtls_asn1_get_tag( p, end, &len,\r
 218                 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 219             return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );\r
 220 \r
 221         *p += len;\r
 222     }\r
 223 \r
 224     if( *p != end )\r
 225         return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +\r
 226                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 227 \r
 228     return( 0 );\r
 229 }\r
 230 \r
 231 /*\r
 232  * X.509 CRL Entries\r
 233  */\r
 234 static int x509_get_entries( unsigned char **p,\r
 235                              const unsigned char *end,\r
 236                              mbedtls_x509_crl_entry *entry )\r
 237 {\r
 238     int ret;\r
 239     size_t entry_len;\r
 240     mbedtls_x509_crl_entry *cur_entry = entry;\r
 241 \r
 242     if( *p == end )\r
 243         return( 0 );\r
 244 \r
 245     if( ( ret = mbedtls_asn1_get_tag( p, end, &entry_len,\r
 246             MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED ) ) != 0 )\r
 247     {\r
 248         if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )\r
 249             return( 0 );\r
 250 \r
 251         return( ret );\r
 252     }\r
 253 \r
 254     end = *p + entry_len;\r
 255 \r
 256     while( *p < end )\r
 257     {\r
 258         size_t len2;\r
 259         const unsigned char *end2;\r
 260 \r
 261         if( ( ret = mbedtls_asn1_get_tag( p, end, &len2,\r
 262                 MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED ) ) != 0 )\r
 263         {\r
 264             return( ret );\r
 265         }\r
 266 \r
 267         cur_entry->raw.tag = **p;\r
 268         cur_entry->raw.p = *p;\r
 269         cur_entry->raw.len = len2;\r
 270         end2 = *p + len2;\r
 271 \r
 272         if( ( ret = mbedtls_x509_get_serial( p, end2, &cur_entry->serial ) ) != 0 )\r
 273             return( ret );\r
 274 \r
 275         if( ( ret = mbedtls_x509_get_time( p, end2,\r
 276                                    &cur_entry->revocation_date ) ) != 0 )\r
 277             return( ret );\r
 278 \r
 279         if( ( ret = x509_get_crl_entry_ext( p, end2,\r
 280                                             &cur_entry->entry_ext ) ) != 0 )\r
 281             return( ret );\r
 282 \r
 283         if( *p < end )\r
 284         {\r
 285             cur_entry->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crl_entry ) );\r
 286 \r
 287             if( cur_entry->next == NULL )\r
 288                 return( MBEDTLS_ERR_X509_ALLOC_FAILED );\r
 289 \r
 290             cur_entry = cur_entry->next;\r
 291         }\r
 292     }\r
 293 \r
 294     return( 0 );\r
 295 }\r
 296 \r
 297 /*\r
 298  * Parse one  CRLs in DER format and append it to the chained list\r
 299  */\r
 300 int mbedtls_x509_crl_parse_der( mbedtls_x509_crl *chain,\r
 301                         const unsigned char *buf, size_t buflen )\r
 302 {\r
 303     int ret;\r
 304     size_t len;\r
 305     unsigned char *p = NULL, *end = NULL;\r
 306     mbedtls_x509_buf sig_params1, sig_params2, sig_oid2;\r
 307     mbedtls_x509_crl *crl = chain;\r
 308 \r
 309     /*\r
 310      * Check for valid input\r
 311      */\r
 312     if( crl == NULL || buf == NULL )\r
 313         return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );\r
 314 \r
 315     memset( &sig_params1, 0, sizeof( mbedtls_x509_buf ) );\r
 316     memset( &sig_params2, 0, sizeof( mbedtls_x509_buf ) );\r
 317     memset( &sig_oid2, 0, sizeof( mbedtls_x509_buf ) );\r
 318 \r
 319     /*\r
 320      * Add new CRL on the end of the chain if needed.\r
 321      */\r
 322     while( crl->version != 0 && crl->next != NULL )\r
 323         crl = crl->next;\r
 324 \r
 325     if( crl->version != 0 && crl->next == NULL )\r
 326     {\r
 327         crl->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crl ) );\r
 328 \r
 329         if( crl->next == NULL )\r
 330         {\r
 331             mbedtls_x509_crl_free( crl );\r
 332             return( MBEDTLS_ERR_X509_ALLOC_FAILED );\r
 333         }\r
 334 \r
 335         mbedtls_x509_crl_init( crl->next );\r
 336         crl = crl->next;\r
 337     }\r
 338 \r
 339     /*\r
 340      * Copy raw DER-encoded CRL\r
 341      */\r
 342     if( buflen == 0 )\r
 343         return( MBEDTLS_ERR_X509_INVALID_FORMAT );\r
 344 \r
 345     p = mbedtls_calloc( 1, buflen );\r
 346     if( p == NULL )\r
 347         return( MBEDTLS_ERR_X509_ALLOC_FAILED );\r
 348 \r
 349     memcpy( p, buf, buflen );\r
 350 \r
 351     crl->raw.p = p;\r
 352     crl->raw.len = buflen;\r
 353 \r
 354     end = p + buflen;\r
 355 \r
 356     /*\r
 357      * CertificateList  ::=  SEQUENCE  {\r
 358      *      tbsCertList          TBSCertList,\r
 359      *      signatureAlgorithm   AlgorithmIdentifier,\r
 360      *      signatureValue       BIT STRING  }\r
 361      */\r
 362     if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,\r
 363             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 364     {\r
 365         mbedtls_x509_crl_free( crl );\r
 366         return( MBEDTLS_ERR_X509_INVALID_FORMAT );\r
 367     }\r
 368 \r
 369     if( len != (size_t) ( end - p ) )\r
 370     {\r
 371         mbedtls_x509_crl_free( crl );\r
 372         return( MBEDTLS_ERR_X509_INVALID_FORMAT +\r
 373                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 374     }\r
 375 \r
 376     /*\r
 377      * TBSCertList  ::=  SEQUENCE  {\r
 378      */\r
 379     crl->tbs.p = p;\r
 380 \r
 381     if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,\r
 382             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 383     {\r
 384         mbedtls_x509_crl_free( crl );\r
 385         return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );\r
 386     }\r
 387 \r
 388     end = p + len;\r
 389     crl->tbs.len = end - crl->tbs.p;\r
 390 \r
 391     /*\r
 392      * Version  ::=  INTEGER  OPTIONAL {  v1(0), v2(1)  }\r
 393      *               -- if present, MUST be v2\r
 394      *\r
 395      * signature            AlgorithmIdentifier\r
 396      */\r
 397     if( ( ret = x509_crl_get_version( &p, end, &crl->version ) ) != 0 ||\r
 398         ( ret = mbedtls_x509_get_alg( &p, end, &crl->sig_oid, &sig_params1 ) ) != 0 )\r
 399     {\r
 400         mbedtls_x509_crl_free( crl );\r
 401         return( ret );\r
 402     }\r
 403 \r
 404     if( crl->version < 0 || crl->version > 1 )\r
 405     {\r
 406         mbedtls_x509_crl_free( crl );\r
 407         return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );\r
 408     }\r
 409 \r
 410     crl->version++;\r
 411 \r
 412     if( ( ret = mbedtls_x509_get_sig_alg( &crl->sig_oid, &sig_params1,\r
 413                                   &crl->sig_md, &crl->sig_pk,\r
 414                                   &crl->sig_opts ) ) != 0 )\r
 415     {\r
 416         mbedtls_x509_crl_free( crl );\r
 417         return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG );\r
 418     }\r
 419 \r
 420     /*\r
 421      * issuer               Name\r
 422      */\r
 423     crl->issuer_raw.p = p;\r
 424 \r
 425     if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,\r
 426             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 427     {\r
 428         mbedtls_x509_crl_free( crl );\r
 429         return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );\r
 430     }\r
 431 \r
 432     if( ( ret = mbedtls_x509_get_name( &p, p + len, &crl->issuer ) ) != 0 )\r
 433     {\r
 434         mbedtls_x509_crl_free( crl );\r
 435         return( ret );\r
 436     }\r
 437 \r
 438     crl->issuer_raw.len = p - crl->issuer_raw.p;\r
 439 \r
 440     /*\r
 441      * thisUpdate          Time\r
 442      * nextUpdate          Time OPTIONAL\r
 443      */\r
 444     if( ( ret = mbedtls_x509_get_time( &p, end, &crl->this_update ) ) != 0 )\r
 445     {\r
 446         mbedtls_x509_crl_free( crl );\r
 447         return( ret );\r
 448     }\r
 449 \r
 450     if( ( ret = mbedtls_x509_get_time( &p, end, &crl->next_update ) ) != 0 )\r
 451     {\r
 452         if( ret != ( MBEDTLS_ERR_X509_INVALID_DATE +\r
 453                         MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) &&\r
 454             ret != ( MBEDTLS_ERR_X509_INVALID_DATE +\r
 455                         MBEDTLS_ERR_ASN1_OUT_OF_DATA ) )\r
 456         {\r
 457             mbedtls_x509_crl_free( crl );\r
 458             return( ret );\r
 459         }\r
 460     }\r
 461 \r
 462     /*\r
 463      * revokedCertificates    SEQUENCE OF SEQUENCE   {\r
 464      *      userCertificate        CertificateSerialNumber,\r
 465      *      revocationDate         Time,\r
 466      *      crlEntryExtensions     Extensions OPTIONAL\r
 467      *                                   -- if present, MUST be v2\r
 468      *                        } OPTIONAL\r
 469      */\r
 470     if( ( ret = x509_get_entries( &p, end, &crl->entry ) ) != 0 )\r
 471     {\r
 472         mbedtls_x509_crl_free( crl );\r
 473         return( ret );\r
 474     }\r
 475 \r
 476     /*\r
 477      * crlExtensions          EXPLICIT Extensions OPTIONAL\r
 478      *                              -- if present, MUST be v2\r
 479      */\r
 480     if( crl->version == 2 )\r
 481     {\r
 482         ret = x509_get_crl_ext( &p, end, &crl->crl_ext );\r
 483 \r
 484         if( ret != 0 )\r
 485         {\r
 486             mbedtls_x509_crl_free( crl );\r
 487             return( ret );\r
 488         }\r
 489     }\r
 490 \r
 491     if( p != end )\r
 492     {\r
 493         mbedtls_x509_crl_free( crl );\r
 494         return( MBEDTLS_ERR_X509_INVALID_FORMAT +\r
 495                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 496     }\r
 497 \r
 498     end = crl->raw.p + crl->raw.len;\r
 499 \r
 500     /*\r
 501      *  signatureAlgorithm   AlgorithmIdentifier,\r
 502      *  signatureValue       BIT STRING\r
 503      */\r
 504     if( ( ret = mbedtls_x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) != 0 )\r
 505     {\r
 506         mbedtls_x509_crl_free( crl );\r
 507         return( ret );\r
 508     }\r
 509 \r
 510     if( crl->sig_oid.len != sig_oid2.len ||\r
 511         memcmp( crl->sig_oid.p, sig_oid2.p, crl->sig_oid.len ) != 0 ||\r
 512         sig_params1.len != sig_params2.len ||\r
 513         ( sig_params1.len != 0 &&\r
 514           memcmp( sig_params1.p, sig_params2.p, sig_params1.len ) != 0 ) )\r
 515     {\r
 516         mbedtls_x509_crl_free( crl );\r
 517         return( MBEDTLS_ERR_X509_SIG_MISMATCH );\r
 518     }\r
 519 \r
 520     if( ( ret = mbedtls_x509_get_sig( &p, end, &crl->sig ) ) != 0 )\r
 521     {\r
 522         mbedtls_x509_crl_free( crl );\r
 523         return( ret );\r
 524     }\r
 525 \r
 526     if( p != end )\r
 527     {\r
 528         mbedtls_x509_crl_free( crl );\r
 529         return( MBEDTLS_ERR_X509_INVALID_FORMAT +\r
 530                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 531     }\r
 532 \r
 533     return( 0 );\r
 534 }\r
 535 \r
 536 /*\r
 537  * Parse one or more CRLs and add them to the chained list\r
 538  */\r
 539 int mbedtls_x509_crl_parse( mbedtls_x509_crl *chain, const unsigned char *buf, size_t buflen )\r
 540 {\r
 541 #if defined(MBEDTLS_PEM_PARSE_C)\r
 542     int ret;\r
 543     size_t use_len;\r
 544     mbedtls_pem_context pem;\r
 545     int is_pem = 0;\r
 546 \r
 547     if( chain == NULL || buf == NULL )\r
 548         return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );\r
 549 \r
 550     do\r
 551     {\r
 552         mbedtls_pem_init( &pem );\r
 553 \r
 554         // Avoid calling mbedtls_pem_read_buffer() on non-null-terminated\r
 555         // string\r
 556         if( buflen == 0 || buf[buflen - 1] != '\0' )\r
 557             ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;\r
 558         else\r
 559             ret = mbedtls_pem_read_buffer( &pem,\r
 560                                            "-----BEGIN X509 CRL-----",\r
 561                                            "-----END X509 CRL-----",\r
 562                                             buf, NULL, 0, &use_len );\r
 563 \r
 564         if( ret == 0 )\r
 565         {\r
 566             /*\r
 567              * Was PEM encoded\r
 568              */\r
 569             is_pem = 1;\r
 570 \r
 571             buflen -= use_len;\r
 572             buf += use_len;\r
 573 \r
 574             if( ( ret = mbedtls_x509_crl_parse_der( chain,\r
 575                                             pem.buf, pem.buflen ) ) != 0 )\r
 576             {\r
 577                 mbedtls_pem_free( &pem );\r
 578                 return( ret );\r
 579             }\r
 580         }\r
 581         else if( is_pem )\r
 582         {\r
 583             mbedtls_pem_free( &pem );\r
 584             return( ret );\r
 585         }\r
 586 \r
 587         mbedtls_pem_free( &pem );\r
 588     }\r
 589     /* In the PEM case, buflen is 1 at the end, for the terminated NULL byte.\r
 590      * And a valid CRL cannot be less than 1 byte anyway. */\r
 591     while( is_pem && buflen > 1 );\r
 592 \r
 593     if( is_pem )\r
 594         return( 0 );\r
 595     else\r
 596 #endif /* MBEDTLS_PEM_PARSE_C */\r
 597         return( mbedtls_x509_crl_parse_der( chain, buf, buflen ) );\r
 598 }\r
 599 \r
 600 #if defined(MBEDTLS_FS_IO)\r
 601 /*\r
 602  * Load one or more CRLs and add them to the chained list\r
 603  */\r
 604 int mbedtls_x509_crl_parse_file( mbedtls_x509_crl *chain, const char *path )\r
 605 {\r
 606     int ret;\r
 607     size_t n;\r
 608     unsigned char *buf;\r
 609 \r
 610     if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )\r
 611         return( ret );\r
 612 \r
 613     ret = mbedtls_x509_crl_parse( chain, buf, n );\r
 614 \r
 615     mbedtls_platform_zeroize( buf, n );\r
 616     mbedtls_free( buf );\r
 617 \r
 618     return( ret );\r
 619 }\r
 620 #endif /* MBEDTLS_FS_IO */\r
 621 \r
 622 /*\r
 623  * Return an informational string about the certificate.\r
 624  */\r
 625 #define BEFORE_COLON    14\r
 626 #define BC              "14"\r
 627 /*\r
 628  * Return an informational string about the CRL.\r
 629  */\r
 630 int mbedtls_x509_crl_info( char *buf, size_t size, const char *prefix,\r
 631                    const mbedtls_x509_crl *crl )\r
 632 {\r
 633     int ret;\r
 634     size_t n;\r
 635     char *p;\r
 636     const mbedtls_x509_crl_entry *entry;\r
 637 \r
 638     p = buf;\r
 639     n = size;\r
 640 \r
 641     ret = mbedtls_snprintf( p, n, "%sCRL version   : %d",\r
 642                                prefix, crl->version );\r
 643     MBEDTLS_X509_SAFE_SNPRINTF;\r
 644 \r
 645     ret = mbedtls_snprintf( p, n, "\n%sissuer name   : ", prefix );\r
 646     MBEDTLS_X509_SAFE_SNPRINTF;\r
 647     ret = mbedtls_x509_dn_gets( p, n, &crl->issuer );\r
 648     MBEDTLS_X509_SAFE_SNPRINTF;\r
 649 \r
 650     ret = mbedtls_snprintf( p, n, "\n%sthis update   : " \\r
 651                    "%04d-%02d-%02d %02d:%02d:%02d", prefix,\r
 652                    crl->this_update.year, crl->this_update.mon,\r
 653                    crl->this_update.day,  crl->this_update.hour,\r
 654                    crl->this_update.min,  crl->this_update.sec );\r
 655     MBEDTLS_X509_SAFE_SNPRINTF;\r
 656 \r
 657     ret = mbedtls_snprintf( p, n, "\n%snext update   : " \\r
 658                    "%04d-%02d-%02d %02d:%02d:%02d", prefix,\r
 659                    crl->next_update.year, crl->next_update.mon,\r
 660                    crl->next_update.day,  crl->next_update.hour,\r
 661                    crl->next_update.min,  crl->next_update.sec );\r
 662     MBEDTLS_X509_SAFE_SNPRINTF;\r
 663 \r
 664     entry = &crl->entry;\r
 665 \r
 666     ret = mbedtls_snprintf( p, n, "\n%sRevoked certificates:",\r
 667                                prefix );\r
 668     MBEDTLS_X509_SAFE_SNPRINTF;\r
 669 \r
 670     while( entry != NULL && entry->raw.len != 0 )\r
 671     {\r
 672         ret = mbedtls_snprintf( p, n, "\n%sserial number: ",\r
 673                                prefix );\r
 674         MBEDTLS_X509_SAFE_SNPRINTF;\r
 675 \r
 676         ret = mbedtls_x509_serial_gets( p, n, &entry->serial );\r
 677         MBEDTLS_X509_SAFE_SNPRINTF;\r
 678 \r
 679         ret = mbedtls_snprintf( p, n, " revocation date: " \\r
 680                    "%04d-%02d-%02d %02d:%02d:%02d",\r
 681                    entry->revocation_date.year, entry->revocation_date.mon,\r
 682                    entry->revocation_date.day,  entry->revocation_date.hour,\r
 683                    entry->revocation_date.min,  entry->revocation_date.sec );\r
 684         MBEDTLS_X509_SAFE_SNPRINTF;\r
 685 \r
 686         entry = entry->next;\r
 687     }\r
 688 \r
 689     ret = mbedtls_snprintf( p, n, "\n%ssigned using  : ", prefix );\r
 690     MBEDTLS_X509_SAFE_SNPRINTF;\r
 691 \r
 692     ret = mbedtls_x509_sig_alg_gets( p, n, &crl->sig_oid, crl->sig_pk, crl->sig_md,\r
 693                              crl->sig_opts );\r
 694     MBEDTLS_X509_SAFE_SNPRINTF;\r
 695 \r
 696     ret = mbedtls_snprintf( p, n, "\n" );\r
 697     MBEDTLS_X509_SAFE_SNPRINTF;\r
 698 \r
 699     return( (int) ( size - n ) );\r
 700 }\r
 701 \r
 702 /*\r
 703  * Initialize a CRL chain\r
 704  */\r
 705 void mbedtls_x509_crl_init( mbedtls_x509_crl *crl )\r
 706 {\r
 707     memset( crl, 0, sizeof(mbedtls_x509_crl) );\r
 708 }\r
 709 \r
 710 /*\r
 711  * Unallocate all CRL data\r
 712  */\r
 713 void mbedtls_x509_crl_free( mbedtls_x509_crl *crl )\r
 714 {\r
 715     mbedtls_x509_crl *crl_cur = crl;\r
 716     mbedtls_x509_crl *crl_prv;\r
 717     mbedtls_x509_name *name_cur;\r
 718     mbedtls_x509_name *name_prv;\r
 719     mbedtls_x509_crl_entry *entry_cur;\r
 720     mbedtls_x509_crl_entry *entry_prv;\r
 721 \r
 722     if( crl == NULL )\r
 723         return;\r
 724 \r
 725     do\r
 726     {\r
 727 #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)\r
 728         mbedtls_free( crl_cur->sig_opts );\r
 729 #endif\r
 730 \r
 731         name_cur = crl_cur->issuer.next;\r
 732         while( name_cur != NULL )\r
 733         {\r
 734             name_prv = name_cur;\r
 735             name_cur = name_cur->next;\r
 736             mbedtls_platform_zeroize( name_prv, sizeof( mbedtls_x509_name ) );\r
 737             mbedtls_free( name_prv );\r
 738         }\r
 739 \r
 740         entry_cur = crl_cur->entry.next;\r
 741         while( entry_cur != NULL )\r
 742         {\r
 743             entry_prv = entry_cur;\r
 744             entry_cur = entry_cur->next;\r
 745             mbedtls_platform_zeroize( entry_prv,\r
 746                                       sizeof( mbedtls_x509_crl_entry ) );\r
 747             mbedtls_free( entry_prv );\r
 748         }\r
 749 \r
 750         if( crl_cur->raw.p != NULL )\r
 751         {\r
 752             mbedtls_platform_zeroize( crl_cur->raw.p, crl_cur->raw.len );\r
 753             mbedtls_free( crl_cur->raw.p );\r
 754         }\r
 755 \r
 756         crl_cur = crl_cur->next;\r
 757     }\r
 758     while( crl_cur != NULL );\r
 759 \r
 760     crl_cur = crl;\r
 761     do\r
 762     {\r
 763         crl_prv = crl_cur;\r
 764         crl_cur = crl_cur->next;\r
 765 \r
 766         mbedtls_platform_zeroize( crl_prv, sizeof( mbedtls_x509_crl ) );\r
 767         if( crl_prv != crl )\r
 768             mbedtls_free( crl_prv );\r
 769     }\r
 770     while( crl_cur != NULL );\r
 771 }\r
 772 \r
 773 #endif /* MBEDTLS_X509_CRL_PARSE_C */\r