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

   1 /*\r
   2  *  X.509 Certificate Signing Request (CSR) 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_CSR_PARSE_C)\r
  39 \r
  40 #include "mbedtls/x509_csr.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(MBEDTLS_FS_IO) || defined(EFIX64) || defined(EFI32)\r
  61 #include <stdio.h>\r
  62 #endif\r
  63 \r
  64 /*\r
  65  *  Version  ::=  INTEGER  {  v1(0)  }\r
  66  */\r
  67 static int x509_csr_get_version( unsigned char **p,\r
  68                              const unsigned char *end,\r
  69                              int *ver )\r
  70 {\r
  71     int ret;\r
  72 \r
  73     if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )\r
  74     {\r
  75         if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )\r
  76         {\r
  77             *ver = 0;\r
  78             return( 0 );\r
  79         }\r
  80 \r
  81         return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );\r
  82     }\r
  83 \r
  84     return( 0 );\r
  85 }\r
  86 \r
  87 /*\r
  88  * Parse a CSR in DER format\r
  89  */\r
  90 int mbedtls_x509_csr_parse_der( mbedtls_x509_csr *csr,\r
  91                         const unsigned char *buf, size_t buflen )\r
  92 {\r
  93     int ret;\r
  94     size_t len;\r
  95     unsigned char *p, *end;\r
  96     mbedtls_x509_buf sig_params;\r
  97 \r
  98     memset( &sig_params, 0, sizeof( mbedtls_x509_buf ) );\r
  99 \r
 100     /*\r
 101      * Check for valid input\r
 102      */\r
 103     if( csr == NULL || buf == NULL || buflen == 0 )\r
 104         return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );\r
 105 \r
 106     mbedtls_x509_csr_init( csr );\r
 107 \r
 108     /*\r
 109      * first copy the raw DER data\r
 110      */\r
 111     p = mbedtls_calloc( 1, len = buflen );\r
 112 \r
 113     if( p == NULL )\r
 114         return( MBEDTLS_ERR_X509_ALLOC_FAILED );\r
 115 \r
 116     memcpy( p, buf, buflen );\r
 117 \r
 118     csr->raw.p = p;\r
 119     csr->raw.len = len;\r
 120     end = p + len;\r
 121 \r
 122     /*\r
 123      *  CertificationRequest ::= SEQUENCE {\r
 124      *       certificationRequestInfo CertificationRequestInfo,\r
 125      *       signatureAlgorithm AlgorithmIdentifier,\r
 126      *       signature          BIT STRING\r
 127      *  }\r
 128      */\r
 129     if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,\r
 130             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 131     {\r
 132         mbedtls_x509_csr_free( csr );\r
 133         return( MBEDTLS_ERR_X509_INVALID_FORMAT );\r
 134     }\r
 135 \r
 136     if( len != (size_t) ( end - p ) )\r
 137     {\r
 138         mbedtls_x509_csr_free( csr );\r
 139         return( MBEDTLS_ERR_X509_INVALID_FORMAT +\r
 140                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 141     }\r
 142 \r
 143     /*\r
 144      *  CertificationRequestInfo ::= SEQUENCE {\r
 145      */\r
 146     csr->cri.p = p;\r
 147 \r
 148     if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,\r
 149             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 150     {\r
 151         mbedtls_x509_csr_free( csr );\r
 152         return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );\r
 153     }\r
 154 \r
 155     end = p + len;\r
 156     csr->cri.len = end - csr->cri.p;\r
 157 \r
 158     /*\r
 159      *  Version  ::=  INTEGER {  v1(0) }\r
 160      */\r
 161     if( ( ret = x509_csr_get_version( &p, end, &csr->version ) ) != 0 )\r
 162     {\r
 163         mbedtls_x509_csr_free( csr );\r
 164         return( ret );\r
 165     }\r
 166 \r
 167     if( csr->version != 0 )\r
 168     {\r
 169         mbedtls_x509_csr_free( csr );\r
 170         return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );\r
 171     }\r
 172 \r
 173     csr->version++;\r
 174 \r
 175     /*\r
 176      *  subject               Name\r
 177      */\r
 178     csr->subject_raw.p = p;\r
 179 \r
 180     if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,\r
 181             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )\r
 182     {\r
 183         mbedtls_x509_csr_free( csr );\r
 184         return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );\r
 185     }\r
 186 \r
 187     if( ( ret = mbedtls_x509_get_name( &p, p + len, &csr->subject ) ) != 0 )\r
 188     {\r
 189         mbedtls_x509_csr_free( csr );\r
 190         return( ret );\r
 191     }\r
 192 \r
 193     csr->subject_raw.len = p - csr->subject_raw.p;\r
 194 \r
 195     /*\r
 196      *  subjectPKInfo SubjectPublicKeyInfo\r
 197      */\r
 198     if( ( ret = mbedtls_pk_parse_subpubkey( &p, end, &csr->pk ) ) != 0 )\r
 199     {\r
 200         mbedtls_x509_csr_free( csr );\r
 201         return( ret );\r
 202     }\r
 203 \r
 204     /*\r
 205      *  attributes    [0] Attributes\r
 206      *\r
 207      *  The list of possible attributes is open-ended, though RFC 2985\r
 208      *  (PKCS#9) defines a few in section 5.4. We currently don't support any,\r
 209      *  so we just ignore them. This is a safe thing to do as the worst thing\r
 210      *  that could happen is that we issue a certificate that does not match\r
 211      *  the requester's expectations - this cannot cause a violation of our\r
 212      *  signature policies.\r
 213      */\r
 214     if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,\r
 215             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC ) ) != 0 )\r
 216     {\r
 217         mbedtls_x509_csr_free( csr );\r
 218         return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );\r
 219     }\r
 220 \r
 221     p += len;\r
 222 \r
 223     end = csr->raw.p + csr->raw.len;\r
 224 \r
 225     /*\r
 226      *  signatureAlgorithm   AlgorithmIdentifier,\r
 227      *  signature            BIT STRING\r
 228      */\r
 229     if( ( ret = mbedtls_x509_get_alg( &p, end, &csr->sig_oid, &sig_params ) ) != 0 )\r
 230     {\r
 231         mbedtls_x509_csr_free( csr );\r
 232         return( ret );\r
 233     }\r
 234 \r
 235     if( ( ret = mbedtls_x509_get_sig_alg( &csr->sig_oid, &sig_params,\r
 236                                   &csr->sig_md, &csr->sig_pk,\r
 237                                   &csr->sig_opts ) ) != 0 )\r
 238     {\r
 239         mbedtls_x509_csr_free( csr );\r
 240         return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG );\r
 241     }\r
 242 \r
 243     if( ( ret = mbedtls_x509_get_sig( &p, end, &csr->sig ) ) != 0 )\r
 244     {\r
 245         mbedtls_x509_csr_free( csr );\r
 246         return( ret );\r
 247     }\r
 248 \r
 249     if( p != end )\r
 250     {\r
 251         mbedtls_x509_csr_free( csr );\r
 252         return( MBEDTLS_ERR_X509_INVALID_FORMAT +\r
 253                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );\r
 254     }\r
 255 \r
 256     return( 0 );\r
 257 }\r
 258 \r
 259 /*\r
 260  * Parse a CSR, allowing for PEM or raw DER encoding\r
 261  */\r
 262 int mbedtls_x509_csr_parse( mbedtls_x509_csr *csr, const unsigned char *buf, size_t buflen )\r
 263 {\r
 264 #if defined(MBEDTLS_PEM_PARSE_C)\r
 265     int ret;\r
 266     size_t use_len;\r
 267     mbedtls_pem_context pem;\r
 268 #endif\r
 269 \r
 270     /*\r
 271      * Check for valid input\r
 272      */\r
 273     if( csr == NULL || buf == NULL || buflen == 0 )\r
 274         return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );\r
 275 \r
 276 #if defined(MBEDTLS_PEM_PARSE_C)\r
 277     /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */\r
 278     if( buf[buflen - 1] == '\0' )\r
 279     {\r
 280         mbedtls_pem_init( &pem );\r
 281         ret = mbedtls_pem_read_buffer( &pem,\r
 282                                        "-----BEGIN CERTIFICATE REQUEST-----",\r
 283                                        "-----END CERTIFICATE REQUEST-----",\r
 284                                        buf, NULL, 0, &use_len );\r
 285         if( ret == MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )\r
 286         {\r
 287             ret = mbedtls_pem_read_buffer( &pem,\r
 288                                            "-----BEGIN NEW CERTIFICATE REQUEST-----",\r
 289                                            "-----END NEW CERTIFICATE REQUEST-----",\r
 290                                            buf, NULL, 0, &use_len );\r
 291         }\r
 292 \r
 293         if( ret == 0 )\r
 294         {\r
 295             /*\r
 296              * Was PEM encoded, parse the result\r
 297              */\r
 298             ret = mbedtls_x509_csr_parse_der( csr, pem.buf, pem.buflen );\r
 299         }\r
 300 \r
 301         mbedtls_pem_free( &pem );\r
 302         if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )\r
 303             return( ret );\r
 304     }\r
 305 #endif /* MBEDTLS_PEM_PARSE_C */\r
 306     return( mbedtls_x509_csr_parse_der( csr, buf, buflen ) );\r
 307 }\r
 308 \r
 309 #if defined(MBEDTLS_FS_IO)\r
 310 /*\r
 311  * Load a CSR into the structure\r
 312  */\r
 313 int mbedtls_x509_csr_parse_file( mbedtls_x509_csr *csr, const char *path )\r
 314 {\r
 315     int ret;\r
 316     size_t n;\r
 317     unsigned char *buf;\r
 318 \r
 319     if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )\r
 320         return( ret );\r
 321 \r
 322     ret = mbedtls_x509_csr_parse( csr, buf, n );\r
 323 \r
 324     mbedtls_platform_zeroize( buf, n );\r
 325     mbedtls_free( buf );\r
 326 \r
 327     return( ret );\r
 328 }\r
 329 #endif /* MBEDTLS_FS_IO */\r
 330 \r
 331 #define BEFORE_COLON    14\r
 332 #define BC              "14"\r
 333 /*\r
 334  * Return an informational string about the CSR.\r
 335  */\r
 336 int mbedtls_x509_csr_info( char *buf, size_t size, const char *prefix,\r
 337                    const mbedtls_x509_csr *csr )\r
 338 {\r
 339     int ret;\r
 340     size_t n;\r
 341     char *p;\r
 342     char key_size_str[BEFORE_COLON];\r
 343 \r
 344     p = buf;\r
 345     n = size;\r
 346 \r
 347     ret = mbedtls_snprintf( p, n, "%sCSR version   : %d",\r
 348                                prefix, csr->version );\r
 349     MBEDTLS_X509_SAFE_SNPRINTF;\r
 350 \r
 351     ret = mbedtls_snprintf( p, n, "\n%ssubject name  : ", prefix );\r
 352     MBEDTLS_X509_SAFE_SNPRINTF;\r
 353     ret = mbedtls_x509_dn_gets( p, n, &csr->subject );\r
 354     MBEDTLS_X509_SAFE_SNPRINTF;\r
 355 \r
 356     ret = mbedtls_snprintf( p, n, "\n%ssigned using  : ", prefix );\r
 357     MBEDTLS_X509_SAFE_SNPRINTF;\r
 358 \r
 359     ret = mbedtls_x509_sig_alg_gets( p, n, &csr->sig_oid, csr->sig_pk, csr->sig_md,\r
 360                              csr->sig_opts );\r
 361     MBEDTLS_X509_SAFE_SNPRINTF;\r
 362 \r
 363     if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,\r
 364                                       mbedtls_pk_get_name( &csr->pk ) ) ) != 0 )\r
 365     {\r
 366         return( ret );\r
 367     }\r
 368 \r
 369     ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits\n", prefix, key_size_str,\r
 370                           (int) mbedtls_pk_get_bitlen( &csr->pk ) );\r
 371     MBEDTLS_X509_SAFE_SNPRINTF;\r
 372 \r
 373     return( (int) ( size - n ) );\r
 374 }\r
 375 \r
 376 /*\r
 377  * Initialize a CSR\r
 378  */\r
 379 void mbedtls_x509_csr_init( mbedtls_x509_csr *csr )\r
 380 {\r
 381     memset( csr, 0, sizeof(mbedtls_x509_csr) );\r
 382 }\r
 383 \r
 384 /*\r
 385  * Unallocate all CSR data\r
 386  */\r
 387 void mbedtls_x509_csr_free( mbedtls_x509_csr *csr )\r
 388 {\r
 389     mbedtls_x509_name *name_cur;\r
 390     mbedtls_x509_name *name_prv;\r
 391 \r
 392     if( csr == NULL )\r
 393         return;\r
 394 \r
 395     mbedtls_pk_free( &csr->pk );\r
 396 \r
 397 #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)\r
 398     mbedtls_free( csr->sig_opts );\r
 399 #endif\r
 400 \r
 401     name_cur = csr->subject.next;\r
 402     while( name_cur != NULL )\r
 403     {\r
 404         name_prv = name_cur;\r
 405         name_cur = name_cur->next;\r
 406         mbedtls_platform_zeroize( name_prv, sizeof( mbedtls_x509_name ) );\r
 407         mbedtls_free( name_prv );\r
 408     }\r
 409 \r
 410     if( csr->raw.p != NULL )\r
 411     {\r
 412         mbedtls_platform_zeroize( csr->raw.p, csr->raw.len );\r
 413         mbedtls_free( csr->raw.p );\r
 414     }\r
 415 \r
 416     mbedtls_platform_zeroize( csr, sizeof( mbedtls_x509_csr ) );\r
 417 }\r
 418 \r
 419 #endif /* MBEDTLS_X509_CSR_PARSE_C */\r