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