eb799b103c2dc79f0e5eaf36f3c90d2888c24900
[openssl.git] / crypto / cmp / cmp_ctx.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 #include <openssl/trace.h>
13 #include <openssl/bio.h>
14 #include <openssl/ocsp.h> /* for OCSP_REVOKED_STATUS_* */
15
16 #include "cmp_local.h"
17
18 /* explicit #includes not strictly needed since implied by the above: */
19 #include <openssl/cmp.h>
20 #include <openssl/crmf.h>
21 #include <openssl/err.h>
22
23 /* Get current certificate store containing trusted root CA certs */
24 X509_STORE *OSSL_CMP_CTX_get0_trustedStore(const OSSL_CMP_CTX *ctx)
25 {
26     if (ctx == NULL) {
27         CMPerr(0, CMP_R_NULL_ARGUMENT);
28         return NULL;
29     }
30     return ctx->trusted;
31 }
32
33 /*
34  * Set certificate store containing trusted (root) CA certs and possibly CRLs
35  * and a cert verification callback function used for CMP server authentication.
36  * Any already existing store entry is freed. Given NULL, the entry is reset.
37  */
38 int OSSL_CMP_CTX_set0_trustedStore(OSSL_CMP_CTX *ctx, X509_STORE *store)
39 {
40     if (ctx == NULL) {
41         CMPerr(0, CMP_R_NULL_ARGUMENT);
42         return 0;
43     }
44     X509_STORE_free(ctx->trusted);
45     ctx->trusted = store;
46     return 1;
47 }
48
49 /* Get current list of non-trusted intermediate certs */
50 STACK_OF(X509) *OSSL_CMP_CTX_get0_untrusted_certs(const OSSL_CMP_CTX *ctx)
51 {
52     if (ctx == NULL) {
53         CMPerr(0, CMP_R_NULL_ARGUMENT);
54         return NULL;
55     }
56     return ctx->untrusted_certs;
57 }
58
59 /*
60  * Set untrusted certificates for path construction in authentication of
61  * the CMP server and potentially others (TLS server, newly enrolled cert).
62  */
63 int OSSL_CMP_CTX_set1_untrusted_certs(OSSL_CMP_CTX *ctx, STACK_OF(X509) *certs)
64 {
65     STACK_OF(X509) *untrusted_certs;
66     if (ctx == NULL) {
67         CMPerr(0, CMP_R_NULL_ARGUMENT);
68         return 0;
69     }
70     if ((untrusted_certs = sk_X509_new_null()) == NULL)
71         return 0;
72     if (ossl_cmp_sk_X509_add1_certs(untrusted_certs, certs, 0, 1, 0) != 1)
73         goto err;
74     sk_X509_pop_free(ctx->untrusted_certs, X509_free);
75     ctx->untrusted_certs = untrusted_certs;
76     return 1;
77  err:
78     sk_X509_pop_free(untrusted_certs, X509_free);
79     return 0;
80 }
81
82 /*
83  * Allocates and initializes OSSL_CMP_CTX context structure with default values.
84  * Returns new context on success, NULL on error
85  */
86 OSSL_CMP_CTX *OSSL_CMP_CTX_new(void)
87 {
88     OSSL_CMP_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
89
90     if (ctx == NULL)
91         return NULL;
92
93     ctx->log_verbosity = OSSL_CMP_LOG_INFO;
94
95     ctx->status = -1;
96     ctx->failInfoCode = -1;
97
98     ctx->serverPort = OSSL_CMP_DEFAULT_PORT;
99     ctx->msg_timeout = 2 * 60;
100
101     if ((ctx->untrusted_certs = sk_X509_new_null()) == NULL)
102         goto err;
103
104     ctx->pbm_slen = 16;
105     ctx->pbm_owf = NID_sha256;
106     ctx->pbm_itercnt = 500;
107     ctx->pbm_mac = NID_hmac_sha1;
108
109     ctx->digest = NID_sha256;
110     ctx->popoMethod = OSSL_CRMF_POPO_SIGNATURE;
111     ctx->revocationReason = CRL_REASON_NONE;
112
113     /* all other elements are initialized to 0 or NULL, respectively */
114     return ctx;
115
116  err:
117     OSSL_CMP_CTX_free(ctx);
118     return NULL;
119 }
120
121 /* Prepare the OSSL_CMP_CTX for next use, partly re-initializing OSSL_CMP_CTX */
122 int OSSL_CMP_CTX_reinit(OSSL_CMP_CTX *ctx)
123 {
124     if (ctx == NULL) {
125         CMPerr(0, CMP_R_NULL_ARGUMENT);
126         return 0;
127     }
128
129     ctx->status = -1;
130     ctx->failInfoCode = -1;
131
132     return ossl_cmp_ctx_set0_statusString(ctx, NULL)
133         && ossl_cmp_ctx_set0_newCert(ctx, NULL)
134         && ossl_cmp_ctx_set1_caPubs(ctx, NULL)
135         && ossl_cmp_ctx_set1_extraCertsIn(ctx, NULL)
136         && ossl_cmp_ctx_set0_validatedSrvCert(ctx, NULL)
137         && OSSL_CMP_CTX_set1_transactionID(ctx, NULL)
138         && OSSL_CMP_CTX_set1_senderNonce(ctx, NULL)
139         && ossl_cmp_ctx_set1_recipNonce(ctx, NULL);
140 }
141
142 /* Frees OSSL_CMP_CTX variables allocated in OSSL_CMP_CTX_new() */
143 void OSSL_CMP_CTX_free(OSSL_CMP_CTX *ctx)
144 {
145     if (ctx == NULL)
146         return;
147
148     OPENSSL_free(ctx->serverPath);
149     OPENSSL_free(ctx->serverName);
150     OPENSSL_free(ctx->proxy);
151     OPENSSL_free(ctx->no_proxy);
152
153     X509_free(ctx->srvCert);
154     X509_free(ctx->validatedSrvCert);
155     X509_NAME_free(ctx->expected_sender);
156     X509_STORE_free(ctx->trusted);
157     sk_X509_pop_free(ctx->untrusted_certs, X509_free);
158
159     X509_free(ctx->clCert);
160     EVP_PKEY_free(ctx->pkey);
161     ASN1_OCTET_STRING_free(ctx->referenceValue);
162     if (ctx->secretValue != NULL)
163         OPENSSL_cleanse(ctx->secretValue->data, ctx->secretValue->length);
164     ASN1_OCTET_STRING_free(ctx->secretValue);
165
166     X509_NAME_free(ctx->recipient);
167     ASN1_OCTET_STRING_free(ctx->transactionID);
168     ASN1_OCTET_STRING_free(ctx->senderNonce);
169     ASN1_OCTET_STRING_free(ctx->recipNonce);
170     sk_OSSL_CMP_ITAV_pop_free(ctx->geninfo_ITAVs, OSSL_CMP_ITAV_free);
171     sk_X509_pop_free(ctx->extraCertsOut, X509_free);
172
173     EVP_PKEY_free(ctx->newPkey);
174     X509_NAME_free(ctx->issuer);
175     X509_NAME_free(ctx->subjectName);
176     sk_GENERAL_NAME_pop_free(ctx->subjectAltNames, GENERAL_NAME_free);
177     sk_X509_EXTENSION_pop_free(ctx->reqExtensions, X509_EXTENSION_free);
178     sk_POLICYINFO_pop_free(ctx->policies, POLICYINFO_free);
179     X509_free(ctx->oldCert);
180     X509_REQ_free(ctx->p10CSR);
181
182     sk_OSSL_CMP_ITAV_pop_free(ctx->genm_ITAVs, OSSL_CMP_ITAV_free);
183
184     sk_ASN1_UTF8STRING_pop_free(ctx->statusString, ASN1_UTF8STRING_free);
185     X509_free(ctx->newCert);
186     sk_X509_pop_free(ctx->caPubs, X509_free);
187     sk_X509_pop_free(ctx->extraCertsIn, X509_free);
188
189     OPENSSL_free(ctx);
190 }
191
192 int ossl_cmp_ctx_set_status(OSSL_CMP_CTX *ctx, int status)
193 {
194     if (!ossl_assert(ctx != NULL))
195         return 0;
196     ctx->status = status;
197     return 1;
198 }
199
200 /*
201  * Returns the PKIStatus from the last CertRepMessage
202  * or Revocation Response or error message, -1 on error
203  */
204 int OSSL_CMP_CTX_get_status(const OSSL_CMP_CTX *ctx)
205 {
206     if (ctx == NULL) {
207         CMPerr(0, CMP_R_NULL_ARGUMENT);
208         return -1;
209     }
210     return ctx->status;
211 }
212
213 /*
214  * Returns the statusString from the last CertRepMessage
215  * or Revocation Response or error message, NULL on error
216  */
217 OSSL_CMP_PKIFREETEXT *OSSL_CMP_CTX_get0_statusString(const OSSL_CMP_CTX *ctx)
218 {
219     if (ctx == NULL) {
220         CMPerr(0, CMP_R_NULL_ARGUMENT);
221         return NULL;
222     }
223     return ctx->statusString;
224 }
225
226 int ossl_cmp_ctx_set0_statusString(OSSL_CMP_CTX *ctx,
227                                    OSSL_CMP_PKIFREETEXT *text)
228 {
229     if (!ossl_assert(ctx != NULL))
230         return 0;
231     sk_ASN1_UTF8STRING_pop_free(ctx->statusString, ASN1_UTF8STRING_free);
232     ctx->statusString = text;
233     return 1;
234 }
235
236 int ossl_cmp_ctx_set0_validatedSrvCert(OSSL_CMP_CTX *ctx, X509 *cert)
237 {
238     if (!ossl_assert(ctx != NULL))
239         return 0;
240     X509_free(ctx->validatedSrvCert);
241     ctx->validatedSrvCert = cert;
242     return 1;
243 }
244
245 /* Set callback function for checking if the cert is ok or should be rejected */
246 int OSSL_CMP_CTX_set_certConf_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_certConf_cb_t cb)
247 {
248     if (ctx == NULL) {
249         CMPerr(0, CMP_R_NULL_ARGUMENT);
250         return 0;
251     }
252     ctx->certConf_cb = cb;
253     return 1;
254 }
255
256 /*
257  * Set argument, respectively a pointer to a structure containing arguments,
258  * optionally to be used by the certConf callback.
259  */
260 int OSSL_CMP_CTX_set_certConf_cb_arg(OSSL_CMP_CTX *ctx, void *arg)
261 {
262     if (ctx == NULL) {
263         CMPerr(0, CMP_R_NULL_ARGUMENT);
264         return 0;
265     }
266     ctx->certConf_cb_arg = arg;
267     return 1;
268 }
269
270 /*
271  * Get argument, respectively the pointer to a structure containing arguments,
272  * optionally to be used by certConf callback.
273  * Returns callback argument set previously (NULL if not set or on error)
274  */
275 void *OSSL_CMP_CTX_get_certConf_cb_arg(const OSSL_CMP_CTX *ctx)
276 {
277     if (ctx == NULL) {
278         CMPerr(0, CMP_R_NULL_ARGUMENT);
279         return NULL;
280     }
281     return ctx->certConf_cb_arg;
282 }
283
284 #ifndef OPENSSL_NO_TRACE
285 static size_t ossl_cmp_log_trace_cb(const char *buf, size_t cnt,
286                                     int category, int cmd, void *vdata)
287 {
288     OSSL_CMP_CTX *ctx = vdata;
289     const char *msg;
290     OSSL_CMP_severity level = -1;
291     char *func = NULL;
292     char *file = NULL;
293     int line = 0;
294
295     if (buf == NULL || cnt == 0 || cmd != OSSL_TRACE_CTRL_WRITE || ctx == NULL)
296         return 0;
297     if (ctx->log_cb == NULL)
298         return 1; /* silently drop message */
299
300     msg = ossl_cmp_log_parse_metadata(buf, &level, &func, &file, &line);
301
302     if (level > ctx->log_verbosity) /* excludes the case level is unknown */
303         goto end; /* suppress output since severity is not sufficient */
304
305     if (!ctx->log_cb(func != NULL ? func : "(no func)",
306                      file != NULL ? file : "(no file)",
307                      line, level, msg))
308         cnt = 0;
309
310  end:
311     OPENSSL_free(func);
312     OPENSSL_free(file);
313     return cnt;
314 }
315 #endif
316
317 /* Print CMP log messages (i.e., diagnostic info) via the log cb of the ctx */
318 int ossl_cmp_print_log(OSSL_CMP_severity level, const OSSL_CMP_CTX *ctx,
319                        const char *func, const char *file, int line,
320                        const char *level_str, const char *format, ...)
321 {
322     va_list args;
323     char hugebuf[1024 * 2];
324     int res = 0;
325
326     if (ctx == NULL || ctx->log_cb == NULL)
327         return 1; /* silently drop message */
328
329     if (level > ctx->log_verbosity) /* excludes the case level is unknown */
330         return 1; /* suppress output since severity is not sufficient */
331
332     if (format == NULL)
333         return 0;
334
335     va_start(args, format);
336
337     if (func == NULL)
338         func = "(unset function name)";
339     if (file == NULL)
340         file = "(unset file name)";
341     if (level_str == NULL)
342         level_str = "(unset level string)";
343
344 #ifndef OPENSSL_NO_TRACE
345     if (OSSL_TRACE_ENABLED(CMP)) {
346         OSSL_TRACE_BEGIN(CMP) {
347             int printed =
348                 BIO_snprintf(hugebuf, sizeof(hugebuf),
349                              "%s:%s:%d:" OSSL_CMP_LOG_PREFIX "%s: ",
350                              func, file, line, level_str);
351             if (printed > 0 && (size_t)printed < sizeof(hugebuf)) {
352                 if (BIO_vsnprintf(hugebuf + printed,
353                                   sizeof(hugebuf) - printed, format, args) > 0)
354                     res = BIO_puts(trc_out, hugebuf) > 0;
355             }
356         } OSSL_TRACE_END(CMP);
357     }
358 #else /* compensate for disabled trace API */
359     {
360         if (BIO_vsnprintf(hugebuf, sizeof(hugebuf), format, args) > 0)
361             res = ctx->log_cb(func, file, line, level, hugebuf);
362     }
363 #endif
364     va_end(args);
365     return res;
366 }
367
368 /* Set a callback function for error reporting and logging messages */
369 int OSSL_CMP_CTX_set_log_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_log_cb_t cb)
370 {
371     if (ctx == NULL) {
372         CMPerr(0, CMP_R_NULL_ARGUMENT);
373         return 0;
374     }
375     ctx->log_cb = cb;
376
377 #ifndef OPENSSL_NO_TRACE
378     /* do also in case cb == NULL, to switch off logging output: */
379     if (!OSSL_trace_set_callback(OSSL_TRACE_CATEGORY_CMP,
380                                  ossl_cmp_log_trace_cb, ctx))
381         return 0;
382 #endif
383
384     return 1;
385 }
386
387 /* Print OpenSSL and CMP errors via the log cb of the ctx or ERR_print_errors */
388 void OSSL_CMP_CTX_print_errors(OSSL_CMP_CTX *ctx)
389 {
390     OSSL_CMP_print_errors_cb(ctx == NULL ? NULL : ctx->log_cb);
391 }
392
393 /*
394  * Set or clear the reference value to be used for identification
395  * (i.e., the user name) when using PBMAC.
396  */
397 int OSSL_CMP_CTX_set1_referenceValue(OSSL_CMP_CTX *ctx,
398                                      const unsigned char *ref, int len)
399 {
400     if (ctx == NULL) {
401         CMPerr(0, CMP_R_NULL_ARGUMENT);
402         return 0;
403     }
404     return ossl_cmp_asn1_octet_string_set1_bytes(&ctx->referenceValue, ref,
405                                                  len);
406 }
407
408 /* Set or clear the password to be used for protecting messages with PBMAC */
409 int OSSL_CMP_CTX_set1_secretValue(OSSL_CMP_CTX *ctx, const unsigned char *sec,
410                                   const int len)
411 {
412     ASN1_OCTET_STRING *secretValue = NULL;
413     if (ctx == NULL) {
414         CMPerr(0, CMP_R_NULL_ARGUMENT);
415         return 0;
416     }
417     if (ossl_cmp_asn1_octet_string_set1_bytes(&secretValue, sec, len) != 1)
418         return 0;
419     if (ctx->secretValue != NULL) {
420         OPENSSL_cleanse(ctx->secretValue->data, ctx->secretValue->length);
421         ASN1_OCTET_STRING_free(ctx->secretValue);
422     }
423     ctx->secretValue = secretValue;
424     return 1;
425 }
426
427 /*
428  * Returns the stack of certificates received in a response message.
429  * The stack is duplicated so the caller must handle freeing it!
430  * Returns pointer to created stack on success, NULL on error
431  */
432 STACK_OF(X509) *OSSL_CMP_CTX_get1_extraCertsIn(const OSSL_CMP_CTX *ctx)
433 {
434     if (ctx == NULL) {
435         CMPerr(0, CMP_R_NULL_ARGUMENT);
436         return NULL;
437     }
438     if (ctx->extraCertsIn == NULL)
439         return sk_X509_new_null();
440     return X509_chain_up_ref(ctx->extraCertsIn);
441 }
442
443 /*
444  * Copies any given stack of inbound X509 certificates to extraCertsIn
445  * of the OSSL_CMP_CTX structure so that they may be retrieved later.
446  */
447 int ossl_cmp_ctx_set1_extraCertsIn(OSSL_CMP_CTX *ctx,
448                                    STACK_OF(X509) *extraCertsIn)
449 {
450     if (!ossl_assert(ctx != NULL))
451         return 0;
452
453     sk_X509_pop_free(ctx->extraCertsIn, X509_free);
454     ctx->extraCertsIn = NULL;
455     if (extraCertsIn == NULL)
456         return 1;
457     return (ctx->extraCertsIn = X509_chain_up_ref(extraCertsIn)) != NULL;
458 }
459
460 /*
461  * Duplicate and set the given stack as the new stack of X509
462  * certificates to send out in the extraCerts field.
463  */
464 int OSSL_CMP_CTX_set1_extraCertsOut(OSSL_CMP_CTX *ctx,
465                                     STACK_OF(X509) *extraCertsOut)
466 {
467     if (ctx == NULL) {
468         CMPerr(0, CMP_R_NULL_ARGUMENT);
469         return 0;
470     }
471
472     sk_X509_pop_free(ctx->extraCertsOut, X509_free);
473     ctx->extraCertsOut = NULL;
474     if (extraCertsOut == NULL)
475         return 1;
476     return (ctx->extraCertsOut = X509_chain_up_ref(extraCertsOut)) != NULL;
477 }
478
479 /*
480  * Add the given policy info object
481  * to the X509_EXTENSIONS of the requested certificate template.
482  */
483 int OSSL_CMP_CTX_push0_policy(OSSL_CMP_CTX *ctx, POLICYINFO *pinfo)
484 {
485     if (ctx == NULL || pinfo == NULL) {
486         CMPerr(0, CMP_R_NULL_ARGUMENT);
487         return 0;
488     }
489
490     if (ctx->policies == NULL
491             && (ctx->policies = CERTIFICATEPOLICIES_new()) == NULL)
492         return 0;
493
494     return sk_POLICYINFO_push(ctx->policies, pinfo);
495 }
496
497 /* Add an ITAV for geninfo of the PKI message header */
498 int OSSL_CMP_CTX_push0_geninfo_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav)
499 {
500     if (ctx == NULL) {
501         CMPerr(0, CMP_R_NULL_ARGUMENT);
502         return 0;
503     }
504     return OSSL_CMP_ITAV_push0_stack_item(&ctx->geninfo_ITAVs, itav);
505 }
506
507 /* Add an itav for the body of outgoing general messages */
508 int OSSL_CMP_CTX_push0_genm_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav)
509 {
510     if (ctx == NULL) {
511         CMPerr(0, CMP_R_NULL_ARGUMENT);
512         return 0;
513     }
514     return OSSL_CMP_ITAV_push0_stack_item(&ctx->genm_ITAVs, itav);
515 }
516
517 /*
518  * Returns a duplicate of the stack of X509 certificates that
519  * were received in the caPubs field of the last CertRepMessage.
520  * Returns NULL on error
521  */
522 STACK_OF(X509) *OSSL_CMP_CTX_get1_caPubs(const OSSL_CMP_CTX *ctx)
523 {
524     if (ctx == NULL) {
525         CMPerr(0, CMP_R_NULL_ARGUMENT);
526         return NULL;
527     }
528     if (ctx->caPubs == NULL)
529         return sk_X509_new_null();
530     return X509_chain_up_ref(ctx->caPubs);
531 }
532
533 /*
534  * Duplicate and copy the given stack of certificates to the given
535  * OSSL_CMP_CTX structure so that they may be retrieved later.
536  */
537 int ossl_cmp_ctx_set1_caPubs(OSSL_CMP_CTX *ctx, STACK_OF(X509) *caPubs)
538 {
539     if (!ossl_assert(ctx != NULL))
540         return 0;
541
542     sk_X509_pop_free(ctx->caPubs, X509_free);
543     ctx->caPubs = NULL;
544     if (caPubs == NULL)
545         return 1;
546     return (ctx->caPubs = X509_chain_up_ref(caPubs)) != NULL;
547 }
548
549 #define char_dup OPENSSL_strdup
550 #define char_free OPENSSL_free
551 #define DEFINE_OSSL_CMP_CTX_set1(FIELD, TYPE) /* this uses _dup */ \
552 int OSSL_CMP_CTX_set1_##FIELD(OSSL_CMP_CTX *ctx, const TYPE *val) \
553 { \
554     TYPE *val_dup = NULL; \
555     \
556     if (ctx == NULL) { \
557         CMPerr(0, CMP_R_NULL_ARGUMENT); \
558         return 0; \
559     } \
560     \
561     if (val != NULL && (val_dup = TYPE##_dup(val)) == NULL) \
562         return 0; \
563     TYPE##_free(ctx->FIELD); \
564     ctx->FIELD = val_dup; \
565     return 1; \
566 }
567
568 #define DEFINE_OSSL_CMP_CTX_set1_up_ref(FIELD, TYPE) \
569 int OSSL_CMP_CTX_set1_##FIELD(OSSL_CMP_CTX *ctx, TYPE *val) \
570 { \
571     if (ctx == NULL) { \
572         CMPerr(0, CMP_R_NULL_ARGUMENT); \
573         return 0; \
574     } \
575     \
576     if (val != NULL && !TYPE##_up_ref(val)) \
577         return 0; \
578     TYPE##_free(ctx->FIELD); \
579     ctx->FIELD = val; \
580     return 1; \
581 }
582
583 /*
584  * Pins the server certificate to be directly trusted (even if it is expired)
585  * for verifying response messages.
586  * Cert pointer is not consumed. It may be NULL to clear the entry.
587  */
588 DEFINE_OSSL_CMP_CTX_set1_up_ref(srvCert, X509)
589
590 /* Set the X509 name of the recipient. Set in the PKIHeader */
591 DEFINE_OSSL_CMP_CTX_set1(recipient, X509_NAME)
592
593 /* Store the X509 name of the expected sender in the PKIHeader of responses */
594 DEFINE_OSSL_CMP_CTX_set1(expected_sender, X509_NAME)
595
596 /* Set the X509 name of the issuer. Set in the PKIHeader */
597 DEFINE_OSSL_CMP_CTX_set1(issuer, X509_NAME)
598
599 /*
600  * Set the subject name that will be placed in the certificate
601  * request. This will be the subject name on the received certificate.
602  */
603 DEFINE_OSSL_CMP_CTX_set1(subjectName, X509_NAME)
604
605 /* Set the X.509v3 certificate request extensions to be used in IR/CR/KUR */
606 int OSSL_CMP_CTX_set0_reqExtensions(OSSL_CMP_CTX *ctx, X509_EXTENSIONS *exts)
607 {
608     if (ctx == NULL) {
609         CMPerr(0, CMP_R_NULL_ARGUMENT);
610         return 0;
611     }
612
613     if (sk_GENERAL_NAME_num(ctx->subjectAltNames) > 0 && exts != NULL
614             && X509v3_get_ext_by_NID(exts, NID_subject_alt_name, -1) >= 0) {
615         CMPerr(0, CMP_R_MULTIPLE_SAN_SOURCES);
616         return 0;
617     }
618     sk_X509_EXTENSION_pop_free(ctx->reqExtensions, X509_EXTENSION_free);
619     ctx->reqExtensions = exts;
620     return 1;
621 }
622
623 /* returns 1 if ctx contains a Subject Alternative Name extension, else 0 */
624 int OSSL_CMP_CTX_reqExtensions_have_SAN(OSSL_CMP_CTX *ctx)
625 {
626     if (ctx == NULL) {
627         CMPerr(0, CMP_R_NULL_ARGUMENT);
628         return -1;
629     }
630     /* if one of the following conditions 'fail' this is not an error */
631     return ctx->reqExtensions != NULL
632         && X509v3_get_ext_by_NID(ctx->reqExtensions,
633                                  NID_subject_alt_name, -1) >= 0;
634 }
635
636 /*
637  * Add a GENERAL_NAME structure that will be added to the CRMF
638  * request's extensions field to request subject alternative names.
639  */
640 int OSSL_CMP_CTX_push1_subjectAltName(OSSL_CMP_CTX *ctx,
641                                       const GENERAL_NAME *name)
642 {
643     GENERAL_NAME *name_dup;
644
645     if (ctx == NULL || name == NULL) {
646         CMPerr(0, CMP_R_NULL_ARGUMENT);
647         return 0;
648     }
649
650     if (OSSL_CMP_CTX_reqExtensions_have_SAN(ctx) == 1) {
651         CMPerr(0, CMP_R_MULTIPLE_SAN_SOURCES);
652         return 0;
653     }
654
655     if (ctx->subjectAltNames == NULL
656             && (ctx->subjectAltNames = sk_GENERAL_NAME_new_null()) == NULL)
657         return 0;
658     if ((name_dup = GENERAL_NAME_dup(name)) == NULL)
659         return 0;
660     if (!sk_GENERAL_NAME_push(ctx->subjectAltNames, name_dup)) {
661         GENERAL_NAME_free(name_dup);
662         return 0;
663     }
664     return 1;
665 }
666
667 /*
668  * Set our own client certificate, used for example in KUR and when
669  * doing the IR with existing certificate.
670  */
671 DEFINE_OSSL_CMP_CTX_set1_up_ref(clCert, X509)
672
673 /*
674  * Set the old certificate that we are updating in KUR
675  * or the certificate to be revoked in RR, respectively.
676  * Also used as reference cert (defaulting to clCert) for deriving subject DN
677  * and SANs. Its issuer is used as default recipient in the CMP message header.
678  */
679 DEFINE_OSSL_CMP_CTX_set1_up_ref(oldCert, X509)
680
681 /* Set the PKCS#10 CSR to be sent in P10CR */
682 DEFINE_OSSL_CMP_CTX_set1(p10CSR, X509_REQ)
683
684 /*
685  * Set the (newly received in IP/KUP/CP) certificate in the context.
686  * TODO: this only permits for one cert to be enrolled at a time.
687  */
688 int ossl_cmp_ctx_set0_newCert(OSSL_CMP_CTX *ctx, X509 *cert)
689 {
690     if (!ossl_assert(ctx != NULL))
691         return 0;
692
693     X509_free(ctx->newCert);
694     ctx->newCert = cert;
695     return 1;
696 }
697
698 /*
699  * Get the (newly received in IP/KUP/CP) client certificate from the context
700  * TODO: this only permits for one client cert to be received...
701  */
702 X509 *OSSL_CMP_CTX_get0_newCert(const OSSL_CMP_CTX *ctx)
703 {
704     if (ctx == NULL) {
705         CMPerr(0, CMP_R_NULL_ARGUMENT);
706         return NULL;
707     }
708     return ctx->newCert;
709 }
710
711 /* Set the client's current private key */
712 DEFINE_OSSL_CMP_CTX_set1_up_ref(pkey, EVP_PKEY)
713
714 /* Set new key pair. Used e.g. when doing Key Update */
715 int OSSL_CMP_CTX_set0_newPkey(OSSL_CMP_CTX *ctx, int priv, EVP_PKEY *pkey)
716 {
717     if (ctx == NULL) {
718         CMPerr(0, CMP_R_NULL_ARGUMENT);
719         return 0;
720     }
721
722     EVP_PKEY_free(ctx->newPkey);
723     ctx->newPkey = pkey;
724     ctx->newPkey_priv = priv;
725     return 1;
726 }
727
728 /* Get the private/public key to use for cert enrollment, or NULL on error */
729 EVP_PKEY *OSSL_CMP_CTX_get0_newPkey(const OSSL_CMP_CTX *ctx, int priv)
730 {
731     if (ctx == NULL) {
732         CMPerr(0, CMP_R_NULL_ARGUMENT);
733         return NULL;
734     }
735
736     if (ctx->newPkey != NULL)
737         return priv && !ctx->newPkey_priv ? NULL : ctx->newPkey;
738     if (ctx->p10CSR != NULL)
739         return priv ? NULL : X509_REQ_get0_pubkey(ctx->p10CSR);
740     return ctx->pkey; /* may be NULL */
741 }
742
743 /* Set the given transactionID to the context */
744 int OSSL_CMP_CTX_set1_transactionID(OSSL_CMP_CTX *ctx,
745                                     const ASN1_OCTET_STRING *id)
746 {
747     if (ctx == NULL) {
748         CMPerr(0, CMP_R_NULL_ARGUMENT);
749         return 0;
750     }
751     return ossl_cmp_asn1_octet_string_set1(&ctx->transactionID, id);
752 }
753
754 /* Set the nonce to be used for the recipNonce in the message created next */
755 int ossl_cmp_ctx_set1_recipNonce(OSSL_CMP_CTX *ctx,
756                                  const ASN1_OCTET_STRING *nonce)
757 {
758     if (!ossl_assert(ctx != NULL))
759         return 0;
760     return ossl_cmp_asn1_octet_string_set1(&ctx->recipNonce, nonce);
761 }
762
763 /* Stores the given nonce as the last senderNonce sent out */
764 int OSSL_CMP_CTX_set1_senderNonce(OSSL_CMP_CTX *ctx,
765                                   const ASN1_OCTET_STRING *nonce)
766 {
767     if (ctx == NULL) {
768         CMPerr(0, CMP_R_NULL_ARGUMENT);
769         return 0;
770     }
771     return ossl_cmp_asn1_octet_string_set1(&ctx->senderNonce, nonce);
772 }
773
774 /* Set the proxy server to use for HTTP(S) connections */
775 DEFINE_OSSL_CMP_CTX_set1(proxy, char)
776
777 /* Set the (HTTP) host name of the CMP server */
778 DEFINE_OSSL_CMP_CTX_set1(serverName, char)
779
780 /* Set the server exclusion list of the HTTP proxy server */
781 DEFINE_OSSL_CMP_CTX_set1(no_proxy, char)
782
783 /* Set the http connect/disconnect callback function to be used for HTTP(S) */
784 int OSSL_CMP_CTX_set_http_cb(OSSL_CMP_CTX *ctx, OSSL_HTTP_bio_cb_t cb)
785 {
786     if (ctx == NULL) {
787         CMPerr(0, CMP_R_NULL_ARGUMENT);
788         return 0;
789     }
790     ctx->http_cb = cb;
791     return 1;
792 }
793
794 /* Set argument optionally to be used by the http connect/disconnect callback */
795 int OSSL_CMP_CTX_set_http_cb_arg(OSSL_CMP_CTX *ctx, void *arg)
796 {
797     if (ctx == NULL) {
798         CMPerr(0, CMP_R_NULL_ARGUMENT);
799         return 0;
800     }
801     ctx->http_cb_arg = arg;
802     return 1;
803 }
804
805 /*
806  * Get argument optionally to be used by the http connect/disconnect callback
807  * Returns callback argument set previously (NULL if not set or on error)
808  */
809 void *OSSL_CMP_CTX_get_http_cb_arg(const OSSL_CMP_CTX *ctx)
810 {
811     if (ctx == NULL) {
812         CMPerr(0, CMP_R_NULL_ARGUMENT);
813         return NULL;
814     }
815     return ctx->http_cb_arg;
816 }
817
818 /* Set callback function for sending CMP request and receiving response */
819 int OSSL_CMP_CTX_set_transfer_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_transfer_cb_t cb)
820 {
821     if (ctx == NULL) {
822         CMPerr(0, CMP_R_NULL_ARGUMENT);
823         return 0;
824     }
825     ctx->transfer_cb = cb;
826     return 1;
827 }
828
829 /* Set argument optionally to be used by the transfer callback */
830 int OSSL_CMP_CTX_set_transfer_cb_arg(OSSL_CMP_CTX *ctx, void *arg)
831 {
832     if (ctx == NULL) {
833         CMPerr(0, CMP_R_NULL_ARGUMENT);
834         return 0;
835     }
836     ctx->transfer_cb_arg = arg;
837     return 1;
838 }
839
840 /*
841  * Get argument optionally to be used by the transfer callback.
842  * Returns callback argument set previously (NULL if not set or on error)
843  */
844 void *OSSL_CMP_CTX_get_transfer_cb_arg(const OSSL_CMP_CTX *ctx)
845 {
846     if (ctx == NULL) {
847         CMPerr(0, CMP_R_NULL_ARGUMENT);
848         return NULL;
849     }
850     return ctx->transfer_cb_arg;
851 }
852
853 /** Set the HTTP server port to be used */
854 int OSSL_CMP_CTX_set_serverPort(OSSL_CMP_CTX *ctx, int port)
855 {
856     if (ctx == NULL) {
857         CMPerr(0, CMP_R_NULL_ARGUMENT);
858         return 0;
859     }
860     ctx->serverPort = port;
861     return 1;
862 }
863
864 /* Set the HTTP path to be used on the server (e.g "pkix/") */
865 DEFINE_OSSL_CMP_CTX_set1(serverPath, char)
866
867 /* Set the failInfo error code as bit encoding in OSSL_CMP_CTX */
868 int ossl_cmp_ctx_set_failInfoCode(OSSL_CMP_CTX *ctx, int fail_info)
869 {
870     if (!ossl_assert(ctx != NULL))
871         return 0;
872     ctx->failInfoCode = fail_info;
873     return 1;
874 }
875
876 /*
877  * Get the failInfo error code in OSSL_CMP_CTX as bit encoding.
878  * Returns bit string as integer on success, -1 on error
879  */
880 int OSSL_CMP_CTX_get_failInfoCode(const OSSL_CMP_CTX *ctx)
881 {
882     if (ctx == NULL) {
883         CMPerr(0, CMP_R_NULL_ARGUMENT);
884         return -1;
885     }
886     return ctx->failInfoCode;
887 }
888
889 /* Set a Boolean or integer option of the context to the "val" arg */
890 int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX *ctx, int opt, int val)
891 {
892     int min_val;
893
894     if (ctx == NULL) {
895         CMPerr(0, CMP_R_NULL_ARGUMENT);
896         return 0;
897     }
898
899     switch (opt) {
900     case OSSL_CMP_OPT_REVOCATION_REASON:
901         min_val = OCSP_REVOKED_STATUS_NOSTATUS;
902         break;
903     case OSSL_CMP_OPT_POPO_METHOD:
904         min_val = OSSL_CRMF_POPO_NONE;
905         break;
906     default:
907         min_val = 0;
908         break;
909     }
910     if (val < min_val) {
911         CMPerr(0, CMP_R_INVALID_ARGS);
912         return 0;
913     }
914
915     switch (opt) {
916     case OSSL_CMP_OPT_LOG_VERBOSITY:
917         if (val > OSSL_CMP_LOG_DEBUG) {
918             CMPerr(0, CMP_R_INVALID_ARGS);
919             return 0;
920         }
921         ctx->log_verbosity = val;
922         break;
923     case OSSL_CMP_OPT_IMPLICIT_CONFIRM:
924         ctx->implicitConfirm = val;
925         break;
926     case OSSL_CMP_OPT_DISABLE_CONFIRM:
927         ctx->disableConfirm = val;
928         break;
929     case OSSL_CMP_OPT_UNPROTECTED_SEND:
930         ctx->unprotectedSend = val;
931         break;
932     case OSSL_CMP_OPT_UNPROTECTED_ERRORS:
933         ctx->unprotectedErrors = val;
934         break;
935     case OSSL_CMP_OPT_VALIDITY_DAYS:
936         ctx->days = val;
937         break;
938     case OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT:
939         ctx->SubjectAltName_nodefault = val;
940         break;
941     case OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL:
942         ctx->setSubjectAltNameCritical = val;
943         break;
944     case OSSL_CMP_OPT_POLICIES_CRITICAL:
945         ctx->setPoliciesCritical = val;
946         break;
947     case OSSL_CMP_OPT_IGNORE_KEYUSAGE:
948         ctx->ignore_keyusage = val;
949         break;
950     case OSSL_CMP_OPT_POPO_METHOD:
951         if (val > OSSL_CRMF_POPO_KEYAGREE) {
952             CMPerr(0, CMP_R_INVALID_ARGS);
953             return 0;
954         }
955         ctx->popoMethod = val;
956         break;
957     case OSSL_CMP_OPT_DIGEST_ALGNID:
958         ctx->digest = val;
959         break;
960     case OSSL_CMP_OPT_OWF_ALGNID:
961         ctx->pbm_owf = val;
962         break;
963     case OSSL_CMP_OPT_MAC_ALGNID:
964         ctx->pbm_mac = val;
965         break;
966     case OSSL_CMP_OPT_MSG_TIMEOUT:
967         ctx->msg_timeout = val;
968         break;
969     case OSSL_CMP_OPT_TOTAL_TIMEOUT:
970         ctx->total_timeout = val;
971         break;
972     case OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR:
973         ctx->permitTAInExtraCertsForIR = val;
974         break;
975     case OSSL_CMP_OPT_REVOCATION_REASON:
976         if (val > OCSP_REVOKED_STATUS_AACOMPROMISE) {
977             CMPerr(0, CMP_R_INVALID_ARGS);
978             return 0;
979         }
980         ctx->revocationReason = val;
981         break;
982     default:
983         CMPerr(0, CMP_R_INVALID_ARGS);
984         return 0;
985     }
986
987     return 1;
988 }
989
990 /*
991  * Reads a Boolean or integer option value from the context.
992  * Returns -1 on error (which is the default OSSL_CMP_OPT_REVOCATION_REASON)
993  */
994 int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX *ctx, int opt)
995 {
996     if (ctx == NULL) {
997         CMPerr(0, CMP_R_NULL_ARGUMENT);
998         return -1;
999     }
1000
1001     switch (opt) {
1002     case OSSL_CMP_OPT_LOG_VERBOSITY:
1003         return ctx->log_verbosity;
1004     case OSSL_CMP_OPT_IMPLICIT_CONFIRM:
1005         return ctx->implicitConfirm;
1006     case OSSL_CMP_OPT_DISABLE_CONFIRM:
1007         return ctx->disableConfirm;
1008     case OSSL_CMP_OPT_UNPROTECTED_SEND:
1009         return ctx->unprotectedSend;
1010     case OSSL_CMP_OPT_UNPROTECTED_ERRORS:
1011         return ctx->unprotectedErrors;
1012     case OSSL_CMP_OPT_VALIDITY_DAYS:
1013         return ctx->days;
1014     case OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT:
1015         return ctx->SubjectAltName_nodefault;
1016     case OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL:
1017         return ctx->setSubjectAltNameCritical;
1018     case OSSL_CMP_OPT_POLICIES_CRITICAL:
1019         return ctx->setPoliciesCritical;
1020     case OSSL_CMP_OPT_IGNORE_KEYUSAGE:
1021         return ctx->ignore_keyusage;
1022     case OSSL_CMP_OPT_POPO_METHOD:
1023         return ctx->popoMethod;
1024     case OSSL_CMP_OPT_DIGEST_ALGNID:
1025         return ctx->digest;
1026     case OSSL_CMP_OPT_OWF_ALGNID:
1027         return ctx->pbm_owf;
1028     case OSSL_CMP_OPT_MAC_ALGNID:
1029         return ctx->pbm_mac;
1030     case OSSL_CMP_OPT_MSG_TIMEOUT:
1031         return ctx->msg_timeout;
1032     case OSSL_CMP_OPT_TOTAL_TIMEOUT:
1033         return ctx->total_timeout;
1034     case OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR:
1035         return ctx->permitTAInExtraCertsForIR;
1036     case OSSL_CMP_OPT_REVOCATION_REASON:
1037         return ctx->revocationReason;
1038     default:
1039         CMPerr(0, CMP_R_INVALID_ARGS);
1040         return -1;
1041     }
1042 }