path: root/crypto/cmp/cmp_protect.c

/*
 * Copyright 2007-2020 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright Nokia 2007-2019
 * Copyright Siemens AG 2015-2019
 *
 * 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
 */

#include "cmp_local.h"

/* explicit #includes not strictly needed since implied by the above: */
#include <openssl/asn1t.h>
#include <openssl/cmp.h>
#include <openssl/crmf.h>
#include <openssl/err.h>
#include <openssl/x509.h>

DEFINE_STACK_OF(X509)

/*
 * This function is also used for verification from cmp_vfy.
 *
 * Calculate protection for given PKImessage utilizing the given credentials
 * and the algorithm parameters set inside the message header's protectionAlg.
 *
 * Either secret or pkey must be set, the other must be NULL. Attempts doing
 * PBMAC in case 'secret' is set and signature if 'pkey' is set - but will only
 * do the protection already marked in msg->header->protectionAlg.
 *
 * returns ptr to ASN1_BIT_STRING containing protection on success, else NULL
 */
ASN1_BIT_STRING *ossl_cmp_calc_protection(const OSSL_CMP_MSG *msg,
                                          const ASN1_OCTET_STRING *secret,
                                          EVP_PKEY *pkey)
{
    ASN1_BIT_STRING *prot = NULL;
    OSSL_CMP_PROTECTEDPART prot_part;
    const ASN1_OBJECT *algorOID = NULL;
    int len;
    size_t prot_part_der_len;
    unsigned char *prot_part_der = NULL;
    size_t sig_len;
    unsigned char *protection = NULL;
    const void *ppval = NULL;
    int pptype = 0;
    OSSL_CRMF_PBMPARAMETER *pbm = NULL;
    ASN1_STRING *pbm_str = NULL;
    const unsigned char *pbm_str_uc = NULL;
    EVP_MD_CTX *evp_ctx = NULL;
    int md_NID;
    const EVP_MD *md = NULL;

    if (!ossl_assert(msg != NULL))
        return NULL;

    /* construct data to be signed */
    prot_part.header = msg->header;
    prot_part.body = msg->body;

    len = i2d_OSSL_CMP_PROTECTEDPART(&prot_part, &prot_part_der);
    if (len < 0 || prot_part_der == NULL) {
        CMPerr(0, CMP_R_ERROR_CALCULATING_PROTECTION);
        goto end;
    }
    prot_part_der_len = (size_t) len;

    if (msg->header->protectionAlg == NULL) {
        CMPerr(0, CMP_R_UNKNOWN_ALGORITHM_ID);
        goto end;
    }
    X509_ALGOR_get0(&algorOID, &pptype, &ppval, msg->header->protectionAlg);

    if (secret != NULL && pkey == NULL) {
        if (ppval == NULL) {
            CMPerr(0, CMP_R_ERROR_CALCULATING_PROTECTION);
            goto end;
        }
        if (NID_id_PasswordBasedMAC != OBJ_obj2nid(algorOID)) {
            CMPerr(0, CMP_R_WRONG_ALGORITHM_OID);
            goto end;
        }
        pbm_str = (ASN1_STRING *)ppval;
        pbm_str_uc = pbm_str->data;
        pbm = d2i_OSSL_CRMF_PBMPARAMETER(NULL, &pbm_str_uc, pbm_str->length);
        if (pbm == NULL) {
            CMPerr(0, CMP_R_WRONG_ALGORITHM_OID);
            goto end;
        }

        if (!OSSL_CRMF_pbm_new(pbm, prot_part_der, prot_part_der_len,
                               secret->data, secret->length,
                               &protection, &sig_len))
            goto end;
    } else if (secret == NULL && pkey != NULL) {
        /* TODO combine this with large parts of CRMF_poposigningkey_init() */
        /* EVP_DigestSignInit() checks that pkey type is correct for the alg */

        if (!OBJ_find_sigid_algs(OBJ_obj2nid(algorOID), &md_NID, NULL)
                || (md = EVP_get_digestbynid(md_NID)) == NULL
                || (evp_ctx = EVP_MD_CTX_new()) == NULL) {
            CMPerr(0, CMP_R_UNKNOWN_ALGORITHM_ID);
            goto end;
        }
        if (EVP_DigestSignInit(evp_ctx, NULL, md, NULL, pkey) <= 0
                || EVP_DigestSignUpdate(evp_ctx, prot_part_der,
                                        prot_part_der_len) <= 0
                || EVP_DigestSignFinal(evp_ctx, NULL, &sig_len) <= 0
                || (protection = OPENSSL_malloc(sig_len)) == NULL
                || EVP_DigestSignFinal(evp_ctx, protection, &sig_len) <= 0) {
            CMPerr(0, CMP_R_ERROR_CALCULATING_PROTECTION);
            goto end;
        }
    } else {
        CMPerr(0, CMP_R_INVALID_ARGS);
        goto end;
    }

    if ((prot = ASN1_BIT_STRING_new()) == NULL)
        goto end;
    /* OpenSSL defaults all bit strings to be encoded as ASN.1 NamedBitList */
    prot->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
    prot->flags |= ASN1_STRING_FLAG_BITS_LEFT;
    if (!ASN1_BIT_STRING_set(prot, protection, sig_len)) {
        ASN1_BIT_STRING_free(prot);
        prot = NULL;
    }

 end:
    OSSL_CRMF_PBMPARAMETER_free(pbm);
    EVP_MD_CTX_free(evp_ctx);
    OPENSSL_free(protection);
    OPENSSL_free(prot_part_der);
    return prot;
}

int ossl_cmp_msg_add_extraCerts(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg)
{
    if (!ossl_assert(ctx != NULL && msg != NULL))
        return 0;

    if (msg->extraCerts == NULL
            && (msg->extraCerts = sk_X509_new_null()) == NULL)
        return 0;

    if (ctx->clCert != NULL) {
        /* Make sure that our own cert gets sent, in the first position */
        if (!X509_up_ref(ctx->clCert))
            return 0;
        if (!sk_X509_push(msg->extraCerts, ctx->clCert)) {
            X509_free(ctx->clCert);
            return 0;
        }
        /* if we have untrusted store, try to add intermediate certs */
        if (ctx->untrusted_certs != NULL) {
            STACK_OF(X509) *chain =
                ossl_cmp_build_cert_chain(ctx->untrusted_certs, ctx->clCert);
            int res = ossl_cmp_sk_X509_add1_certs(msg->extraCerts, chain,
                                                  1 /* no self-issued */,
                                                  1 /* no duplicates */, 0);
            sk_X509_pop_free(chain, X509_free);
            if (res == 0)
                return 0;
        }
    }

    /* add any additional certificates from ctx->extraCertsOut */
    if (!ossl_cmp_sk_X509_add1_certs(msg->extraCerts, ctx->extraCertsOut, 0,
                                     1 /* no duplicates */, 0))
        return 0;

    /* if none was found avoid empty ASN.1 sequence */
    if (sk_X509_num(msg->extraCerts) == 0) {
        sk_X509_free(msg->extraCerts);
        msg->extraCerts = NULL;
    }
    return 1;
}

/*
 * Create an X509_ALGOR structure for PasswordBasedMAC protection based on
 * the pbm settings in the context
 * returns pointer to X509_ALGOR on success, NULL on error
 */
static X509_ALGOR *create_pbmac_algor(OSSL_CMP_CTX *ctx)
{
    X509_ALGOR *alg = NULL;
    OSSL_CRMF_PBMPARAMETER *pbm = NULL;
    unsigned char *pbm_der = NULL;
    int pbm_der_len;
    ASN1_STRING *pbm_str = NULL;

    if (!ossl_assert(ctx != NULL))
        return NULL;

    alg = X509_ALGOR_new();
    pbm = OSSL_CRMF_pbmp_new(ctx->pbm_slen, ctx->pbm_owf, ctx->pbm_itercnt,
                             ctx->pbm_mac);
    pbm_str = ASN1_STRING_new();
    if (alg == NULL || pbm == NULL || pbm_str == NULL)
        goto err;

    if ((pbm_der_len = i2d_OSSL_CRMF_PBMPARAMETER(pbm, &pbm_der)) < 0)
        goto err;

    if (!ASN1_STRING_set(pbm_str, pbm_der, pbm_der_len))
        goto err;
    OPENSSL_free(pbm_der);

    X509_ALGOR_set0(alg, OBJ_nid2obj(NID_id_PasswordBasedMAC),
                    V_ASN1_SEQUENCE, pbm_str);
    OSSL_CRMF_PBMPARAMETER_free(pbm);
    return alg;

 err:
    ASN1_STRING_free(pbm_str);
    X509_ALGOR_free(alg);
    OPENSSL_free(pbm_der);
    OSSL_CRMF_PBMPARAMETER_free(pbm);
    return NULL;
}

int ossl_cmp_msg_protect(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg)
{
    if (!ossl_assert(ctx != NULL && msg != NULL))
        return 0;

    if (ctx->unprotectedSend)
        return 1;

    /* use PasswordBasedMac according to 5.1.3.1 if secretValue is given */
    if (ctx->secretValue != NULL) {
        if ((msg->header->protectionAlg = create_pbmac_algor(ctx)) == NULL)
            goto err;