crypto/x509v3/v3_conf.c

   1 /* v3_conf.c */
   2 /*
   3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
   4  * 1999.
   5  */
   6 /* ====================================================================
   7  * Copyright (c) 1999-2002 The OpenSSL Project.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  *
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in
  18  *    the documentation and/or other materials provided with the
  19  *    distribution.
  20  *
  21  * 3. All advertising materials mentioning features or use of this
  22  *    software must display the following acknowledgment:
  23  *    "This product includes software developed by the OpenSSL Project
  24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  25  *
  26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  27  *    endorse or promote products derived from this software without
  28  *    prior written permission. For written permission, please contact
  29  *    licensing@OpenSSL.org.
  30  *
  31  * 5. Products derived from this software may not be called "OpenSSL"
  32  *    nor may "OpenSSL" appear in their names without prior written
  33  *    permission of the OpenSSL Project.
  34  *
  35  * 6. Redistributions of any form whatsoever must retain the following
  36  *    acknowledgment:
  37  *    "This product includes software developed by the OpenSSL Project
  38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  51  * OF THE POSSIBILITY OF SUCH DAMAGE.
  52  * ====================================================================
  53  *
  54  * This product includes cryptographic software written by Eric Young
  55  * (eay@cryptsoft.com).  This product includes software written by Tim
  56  * Hudson (tjh@cryptsoft.com).
  57  *
  58  */
  59 /* extension creation utilities */
  60
  61 #include <stdio.h>
  62 #include <ctype.h>
  63 #include "internal/cryptlib.h"
  64 #include <openssl/conf.h>
  65 #include <openssl/x509.h>
  66 #include "internal/x509_int.h"
  67 #include <openssl/x509v3.h>
  68
  69 static int v3_check_critical(char **value);
  70 static int v3_check_generic(char **value);
  71 static X509_EXTENSION *do_ext_nconf(CONF *conf, X509V3_CTX *ctx, int ext_nid,
  72                                     int crit, char *value);
  73 static X509_EXTENSION *v3_generic_extension(const char *ext, char *value,
  74                                             int crit, int type,
  75                                             X509V3_CTX *ctx);
  76 static char *conf_lhash_get_string(void *db, char *section, char *value);
  77 static STACK_OF(CONF_VALUE) *conf_lhash_get_section(void *db, char *section);
  78 static X509_EXTENSION *do_ext_i2d(const X509V3_EXT_METHOD *method,
  79                                   int ext_nid, int crit, void *ext_struc);
  80 static unsigned char *generic_asn1(char *value, X509V3_CTX *ctx,
  81                                    long *ext_len);
  82 /* CONF *conf:  Config file    */
  83 /* char *name:  Name    */
  84 /* char *value:  Value    */
  85 X509_EXTENSION *X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, char *name,
  86                                  char *value)
  87 {
  88     int crit;
  89     int ext_type;
  90     X509_EXTENSION *ret;
  91     crit = v3_check_critical(&value);
  92     if ((ext_type = v3_check_generic(&value)))
  93         return v3_generic_extension(name, value, crit, ext_type, ctx);
  94     ret = do_ext_nconf(conf, ctx, OBJ_sn2nid(name), crit, value);
  95     if (!ret) {
  96         X509V3err(X509V3_F_X509V3_EXT_NCONF, X509V3_R_ERROR_IN_EXTENSION);
  97         ERR_add_error_data(4, "name=", name, ", value=", value);
  98     }
  99     return ret;
 100 }
 101
 102 /* CONF *conf:  Config file    */
 103 /* char *value:  Value    */
 104 X509_EXTENSION *X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid,
 105                                      char *value)
 106 {
 107     int crit;
 108     int ext_type;
 109     crit = v3_check_critical(&value);
 110     if ((ext_type = v3_check_generic(&value)))
 111         return v3_generic_extension(OBJ_nid2sn(ext_nid),
 112                                     value, crit, ext_type, ctx);
 113     return do_ext_nconf(conf, ctx, ext_nid, crit, value);
 114 }
 115
 116 /* CONF *conf:  Config file    */
 117 /* char *value:  Value    */
 118 static X509_EXTENSION *do_ext_nconf(CONF *conf, X509V3_CTX *ctx, int ext_nid,
 119                                     int crit, char *value)
 120 {
 121     const X509V3_EXT_METHOD *method;
 122     X509_EXTENSION *ext;
 123     STACK_OF(CONF_VALUE) *nval;
 124     void *ext_struc;
 125
 126     if (ext_nid == NID_undef) {
 127         X509V3err(X509V3_F_DO_EXT_NCONF, X509V3_R_UNKNOWN_EXTENSION_NAME);
 128         return NULL;
 129     }
 130     if ((method = X509V3_EXT_get_nid(ext_nid)) == NULL) {
 131         X509V3err(X509V3_F_DO_EXT_NCONF, X509V3_R_UNKNOWN_EXTENSION);
 132         return NULL;
 133     }
 134     /* Now get internal extension representation based on type */
 135     if (method->v2i) {
 136         if (*value == '@')
 137             nval = NCONF_get_section(conf, value + 1);
 138         else
 139             nval = X509V3_parse_list(value);
 140         if (sk_CONF_VALUE_num(nval) <= 0) {
 141             X509V3err(X509V3_F_DO_EXT_NCONF,
 142                       X509V3_R_INVALID_EXTENSION_STRING);
 143             ERR_add_error_data(4, "name=", OBJ_nid2sn(ext_nid), ",section=",
 144                                value);
 145             return NULL;
 146         }
 147         ext_struc = method->v2i(method, ctx, nval);
 148         if (*value != '@')
 149             sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
 150         if (!ext_struc)
 151             return NULL;
 152     } else if (method->s2i) {
 153         if ((ext_struc = method->s2i(method, ctx, value)) == NULL)
 154             return NULL;
 155     } else if (method->r2i) {
 156         if (!ctx->db || !ctx->db_meth) {
 157             X509V3err(X509V3_F_DO_EXT_NCONF, X509V3_R_NO_CONFIG_DATABASE);
 158             return NULL;
 159         }
 160         if ((ext_struc = method->r2i(method, ctx, value)) == NULL)
 161             return NULL;
 162     } else {
 163         X509V3err(X509V3_F_DO_EXT_NCONF,
 164                   X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED);
 165         ERR_add_error_data(2, "name=", OBJ_nid2sn(ext_nid));
 166         return NULL;
 167     }
 168
 169     ext = do_ext_i2d(method, ext_nid, crit, ext_struc);
 170     if (method->it)
 171         ASN1_item_free(ext_struc, ASN1_ITEM_ptr(method->it));
 172     else
 173         method->ext_free(ext_struc);
 174     return ext;
 175
 176 }
 177
 178 static X509_EXTENSION *do_ext_i2d(const X509V3_EXT_METHOD *method,
 179                                   int ext_nid, int crit, void *ext_struc)
 180 {
 181     unsigned char *ext_der = NULL;
 182     int ext_len;
 183     ASN1_OCTET_STRING *ext_oct = NULL;
 184     X509_EXTENSION *ext;
 185     /* Convert internal representation to DER */
 186     if (method->it) {
 187         ext_der = NULL;
 188         ext_len =
 189             ASN1_item_i2d(ext_struc, &ext_der, ASN1_ITEM_ptr(method->it));
 190         if (ext_len < 0)
 191             goto merr;
 192     } else {
 193         unsigned char *p;
 194
 195         ext_len = method->i2d(ext_struc, NULL);
 196         if ((ext_der = OPENSSL_malloc(ext_len)) == NULL)
 197             goto merr;
 198         p = ext_der;
 199         method->i2d(ext_struc, &p);
 200     }
 201     if ((ext_oct = ASN1_OCTET_STRING_new()) == NULL)
 202         goto merr;
 203     ext_oct->data = ext_der;
 204     ext_der = NULL;
 205     ext_oct->length = ext_len;
 206
 207     ext = X509_EXTENSION_create_by_NID(NULL, ext_nid, crit, ext_oct);
 208     if (!ext)
 209         goto merr;
 210     ASN1_OCTET_STRING_free(ext_oct);
 211
 212     return ext;
 213
 214  merr:
 215     X509V3err(X509V3_F_DO_EXT_I2D, ERR_R_MALLOC_FAILURE);
 216     OPENSSL_free(ext_der);
 217     ASN1_OCTET_STRING_free(ext_oct);
 218     return NULL;
 219
 220 }
 221
 222 /* Given an internal structure, nid and critical flag create an extension */
 223
 224 X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc)
 225 {
 226     const X509V3_EXT_METHOD *method;
 227
 228     if ((method = X509V3_EXT_get_nid(ext_nid)) == NULL) {
 229         X509V3err(X509V3_F_X509V3_EXT_I2D, X509V3_R_UNKNOWN_EXTENSION);
 230         return NULL;
 231     }
 232     return do_ext_i2d(method, ext_nid, crit, ext_struc);
 233 }
 234
 235 /* Check the extension string for critical flag */
 236 static int v3_check_critical(char **value)
 237 {
 238     char *p = *value;
 239     if ((strlen(p) < 9) || strncmp(p, "critical,", 9))
 240         return 0;
 241     p += 9;
 242     while (isspace((unsigned char)*p))
 243         p++;
 244     *value = p;
 245     return 1;
 246 }
 247
 248 /* Check extension string for generic extension and return the type */
 249 static int v3_check_generic(char **value)
 250 {
 251     int gen_type = 0;
 252     char *p = *value;
 253     if ((strlen(p) >= 4) && strncmp(p, "DER:", 4) == 0) {
 254         p += 4;
 255         gen_type = 1;
 256     } else if ((strlen(p) >= 5) && strncmp(p, "ASN1:", 5) == 0) {
 257         p += 5;
 258         gen_type = 2;
 259     } else
 260         return 0;
 261
 262     while (isspace((unsigned char)*p))
 263         p++;
 264     *value = p;
 265     return gen_type;
 266 }
 267
 268 /* Create a generic extension: for now just handle DER type */
 269 static X509_EXTENSION *v3_generic_extension(const char *ext, char *value,
 270                                             int crit, int gen_type,
 271                                             X509V3_CTX *ctx)
 272 {
 273     unsigned char *ext_der = NULL;
 274     long ext_len = 0;
 275     ASN1_OBJECT *obj = NULL;
 276     ASN1_OCTET_STRING *oct = NULL;
 277     X509_EXTENSION *extension = NULL;
 278
 279     if ((obj = OBJ_txt2obj(ext, 0)) == NULL) {
 280         X509V3err(X509V3_F_V3_GENERIC_EXTENSION,
 281                   X509V3_R_EXTENSION_NAME_ERROR);
 282         ERR_add_error_data(2, "name=", ext);
 283         goto err;
 284     }
 285
 286     if (gen_type == 1)
 287         ext_der = string_to_hex(value, &ext_len);
 288     else if (gen_type == 2)
 289         ext_der = generic_asn1(value, ctx, &ext_len);
 290
 291     if (ext_der == NULL) {
 292         X509V3err(X509V3_F_V3_GENERIC_EXTENSION,
 293                   X509V3_R_EXTENSION_VALUE_ERROR);
 294         ERR_add_error_data(2, "value=", value);
 295         goto err;
 296     }
 297
 298     if ((oct = ASN1_OCTET_STRING_new()) == NULL) {
 299         X509V3err(X509V3_F_V3_GENERIC_EXTENSION, ERR_R_MALLOC_FAILURE);
 300         goto err;
 301     }
 302
 303     oct->data = ext_der;
 304     oct->length = ext_len;
 305     ext_der = NULL;
 306
 307     extension = X509_EXTENSION_create_by_OBJ(NULL, obj, crit, oct);
 308
 309  err:
 310     ASN1_OBJECT_free(obj);
 311     ASN1_OCTET_STRING_free(oct);
 312     OPENSSL_free(ext_der);
 313     return extension;
 314
 315 }
 316
 317 static unsigned char *generic_asn1(char *value, X509V3_CTX *ctx,
 318                                    long *ext_len)
 319 {
 320     ASN1_TYPE *typ;
 321     unsigned char *ext_der = NULL;
 322     typ = ASN1_generate_v3(value, ctx);
 323     if (typ == NULL)
 324         return NULL;
 325     *ext_len = i2d_ASN1_TYPE(typ, &ext_der);
 326     ASN1_TYPE_free(typ);
 327     return ext_der;
 328 }
 329
 330 static void delete_ext(STACK_OF(X509_EXTENSION) *sk, X509_EXTENSION *dext)
 331 {
 332     int idx;
 333     ASN1_OBJECT *obj;
 334     obj = X509_EXTENSION_get_object(dext);
 335     while ((idx = X509v3_get_ext_by_OBJ(sk, obj, -1)) >= 0) {
 336         X509_EXTENSION *tmpext = X509v3_get_ext(sk, idx);
 337         X509v3_delete_ext(sk, idx);
 338         X509_EXTENSION_free(tmpext);
 339     }
 340 }
 341
 342 /*
 343  * This is the main function: add a bunch of extensions based on a config
 344  * file section to an extension STACK.
 345  */
 346
 347 int X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, char *section,
 348                             STACK_OF(X509_EXTENSION) **sk)
 349 {
 350     X509_EXTENSION *ext;
 351     STACK_OF(CONF_VALUE) *nval;
 352     CONF_VALUE *val;
 353     int i;
 354
 355     if ((nval = NCONF_get_section(conf, section)) == NULL)
 356         return 0;
 357     for (i = 0; i < sk_CONF_VALUE_num(nval); i++) {
 358         val = sk_CONF_VALUE_value(nval, i);
 359         if ((ext = X509V3_EXT_nconf(conf, ctx, val->name, val->value)) == NULL)
 360             return 0;
 361         if (ctx->flags == X509V3_CTX_REPLACE)
 362             delete_ext(*sk, ext);
 363         if (sk)
 364             X509v3_add_ext(sk, ext, -1);
 365         X509_EXTENSION_free(ext);
 366     }
 367     return 1;
 368 }
 369
 370 /*
 371  * Convenience functions to add extensions to a certificate, CRL and request
 372  */
 373
 374 int X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, char *section,
 375                          X509 *cert)
 376 {
 377     STACK_OF(X509_EXTENSION) **sk = NULL;
 378     if (cert)
 379         sk = &cert->cert_info.extensions;
 380     return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
 381 }
 382
 383 /* Same as above but for a CRL */
 384
 385 int X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, char *section,
 386                              X509_CRL *crl)
 387 {
 388     STACK_OF(X509_EXTENSION) **sk = NULL;
 389     if (crl)
 390         sk = &crl->crl.extensions;
 391     return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
 392 }
 393
 394 /* Add extensions to certificate request */
 395
 396 int X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, char *section,
 397                              X509_REQ *req)
 398 {
 399     STACK_OF(X509_EXTENSION) *extlist = NULL, **sk = NULL;
 400     int i;
 401     if (req)
 402         sk = &extlist;
 403     i = X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
 404     if (!i || !sk)
 405         return i;
 406     i = X509_REQ_add_extensions(req, extlist);
 407     sk_X509_EXTENSION_pop_free(extlist, X509_EXTENSION_free);
 408     return i;
 409 }
 410
 411 /* Config database functions */
 412
 413 char *X509V3_get_string(X509V3_CTX *ctx, char *name, char *section)
 414 {
 415     if (!ctx->db || !ctx->db_meth || !ctx->db_meth->get_string) {
 416         X509V3err(X509V3_F_X509V3_GET_STRING, X509V3_R_OPERATION_NOT_DEFINED);
 417         return NULL;
 418     }
 419     if (ctx->db_meth->get_string)
 420         return ctx->db_meth->get_string(ctx->db, name, section);
 421     return NULL;
 422 }
 423
 424 STACK_OF(CONF_VALUE) *X509V3_get_section(X509V3_CTX *ctx, char *section)
 425 {
 426     if (!ctx->db || !ctx->db_meth || !ctx->db_meth->get_section) {
 427         X509V3err(X509V3_F_X509V3_GET_SECTION,
 428                   X509V3_R_OPERATION_NOT_DEFINED);
 429         return NULL;
 430     }
 431     if (ctx->db_meth->get_section)
 432         return ctx->db_meth->get_section(ctx->db, section);
 433     return NULL;
 434 }
 435
 436 void X509V3_string_free(X509V3_CTX *ctx, char *str)
 437 {
 438     if (!str)
 439         return;
 440     if (ctx->db_meth->free_string)
 441         ctx->db_meth->free_string(ctx->db, str);
 442 }
 443
 444 void X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section)
 445 {
 446     if (!section)
 447         return;
 448     if (ctx->db_meth->free_section)
 449         ctx->db_meth->free_section(ctx->db, section);
 450 }
 451
 452 static char *nconf_get_string(void *db, char *section, char *value)
 453 {
 454     return NCONF_get_string(db, section, value);
 455 }
 456
 457 static STACK_OF(CONF_VALUE) *nconf_get_section(void *db, char *section)
 458 {
 459     return NCONF_get_section(db, section);
 460 }
 461
 462 static X509V3_CONF_METHOD nconf_method = {
 463     nconf_get_string,
 464     nconf_get_section,
 465     NULL,
 466     NULL
 467 };
 468
 469 void X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf)
 470 {
 471     ctx->db_meth = &nconf_method;
 472     ctx->db = conf;
 473 }
 474
 475 void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req,
 476                     X509_CRL *crl, int flags)
 477 {
 478     ctx->issuer_cert = issuer;
 479     ctx->subject_cert = subj;
 480     ctx->crl = crl;
 481     ctx->subject_req = req;
 482     ctx->flags = flags;
 483 }
 484
 485 /* Old conf compatibility functions */
 486
 487 X509_EXTENSION *X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
 488                                 char *name, char *value)
 489 {
 490     CONF ctmp;
 491     CONF_set_nconf(&ctmp, conf);
 492     return X509V3_EXT_nconf(&ctmp, ctx, name, value);
 493 }
 494
 495 /* LHASH *conf:  Config file    */
 496 /* char *value:  Value    */
 497 X509_EXTENSION *X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf,
 498                                     X509V3_CTX *ctx, int ext_nid, char *value)
 499 {
 500     CONF ctmp;
 501     CONF_set_nconf(&ctmp, conf);
 502     return X509V3_EXT_nconf_nid(&ctmp, ctx, ext_nid, value);
 503 }
 504
 505 static char *conf_lhash_get_string(void *db, char *section, char *value)
 506 {
 507     return CONF_get_string(db, section, value);
 508 }
 509
 510 static STACK_OF(CONF_VALUE) *conf_lhash_get_section(void *db, char *section)
 511 {
 512     return CONF_get_section(db, section);
 513 }
 514
 515 static X509V3_CONF_METHOD conf_lhash_method = {
 516     conf_lhash_get_string,
 517     conf_lhash_get_section,
 518     NULL,
 519     NULL
 520 };
 521
 522 void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash)
 523 {
 524     ctx->db_meth = &conf_lhash_method;
 525     ctx->db = lhash;
 526 }
 527
 528 int X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
 529                         char *section, X509 *cert)
 530 {
 531     CONF ctmp;
 532     CONF_set_nconf(&ctmp, conf);
 533     return X509V3_EXT_add_nconf(&ctmp, ctx, section, cert);
 534 }
 535
 536 /* Same as above but for a CRL */
 537
 538 int X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
 539                             char *section, X509_CRL *crl)
 540 {
 541     CONF ctmp;
 542     CONF_set_nconf(&ctmp, conf);
 543     return X509V3_EXT_CRL_add_nconf(&ctmp, ctx, section, crl);
 544 }
 545
 546 /* Add extensions to certificate request */
 547
 548 int X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
 549                             char *section, X509_REQ *req)
 550 {
 551     CONF ctmp;
 552     CONF_set_nconf(&ctmp, conf);
 553     return X509V3_EXT_REQ_add_nconf(&ctmp, ctx, section, req);
 554 }