| OLD | NEW |
|---|
| (Empty) |
| 1 /* v3_alt.c */ | |
| 2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | |
| 3 * project. | |
| 4 */ | |
| 5 /* ==================================================================== | |
| 6 * Copyright (c) 1999-2003 The OpenSSL Project. All rights reserved. | |
| 7 * | |
| 8 * Redistribution and use in source and binary forms, with or without | |
| 9 * modification, are permitted provided that the following conditions | |
| 10 * are met: | |
| 11 * | |
| 12 * 1. Redistributions of source code must retain the above copyright | |
| 13 * notice, this list of conditions and the following disclaimer. | |
| 14 * | |
| 15 * 2. Redistributions in binary form must reproduce the above copyright | |
| 16 * notice, this list of conditions and the following disclaimer in | |
| 17 * the documentation and/or other materials provided with the | |
| 18 * distribution. | |
| 19 * | |
| 20 * 3. All advertising materials mentioning features or use of this | |
| 21 * software must display the following acknowledgment: | |
| 22 * "This product includes software developed by the OpenSSL Project | |
| 23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | |
| 24 * | |
| 25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |
| 26 * endorse or promote products derived from this software without | |
| 27 * prior written permission. For written permission, please contact | |
| 28 * licensing@OpenSSL.org. | |
| 29 * | |
| 30 * 5. Products derived from this software may not be called "OpenSSL" | |
| 31 * nor may "OpenSSL" appear in their names without prior written | |
| 32 * permission of the OpenSSL Project. | |
| 33 * | |
| 34 * 6. Redistributions of any form whatsoever must retain the following | |
| 35 * acknowledgment: | |
| 36 * "This product includes software developed by the OpenSSL Project | |
| 37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | |
| 38 * | |
| 39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |
| 40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| 41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
| 42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |
| 43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
| 45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
| 46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
| 47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
| 48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
| 49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
| 50 * OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 51 * ==================================================================== | |
| 52 * | |
| 53 * This product includes cryptographic software written by Eric Young | |
| 54 * (eay@cryptsoft.com). This product includes software written by Tim | |
| 55 * Hudson (tjh@cryptsoft.com). | |
| 56 * | |
| 57 */ | |
| 58 | |
| 59 #include <stdio.h> | |
| 60 #include "cryptlib.h" | |
| 61 #include <openssl/conf.h> | |
| 62 #include <openssl/x509v3.h> | |
| 63 | |
| 64 static GENERAL_NAMES *v2i_subject_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx
, STACK_OF(CONF_VALUE) *nval); | |
| 65 static GENERAL_NAMES *v2i_issuer_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
STACK_OF(CONF_VALUE) *nval); | |
| 66 static int copy_email(X509V3_CTX *ctx, GENERAL_NAMES *gens, int move_p); | |
| 67 static int copy_issuer(X509V3_CTX *ctx, GENERAL_NAMES *gens); | |
| 68 static int do_othername(GENERAL_NAME *gen, char *value, X509V3_CTX *ctx); | |
| 69 static int do_dirname(GENERAL_NAME *gen, char *value, X509V3_CTX *ctx); | |
| 70 | |
| 71 const X509V3_EXT_METHOD v3_alt[] = { | |
| 72 { NID_subject_alt_name, 0, ASN1_ITEM_ref(GENERAL_NAMES), | |
| 73 0,0,0,0, | |
| 74 0,0, | |
| 75 (X509V3_EXT_I2V)i2v_GENERAL_NAMES, | |
| 76 (X509V3_EXT_V2I)v2i_subject_alt, | |
| 77 NULL, NULL, NULL}, | |
| 78 | |
| 79 { NID_issuer_alt_name, 0, ASN1_ITEM_ref(GENERAL_NAMES), | |
| 80 0,0,0,0, | |
| 81 0,0, | |
| 82 (X509V3_EXT_I2V)i2v_GENERAL_NAMES, | |
| 83 (X509V3_EXT_V2I)v2i_issuer_alt, | |
| 84 NULL, NULL, NULL}, | |
| 85 | |
| 86 { NID_certificate_issuer, 0, ASN1_ITEM_ref(GENERAL_NAMES), | |
| 87 0,0,0,0, | |
| 88 0,0, | |
| 89 (X509V3_EXT_I2V)i2v_GENERAL_NAMES, | |
| 90 NULL, NULL, NULL, NULL}, | |
| 91 }; | |
| 92 | |
| 93 STACK_OF(CONF_VALUE) *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method, | |
| 94 GENERAL_NAMES *gens, STACK_OF(CONF_VALUE) *ret) | |
| 95 { | |
| 96 int i; | |
| 97 GENERAL_NAME *gen; | |
| 98 for(i = 0; i < sk_GENERAL_NAME_num(gens); i++) { | |
| 99 gen = sk_GENERAL_NAME_value(gens, i); | |
| 100 ret = i2v_GENERAL_NAME(method, gen, ret); | |
| 101 } | |
| 102 if(!ret) return sk_CONF_VALUE_new_null(); | |
| 103 return ret; | |
| 104 } | |
| 105 | |
| 106 STACK_OF(CONF_VALUE) *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, | |
| 107 GENERAL_NAME *gen, STACK_OF(CONF_VALUE) *ret) | |
| 108 { | |
| 109 unsigned char *p; | |
| 110 char oline[256], htmp[5]; | |
| 111 int i; | |
| 112 switch (gen->type) | |
| 113 { | |
| 114 case GEN_OTHERNAME: | |
| 115 X509V3_add_value("othername","<unsupported>", &ret); | |
| 116 break; | |
| 117 | |
| 118 case GEN_X400: | |
| 119 X509V3_add_value("X400Name","<unsupported>", &ret); | |
| 120 break; | |
| 121 | |
| 122 case GEN_EDIPARTY: | |
| 123 X509V3_add_value("EdiPartyName","<unsupported>", &ret); | |
| 124 break; | |
| 125 | |
| 126 case GEN_EMAIL: | |
| 127 X509V3_add_value_uchar("email",gen->d.ia5->data, &ret); | |
| 128 break; | |
| 129 | |
| 130 case GEN_DNS: | |
| 131 X509V3_add_value_uchar("DNS",gen->d.ia5->data, &ret); | |
| 132 break; | |
| 133 | |
| 134 case GEN_URI: | |
| 135 X509V3_add_value_uchar("URI",gen->d.ia5->data, &ret); | |
| 136 break; | |
| 137 | |
| 138 case GEN_DIRNAME: | |
| 139 X509_NAME_oneline(gen->d.dirn, oline, 256); | |
| 140 X509V3_add_value("DirName",oline, &ret); | |
| 141 break; | |
| 142 | |
| 143 case GEN_IPADD: | |
| 144 p = gen->d.ip->data; | |
| 145 if(gen->d.ip->length == 4) | |
| 146 BIO_snprintf(oline, sizeof oline, | |
| 147 "%d.%d.%d.%d", p[0], p[1], p[2], p[3]); | |
| 148 else if(gen->d.ip->length == 16) | |
| 149 { | |
| 150 oline[0] = 0; | |
| 151 for (i = 0; i < 8; i++) | |
| 152 { | |
| 153 BIO_snprintf(htmp, sizeof htmp, | |
| 154 "%X", p[0] << 8 | p[1]); | |
| 155 p += 2; | |
| 156 strcat(oline, htmp); | |
| 157 if (i != 7) | |
| 158 strcat(oline, ":"); | |
| 159 } | |
| 160 } | |
| 161 else | |
| 162 { | |
| 163 X509V3_add_value("IP Address","<invalid>", &ret); | |
| 164 break; | |
| 165 } | |
| 166 X509V3_add_value("IP Address",oline, &ret); | |
| 167 break; | |
| 168 | |
| 169 case GEN_RID: | |
| 170 i2t_ASN1_OBJECT(oline, 256, gen->d.rid); | |
| 171 X509V3_add_value("Registered ID",oline, &ret); | |
| 172 break; | |
| 173 } | |
| 174 return ret; | |
| 175 } | |
| 176 | |
| 177 int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen) | |
| 178 { | |
| 179 unsigned char *p; | |
| 180 int i; | |
| 181 switch (gen->type) | |
| 182 { | |
| 183 case GEN_OTHERNAME: | |
| 184 BIO_printf(out, "othername:<unsupported>"); | |
| 185 break; | |
| 186 | |
| 187 case GEN_X400: | |
| 188 BIO_printf(out, "X400Name:<unsupported>"); | |
| 189 break; | |
| 190 | |
| 191 case GEN_EDIPARTY: | |
| 192 /* Maybe fix this: it is supported now */ | |
| 193 BIO_printf(out, "EdiPartyName:<unsupported>"); | |
| 194 break; | |
| 195 | |
| 196 case GEN_EMAIL: | |
| 197 BIO_printf(out, "email:%s",gen->d.ia5->data); | |
| 198 break; | |
| 199 | |
| 200 case GEN_DNS: | |
| 201 BIO_printf(out, "DNS:%s",gen->d.ia5->data); | |
| 202 break; | |
| 203 | |
| 204 case GEN_URI: | |
| 205 BIO_printf(out, "URI:%s",gen->d.ia5->data); | |
| 206 break; | |
| 207 | |
| 208 case GEN_DIRNAME: | |
| 209 BIO_printf(out, "DirName: "); | |
| 210 X509_NAME_print_ex(out, gen->d.dirn, 0, XN_FLAG_ONELINE); | |
| 211 break; | |
| 212 | |
| 213 case GEN_IPADD: | |
| 214 p = gen->d.ip->data; | |
| 215 if(gen->d.ip->length == 4) | |
| 216 BIO_printf(out, "IP Address:%d.%d.%d.%d", | |
| 217 p[0], p[1], p[2], p[3]); | |
| 218 else if(gen->d.ip->length == 16) | |
| 219 { | |
| 220 BIO_printf(out, "IP Address"); | |
| 221 for (i = 0; i < 8; i++) | |
| 222 { | |
| 223 BIO_printf(out, ":%X", p[0] << 8 | p[1]); | |
| 224 p += 2; | |
| 225 } | |
| 226 BIO_puts(out, "\n"); | |
| 227 } | |
| 228 else | |
| 229 { | |
| 230 BIO_printf(out,"IP Address:<invalid>"); | |
| 231 break; | |
| 232 } | |
| 233 break; | |
| 234 | |
| 235 case GEN_RID: | |
| 236 BIO_printf(out, "Registered ID"); | |
| 237 i2a_ASN1_OBJECT(out, gen->d.rid); | |
| 238 break; | |
| 239 } | |
| 240 return 1; | |
| 241 } | |
| 242 | |
| 243 static GENERAL_NAMES *v2i_issuer_alt(X509V3_EXT_METHOD *method, | |
| 244 X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval) | |
| 245 { | |
| 246 GENERAL_NAMES *gens = NULL; | |
| 247 CONF_VALUE *cnf; | |
| 248 int i; | |
| 249 if(!(gens = sk_GENERAL_NAME_new_null())) { | |
| 250 X509V3err(X509V3_F_V2I_ISSUER_ALT,ERR_R_MALLOC_FAILURE); | |
| 251 return NULL; | |
| 252 } | |
| 253 for(i = 0; i < sk_CONF_VALUE_num(nval); i++) { | |
| 254 cnf = sk_CONF_VALUE_value(nval, i); | |
| 255 if(!name_cmp(cnf->name, "issuer") && cnf->value && | |
| 256 !strcmp(cnf->value, "copy")) { | |
| 257 if(!copy_issuer(ctx, gens)) goto err; | |
| 258 } else { | |
| 259 GENERAL_NAME *gen; | |
| 260 if(!(gen = v2i_GENERAL_NAME(method, ctx, cnf))) | |
| 261 goto err; | |
| 262 sk_GENERAL_NAME_push(gens, gen); | |
| 263 } | |
| 264 } | |
| 265 return gens; | |
| 266 err: | |
| 267 sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free); | |
| 268 return NULL; | |
| 269 } | |
| 270 | |
| 271 /* Append subject altname of issuer to issuer alt name of subject */ | |
| 272 | |
| 273 static int copy_issuer(X509V3_CTX *ctx, GENERAL_NAMES *gens) | |
| 274 { | |
| 275 GENERAL_NAMES *ialt; | |
| 276 GENERAL_NAME *gen; | |
| 277 X509_EXTENSION *ext; | |
| 278 int i; | |
| 279 if(ctx && (ctx->flags == CTX_TEST)) return 1; | |
| 280 if(!ctx || !ctx->issuer_cert) { | |
| 281 X509V3err(X509V3_F_COPY_ISSUER,X509V3_R_NO_ISSUER_DETAILS); | |
| 282 goto err; | |
| 283 } | |
| 284 i = X509_get_ext_by_NID(ctx->issuer_cert, NID_subject_alt_name, -1); | |
| 285 if(i < 0) return 1; | |
| 286 if(!(ext = X509_get_ext(ctx->issuer_cert, i)) || | |
| 287 !(ialt = X509V3_EXT_d2i(ext)) ) { | |
| 288 X509V3err(X509V3_F_COPY_ISSUER,X509V3_R_ISSUER_DECODE_ERROR); | |
| 289 goto err; | |
| 290 } | |
| 291 | |
| 292 for(i = 0; i < sk_GENERAL_NAME_num(ialt); i++) { | |
| 293 gen = sk_GENERAL_NAME_value(ialt, i); | |
| 294 if(!sk_GENERAL_NAME_push(gens, gen)) { | |
| 295 X509V3err(X509V3_F_COPY_ISSUER,ERR_R_MALLOC_FAILURE); | |
| 296 goto err; | |
| 297 } | |
| 298 } | |
| 299 sk_GENERAL_NAME_free(ialt); | |
| 300 | |
| 301 return 1; | |
| 302 | |
| 303 err: | |
| 304 return 0; | |
| 305 | |
| 306 } | |
| 307 | |
| 308 static GENERAL_NAMES *v2i_subject_alt(X509V3_EXT_METHOD *method, | |
| 309 X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval) | |
| 310 { | |
| 311 GENERAL_NAMES *gens = NULL; | |
| 312 CONF_VALUE *cnf; | |
| 313 int i; | |
| 314 if(!(gens = sk_GENERAL_NAME_new_null())) { | |
| 315 X509V3err(X509V3_F_V2I_SUBJECT_ALT,ERR_R_MALLOC_FAILURE); | |
| 316 return NULL; | |
| 317 } | |
| 318 for(i = 0; i < sk_CONF_VALUE_num(nval); i++) { | |
| 319 cnf = sk_CONF_VALUE_value(nval, i); | |
| 320 if(!name_cmp(cnf->name, "email") && cnf->value && | |
| 321 !strcmp(cnf->value, "copy")) { | |
| 322 if(!copy_email(ctx, gens, 0)) goto err; | |
| 323 } else if(!name_cmp(cnf->name, "email") && cnf->value && | |
| 324 !strcmp(cnf->value, "move")) { | |
| 325 if(!copy_email(ctx, gens, 1)) goto err; | |
| 326 } else { | |
| 327 GENERAL_NAME *gen; | |
| 328 if(!(gen = v2i_GENERAL_NAME(method, ctx, cnf))) | |
| 329 goto err; | |
| 330 sk_GENERAL_NAME_push(gens, gen); | |
| 331 } | |
| 332 } | |
| 333 return gens; | |
| 334 err: | |
| 335 sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free); | |
| 336 return NULL; | |
| 337 } | |
| 338 | |
| 339 /* Copy any email addresses in a certificate or request to | |
| 340 * GENERAL_NAMES | |
| 341 */ | |
| 342 | |
| 343 static int copy_email(X509V3_CTX *ctx, GENERAL_NAMES *gens, int move_p) | |
| 344 { | |
| 345 X509_NAME *nm; | |
| 346 ASN1_IA5STRING *email = NULL; | |
| 347 X509_NAME_ENTRY *ne; | |
| 348 GENERAL_NAME *gen = NULL; | |
| 349 int i; | |
| 350 if(ctx != NULL && ctx->flags == CTX_TEST) | |
| 351 return 1; | |
| 352 if(!ctx || (!ctx->subject_cert && !ctx->subject_req)) { | |
| 353 X509V3err(X509V3_F_COPY_EMAIL,X509V3_R_NO_SUBJECT_DETAILS); | |
| 354 goto err; | |
| 355 } | |
| 356 /* Find the subject name */ | |
| 357 if(ctx->subject_cert) nm = X509_get_subject_name(ctx->subject_cert); | |
| 358 else nm = X509_REQ_get_subject_name(ctx->subject_req); | |
| 359 | |
| 360 /* Now add any email address(es) to STACK */ | |
| 361 i = -1; | |
| 362 while((i = X509_NAME_get_index_by_NID(nm, | |
| 363 NID_pkcs9_emailAddress, i)) >= 0) { | |
| 364 ne = X509_NAME_get_entry(nm, i); | |
| 365 email = M_ASN1_IA5STRING_dup(X509_NAME_ENTRY_get_data(ne)); | |
| 366 if (move_p) | |
| 367 { | |
| 368 X509_NAME_delete_entry(nm, i); | |
| 369 X509_NAME_ENTRY_free(ne); | |
| 370 i--; | |
| 371 } | |
| 372 if(!email || !(gen = GENERAL_NAME_new())) { | |
| 373 X509V3err(X509V3_F_COPY_EMAIL,ERR_R_MALLOC_FAILURE); | |
| 374 goto err; | |
| 375 } | |
| 376 gen->d.ia5 = email; | |
| 377 email = NULL; | |
| 378 gen->type = GEN_EMAIL; | |
| 379 if(!sk_GENERAL_NAME_push(gens, gen)) { | |
| 380 X509V3err(X509V3_F_COPY_EMAIL,ERR_R_MALLOC_FAILURE); | |
| 381 goto err; | |
| 382 } | |
| 383 gen = NULL; | |
| 384 } | |
| 385 | |
| 386 | |
| 387 return 1; | |
| 388 | |
| 389 err: | |
| 390 GENERAL_NAME_free(gen); | |
| 391 M_ASN1_IA5STRING_free(email); | |
| 392 return 0; | |
| 393 | |
| 394 } | |
| 395 | |
| 396 GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method, | |
| 397 X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval) | |
| 398 { | |
| 399 GENERAL_NAME *gen; | |
| 400 GENERAL_NAMES *gens = NULL; | |
| 401 CONF_VALUE *cnf; | |
| 402 int i; | |
| 403 if(!(gens = sk_GENERAL_NAME_new_null())) { | |
| 404 X509V3err(X509V3_F_V2I_GENERAL_NAMES,ERR_R_MALLOC_FAILURE); | |
| 405 return NULL; | |
| 406 } | |
| 407 for(i = 0; i < sk_CONF_VALUE_num(nval); i++) { | |
| 408 cnf = sk_CONF_VALUE_value(nval, i); | |
| 409 if(!(gen = v2i_GENERAL_NAME(method, ctx, cnf))) goto err; | |
| 410 sk_GENERAL_NAME_push(gens, gen); | |
| 411 } | |
| 412 return gens; | |
| 413 err: | |
| 414 sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free); | |
| 415 return NULL; | |
| 416 } | |
| 417 | |
| 418 GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx, | |
| 419 CONF_VALUE *cnf) | |
| 420 { | |
| 421 return v2i_GENERAL_NAME_ex(NULL, method, ctx, cnf, 0); | |
| 422 } | |
| 423 | |
| 424 GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out, | |
| 425 const X509V3_EXT_METHOD *method, X509V3_CTX *ctx, | |
| 426 int gen_type, char *value, int is_nc) | |
| 427 { | |
| 428 char is_string = 0; | |
| 429 GENERAL_NAME *gen = NULL; | |
| 430 | |
| 431 if(!value) | |
| 432 { | |
| 433 X509V3err(X509V3_F_A2I_GENERAL_NAME,X509V3_R_MISSING_VALUE); | |
| 434 return NULL; | |
| 435 } | |
| 436 | |
| 437 if (out) | |
| 438 gen = out; | |
| 439 else | |
| 440 { | |
| 441 gen = GENERAL_NAME_new(); | |
| 442 if(gen == NULL) | |
| 443 { | |
| 444 X509V3err(X509V3_F_A2I_GENERAL_NAME,ERR_R_MALLOC_FAILURE
); | |
| 445 return NULL; | |
| 446 } | |
| 447 } | |
| 448 | |
| 449 switch (gen_type) | |
| 450 { | |
| 451 case GEN_URI: | |
| 452 case GEN_EMAIL: | |
| 453 case GEN_DNS: | |
| 454 is_string = 1; | |
| 455 break; | |
| 456 | |
| 457 case GEN_RID: | |
| 458 { | |
| 459 ASN1_OBJECT *obj; | |
| 460 if(!(obj = OBJ_txt2obj(value,0))) | |
| 461 { | |
| 462 X509V3err(X509V3_F_A2I_GENERAL_NAME,X509V3_R_BAD_OBJECT)
; | |
| 463 ERR_add_error_data(2, "value=", value); | |
| 464 goto err; | |
| 465 } | |
| 466 gen->d.rid = obj; | |
| 467 } | |
| 468 break; | |
| 469 | |
| 470 case GEN_IPADD: | |
| 471 if (is_nc) | |
| 472 gen->d.ip = a2i_IPADDRESS_NC(value); | |
| 473 else | |
| 474 gen->d.ip = a2i_IPADDRESS(value); | |
| 475 if(gen->d.ip == NULL) | |
| 476 { | |
| 477 X509V3err(X509V3_F_A2I_GENERAL_NAME,X509V3_R_BAD_IP_ADDR
ESS); | |
| 478 ERR_add_error_data(2, "value=", value); | |
| 479 goto err; | |
| 480 } | |
| 481 break; | |
| 482 | |
| 483 case GEN_DIRNAME: | |
| 484 if (!do_dirname(gen, value, ctx)) | |
| 485 { | |
| 486 X509V3err(X509V3_F_A2I_GENERAL_NAME,X509V3_R_DIRNAME_ERR
OR); | |
| 487 goto err; | |
| 488 } | |
| 489 break; | |
| 490 | |
| 491 case GEN_OTHERNAME: | |
| 492 if (!do_othername(gen, value, ctx)) | |
| 493 { | |
| 494 X509V3err(X509V3_F_A2I_GENERAL_NAME,X509V3_R_OTHERNAME_E
RROR); | |
| 495 goto err; | |
| 496 } | |
| 497 break; | |
| 498 default: | |
| 499 X509V3err(X509V3_F_A2I_GENERAL_NAME,X509V3_R_UNSUPPORTED_TYPE); | |
| 500 goto err; | |
| 501 } | |
| 502 | |
| 503 if(is_string) | |
| 504 { | |
| 505 if(!(gen->d.ia5 = M_ASN1_IA5STRING_new()) || | |
| 506 !ASN1_STRING_set(gen->d.ia5, (unsigned char*)value
, | |
| 507 strlen(value))) | |
| 508 { | |
| 509 X509V3err(X509V3_F_A2I_GENERAL_NAME,ERR_R_MALLOC_FAILURE
); | |
| 510 goto err; | |
| 511 } | |
| 512 } | |
| 513 | |
| 514 gen->type = gen_type; | |
| 515 | |
| 516 return gen; | |
| 517 | |
| 518 err: | |
| 519 if (!out) | |
| 520 GENERAL_NAME_free(gen); | |
| 521 return NULL; | |
| 522 } | |
| 523 | |
| 524 GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out, | |
| 525 const X509V3_EXT_METHOD *method, | |
| 526 X509V3_CTX *ctx, CONF_VALUE *cnf, int is_nc) | |
| 527 { | |
| 528 int type; | |
| 529 | |
| 530 char *name, *value; | |
| 531 | |
| 532 name = cnf->name; | |
| 533 value = cnf->value; | |
| 534 | |
| 535 if(!value) | |
| 536 { | |
| 537 X509V3err(X509V3_F_V2I_GENERAL_NAME_EX,X509V3_R_MISSING_VALUE); | |
| 538 return NULL; | |
| 539 } | |
| 540 | |
| 541 if(!name_cmp(name, "email")) | |
| 542 type = GEN_EMAIL; | |
| 543 else if(!name_cmp(name, "URI")) | |
| 544 type = GEN_URI; | |
| 545 else if(!name_cmp(name, "DNS")) | |
| 546 type = GEN_DNS; | |
| 547 else if(!name_cmp(name, "RID")) | |
| 548 type = GEN_RID; | |
| 549 else if(!name_cmp(name, "IP")) | |
| 550 type = GEN_IPADD; | |
| 551 else if(!name_cmp(name, "dirName")) | |
| 552 type = GEN_DIRNAME; | |
| 553 else if(!name_cmp(name, "otherName")) | |
| 554 type = GEN_OTHERNAME; | |
| 555 else | |
| 556 { | |
| 557 X509V3err(X509V3_F_V2I_GENERAL_NAME_EX,X509V3_R_UNSUPPORTED_OPTI
ON); | |
| 558 ERR_add_error_data(2, "name=", name); | |
| 559 return NULL; | |
| 560 } | |
| 561 | |
| 562 return a2i_GENERAL_NAME(out, method, ctx, type, value, is_nc); | |
| 563 | |
| 564 } | |
| 565 | |
| 566 static int do_othername(GENERAL_NAME *gen, char *value, X509V3_CTX *ctx) | |
| 567 { | |
| 568 char *objtmp = NULL, *p; | |
| 569 int objlen; | |
| 570 if (!(p = strchr(value, ';'))) | |
| 571 return 0; | |
| 572 if (!(gen->d.otherName = OTHERNAME_new())) | |
| 573 return 0; | |
| 574 /* Free this up because we will overwrite it. | |
| 575 * no need to free type_id because it is static | |
| 576 */ | |
| 577 ASN1_TYPE_free(gen->d.otherName->value); | |
| 578 if (!(gen->d.otherName->value = ASN1_generate_v3(p + 1, ctx))) | |
| 579 return 0; | |
| 580 objlen = p - value; | |
| 581 objtmp = OPENSSL_malloc(objlen + 1); | |
| 582 strncpy(objtmp, value, objlen); | |
| 583 objtmp[objlen] = 0; | |
| 584 gen->d.otherName->type_id = OBJ_txt2obj(objtmp, 0); | |
| 585 OPENSSL_free(objtmp); | |
| 586 if (!gen->d.otherName->type_id) | |
| 587 return 0; | |
| 588 return 1; | |
| 589 } | |
| 590 | |
| 591 static int do_dirname(GENERAL_NAME *gen, char *value, X509V3_CTX *ctx) | |
| 592 { | |
| 593 int ret; | |
| 594 STACK_OF(CONF_VALUE) *sk; | |
| 595 X509_NAME *nm; | |
| 596 if (!(nm = X509_NAME_new())) | |
| 597 return 0; | |
| 598 sk = X509V3_get_section(ctx, value); | |
| 599 if (!sk) | |
| 600 { | |
| 601 X509V3err(X509V3_F_DO_DIRNAME,X509V3_R_SECTION_NOT_FOUND); | |
| 602 ERR_add_error_data(2, "section=", value); | |
| 603 X509_NAME_free(nm); | |
| 604 return 0; | |
| 605 } | |
| 606 /* FIXME: should allow other character types... */ | |
| 607 ret = X509V3_NAME_from_section(nm, sk, MBSTRING_ASC); | |
| 608 if (!ret) | |
| 609 X509_NAME_free(nm); | |
| 610 gen->d.dirn = nm; | |
| 611 X509V3_section_free(ctx, sk); | |
| 612 | |
| 613 return ret; | |
| 614 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2072073002:
Delete bundled copy of OpenSSL and replace with README. (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/openssl@master