OSSL_CMP_SRV_CTX_NEW(3ossl)

✨ NAME ✨

okay bestie, welcome to the CMP server glow-up 💖 this page covers the generic functions that set up and control a CMP server:

• OSSL_CMP_SRV_process_request
• OSSL_CMP_CTX_server_perform
• OSSL_CMP_SRV_CTX_new
• OSSL_CMP_SRV_CTX_free
• OSSL_CMP_SRV_cert_request_cb_t
• OSSL_CMP_SRV_rr_cb_t
• OSSL_CMP_SRV_certConf_cb_t
• OSSL_CMP_SRV_genm_cb_t
• OSSL_CMP_SRV_error_cb_t
• OSSL_CMP_SRV_pollReq_cb_t
• OSSL_CMP_SRV_CTX_init
• OSSL_CMP_SRV_delayed_delivery_cb_t
• OSSL_CMP_SRV_clean_transaction_cb_t
• OSSL_CMP_SRV_CTX_init_trans
• OSSL_CMP_SRV_CTX_get0_cmp_ctx
• OSSL_CMP_SRV_CTX_get0_custom_ctx
• OSSL_CMP_SRV_CTX_set_send_unprotected_errors
• OSSL_CMP_SRV_CTX_set_accept_unprotected
• OSSL_CMP_SRV_CTX_set_accept_raverified
• OSSL_CMP_SRV_CTX_set_grant_implicit_confirm

that's the whole squad right there — and this is the 3ossl manual page for OpenSSL, so you already know it's giving crypto 💅

---

🌸 SYNOPSIS 🌸

#include <openssl/cmp.h>

OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx,
                                           const OSSL_CMP_MSG *req);
OSSL_CMP_MSG *OSSL_CMP_CTX_server_perform(OSSL_CMP_CTX *client_ctx,
                                          const OSSL_CMP_MSG *req);
OSSL_CMP_SRV_CTX *OSSL_CMP_SRV_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
void OSSL_CMP_SRV_CTX_free(OSSL_CMP_SRV_CTX *srv_ctx);

typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_cert_request_cb_t)(
                                                OSSL_CMP_SRV_CTX *srv_ctx,
                                                const OSSL_CMP_MSG *req,
                                                int certReqId,
                                                const OSSL_CRMF_MSG *crm,
                                                const X509_REQ *p10cr,
                                                X509 **certOut,
                                                STACK_OF(X509) **chainOut,
                                                STACK_OF(X509) **caPubs);
typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_rr_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
                                                const OSSL_CMP_MSG *req,
                                                const X509_NAME *issuer,
                                                const ASN1_INTEGER *serial);
typedef int (*OSSL_CMP_SRV_genm_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
                                      const OSSL_CMP_MSG *req,
                                      STACK_OF(OSSL_CMP_ITAV) *in,
                                      STACK_OF(OSSL_CMP_ITAV) **out);
typedef void (*OSSL_CMP_SRV_error_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
                                        const OSSL_CMP_MSG *req,
                                        const OSSL_CMP_PKISI *statusInfo,
                                        const ASN1_INTEGER *errorCode,
                                        const OSSL_CMP_PKIFREETEXT *errorDetails);
typedef int (*OSSL_CMP_SRV_certConf_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
                                          const OSSL_CMP_MSG *req,
                                          int certReqId,
                                          const ASN1_OCTET_STRING *certHash,
                                          const OSSL_CMP_PKISI *si);
typedef int (*OSSL_CMP_SRV_pollReq_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
                                         const OSSL_CMP_MSG *req,
                                         int certReqId,
                                         OSSL_CMP_MSG **certReq,
                                         int64_t *check_after);
int OSSL_CMP_SRV_CTX_init(OSSL_CMP_SRV_CTX *srv_ctx, void *custom_ctx,
                          OSSL_CMP_SRV_cert_request_cb_t process_cert_request,
                          OSSL_CMP_SRV_rr_cb_t process_rr,
                          OSSL_CMP_SRV_genm_cb_t process_genm,
                          OSSL_CMP_SRV_error_cb_t process_error,
                          OSSL_CMP_SRV_certConf_cb_t process_certConf,
                          OSSL_CMP_SRV_pollReq_cb_t process_pollReq);
typedef int (*OSSL_CMP_SRV_delayed_delivery_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
                                                  const OSSL_CMP_MSG *req);
typedef int (*OSSL_CMP_SRV_clean_transaction_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
                                                   const ASN1_OCTET_STRING *id);
int OSSL_CMP_SRV_CTX_init_trans(OSSL_CMP_SRV_CTX *srv_ctx,
                                OSSL_CMP_SRV_delayed_delivery_cb_t delay,
                                OSSL_CMP_SRV_clean_transaction_cb_t clean);

OSSL_CMP_CTX *OSSL_CMP_SRV_CTX_get0_cmp_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
void *OSSL_CMP_SRV_CTX_get0_custom_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);

int OSSL_CMP_SRV_CTX_set_send_unprotected_errors(OSSL_CMP_SRV_CTX *srv_ctx,
                                                 int val);
int OSSL_CMP_SRV_CTX_set_accept_unprotected(OSSL_CMP_SRV_CTX *srv_ctx, int val);
int OSSL_CMP_SRV_CTX_set_accept_raverified(OSSL_CMP_SRV_CTX *srv_ctx, int val);
int OSSL_CMP_SRV_CTX_set_grant_implicit_confirm(OSSL_CMP_SRV_CTX *srv_ctx,
                                                int val);

---

🦋 DESCRIPTION 🦋

OSSL_CMP_SRV_process_request() is literally the main character of this whole page — it implements the generic core aspects of Certificate Management Protocol (CMP) servers ✨. It takes two things: the OSSL_CMP_SRV_CTX named srv_ctx, and a CMP request message req. What it does is: run the typical generic checks on req, call the matching callback function (if there is one) for the more specific processing, and then assemble a response message — which may turn out to be a CMP error message 😭.

Here's the tea 🫖: since OSSL_CMP_SRV_process_request() only handles a single CMP request message at a time, you may need to call it multiple times until a CMP transaction has ended. If, after the function returns, this expression:

OSSL_CMP_CTX_get_status(OSSL_CMP_SRV_CTX_get0_cmp_ctx(srv_ctx))

yields -1, then bestie the function has closed the current transaction — which might be because the transaction ended normally and successfully, or because of an error. Either way, that's it, done, periodt. Otherwise, you should call it again with the next request message of the same transaction (and that next message can be a certificate confirmation or a poll request message) 💫.

⚠️ no cap: the function should not be called by multiple threads sharing the same srv_ctx without explicitly serialising the calls. Calling it in parallel leads to undefined behavior 💀.

And another little situation: when an earlier call did not yet finish its respective transaction, calling it in an interleaved way with a new request belonging to a different transaction will abort the earlier transaction and begin the new one 🙈.

OSSL_CMP_CTX_server_perform() is an interface to OSSL_CMP_SRV_process_request() that a CMP client can use in exactly the same way as OSSL_CMP_MSG_http_perform(3) 💅. In particular, the first parameter client_ctx is the OSSL_CMP_CTX of the client. And the OSSL_CMP_SRV_CTX must be set as transfer_cb_arg of client_ctx — that's the link-up, iykyk.

OSSL_CMP_SRV_CTX_new() creates and initializes an OSSL_CMP_SRV_CTX structure associated with the library context libctx and the property query string propq. Both of those may be NULL to select the defaults 🌈.

OSSL_CMP_SRV_CTX_free() deletes the given srv_ctx. And if the argument is NULL? Nothing happens. No drama, nothing is done 🎀.

OSSL_CMP_SRV_CTX_init() sets, in the given srv_ctx, a custom server context pointer plus the callback functions that perform the specific processing of CMP certificate requests, revocation requests, certificate confirmation requests, general messages, error messages, and poll requests 🧚. Every argument except srv_ctx may be NULL. And here's the key bit: if a callback for some message type is not given, that means the respective type of CMP message is not supported by the server ✨.

OSSL_CMP_SRV_CTX_init_trans() sets in srv_ctx the optional callback functions for initiating delayed delivery and cleaning up a transaction 🌸.

• If the <delay> function is NULL, then delivery of responses is never delayed.
• Otherwise delay takes a custom server context and a request message as input. It must return 1 if delivery of the respective response shall be delayed, 0 if not, and -1 on error.
• If the <clean> function is NULL, then no specific cleanup is performed.
• Otherwise clean takes a custom server context and a transaction ID pointer as input, where the pointer is NULL in case a new transaction is being started, and otherwise provides the ID of the transaction being terminated. The <clean> function should reset the respective portions of the state and free related memory. It must return 1 on success and 0 on error.

OSSL_CMP_SRV_CTX_get0_cmp_ctx() returns the OSSL_CMP_CTX from the srv_ctx 💖.

OSSL_CMP_SRV_CTX_get0_custom_ctx() returns the custom server context from srv_ctx that has been set using OSSL_CMP_SRV_CTX_init() 🫶.

OSSL_CMP_SRV_CTX_set_send_unprotected_errors() enables sending error messages and other forms of negative responses unprotected 👀.

OSSL_CMP_SRV_CTX_set_accept_unprotected() enables acceptance of requests without protection or with invalid protection 😬.

OSSL_CMP_SRV_CTX_set_accept_raverified() enables acceptance of ir/cr/kur messages with POPO 'RAVerified' ✨.

OSSL_CMP_SRV_CTX_set_grant_implicit_confirm() enables granting implicit confirmation of newly enrolled certificates if requested 👑.

---

💜 NOTES 💜

CMP is defined in RFC 9810 (and CRMF in RFC 4211) 📜.

Like the OpenSSL CMP client, the CMP server implementation documented here focuses on the Lightweight CMP Profile (RFC 9483) ✨. Among other things, this implies that only commonly used CMP message types are supported, and that each CMP message may not contain multiple certificate requests or responses 🌸.

So far, this server implementation is single-threaded and should not be called in parallel for any given OSSL_CMP_SRV_CTX srv_ctx 💀. It can handle only one CMP transaction at a time — which, of course, is not a problem for transactions consisting of just a single request/response message pair 💅.

---

🎀 RETURN VALUES 🎀

• OSSL_CMP_SRV_process_request() returns a CMP response message, which may be an error message, or NULL on internal errors that preclude producing a response 😭.
• OSSL_CMP_SRV_CTX_new() returns a OSSL_CMP_SRV_CTX structure on success, NULL on error.
• OSSL_CMP_SRV_CTX_free() does not return a value 🙈.
• OSSL_CMP_SRV_CTX_get0_cmp_ctx() returns a OSSL_CMP_CTX structure on success, NULL on error.
• OSSL_CMP_SRV_CTX_get0_custom_ctx() returns the custom server context that has been set using OSSL_CMP_SRV_CTX_init() 💖.
• All other functions return 1 on success, 0 on error ⭐.

---

🌈 HISTORY 🌈

The OpenSSL CMP support was added in OpenSSL 3.0 🎉.

OSSL_CMP_SRV_CTX_init_trans() supporting delayed delivery of all types of response messages was added in OpenSSL 3.3 🦋.

---

📜 COPYRIGHT (the legal era, bestie, read it) 📜

Copyright 2007-2026 The OpenSSL Project Authors. All Rights Reserved. 🫶

Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at <https://www.openssl.org/source/license.html>.

Okay so fr fr: this is the part nobody reads but everybody needs 💀 — don't skip it, it's giving "legally binding main character energy" and it ate. 👑

---

✨ and that's a wrap, bestie ✨ you just made it through the whole page, which is genuinely iconic of you 💖 This one shipped with 3.5.9, dated 2026-09-29, and lives at OSSL_CMP_SRV_CTX_NEW(3ossl) — go forth and certify responsibly 🌸🦋