x509/x509name.c: fix potential crash in X509_NAME_get_text_by_OBJ.
[openssl.git] / crypto / x509 / x509_req.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/bn.h>
13 #include <openssl/evp.h>
14 #include <openssl/asn1.h>
15 #include <openssl/asn1t.h>
16 #include <openssl/x509.h>
17 #include "internal/x509_int.h"
18 #include <openssl/objects.h>
19 #include <openssl/buffer.h>
20 #include <openssl/pem.h>
21
22 X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
23 {
24     X509_REQ *ret;
25     X509_REQ_INFO *ri;
26     int i;
27     EVP_PKEY *pktmp;
28
29     ret = X509_REQ_new();
30     if (ret == NULL) {
31         X509err(X509_F_X509_TO_X509_REQ, ERR_R_MALLOC_FAILURE);
32         goto err;
33     }
34
35     ri = &ret->req_info;
36
37     ri->version->length = 1;
38     ri->version->data = OPENSSL_malloc(1);
39     if (ri->version->data == NULL)
40         goto err;
41     ri->version->data[0] = 0;   /* version == 0 */
42
43     if (!X509_REQ_set_subject_name(ret, X509_get_subject_name(x)))
44         goto err;
45
46     pktmp = X509_get0_pubkey(x);
47     if (pktmp == NULL)
48         goto err;
49     i = X509_REQ_set_pubkey(ret, pktmp);
50     if (!i)
51         goto err;
52
53     if (pkey != NULL) {
54         if (!X509_REQ_sign(ret, pkey, md))
55             goto err;
56     }
57     return ret;
58  err:
59     X509_REQ_free(ret);
60     return NULL;
61 }
62
63 EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req)
64 {
65     if (req == NULL)
66         return NULL;
67     return X509_PUBKEY_get(req->req_info.pubkey);
68 }
69
70 EVP_PKEY *X509_REQ_get0_pubkey(X509_REQ *req)
71 {
72     if (req == NULL)
73         return NULL;
74     return X509_PUBKEY_get0(req->req_info.pubkey);
75 }
76
77 X509_PUBKEY *X509_REQ_get_X509_PUBKEY(X509_REQ *req)
78 {
79     return req->req_info.pubkey;
80 }
81
82 int X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k)
83 {
84     EVP_PKEY *xk = NULL;
85     int ok = 0;
86
87     xk = X509_REQ_get_pubkey(x);
88     switch (EVP_PKEY_cmp(xk, k)) {
89     case 1:
90         ok = 1;
91         break;
92     case 0:
93         X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
94                 X509_R_KEY_VALUES_MISMATCH);
95         break;
96     case -1:
97         X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY, X509_R_KEY_TYPE_MISMATCH);
98         break;
99     case -2:
100 #ifndef OPENSSL_NO_EC
101         if (EVP_PKEY_id(k) == EVP_PKEY_EC) {
102             X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY, ERR_R_EC_LIB);
103             break;
104         }
105 #endif
106 #ifndef OPENSSL_NO_DH
107         if (EVP_PKEY_id(k) == EVP_PKEY_DH) {
108             /* No idea */
109             X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
110                     X509_R_CANT_CHECK_DH_KEY);
111             break;
112         }
113 #endif
114         X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY, X509_R_UNKNOWN_KEY_TYPE);
115     }
116
117     EVP_PKEY_free(xk);
118     return ok;
119 }
120
121 /*
122  * It seems several organisations had the same idea of including a list of
123  * extensions in a certificate request. There are at least two OIDs that are
124  * used and there may be more: so the list is configurable.
125  */
126
127 static int ext_nid_list[] = { NID_ext_req, NID_ms_ext_req, NID_undef };
128
129 static int *ext_nids = ext_nid_list;
130
131 int X509_REQ_extension_nid(int req_nid)
132 {
133     int i, nid;
134     for (i = 0;; i++) {
135         nid = ext_nids[i];
136         if (nid == NID_undef)
137             return 0;
138         else if (req_nid == nid)
139             return 1;
140     }
141 }
142
143 int *X509_REQ_get_extension_nids(void)
144 {
145     return ext_nids;
146 }
147
148 void X509_REQ_set_extension_nids(int *nids)
149 {
150     ext_nids = nids;
151 }
152
153 STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req)
154 {
155     X509_ATTRIBUTE *attr;
156     ASN1_TYPE *ext = NULL;
157     int idx, *pnid;
158     const unsigned char *p;
159
160     if ((req == NULL) || !ext_nids)
161         return NULL;
162     for (pnid = ext_nids; *pnid != NID_undef; pnid++) {
163         idx = X509_REQ_get_attr_by_NID(req, *pnid, -1);
164         if (idx == -1)
165             continue;
166         attr = X509_REQ_get_attr(req, idx);
167         ext = X509_ATTRIBUTE_get0_type(attr, 0);
168         break;
169     }
170     if (!ext || (ext->type != V_ASN1_SEQUENCE))
171         return NULL;
172     p = ext->value.sequence->data;
173     return (STACK_OF(X509_EXTENSION) *)
174         ASN1_item_d2i(NULL, &p, ext->value.sequence->length,
175                       ASN1_ITEM_rptr(X509_EXTENSIONS));
176 }
177
178 /*
179  * Add a STACK_OF extensions to a certificate request: allow alternative OIDs
180  * in case we want to create a non standard one.
181  */
182
183 int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,
184                                 int nid)
185 {
186     int extlen;
187     int rv = 0;
188     unsigned char *ext = NULL;
189     /* Generate encoding of extensions */
190     extlen = ASN1_item_i2d((ASN1_VALUE *)exts, &ext,
191                            ASN1_ITEM_rptr(X509_EXTENSIONS));
192     if (extlen <= 0)
193         return 0;
194     rv = X509_REQ_add1_attr_by_NID(req, nid, V_ASN1_SEQUENCE, ext, extlen);
195     OPENSSL_free(ext);
196     return rv;
197 }
198
199 /* This is the normal usage: use the "official" OID */
200 int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts)
201 {
202     return X509_REQ_add_extensions_nid(req, exts, NID_ext_req);
203 }
204
205 /* Request attribute functions */
206
207 int X509_REQ_get_attr_count(const X509_REQ *req)
208 {
209     return X509at_get_attr_count(req->req_info.attributes);
210 }
211
212 int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos)
213 {
214     return X509at_get_attr_by_NID(req->req_info.attributes, nid, lastpos);
215 }
216
217 int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
218                              int lastpos)
219 {
220     return X509at_get_attr_by_OBJ(req->req_info.attributes, obj, lastpos);
221 }
222
223 X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc)
224 {
225     return X509at_get_attr(req->req_info.attributes, loc);
226 }
227
228 X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc)
229 {
230     return X509at_delete_attr(req->req_info.attributes, loc);
231 }
232
233 int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr)
234 {
235     if (X509at_add1_attr(&req->req_info.attributes, attr))
236         return 1;
237     return 0;
238 }
239
240 int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
241                               const ASN1_OBJECT *obj, int type,
242                               const unsigned char *bytes, int len)
243 {
244     if (X509at_add1_attr_by_OBJ(&req->req_info.attributes, obj,
245                                 type, bytes, len))
246         return 1;
247     return 0;
248 }
249
250 int X509_REQ_add1_attr_by_NID(X509_REQ *req,
251                               int nid, int type,
252                               const unsigned char *bytes, int len)
253 {
254     if (X509at_add1_attr_by_NID(&req->req_info.attributes, nid,
255                                 type, bytes, len))
256         return 1;
257     return 0;
258 }
259
260 int X509_REQ_add1_attr_by_txt(X509_REQ *req,
261                               const char *attrname, int type,
262                               const unsigned char *bytes, int len)
263 {
264     if (X509at_add1_attr_by_txt(&req->req_info.attributes, attrname,
265                                 type, bytes, len))
266         return 1;
267     return 0;
268 }
269
270 long X509_REQ_get_version(const X509_REQ *req)
271 {
272     return ASN1_INTEGER_get(req->req_info.version);
273 }
274
275 X509_NAME *X509_REQ_get_subject_name(const X509_REQ *req)
276 {
277     return req->req_info.subject;
278 }
279
280 void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
281                              const X509_ALGOR **palg)
282 {
283     if (psig != NULL)
284         *psig = req->signature;
285     if (palg != NULL)
286         *palg = &req->sig_alg;
287 }
288
289 int X509_REQ_get_signature_nid(const X509_REQ *req)
290 {
291     return OBJ_obj2nid(req->sig_alg.algorithm);
292 }
293
294 int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp)
295 {
296     req->req_info.enc.modified = 1;
297     return i2d_X509_REQ_INFO(&req->req_info, pp);
298 }