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