common/mbedtls/x509_csr.c

   1 /*
   2  *  X.509 Certificate Signing Request (CSR) parsing
   3  *
   4  *  Copyright The Mbed TLS Contributors
   5  *  SPDX-License-Identifier: Apache-2.0
   6  *
   7  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
   8  *  not use this file except in compliance with the License.
   9  *  You may obtain a copy of the License at
  10  *
  11  *  http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  *  Unless required by applicable law or agreed to in writing, software
  14  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  *  See the License for the specific language governing permissions and
  17  *  limitations under the License.
  18  */
  19 /*
  20  *  The ITU-T X.509 standard defines a certificate format for PKI.
  21  *
  22  *  http://www.ietf.org/rfc/rfc5280.txt (Certificates and CRLs)
  23  *  http://www.ietf.org/rfc/rfc3279.txt (Alg IDs for CRLs)
  24  *  http://www.ietf.org/rfc/rfc2986.txt (CSRs, aka PKCS#10)
  25  *
  26  *  http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
  27  *  http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
  28  */
  29
  30 #include "common.h"
  31
  32 #if defined(MBEDTLS_X509_CSR_PARSE_C)
  33
  34 #include "mbedtls/x509_csr.h"
  35 #include "mbedtls/error.h"
  36 #include "mbedtls/oid.h"
  37 #include "mbedtls/platform_util.h"
  38
  39 #include <string.h>
  40
  41 #if defined(MBEDTLS_PEM_PARSE_C)
  42 #include "mbedtls/pem.h"
  43 #endif
  44
  45 #if defined(MBEDTLS_PLATFORM_C)
  46 #include "mbedtls/platform.h"
  47 #else
  48 #include <stdlib.h>
  49 #include <stdio.h>
  50 #define mbedtls_free       free
  51 #define mbedtls_calloc    calloc
  52 #define mbedtls_snprintf   snprintf
  53 #endif
  54
  55 #if defined(MBEDTLS_FS_IO) || defined(EFIX64) || defined(EFI32)
  56 #include <stdio.h>
  57 #endif
  58
  59 /*
  60  *  Version  ::=  INTEGER  {  v1(0)  }
  61  */
  62 static int x509_csr_get_version(unsigned char **p,
  63                                 const unsigned char *end,
  64                                 int *ver) {
  65     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
  66
  67     if ((ret = mbedtls_asn1_get_int(p, end, ver)) != 0) {
  68         if (ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG) {
  69             *ver = 0;
  70             return (0);
  71         }
  72
  73         return (MBEDTLS_ERR_X509_INVALID_VERSION + ret);
  74     }
  75
  76     return (0);
  77 }
  78
  79 /*
  80  * Parse a CSR in DER format
  81  */
  82 int mbedtls_x509_csr_parse_der(mbedtls_x509_csr *csr,
  83                                const unsigned char *buf, size_t buflen) {
  84     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
  85     size_t len;
  86     unsigned char *p, *end;
  87     mbedtls_x509_buf sig_params;
  88
  89     memset(&sig_params, 0, sizeof(mbedtls_x509_buf));
  90
  91     /*
  92      * Check for valid input
  93      */
  94     if (csr == NULL || buf == NULL || buflen == 0)
  95         return (MBEDTLS_ERR_X509_BAD_INPUT_DATA);
  96
  97     mbedtls_x509_csr_init(csr);
  98
  99     /*
 100      * first copy the raw DER data
 101      */
 102     p = mbedtls_calloc(1, len = buflen);
 103
 104     if (p == NULL)
 105         return (MBEDTLS_ERR_X509_ALLOC_FAILED);
 106
 107     memcpy(p, buf, buflen);
 108
 109     csr->raw.p = p;
 110     csr->raw.len = len;
 111     end = p + len;
 112
 113     /*
 114      *  CertificationRequest ::= SEQUENCE {
 115      *       certificationRequestInfo CertificationRequestInfo,
 116      *       signatureAlgorithm AlgorithmIdentifier,
 117      *       signature          BIT STRING
 118      *  }
 119      */
 120     if ((ret = mbedtls_asn1_get_tag(&p, end, &len,
 121                                     MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) != 0) {
 122         mbedtls_x509_csr_free(csr);
 123         return (MBEDTLS_ERR_X509_INVALID_FORMAT);
 124     }
 125
 126     if (len != (size_t)(end - p)) {
 127         mbedtls_x509_csr_free(csr);
 128         return (MBEDTLS_ERR_X509_INVALID_FORMAT +
 129                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH);
 130     }
 131
 132     /*
 133      *  CertificationRequestInfo ::= SEQUENCE {
 134      */
 135     csr->cri.p = p;
 136
 137     if ((ret = mbedtls_asn1_get_tag(&p, end, &len,
 138                                     MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) != 0) {
 139         mbedtls_x509_csr_free(csr);
 140         return (MBEDTLS_ERR_X509_INVALID_FORMAT + ret);
 141     }
 142
 143     end = p + len;
 144     csr->cri.len = end - csr->cri.p;
 145
 146     /*
 147      *  Version  ::=  INTEGER {  v1(0) }
 148      */
 149     if ((ret = x509_csr_get_version(&p, end, &csr->version)) != 0) {
 150         mbedtls_x509_csr_free(csr);
 151         return (ret);
 152     }
 153
 154     if (csr->version != 0) {
 155         mbedtls_x509_csr_free(csr);
 156         return (MBEDTLS_ERR_X509_UNKNOWN_VERSION);
 157     }
 158
 159     csr->version++;
 160
 161     /*
 162      *  subject               Name
 163      */
 164     csr->subject_raw.p = p;
 165
 166     if ((ret = mbedtls_asn1_get_tag(&p, end, &len,
 167                                     MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) != 0) {
 168         mbedtls_x509_csr_free(csr);
 169         return (MBEDTLS_ERR_X509_INVALID_FORMAT + ret);
 170     }
 171
 172     if ((ret = mbedtls_x509_get_name(&p, p + len, &csr->subject)) != 0) {
 173         mbedtls_x509_csr_free(csr);
 174         return (ret);
 175     }
 176
 177     csr->subject_raw.len = p - csr->subject_raw.p;
 178
 179     /*
 180      *  subjectPKInfo SubjectPublicKeyInfo
 181      */
 182     if ((ret = mbedtls_pk_parse_subpubkey(&p, end, &csr->pk)) != 0) {
 183         mbedtls_x509_csr_free(csr);
 184         return (ret);
 185     }
 186
 187     /*
 188      *  attributes    [0] Attributes
 189      *
 190      *  The list of possible attributes is open-ended, though RFC 2985
 191      *  (PKCS#9) defines a few in section 5.4. We currently don't support any,
 192      *  so we just ignore them. This is a safe thing to do as the worst thing
 193      *  that could happen is that we issue a certificate that does not match
 194      *  the requester's expectations - this cannot cause a violation of our
 195      *  signature policies.
 196      */
 197     if ((ret = mbedtls_asn1_get_tag(&p, end, &len,
 198                                     MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC)) != 0) {
 199         mbedtls_x509_csr_free(csr);
 200         return (MBEDTLS_ERR_X509_INVALID_FORMAT + ret);
 201     }
 202
 203     p += len;
 204
 205     end = csr->raw.p + csr->raw.len;
 206
 207     /*
 208      *  signatureAlgorithm   AlgorithmIdentifier,
 209      *  signature            BIT STRING
 210      */
 211     if ((ret = mbedtls_x509_get_alg(&p, end, &csr->sig_oid, &sig_params)) != 0) {
 212         mbedtls_x509_csr_free(csr);
 213         return (ret);
 214     }
 215
 216     if ((ret = mbedtls_x509_get_sig_alg(&csr->sig_oid, &sig_params,
 217                                         &csr->sig_md, &csr->sig_pk,
 218                                         &csr->sig_opts)) != 0) {
 219         mbedtls_x509_csr_free(csr);
 220         return (MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG);
 221     }
 222
 223     if ((ret = mbedtls_x509_get_sig(&p, end, &csr->sig)) != 0) {
 224         mbedtls_x509_csr_free(csr);
 225         return (ret);
 226     }
 227
 228     if (p != end) {
 229         mbedtls_x509_csr_free(csr);
 230         return (MBEDTLS_ERR_X509_INVALID_FORMAT +
 231                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH);
 232     }
 233
 234     return (0);
 235 }
 236
 237 /*
 238  * Parse a CSR, allowing for PEM or raw DER encoding
 239  */
 240 int mbedtls_x509_csr_parse(mbedtls_x509_csr *csr, const unsigned char *buf, size_t buflen) {
 241 #if defined(MBEDTLS_PEM_PARSE_C)
 242     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
 243     size_t use_len;
 244     mbedtls_pem_context pem;
 245 #endif
 246
 247     /*
 248      * Check for valid input
 249      */
 250     if (csr == NULL || buf == NULL || buflen == 0)
 251         return (MBEDTLS_ERR_X509_BAD_INPUT_DATA);
 252
 253 #if defined(MBEDTLS_PEM_PARSE_C)
 254     /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
 255     if (buf[buflen - 1] == '\0') {
 256         mbedtls_pem_init(&pem);
 257         ret = mbedtls_pem_read_buffer(&pem,
 258                                       "-----BEGIN CERTIFICATE REQUEST-----",
 259                                       "-----END CERTIFICATE REQUEST-----",
 260                                       buf, NULL, 0, &use_len);
 261         if (ret == MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT) {
 262             ret = mbedtls_pem_read_buffer(&pem,
 263                                           "-----BEGIN NEW CERTIFICATE REQUEST-----",
 264                                           "-----END NEW CERTIFICATE REQUEST-----",
 265                                           buf, NULL, 0, &use_len);
 266         }
 267
 268         if (ret == 0) {
 269             /*
 270              * Was PEM encoded, parse the result
 271              */
 272             ret = mbedtls_x509_csr_parse_der(csr, pem.buf, pem.buflen);
 273         }
 274
 275         mbedtls_pem_free(&pem);
 276         if (ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT)
 277             return (ret);
 278     }
 279 #endif /* MBEDTLS_PEM_PARSE_C */
 280     return (mbedtls_x509_csr_parse_der(csr, buf, buflen));
 281 }
 282
 283 #if defined(MBEDTLS_FS_IO)
 284 /*
 285  * Load a CSR into the structure
 286  */
 287 int mbedtls_x509_csr_parse_file(mbedtls_x509_csr *csr, const char *path) {
 288     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
 289     size_t n;
 290     unsigned char *buf;
 291
 292     if ((ret = mbedtls_pk_load_file(path, &buf, &n)) != 0)
 293         return (ret);
 294
 295     ret = mbedtls_x509_csr_parse(csr, buf, n);
 296
 297     mbedtls_platform_zeroize(buf, n);
 298     mbedtls_free(buf);
 299
 300     return (ret);
 301 }
 302 #endif /* MBEDTLS_FS_IO */
 303
 304 #define BEFORE_COLON    14
 305 #define BC              "14"
 306 /*
 307  * Return an informational string about the CSR.
 308  */
 309 int mbedtls_x509_csr_info(char *buf, size_t size, const char *prefix,
 310                           const mbedtls_x509_csr *csr) {
 311     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
 312     size_t n;
 313     char *p;
 314     char key_size_str[BEFORE_COLON];
 315
 316     p = buf;
 317     n = size;
 318
 319     ret = mbedtls_snprintf(p, n, "%sCSR version   : %d",
 320                            prefix, csr->version);
 321     MBEDTLS_X509_SAFE_SNPRINTF;
 322
 323     ret = mbedtls_snprintf(p, n, "\n%ssubject name  : ", prefix);
 324     MBEDTLS_X509_SAFE_SNPRINTF;
 325     ret = mbedtls_x509_dn_gets(p, n, &csr->subject);
 326     MBEDTLS_X509_SAFE_SNPRINTF;
 327
 328     ret = mbedtls_snprintf(p, n, "\n%ssigned using  : ", prefix);
 329     MBEDTLS_X509_SAFE_SNPRINTF;
 330
 331     ret = mbedtls_x509_sig_alg_gets(p, n, &csr->sig_oid, csr->sig_pk, csr->sig_md,
 332                                     csr->sig_opts);
 333     MBEDTLS_X509_SAFE_SNPRINTF;
 334
 335     if ((ret = mbedtls_x509_key_size_helper(key_size_str, BEFORE_COLON,
 336                                             mbedtls_pk_get_name(&csr->pk))) != 0) {
 337         return (ret);
 338     }
 339
 340     ret = mbedtls_snprintf(p, n, "\n%s%-" BC "s: %d bits\n", prefix, key_size_str,
 341                            (int) mbedtls_pk_get_bitlen(&csr->pk));
 342     MBEDTLS_X509_SAFE_SNPRINTF;
 343
 344     return ((int)(size - n));
 345 }
 346
 347 /*
 348  * Initialize a CSR
 349  */
 350 void mbedtls_x509_csr_init(mbedtls_x509_csr *csr) {
 351     memset(csr, 0, sizeof(mbedtls_x509_csr));
 352 }
 353
 354 /*
 355  * Unallocate all CSR data
 356  */
 357 void mbedtls_x509_csr_free(mbedtls_x509_csr *csr) {
 358     mbedtls_x509_name *name_cur;
 359     mbedtls_x509_name *name_prv;
 360
 361     if (csr == NULL)
 362         return;
 363
 364     mbedtls_pk_free(&csr->pk);
 365
 366 #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
 367     mbedtls_free(csr->sig_opts);
 368 #endif
 369
 370     name_cur = csr->subject.next;
 371     while (name_cur != NULL) {
 372         name_prv = name_cur;
 373         name_cur = name_cur->next;
 374         mbedtls_platform_zeroize(name_prv, sizeof(mbedtls_x509_name));
 375         mbedtls_free(name_prv);
 376     }
 377
 378     if (csr->raw.p != NULL) {
 379         mbedtls_platform_zeroize(csr->raw.p, csr->raw.len);
 380         mbedtls_free(csr->raw.p);
 381     }
 382
 383     mbedtls_platform_zeroize(csr, sizeof(mbedtls_x509_csr));
 384 }
 385
 386 #endif /* MBEDTLS_X509_CSR_PARSE_C */