crypto/libressl/crypto/x509/x509_req.c

   1 /* $OpenBSD: x509_req.c,v 1.17 2015/03/15 22:52:17 doug Exp $ */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60
  61 #include <openssl/opensslconf.h>
  62
  63 #include <openssl/asn1.h>
  64 #include <openssl/asn1t.h>
  65 #include <openssl/bn.h>
  66 #include <openssl/buffer.h>
  67 #include <openssl/err.h>
  68 #include <openssl/evp.h>
  69 #include <openssl/objects.h>
  70 #include <openssl/pem.h>
  71 #include <openssl/x509.h>
  72
  73 X509_REQ *
  74 X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
  75 {
  76         X509_REQ *ret;
  77         X509_REQ_INFO *ri;
  78         int i;
  79         EVP_PKEY *pktmp;
  80
  81         ret = X509_REQ_new();
  82         if (ret == NULL) {
  83                 X509err(X509_F_X509_TO_X509_REQ, ERR_R_MALLOC_FAILURE);
  84                 goto err;
  85         }
  86
  87         ri = ret->req_info;
  88
  89         if ((ri->version = ASN1_INTEGER_new()) == NULL)
  90                 goto err;
  91         if (ASN1_INTEGER_set(ri->version, 0) == 0)
  92                 goto err;
  93
  94         if (!X509_REQ_set_subject_name(ret, X509_get_subject_name(x)))
  95                 goto err;
  96
  97         if ((pktmp = X509_get_pubkey(x)) == NULL)
  98                 goto err;
  99
 100         i = X509_REQ_set_pubkey(ret, pktmp);
 101         EVP_PKEY_free(pktmp);
 102         if (!i)
 103                 goto err;
 104
 105         if (pkey != NULL) {
 106                 if (!X509_REQ_sign(ret, pkey, md))
 107                         goto err;
 108         }
 109         return (ret);
 110
 111 err:
 112         X509_REQ_free(ret);
 113         return (NULL);
 114 }
 115
 116 EVP_PKEY *
 117 X509_REQ_get_pubkey(X509_REQ *req)
 118 {
 119         if ((req == NULL) || (req->req_info == NULL))
 120                 return (NULL);
 121         return (X509_PUBKEY_get(req->req_info->pubkey));
 122 }
 123
 124 int
 125 X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k)
 126 {
 127         EVP_PKEY *xk = NULL;
 128         int ok = 0;
 129
 130         xk = X509_REQ_get_pubkey(x);
 131         switch (EVP_PKEY_cmp(xk, k)) {
 132         case 1:
 133                 ok = 1;
 134                 break;
 135         case 0:
 136                 X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
 137                     X509_R_KEY_VALUES_MISMATCH);
 138                 break;
 139         case -1:
 140                 X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
 141                     X509_R_KEY_TYPE_MISMATCH);
 142                 break;
 143         case -2:
 144 #ifndef OPENSSL_NO_EC
 145                 if (k->type == EVP_PKEY_EC) {
 146                         X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
 147                             ERR_R_EC_LIB);
 148                         break;
 149                 }
 150 #endif
 151 #ifndef OPENSSL_NO_DH
 152                 if (k->type == EVP_PKEY_DH) {
 153                         /* No idea */
 154                         X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
 155                             X509_R_CANT_CHECK_DH_KEY);
 156                         break;
 157                 }
 158 #endif
 159                 X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
 160                     X509_R_UNKNOWN_KEY_TYPE);
 161         }
 162
 163         EVP_PKEY_free(xk);
 164         return (ok);
 165 }
 166
 167 /* It seems several organisations had the same idea of including a list of
 168  * extensions in a certificate request. There are at least two OIDs that are
 169  * used and there may be more: so the list is configurable.
 170  */
 171
 172 static int ext_nid_list[] = {NID_ext_req, NID_ms_ext_req, NID_undef};
 173
 174 static int *ext_nids = ext_nid_list;
 175
 176 int
 177 X509_REQ_extension_nid(int req_nid)
 178 {
 179         int i, nid;
 180
 181         for (i = 0; ; i++) {
 182                 nid = ext_nids[i];
 183                 if (nid == NID_undef)
 184                         return 0;
 185                 else if (req_nid == nid)
 186                         return 1;
 187         }
 188 }
 189
 190 int *
 191 X509_REQ_get_extension_nids(void)
 192 {
 193         return ext_nids;
 194 }
 195
 196 void
 197 X509_REQ_set_extension_nids(int *nids)
 198 {
 199         ext_nids = nids;
 200 }
 201
 202 STACK_OF(X509_EXTENSION) *
 203 X509_REQ_get_extensions(X509_REQ *req)
 204 {
 205         X509_ATTRIBUTE *attr;
 206         ASN1_TYPE *ext = NULL;
 207         int idx, *pnid;
 208         const unsigned char *p;
 209
 210         if ((req == NULL) || (req->req_info == NULL) || !ext_nids)
 211                 return (NULL);
 212         for (pnid = ext_nids; *pnid != NID_undef; pnid++) {
 213                 idx = X509_REQ_get_attr_by_NID(req, *pnid, -1);
 214                 if (idx == -1)
 215                         continue;
 216                 attr = X509_REQ_get_attr(req, idx);
 217                 if (attr->single)
 218                         ext = attr->value.single;
 219                 else if (sk_ASN1_TYPE_num(attr->value.set))
 220                         ext = sk_ASN1_TYPE_value(attr->value.set, 0);
 221                 break;
 222         }
 223         if (!ext || (ext->type != V_ASN1_SEQUENCE))
 224                 return NULL;
 225         p = ext->value.sequence->data;
 226         return (STACK_OF(X509_EXTENSION) *)ASN1_item_d2i(NULL, &p,
 227             ext->value.sequence->length, ASN1_ITEM_rptr(X509_EXTENSIONS));
 228 }
 229
 230 /* Add a STACK_OF extensions to a certificate request: allow alternative OIDs
 231  * in case we want to create a non standard one.
 232  */
 233
 234 int
 235 X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,
 236     int nid)
 237 {
 238         ASN1_TYPE *at = NULL;
 239         X509_ATTRIBUTE *attr = NULL;
 240
 241         if (!(at = ASN1_TYPE_new()) ||
 242             !(at->value.sequence = ASN1_STRING_new()))
 243                 goto err;
 244
 245         at->type = V_ASN1_SEQUENCE;
 246         /* Generate encoding of extensions */
 247         at->value.sequence->length = ASN1_item_i2d((ASN1_VALUE *)exts,
 248             &at->value.sequence->data, ASN1_ITEM_rptr(X509_EXTENSIONS));
 249         if (!(attr = X509_ATTRIBUTE_new()))
 250                 goto err;
 251         if (!(attr->value.set = sk_ASN1_TYPE_new_null()))
 252                 goto err;
 253         if (!sk_ASN1_TYPE_push(attr->value.set, at))
 254                 goto err;
 255         at = NULL;
 256         attr->single = 0;
 257         attr->object = OBJ_nid2obj(nid);
 258         if (!req->req_info->attributes) {
 259                 if (!(req->req_info->attributes = sk_X509_ATTRIBUTE_new_null()))
 260                         goto err;
 261         }
 262         if (!sk_X509_ATTRIBUTE_push(req->req_info->attributes, attr))
 263                 goto err;
 264         return 1;
 265
 266 err:
 267         X509_ATTRIBUTE_free(attr);
 268         ASN1_TYPE_free(at);
 269         return 0;
 270 }
 271
 272 /* This is the normal usage: use the "official" OID */
 273 int
 274 X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts)
 275 {
 276         return X509_REQ_add_extensions_nid(req, exts, NID_ext_req);
 277 }
 278
 279 /* Request attribute functions */
 280
 281 int
 282 X509_REQ_get_attr_count(const X509_REQ *req)
 283 {
 284         return X509at_get_attr_count(req->req_info->attributes);
 285 }
 286
 287 int
 288 X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos)
 289 {
 290         return X509at_get_attr_by_NID(req->req_info->attributes, nid, lastpos);
 291 }
 292
 293 int
 294 X509_REQ_get_attr_by_OBJ(const X509_REQ *req, ASN1_OBJECT *obj, int lastpos)
 295 {
 296         return X509at_get_attr_by_OBJ(req->req_info->attributes, obj, lastpos);
 297 }
 298
 299 X509_ATTRIBUTE *
 300 X509_REQ_get_attr(const X509_REQ *req, int loc)
 301 {
 302         return X509at_get_attr(req->req_info->attributes, loc);
 303 }
 304
 305 X509_ATTRIBUTE *
 306 X509_REQ_delete_attr(X509_REQ *req, int loc)
 307 {
 308         return X509at_delete_attr(req->req_info->attributes, loc);
 309 }
 310
 311 int
 312 X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr)
 313 {
 314         if (X509at_add1_attr(&req->req_info->attributes, attr))
 315                 return 1;
 316         return 0;
 317 }
 318
 319 int
 320 X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int type,
 321     const unsigned char *bytes, int len)
 322 {
 323         if (X509at_add1_attr_by_OBJ(&req->req_info->attributes, obj,
 324             type, bytes, len))
 325                 return 1;
 326         return 0;
 327 }
 328
 329 int
 330 X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int type,
 331     const unsigned char *bytes, int len)
 332 {
 333         if (X509at_add1_attr_by_NID(&req->req_info->attributes, nid,
 334             type, bytes, len))
 335                 return 1;
 336         return 0;
 337 }
 338
 339 int
 340 X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int type,
 341     const unsigned char *bytes, int len)
 342 {
 343         if (X509at_add1_attr_by_txt(&req->req_info->attributes, attrname,
 344             type, bytes, len))
 345                 return 1;
 346         return 0;
 347 }