Rename OSSL_CMP_CTX_set1_clCert() to OSSL_CMP_CTX_set1_cert()
[openssl.git] / crypto / cmp / cmp_hdr.c
1 /*
2  * Copyright 2007-2020 The OpenSSL Project Authors. All Rights Reserved.
3  * Copyright Nokia 2007-2019
4  * Copyright Siemens AG 2015-2019
5  *
6  * Licensed under the Apache License 2.0 (the "License").  You may not use
7  * this file except in compliance with the License.  You can obtain a copy
8  * in the file LICENSE in the source distribution or at
9  * https://www.openssl.org/source/license.html
10  */
11
12 /* CMP functions for PKIHeader handling */
13
14 #include "cmp_local.h"
15
16 #include <openssl/rand.h>
17
18 /* explicit #includes not strictly needed since implied by the above: */
19 #include <openssl/asn1t.h>
20 #include <openssl/cmp.h>
21 #include <openssl/err.h>
22
23 DEFINE_STACK_OF(ASN1_UTF8STRING)
24 DEFINE_STACK_OF(OSSL_CMP_ITAV)
25
26 int ossl_cmp_hdr_set_pvno(OSSL_CMP_PKIHEADER *hdr, int pvno)
27 {
28     if (!ossl_assert(hdr != NULL))
29         return 0;
30     return ASN1_INTEGER_set(hdr->pvno, pvno);
31 }
32
33 int ossl_cmp_hdr_get_pvno(const OSSL_CMP_PKIHEADER *hdr)
34 {
35     int64_t pvno;
36
37     if (!ossl_assert(hdr != NULL))
38         return -1;
39     if (!ASN1_INTEGER_get_int64(&pvno, hdr->pvno) || pvno < 0 || pvno > INT_MAX)
40         return -1;
41     return (int)pvno;
42 }
43
44 ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_transactionID(const
45                                                    OSSL_CMP_PKIHEADER *hdr)
46 {
47     if (hdr == NULL) {
48         CMPerr(0, CMP_R_NULL_ARGUMENT);
49         return NULL;
50     }
51     return hdr->transactionID;
52 }
53
54 ASN1_OCTET_STRING *ossl_cmp_hdr_get0_senderNonce(const OSSL_CMP_PKIHEADER *hdr)
55 {
56     if (!ossl_assert(hdr != NULL))
57         return NULL;
58     return hdr->senderNonce;
59 }
60
61 ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_recipNonce(const OSSL_CMP_PKIHEADER *hdr)
62 {
63     if (hdr == NULL) {
64         CMPerr(0, CMP_R_NULL_ARGUMENT);
65         return NULL;
66     }
67     return hdr->recipNonce;
68 }
69
70 int ossl_cmp_general_name_is_NULL_DN(GENERAL_NAME *name)
71 {
72     X509_NAME *null = X509_NAME_new();
73     int res = name == NULL || null == NULL
74         || (name->type == GEN_DIRNAME
75                 && X509_NAME_cmp(name->d.directoryName, null) == 0);
76
77     X509_NAME_free(null);
78     return res;
79 }
80
81 /* assign to *tgt a copy of src (which may be NULL to indicate an empty DN) */
82 static int set1_general_name(GENERAL_NAME **tgt, const X509_NAME *src)
83 {
84     GENERAL_NAME *name;
85
86     if (!ossl_assert(tgt != NULL))
87         return 0;
88     if ((name = GENERAL_NAME_new()) == NULL)
89         goto err;
90     name->type = GEN_DIRNAME;
91
92     if (src == NULL) { /* NULL-DN */
93         if ((name->d.directoryName = X509_NAME_new()) == NULL)
94             goto err;
95     } else if (!X509_NAME_set(&name->d.directoryName, src)) {
96         goto err;
97     }
98
99     GENERAL_NAME_free(*tgt);
100     *tgt = name;
101
102     return 1;
103
104  err:
105     GENERAL_NAME_free(name);
106     return 0;
107 }
108
109 /*
110  * Set the sender name in PKIHeader.
111  * when nm is NULL, sender is set to an empty string
112  * returns 1 on success, 0 on error
113  */
114 int ossl_cmp_hdr_set1_sender(OSSL_CMP_PKIHEADER *hdr, const X509_NAME *nm)
115 {
116     if (!ossl_assert(hdr != NULL))
117         return 0;
118     return set1_general_name(&hdr->sender, nm);
119 }
120
121 int ossl_cmp_hdr_set1_recipient(OSSL_CMP_PKIHEADER *hdr, const X509_NAME *nm)
122 {
123     if (!ossl_assert(hdr != NULL))
124         return 0;
125     return set1_general_name(&hdr->recipient, nm);
126 }
127
128 int ossl_cmp_hdr_update_messageTime(OSSL_CMP_PKIHEADER *hdr)
129 {
130     if (!ossl_assert(hdr != NULL))
131         return 0;
132     if (hdr->messageTime == NULL
133             && (hdr->messageTime = ASN1_GENERALIZEDTIME_new()) == NULL)
134         return 0;
135     return ASN1_GENERALIZEDTIME_set(hdr->messageTime, time(NULL)) != NULL;
136 }
137
138 /* assign to *tgt a copy of src (or if NULL a random byte array of given len) */
139 static int set1_aostr_else_random(ASN1_OCTET_STRING **tgt,
140                                   const ASN1_OCTET_STRING *src, size_t len)
141 {
142     unsigned char *bytes = NULL;
143     int res = 0;
144
145     if (src == NULL) { /* generate a random value if src == NULL */
146         if ((bytes = OPENSSL_malloc(len)) == NULL)
147             goto err;
148         if (RAND_bytes(bytes, len) <= 0) {
149             CMPerr(0, CMP_R_FAILURE_OBTAINING_RANDOM);
150             goto err;
151         }
152         res = ossl_cmp_asn1_octet_string_set1_bytes(tgt, bytes, len);
153     } else {
154         res = ossl_cmp_asn1_octet_string_set1(tgt, src);
155     }
156
157  err:
158     OPENSSL_free(bytes);
159     return res;
160 }
161
162 int ossl_cmp_hdr_set1_senderKID(OSSL_CMP_PKIHEADER *hdr,
163                                 const ASN1_OCTET_STRING *senderKID)
164 {
165     if (!ossl_assert(hdr != NULL))
166         return 0;
167     return ossl_cmp_asn1_octet_string_set1(&hdr->senderKID, senderKID);
168 }
169
170 /* push the given text string to the given PKIFREETEXT ft */
171 int ossl_cmp_hdr_push0_freeText(OSSL_CMP_PKIHEADER *hdr, ASN1_UTF8STRING *text)
172 {
173     if (!ossl_assert(hdr != NULL && text != NULL))
174         return 0;
175
176     if (hdr->freeText == NULL
177             && (hdr->freeText = sk_ASN1_UTF8STRING_new_null()) == NULL)
178         return 0;
179
180     return sk_ASN1_UTF8STRING_push(hdr->freeText, text);
181 }
182
183 int ossl_cmp_hdr_push1_freeText(OSSL_CMP_PKIHEADER *hdr, ASN1_UTF8STRING *text)
184 {
185     if (!ossl_assert(hdr != NULL && text != NULL))
186         return 0;
187
188     if (hdr->freeText == NULL
189             && (hdr->freeText = sk_ASN1_UTF8STRING_new_null()) == NULL)
190         return 0;
191
192     return
193         ossl_cmp_sk_ASN1_UTF8STRING_push_str(hdr->freeText, (char *)text->data);
194 }
195
196 int ossl_cmp_hdr_generalInfo_push0_item(OSSL_CMP_PKIHEADER *hdr,
197                                         OSSL_CMP_ITAV *itav)
198 {
199     if (!ossl_assert(hdr != NULL && itav != NULL))
200         return 0;
201     return OSSL_CMP_ITAV_push0_stack_item(&hdr->generalInfo, itav);
202 }
203
204 int ossl_cmp_hdr_generalInfo_push1_items(OSSL_CMP_PKIHEADER *hdr,
205                                          const STACK_OF(OSSL_CMP_ITAV) *itavs)
206 {
207     int i;
208     OSSL_CMP_ITAV *itav;
209
210     if (!ossl_assert(hdr != NULL))
211         return 0;
212
213     for (i = 0; i < sk_OSSL_CMP_ITAV_num(itavs); i++) {
214         itav = OSSL_CMP_ITAV_dup(sk_OSSL_CMP_ITAV_value(itavs, i));
215         if (itav == NULL)
216             return 0;
217
218         if (!ossl_cmp_hdr_generalInfo_push0_item(hdr, itav)) {
219             OSSL_CMP_ITAV_free(itav);
220             return 0;
221         }
222     }
223     return 1;
224 }
225
226 int ossl_cmp_hdr_set_implicitConfirm(OSSL_CMP_PKIHEADER *hdr)
227 {
228     OSSL_CMP_ITAV *itav;
229     ASN1_TYPE *asn1null;
230
231     if (!ossl_assert(hdr != NULL))
232         return 0;
233     asn1null = (ASN1_TYPE *)ASN1_NULL_new();
234     if (asn1null == NULL)
235         return 0;
236     if ((itav = OSSL_CMP_ITAV_create(OBJ_nid2obj(NID_id_it_implicitConfirm),
237                                      asn1null)) == NULL)
238         goto err;
239     if (!ossl_cmp_hdr_generalInfo_push0_item(hdr, itav))
240         goto err;
241     return 1;
242
243  err:
244     ASN1_TYPE_free(asn1null);
245     OSSL_CMP_ITAV_free(itav);
246     return 0;
247 }
248
249 /* return 1 if implicitConfirm in the generalInfo field of the header is set */
250 int ossl_cmp_hdr_has_implicitConfirm(const OSSL_CMP_PKIHEADER *hdr)
251 {
252     int itavCount;
253     int i;
254     OSSL_CMP_ITAV *itav;
255
256     if (!ossl_assert(hdr != NULL))
257         return 0;
258
259     itavCount = sk_OSSL_CMP_ITAV_num(hdr->generalInfo);
260     for (i = 0; i < itavCount; i++) {
261         itav = sk_OSSL_CMP_ITAV_value(hdr->generalInfo, i);
262         if (itav != NULL
263                 && OBJ_obj2nid(itav->infoType) == NID_id_it_implicitConfirm)
264             return 1;
265     }
266
267     return 0;
268 }
269
270 /*
271  * set ctx->transactionID in CMP header
272  * if ctx->transactionID is NULL, a random one is created with 128 bit
273  * according to section 5.1.1:
274  *
275  * It is RECOMMENDED that the clients fill the transactionID field with
276  * 128 bits of (pseudo-) random data for the start of a transaction to
277  * reduce the probability of having the transactionID in use at the server.
278  */
279 int ossl_cmp_hdr_set_transactionID(OSSL_CMP_CTX *ctx, OSSL_CMP_PKIHEADER *hdr)
280 {
281     if (ctx->transactionID == NULL
282             && !set1_aostr_else_random(&ctx->transactionID, NULL,
283                                        OSSL_CMP_TRANSACTIONID_LENGTH))
284         return 0;
285     return ossl_cmp_asn1_octet_string_set1(&hdr->transactionID,
286                                            ctx->transactionID);
287 }
288
289 /* fill in all fields of the hdr according to the info given in ctx */
290 int ossl_cmp_hdr_init(OSSL_CMP_CTX *ctx, OSSL_CMP_PKIHEADER *hdr)
291 {
292     const X509_NAME *sender;
293     const X509_NAME *rcp = NULL;
294
295     if (!ossl_assert(ctx != NULL && hdr != NULL))
296         return 0;
297
298     /* set the CMP version */
299     if (!ossl_cmp_hdr_set_pvno(hdr, OSSL_CMP_PVNO))
300         return 0;
301
302     /*
303      * The sender name is copied from the subject of the client cert, if any,
304      * or else from the subject name provided for certification requests.
305      */
306     sender = ctx->cert != NULL ?
307         X509_get_subject_name(ctx->cert) : ctx->subjectName;
308     if (!ossl_cmp_hdr_set1_sender(hdr, sender))
309         return 0;
310
311     /* determine recipient entry in PKIHeader */
312     if (ctx->srvCert != NULL) {
313         rcp = X509_get_subject_name(ctx->srvCert);
314         /* set also as expected_sender of responses unless set explicitly */
315         if (ctx->expected_sender == NULL && rcp != NULL
316                 && !OSSL_CMP_CTX_set1_expected_sender(ctx, rcp))
317             return 0;
318     } else if (ctx->recipient != NULL) {
319         rcp = ctx->recipient;
320     } else if (ctx->issuer != NULL) {
321         rcp = ctx->issuer;
322     } else if (ctx->oldCert != NULL) {
323         rcp = X509_get_issuer_name(ctx->oldCert);
324     } else if (ctx->cert != NULL) {
325         rcp = X509_get_issuer_name(ctx->cert);
326     }
327     if (!ossl_cmp_hdr_set1_recipient(hdr, rcp))
328         return 0;
329
330     /* set current time as message time */
331     if (!ossl_cmp_hdr_update_messageTime(hdr))
332         return 0;
333
334     if (ctx->recipNonce != NULL
335             && !ossl_cmp_asn1_octet_string_set1(&hdr->recipNonce,
336                                                 ctx->recipNonce))
337         return 0;
338
339     if (!ossl_cmp_hdr_set_transactionID(ctx, hdr))
340         return 0;
341
342     /*-
343      * set random senderNonce
344      * according to section 5.1.1:
345      *
346      * senderNonce                  present
347      *         -- 128 (pseudo-)random bits
348      * The senderNonce and recipNonce fields protect the PKIMessage against
349      * replay attacks. The senderNonce will typically be 128 bits of
350      * (pseudo-) random data generated by the sender, whereas the recipNonce
351      * is copied from the senderNonce of the previous message in the
352      * transaction.
353      */
354     if (!set1_aostr_else_random(&hdr->senderNonce, NULL,
355                                 OSSL_CMP_SENDERNONCE_LENGTH))
356         return 0;
357
358     /* store senderNonce - for cmp with recipNonce in next outgoing msg */
359     if (!OSSL_CMP_CTX_set1_senderNonce(ctx, hdr->senderNonce))
360         return 0;
361
362     /*-
363      * freeText                [7] PKIFreeText OPTIONAL,
364      * -- this may be used to indicate context-specific instructions
365      * -- (this field is intended for human consumption)
366      */
367     if (ctx->freeText != NULL
368             && !ossl_cmp_hdr_push1_freeText(hdr, ctx->freeText))
369         return 0;
370
371     return 1;
372 }