OpenSuSE Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
x SuSE Linux 13.1-RELEASE x
x SuSE Linux 13.1-RELEASEx
OSSL_CMP_SRV_CTX_NEW(3ossl)         OpenSSL        OSSL_CMP_SRV_CTX_NEW(3ossl)

NAME
       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 - generic functions to set
       up and control a CMP server

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() implements the generic core aspects of
       Certificate Management Protocol (CMP) servers.  Its arguments are the
       OSSL_CMP_SRV_CTX srv_ctx and a CMP request message req. It does the
       typical generic checks on req, calls the respective callback function
       (if present) for more specific processing, and then assembles a
       response message, which may be a CMP error message.

       Since OSSL_CMP_SRV_process_request() handles only a single CMP request
       message, it may need to be called multiple times until a CMP
       transaction has ended.  If after return of the function the expression
       OSSL_CMP_CTX_get_status(OSSL_CMP_SRV_CTX_get0_cmp_ctx(srv_ctx)) yields
       -1 then the function has closed the current transaction, which may be
       due to normal successful end of the transaction or due to an error.
       Otherwise, it should be called again with the next request message of
       the same transaction (which can be a certificate confirmation or a poll
       request message).  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.  When an
       earlier call did not yet finish the 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 can be used by a CMP client in 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.  The
       OSSL_CMP_SRV_CTX must be set as transfer_cb_arg of client_ctx.

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

       OSSL_CMP_SRV_CTX_free() deletes the given srv_ctx.  If the argument is
       NULL, nothing is done.

       OSSL_CMP_SRV_CTX_init() sets in the given srv_ctx a custom server
       context pointer as well as callback functions performing the specific
       processing of CMP certificate requests, revocation requests,
       certificate confirmation requests, general messages, error messages,
       and poll requests.  All arguments except srv_ctx may be NULL.  If a
       callback for some message type is not given this means that 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 of 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
       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>.

3.5.9                             2026-09-29       OSSL_CMP_SRV_CTX_NEW(3ossl)

Want to link to this manual page? Use this URL:
<
https://star2.abcm.com/cgi-bin/linux-man?query=OSSL_CMP_SRV_CTX_new&sektion=3&manpath=>

home | help