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