/src/openssl36/providers/implementations/ciphers/ciphercommon_ccm.c

Source
/*
 * Copyright 2019-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
 */
/* clang-format off */

/* clang-format on */

/* Dispatch functions for ccm mode */

#include <openssl/proverr.h>
#include "prov/ciphercommon.h"
#include "prov/ciphercommon_ccm.h"
#include "prov/providercommon.h"

static int ccm_cipher_internal(PROV_CCM_CTX *ctx, unsigned char *out,
    size_t *padlen, const unsigned char *in,
    size_t len);

static int ccm_tls_init(PROV_CCM_CTX *ctx, unsigned char *aad, size_t alen)
{
    size_t len;

    if (!ossl_prov_is_running() || alen != EVP_AEAD_TLS1_AAD_LEN)
        return 0;

    /* Save the aad for later use. */
    memcpy(ctx->buf, aad, alen);
    ctx->tls_aad_len = alen;

    len = ctx->buf[alen - 2] << 8 | ctx->buf[alen - 1];
    if (len < EVP_CCM_TLS_EXPLICIT_IV_LEN)
        return 0;

    /* Correct length for explicit iv. */
    len -= EVP_CCM_TLS_EXPLICIT_IV_LEN;

    if (!ctx->enc) {
        if (len < ctx->m)
            return 0;
        /* Correct length for tag. */
        len -= ctx->m;
    }
    ctx->buf[alen - 2] = (unsigned char)(len >> 8);
    ctx->buf[alen - 1] = (unsigned char)(len & 0xff);

    /* Extra padding: tag appended to record. */
    return (int)ctx->m;
}

static int ccm_tls_iv_set_fixed(PROV_CCM_CTX *ctx, unsigned char *fixed,
    size_t flen)
{
    if (flen != EVP_CCM_TLS_FIXED_IV_LEN)
        return 0;

    /* Copy to first part of the iv. */
    memcpy(ctx->iv, fixed, flen);
    return 1;
}

static size_t ccm_get_ivlen(PROV_CCM_CTX *ctx)
{
    return 15 - ctx->l;
}

/* clang-format off */
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef ossl_cipher_ccm_set_ctx_params_list
static ossl_unused const OSSL_PARAM ossl_cipher_ccm_set_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ossl_cipher_ccm_set_ctx_params_st
struct ossl_cipher_ccm_set_ctx_params_st {
    OSSL_PARAM *aad;
    OSSL_PARAM *fixed;
    OSSL_PARAM *ivlen;
    OSSL_PARAM *tag;
};
#endif

#ifndef ossl_cipher_ccm_set_ctx_params_decoder
static ossl_unused int ossl_cipher_ccm_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct ossl_cipher_ccm_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'i':
                if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_AEAD_IVLEN */
                    if (ossl_unlikely(r->ivlen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ivlen = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    if (ossl_likely(strcmp("g", s + 2) == 0)) {
                        /* OSSL_CIPHER_PARAM_AEAD_TAG */
                        if (ossl_unlikely(r->tag != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->tag = (OSSL_PARAM *)p;
                    }
                    break;
                case 'l':
                    switch(s[2]) {
                    default:
                        break;
                    case 's':
                        switch(s[3]) {
                        default:
                            break;
                        case 'a':
                            if (ossl_likely(strcmp("ad", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_AEAD_TLS1_AAD */
                                if (ossl_unlikely(r->aad != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->aad = (OSSL_PARAM *)p;
                            }
                            break;
                        case 'i':
                            if (ossl_likely(strcmp("vfixed", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED */
                                if (ossl_unlikely(r->fixed != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->fixed = (OSSL_PARAM *)p;
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */
/* clang-format on */

const OSSL_PARAM *ossl_ccm_settable_ctx_params(
    ossl_unused void *cctx, ossl_unused void *provctx)
{
    return ossl_cipher_ccm_set_ctx_params_list;
}

int ossl_ccm_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
    PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
    size_t sz, ivlen;
    struct ossl_cipher_ccm_set_ctx_params_st p;

    if (ctx == NULL || !ossl_cipher_ccm_set_ctx_params_decoder(params, &p))
        return 0;

    if (p.tag != NULL) {
        if (p.tag->data_type != OSSL_PARAM_OCTET_STRING) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        if ((p.tag->data_size & 1) || (p.tag->data_size < 4) || p.tag->data_size > 16) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG_LENGTH);
            return 0;
        }

        if (p.tag->data != NULL) {
            if (ctx->enc) {
                ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_NEEDED);
                return 0;
            }
            memcpy(ctx->buf, p.tag->data, p.tag->data_size);
            ctx->tag_set = 1;
        }
        ctx->m = p.tag->data_size;
    }

    if (p.ivlen != NULL) {
        if (!OSSL_PARAM_get_size_t(p.ivlen, &sz)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        ivlen = 15 - sz;
        if (ivlen < 2 || ivlen > 8) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
            return 0;
        }
        if (ctx->l != ivlen) {
            ctx->l = ivlen;
            ctx->iv_set = 0;
        }
    }

    if (p.aad != NULL) {
        if (p.aad->data_type != OSSL_PARAM_OCTET_STRING) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        sz = ccm_tls_init(ctx, p.aad->data, p.aad->data_size);
        if (sz == 0) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
            return 0;
        }
        ctx->tls_aad_pad_sz = sz;
    }

    if (p.fixed != NULL) {
        if (p.fixed->data_type != OSSL_PARAM_OCTET_STRING) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        if (ccm_tls_iv_set_fixed(ctx, p.fixed->data, p.fixed->data_size) == 0) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
            return 0;
        }
    }
    return 1;
}

/* clang-format off */
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef ossl_cipher_ccm_get_ctx_params_list
static ossl_unused const OSSL_PARAM ossl_cipher_ccm_get_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef ossl_cipher_ccm_get_ctx_params_st
struct ossl_cipher_ccm_get_ctx_params_st {
    OSSL_PARAM *iv;
    OSSL_PARAM *ivlen;
    OSSL_PARAM *keylen;
    OSSL_PARAM *pad;
    OSSL_PARAM *tag;
    OSSL_PARAM *taglen;
    OSSL_PARAM *updiv;
};
#endif

#ifndef ossl_cipher_ccm_get_ctx_params_decoder
static ossl_unused int ossl_cipher_ccm_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct ossl_cipher_ccm_get_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR */
                    if (!OSSL_PARAM_set_int((OSSL_PARAM *)p, 1))
                        return 0;
                }
# endif
                break;
            case 'i':
                switch(s[1]) {
                default:
                    break;
                case 'v':
                    switch(s[2]) {
                    default:
                        break;
                    case 'l':
                        if (ossl_likely(strcmp("en", s + 3) == 0)) {
                            /* OSSL_CIPHER_PARAM_IVLEN */
                            if (ossl_unlikely(r->ivlen != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->ivlen = (OSSL_PARAM *)p;
                        }
                        break;
                    case '\0':
                        if (ossl_unlikely(r->iv != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->iv = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'k':
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_KEYLEN */
                    if (ossl_unlikely(r->keylen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->keylen = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    switch(s[2]) {
                    default:
                        break;
                    case 'g':
                        switch(s[3]) {
                        default:
                            break;
                        case 'l':
                            if (ossl_likely(strcmp("en", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_AEAD_TAGLEN */
                                if (ossl_unlikely(r->taglen != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->taglen = (OSSL_PARAM *)p;
                            }
                            break;
                        case '\0':
                            if (ossl_unlikely(r->tag != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->tag = (OSSL_PARAM *)p;
                        }
                    }
                    break;
                case 'l':
                    if (ossl_likely(strcmp("saadpad", s + 2) == 0)) {
                        /* OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD */
                        if (ossl_unlikely(r->pad != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->pad = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'u':
                if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_UPDATED_IV */
                    if (ossl_unlikely(r->updiv != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->updiv = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */
/* clang-format on */

const OSSL_PARAM *ossl_ccm_gettable_ctx_params(
    ossl_unused void *cctx, ossl_unused void *provctx)
{
    return ossl_cipher_ccm_get_ctx_params_list;
}

int ossl_ccm_get_ctx_params(void *vctx, OSSL_PARAM params[])
{
    PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
    struct ossl_cipher_ccm_get_ctx_params_st p;

    if (ctx == NULL || !ossl_cipher_ccm_get_ctx_params_decoder(params, &p))
        return 0;

    if (p.ivlen != NULL && !OSSL_PARAM_set_size_t(p.ivlen, ccm_get_ivlen(ctx))) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }

    if (p.taglen != NULL && !OSSL_PARAM_set_size_t(p.taglen, ctx->m)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }

    if (p.iv != NULL) {
        if (ccm_get_ivlen(ctx) > p.iv->data_size) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
            return 0;
        }
        if (!OSSL_PARAM_set_octet_string_or_ptr(p.iv, ctx->iv, p.iv->data_size)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
            return 0;
        }
    }

    if (p.updiv != NULL) {
        if (ccm_get_ivlen(ctx) > p.updiv->data_size) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
            return 0;
        }
        if (!OSSL_PARAM_set_octet_string_or_ptr(p.updiv, ctx->iv, p.updiv->data_size)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
            return 0;
        }
    }

    if (p.keylen != NULL && !OSSL_PARAM_set_size_t(p.keylen, ctx->keylen)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }

    if (p.pad != NULL && !OSSL_PARAM_set_size_t(p.pad, ctx->tls_aad_pad_sz)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }

    if (p.tag != NULL) {
        if (!ctx->enc || !ctx->tag_set) {
            ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
            return 0;
        }
        if (p.tag->data_type != OSSL_PARAM_OCTET_STRING) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
            return 0;
        }
        if (!ctx->hw->gettag(ctx, p.tag->data, p.tag->data_size))
            return 0;
        ctx->tag_set = 0;
        ctx->iv_set = 0;
        ctx->len_set = 0;
    }

    return 1;
}

static int ccm_init(void *vctx, const unsigned char *key, size_t keylen,
    const unsigned char *iv, size_t ivlen,
    const OSSL_PARAM params[], int enc)
{
    PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;

    if (!ossl_prov_is_running())
        return 0;

    ctx->enc = enc;

    if (iv != NULL) {
        if (ivlen != ccm_get_ivlen(ctx)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
            return 0;
        }
        memcpy(ctx->iv, iv, ivlen);
        ctx->iv_set = 1;
    }
    if (key != NULL) {
        if (keylen != ctx->keylen) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
            return 0;
        }
        if (!ctx->hw->setkey(ctx, key, keylen))
            return 0;
    }
    return ossl_ccm_set_ctx_params(ctx, params);
}

int ossl_ccm_einit(void *vctx, const unsigned char *key, size_t keylen,
    const unsigned char *iv, size_t ivlen,
    const OSSL_PARAM params[])
{
    return ccm_init(vctx, key, keylen, iv, ivlen, params, 1);
}

int ossl_ccm_dinit(void *vctx, const unsigned char *key, size_t keylen,
    const unsigned char *iv, size_t ivlen,
    const OSSL_PARAM params[])
{
    return ccm_init(vctx, key, keylen, iv, ivlen, params, 0);
}

int ossl_ccm_stream_update(void *vctx, unsigned char *out, size_t *outl,
    size_t outsize, const unsigned char *in,
    size_t inl)
{
    PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;

    if (outsize < inl) {
        ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
        return 0;
    }

    if (!ccm_cipher_internal(ctx, out, outl, in, inl)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
        return 0;
    }
    return 1;
}

int ossl_ccm_stream_final(void *vctx, unsigned char *out, size_t *outl,
    size_t outsize)
{
    PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
    unsigned char dummy_in = 0, dummy_out = 0;

    if (!ossl_prov_is_running())
        return 0;

    /*
     * Encryption sets tag_set after processing the payload, while successful
     * decryption clears iv_set. Use those transitions to avoid processing an
     * operation twice.
     */
    if (!ctx->key_set
        || (ctx->iv_set && (!ctx->enc || !ctx->tag_set)
            && ccm_cipher_internal(ctx, &dummy_out, outl, &dummy_in, 0) <= 0))
        return 0;

    *outl = 0;
    return 1;
}

int ossl_ccm_cipher(void *vctx, unsigned char *out, size_t *outl, size_t outsize,
    const unsigned char *in, size_t inl)
{
    PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;

    if (!ossl_prov_is_running())
        return 0;

    if (in == NULL)
        return ossl_ccm_stream_final(vctx, out, outl, outsize);

    if (outsize < inl) {
        ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
        return 0;
    }

    if (ccm_cipher_internal(ctx, out, outl, in, inl) <= 0)
        return 0;

    *outl = inl;
    return 1;
}

/* Copy the buffered iv */
static int ccm_set_iv(PROV_CCM_CTX *ctx, size_t mlen)
{
    const PROV_CCM_HW *hw = ctx->hw;

    if (!hw->setiv(ctx, ctx->iv, ccm_get_ivlen(ctx), mlen))
        return 0;
    ctx->len_set = 1;
    return 1;
}

static int ccm_tls_cipher(PROV_CCM_CTX *ctx,
    unsigned char *out, size_t *padlen,
    const unsigned char *in, size_t len)
{
    int rv = 0;
    size_t olen = 0;

    if (!ossl_prov_is_running())
        goto err;

    /* Encrypt/decrypt must be performed in place */
    if (in == NULL || out != in || len < EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m)
        goto err;

    /* If encrypting set explicit IV from sequence number (start of AAD) */
    if (ctx->enc)
        memcpy(out, ctx->buf, EVP_CCM_TLS_EXPLICIT_IV_LEN);
    /* Get rest of IV from explicit IV */
    memcpy(ctx->iv + EVP_CCM_TLS_FIXED_IV_LEN, in, EVP_CCM_TLS_EXPLICIT_IV_LEN);
    /* Correct length value */
    len -= EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m;
    if (!ccm_set_iv(ctx, len))
        goto err;

    /* Use saved AAD */
    if (!ctx->hw->setaad(ctx, ctx->buf, ctx->tls_aad_len))
        goto err;

    /* Fix buffer to point to payload */
    in += EVP_CCM_TLS_EXPLICIT_IV_LEN;
    out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
    if (ctx->enc) {
        if (!ctx->hw->auth_encrypt(ctx, in, out, len, out + len, ctx->m))
            goto err;
        olen = len + EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m;
    } else {
        if (!ctx->hw->auth_decrypt(ctx, in, out, len,
                (unsigned char *)in + len, ctx->m))
            goto err;
        olen = len;
    }
    rv = 1;
err:
    *padlen = olen;
    return rv;
}

static int ccm_cipher_internal(PROV_CCM_CTX *ctx, unsigned char *out,
    size_t *padlen, const unsigned char *in,
    size_t len)
{
    int rv = 0;
    size_t olen = 0;
    const PROV_CCM_HW *hw = ctx->hw;

    /* If no key set, return error */
    if (!ctx->key_set)
        return 0;

    if (ctx->tls_aad_len != UNINITIALISED_SIZET)
        return ccm_tls_cipher(ctx, out, padlen, in, len);

    /* EVP_*Final() doesn't return any data */
    if (in == NULL && out != NULL)
        goto finish;

    if (!ctx->iv_set)
        goto err;

    if (out == NULL) {
        if (in == NULL) {
            if (!ccm_set_iv(ctx, len))
                goto err;
        } else {
            /* If we have AAD, we need a message length */
            if (!ctx->len_set && len)
                goto err;
            if (!hw->setaad(ctx, in, len))
                goto err;
        }
    } else {
        /* If not set length yet do it */
        if (!ctx->len_set && !ccm_set_iv(ctx, len))
            goto err;

        if (ctx->enc) {
            if (!hw->auth_encrypt(ctx, in, out, len, NULL, 0))
                goto err;
            ctx->tag_set = 1;
        } else {
            /* The tag must be set before actually decrypting data */
            if (!ctx->tag_set)
                goto err;

            if (!hw->auth_decrypt(ctx, in, out, len, ctx->buf, ctx->m))
                goto err;
            /* Finished - reset flags so calling this method again will fail */
            ctx->iv_set = 0;
            ctx->tag_set = 0;
            ctx->len_set = 0;
        }
    }
    olen = len;
finish:
    rv = 1;
err:
    *padlen = olen;
    return rv;
}

void ossl_ccm_initctx(PROV_CCM_CTX *ctx, size_t keybits, const PROV_CCM_HW *hw)
{
    ctx->keylen = keybits / 8;
    ctx->key_set = 0;
    ctx->iv_set = 0;
    ctx->tag_set = 0;
    ctx->len_set = 0;
    ctx->l = 8;
    ctx->m = 12;
    ctx->tls_aad_len = UNINITIALISED_SIZET;
    ctx->hw = hw;
}

Coverage Report

Created: 2026-10-28 06:28

Line	Count	Source
1		/*
2		* Copyright 2019-2026 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9		/* clang-format off */
10
11		/* clang-format on */
12
13		/* Dispatch functions for ccm mode */
14
15		#include <openssl/proverr.h>
16		#include "prov/ciphercommon.h"
17		#include "prov/ciphercommon_ccm.h"
18		#include "prov/providercommon.h"
19
20		static int ccm_cipher_internal(PROV_CCM_CTX ctx, unsigned char out,
21		size_t padlen, const unsigned char in,
22		size_t len);
23
24		static int ccm_tls_init(PROV_CCM_CTX ctx, unsigned char aad, size_t alen)
25	88.7k	{
26	88.7k	size_t len;
27
28	88.7k	if (!ossl_prov_is_running() \|\| alen != EVP_AEAD_TLS1_AAD_LEN)
29	0	return 0;
30
31		/* Save the aad for later use. */
32	88.7k	memcpy(ctx->buf, aad, alen);
33	88.7k	ctx->tls_aad_len = alen;
34
35	88.7k	len = ctx->buf[alen - 2] << 8 \| ctx->buf[alen - 1];
36	88.7k	if (len < EVP_CCM_TLS_EXPLICIT_IV_LEN)
37	0	return 0;
38
39		/* Correct length for explicit iv. */
40	88.7k	len -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
41
42	88.7k	if (!ctx->enc) {
43	87.7k	if (len < ctx->m)
44	0	return 0;
45		/* Correct length for tag. */
46	87.7k	len -= ctx->m;
47	87.7k	}
48	88.7k	ctx->buf[alen - 2] = (unsigned char)(len >> 8);
49	88.7k	ctx->buf[alen - 1] = (unsigned char)(len & 0xff);
50
51		/* Extra padding: tag appended to record. */
52	88.7k	return (int)ctx->m;
53	88.7k	}
54
55		static int ccm_tls_iv_set_fixed(PROV_CCM_CTX ctx, unsigned char fixed,
56		size_t flen)
57	2.37k	{
58	2.37k	if (flen != EVP_CCM_TLS_FIXED_IV_LEN)
59	0	return 0;
60
61		/* Copy to first part of the iv. */
62	2.37k	memcpy(ctx->iv, fixed, flen);
63	2.37k	return 1;
64	2.37k	}
65
66		static size_t ccm_get_ivlen(PROV_CCM_CTX *ctx)
67	88.8k	{
68	88.8k	return 15 - ctx->l;
69	88.8k	}
70
71		/* clang-format off */
72		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
73		#ifndef ossl_cipher_ccm_set_ctx_params_list
74		static ossl_unused const OSSL_PARAM ossl_cipher_ccm_set_ctx_params_list[] = {
75		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
76		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
77		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
78		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
79		OSSL_PARAM_END
80		};
81		#endif
82
83		#ifndef ossl_cipher_ccm_set_ctx_params_st
84		struct ossl_cipher_ccm_set_ctx_params_st {
85		OSSL_PARAM *aad;
86		OSSL_PARAM *fixed;
87		OSSL_PARAM *ivlen;
88		OSSL_PARAM *tag;
89		};
90		#endif
91
92		#ifndef ossl_cipher_ccm_set_ctx_params_decoder
93		static ossl_unused int ossl_cipher_ccm_set_ctx_params_decoder
94		(const OSSL_PARAM p, struct ossl_cipher_ccm_set_ctx_params_st r)
95	47.8k	{
96	47.8k	const char *s;
97
98	47.8k	memset(r, 0, sizeof(*r));
99	47.8k	if (p != NULL)
100	92.0k	for (; (s = p->key) != NULL; p++)
101	46.6k	switch(s[0]) {
102	1	default:
103	1	break;
104	1.23k	case 'i':
105	1.23k	if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
106		/* OSSL_CIPHER_PARAM_AEAD_IVLEN */
107	1.23k	if (ossl_unlikely(r->ivlen != NULL)) {
108	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
109	0	"param %s is repeated", s);
110	0	return 0;
111	0	}
112	1.23k	r->ivlen = (OSSL_PARAM *)p;
113	1.23k	}
114	1.23k	break;
115	45.4k	case 't':
116	45.4k	switch(s[1]) {
117	0	default:
118	0	break;
119	1.23k	case 'a':
120	1.23k	if (ossl_likely(strcmp("g", s + 2) == 0)) {
121		/* OSSL_CIPHER_PARAM_AEAD_TAG */
122	1.23k	if (ossl_unlikely(r->tag != NULL)) {
123	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
124	0	"param %s is repeated", s);
125	0	return 0;
126	0	}
127	1.23k	r->tag = (OSSL_PARAM *)p;
128	1.23k	}
129	1.23k	break;
130	44.1k	case 'l':
131	44.1k	switch(s[2]) {
132	0	default:
133	0	break;
134	44.1k	case 's':
135	44.1k	switch(s[3]) {
136	2.42k	default:
137	2.42k	break;
138	40.5k	case 'a':
139	40.5k	if (ossl_likely(strcmp("ad", s + 4) == 0)) {
140		/* OSSL_CIPHER_PARAM_AEAD_TLS1_AAD */
141	40.5k	if (ossl_unlikely(r->aad != NULL)) {
142	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
143	0	"param %s is repeated", s);
144	0	return 0;
145	0	}
146	40.5k	r->aad = (OSSL_PARAM *)p;
147	40.5k	}
148	40.5k	break;
149	40.5k	case 'i':
150	1.23k	if (ossl_likely(strcmp("vfixed", s + 4) == 0)) {
151		/* OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED */
152	1.23k	if (ossl_unlikely(r->fixed != NULL)) {
153	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
154	0	"param %s is repeated", s);
155	0	return 0;
156	0	}
157	1.23k	r->fixed = (OSSL_PARAM *)p;
158	1.23k	}
159	44.1k	}
160	44.1k	}
161	45.4k	}
162	46.6k	}
163	47.8k	return 1;
164	47.8k	}
165		#endif
166		/* End of machine generated */
167		/* clang-format on */
168
169		const OSSL_PARAM *ossl_ccm_settable_ctx_params(
170		ossl_unused void cctx, ossl_unused void provctx)
171	32	{
172	32	return ossl_cipher_ccm_set_ctx_params_list;
173	32	}
174
175		int ossl_ccm_set_ctx_params(void *vctx, const OSSL_PARAM params[])
176	47.8k	{
177	47.8k	PROV_CCM_CTX ctx = (PROV_CCM_CTX )vctx;
178	47.8k	size_t sz, ivlen;
179	47.8k	struct ossl_cipher_ccm_set_ctx_params_st p;
180
181	47.8k	if (ctx == NULL \|\| !ossl_cipher_ccm_set_ctx_params_decoder(params, &p))
182	0	return 0;
183
184	47.8k	if (p.tag != NULL) {
185	1.23k	if (p.tag->data_type != OSSL_PARAM_OCTET_STRING) {
186	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
187	0	return 0;
188	0	}
189	1.23k	if ((p.tag->data_size & 1) \|\| (p.tag->data_size < 4) \|\| p.tag->data_size > 16) {
190	23	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG_LENGTH);
191	23	return 0;
192	23	}
193
194	1.21k	if (p.tag->data != NULL) {
195	6	if (ctx->enc) {
196	6	ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_NEEDED);
197	6	return 0;
198	6	}
199	0	memcpy(ctx->buf, p.tag->data, p.tag->data_size);
200	0	ctx->tag_set = 1;
201	0	}
202	1.21k	ctx->m = p.tag->data_size;
203	1.21k	}
204
205	47.8k	if (p.ivlen != NULL) {
206	1.21k	if (!OSSL_PARAM_get_size_t(p.ivlen, &sz)) {
207	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
208	0	return 0;
209	0	}
210	1.21k	ivlen = 15 - sz;
211	1.21k	if (ivlen < 2 \|\| ivlen > 8) {
212	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
213	0	return 0;
214	0	}
215	1.21k	if (ctx->l != ivlen) {
216	1.21k	ctx->l = ivlen;
217	1.21k	ctx->iv_set = 0;
218	1.21k	}
219	1.21k	}
220
221	47.8k	if (p.aad != NULL) {
222	40.4k	if (p.aad->data_type != OSSL_PARAM_OCTET_STRING) {
223	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
224	0	return 0;
225	0	}
226	40.4k	sz = ccm_tls_init(ctx, p.aad->data, p.aad->data_size);
227	40.4k	if (sz == 0) {
228	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
229	0	return 0;
230	0	}
231	40.4k	ctx->tls_aad_pad_sz = sz;
232	40.4k	}
233
234	47.8k	if (p.fixed != NULL) {
235	1.21k	if (p.fixed->data_type != OSSL_PARAM_OCTET_STRING) {
236	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
237	0	return 0;
238	0	}
239	1.21k	if (ccm_tls_iv_set_fixed(ctx, p.fixed->data, p.fixed->data_size) == 0) {
240	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
241	0	return 0;
242	0	}
243	1.21k	}
244	47.8k	return 1;
245	47.8k	}
246
247		/* clang-format off */
248		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
249		#ifndef ossl_cipher_ccm_get_ctx_params_list
250		static ossl_unused const OSSL_PARAM ossl_cipher_ccm_get_ctx_params_list[] = {
251		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
252		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
253		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
254		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
255		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
256		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
257		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
258		# if defined(FIPS_MODULE)
259		OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR, NULL),
260		# endif
261		OSSL_PARAM_END
262		};
263		#endif
264
265		#ifndef ossl_cipher_ccm_get_ctx_params_st
266		struct ossl_cipher_ccm_get_ctx_params_st {
267		OSSL_PARAM *iv;
268		OSSL_PARAM *ivlen;
269		OSSL_PARAM *keylen;
270		OSSL_PARAM *pad;
271		OSSL_PARAM *tag;
272		OSSL_PARAM *taglen;
273		OSSL_PARAM *updiv;
274		};
275		#endif
276
277		#ifndef ossl_cipher_ccm_get_ctx_params_decoder
278		static ossl_unused int ossl_cipher_ccm_get_ctx_params_decoder
279		(const OSSL_PARAM p, struct ossl_cipher_ccm_get_ctx_params_st r)
280	41.7k	{
281	41.7k	const char *s;
282
283	41.7k	memset(r, 0, sizeof(*r));
284	41.7k	if (p != NULL)
285	83.5k	for (; (s = p->key) != NULL; p++)
286	41.7k	switch(s[0]) {
287	0	default:
288	0	break;
289	0	case 'f':
290		# if defined(FIPS_MODULE)
291		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
292		/* OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR */
293		if (!OSSL_PARAM_set_int((OSSL_PARAM *)p, 1))
294		return 0;
295		}
296		# endif
297	0	break;
298	29	case 'i':
299	29	switch(s[1]) {
300	0	default:
301	0	break;
302	29	case 'v':
303	29	switch(s[2]) {
304	0	default:
305	0	break;
306	29	case 'l':
307	29	if (ossl_likely(strcmp("en", s + 3) == 0)) {
308		/* OSSL_CIPHER_PARAM_IVLEN */
309	29	if (ossl_unlikely(r->ivlen != NULL)) {
310	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
311	0	"param %s is repeated", s);
312	0	return 0;
313	0	}
314	29	r->ivlen = (OSSL_PARAM *)p;
315	29	}
316	29	break;
317	29	case '\0':
318	0	if (ossl_unlikely(r->iv != NULL)) {
319	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
320	0	"param %s is repeated", s);
321	0	return 0;
322	0	}
323	0	r->iv = (OSSL_PARAM *)p;
324	29	}
325	29	}
326	29	break;
327	1.24k	case 'k':
328	1.24k	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
329		/* OSSL_CIPHER_PARAM_KEYLEN */
330	1.24k	if (ossl_unlikely(r->keylen != NULL)) {
331	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
332	0	"param %s is repeated", s);
333	0	return 0;
334	0	}
335	1.24k	r->keylen = (OSSL_PARAM *)p;
336	1.24k	}
337	1.24k	break;
338	40.5k	case 't':
339	40.5k	switch(s[1]) {
340	0	default:
341	0	break;
342	0	case 'a':
343	0	switch(s[2]) {
344	0	default:
345	0	break;
346	0	case 'g':
347	0	switch(s[3]) {
348	0	default:
349	0	break;
350	0	case 'l':
351	0	if (ossl_likely(strcmp("en", s + 4) == 0)) {
352		/* OSSL_CIPHER_PARAM_AEAD_TAGLEN */
353	0	if (ossl_unlikely(r->taglen != NULL)) {
354	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
355	0	"param %s is repeated", s);
356	0	return 0;
357	0	}
358	0	r->taglen = (OSSL_PARAM *)p;
359	0	}
360	0	break;
361	0	case '\0':
362	0	if (ossl_unlikely(r->tag != NULL)) {
363	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
364	0	"param %s is repeated", s);
365	0	return 0;
366	0	}
367	0	r->tag = (OSSL_PARAM *)p;
368	0	}
369	0	}
370	0	break;
371	40.5k	case 'l':
372	40.5k	if (ossl_likely(strcmp("saadpad", s + 2) == 0)) {
373		/* OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD */
374	40.4k	if (ossl_unlikely(r->pad != NULL)) {
375	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
376	0	"param %s is repeated", s);
377	0	return 0;
378	0	}
379	40.4k	r->pad = (OSSL_PARAM *)p;
380	40.4k	}
381	40.5k	}
382	40.5k	break;
383	40.5k	case 'u':
384	0	if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
385		/* OSSL_CIPHER_PARAM_UPDATED_IV */
386	0	if (ossl_unlikely(r->updiv != NULL)) {
387	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
388	0	"param %s is repeated", s);
389	0	return 0;
390	0	}
391	0	r->updiv = (OSSL_PARAM *)p;
392	0	}
393	41.7k	}
394	41.7k	return 1;
395	41.7k	}
396		#endif
397		/* End of machine generated */
398		/* clang-format on */
399
400		const OSSL_PARAM *ossl_ccm_gettable_ctx_params(
401		ossl_unused void cctx, ossl_unused void provctx)
402	413	{
403	413	return ossl_cipher_ccm_get_ctx_params_list;
404	413	}
405
406		int ossl_ccm_get_ctx_params(void *vctx, OSSL_PARAM params[])
407	41.7k	{
408	41.7k	PROV_CCM_CTX ctx = (PROV_CCM_CTX )vctx;
409	41.7k	struct ossl_cipher_ccm_get_ctx_params_st p;
410
411	41.7k	if (ctx == NULL \|\| !ossl_cipher_ccm_get_ctx_params_decoder(params, &p))
412	0	return 0;
413
414	41.7k	if (p.ivlen != NULL && !OSSL_PARAM_set_size_t(p.ivlen, ccm_get_ivlen(ctx))) {
415	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
416	0	return 0;
417	0	}
418
419	41.7k	if (p.taglen != NULL && !OSSL_PARAM_set_size_t(p.taglen, ctx->m)) {
420	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
421	0	return 0;
422	0	}
423
424	41.7k	if (p.iv != NULL) {
425	0	if (ccm_get_ivlen(ctx) > p.iv->data_size) {
426	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
427	0	return 0;
428	0	}
429	0	if (!OSSL_PARAM_set_octet_string_or_ptr(p.iv, ctx->iv, p.iv->data_size)) {
430	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
431	0	return 0;
432	0	}
433	0	}
434
435	41.7k	if (p.updiv != NULL) {
436	0	if (ccm_get_ivlen(ctx) > p.updiv->data_size) {
437	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
438	0	return 0;
439	0	}
440	0	if (!OSSL_PARAM_set_octet_string_or_ptr(p.updiv, ctx->iv, p.updiv->data_size)) {
441	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
442	0	return 0;
443	0	}
444	0	}
445
446	41.7k	if (p.keylen != NULL && !OSSL_PARAM_set_size_t(p.keylen, ctx->keylen)) {
447	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
448	0	return 0;
449	0	}
450
451	41.7k	if (p.pad != NULL && !OSSL_PARAM_set_size_t(p.pad, ctx->tls_aad_pad_sz)) {
452	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
453	0	return 0;
454	0	}
455
456	41.7k	if (p.tag != NULL) {
457	0	if (!ctx->enc \|\| !ctx->tag_set) {
458	0	ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
459	0	return 0;
460	0	}
461	0	if (p.tag->data_type != OSSL_PARAM_OCTET_STRING) {
462	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
463	0	return 0;
464	0	}
465	0	if (!ctx->hw->gettag(ctx, p.tag->data, p.tag->data_size))
466	0	return 0;
467	0	ctx->tag_set = 0;
468	0	ctx->iv_set = 0;
469	0	ctx->len_set = 0;
470	0	}
471
472	41.7k	return 1;
473	41.7k	}
474
475		static int ccm_init(void vctx, const unsigned char key, size_t keylen,
476		const unsigned char *iv, size_t ivlen,
477		const OSSL_PARAM params[], int enc)
478	4.83k	{
479	4.83k	PROV_CCM_CTX ctx = (PROV_CCM_CTX )vctx;
480
481	4.83k	if (!ossl_prov_is_running())
482	0	return 0;
483
484	4.83k	ctx->enc = enc;
485
486	4.83k	if (iv != NULL) {
487	29	if (ivlen != ccm_get_ivlen(ctx)) {
488	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
489	0	return 0;
490	0	}
491	29	memcpy(ctx->iv, iv, ivlen);
492	29	ctx->iv_set = 1;
493	29	}
494	4.83k	if (key != NULL) {
495	2.40k	if (keylen != ctx->keylen) {
496	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
497	0	return 0;
498	0	}
499	2.40k	if (!ctx->hw->setkey(ctx, key, keylen))
500	0	return 0;
501	2.40k	}
502	4.83k	return ossl_ccm_set_ctx_params(ctx, params);
503	4.83k	}
504
505		int ossl_ccm_einit(void vctx, const unsigned char key, size_t keylen,
506		const unsigned char *iv, size_t ivlen,
507		const OSSL_PARAM params[])
508	1.71k	{
509	1.71k	return ccm_init(vctx, key, keylen, iv, ivlen, params, 1);
510	1.71k	}
511
512		int ossl_ccm_dinit(void vctx, const unsigned char key, size_t keylen,
513		const unsigned char *iv, size_t ivlen,
514		const OSSL_PARAM params[])
515	3.11k	{
516	3.11k	return ccm_init(vctx, key, keylen, iv, ivlen, params, 0);
517	3.11k	}
518
519		int ossl_ccm_stream_update(void vctx, unsigned char out, size_t *outl,
520		size_t outsize, const unsigned char *in,
521		size_t inl)
522	67.4k	{
523	67.4k	PROV_CCM_CTX ctx = (PROV_CCM_CTX )vctx;
524
525	67.4k	if (outsize < inl) {
526	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
527	0	return 0;
528	0	}
529
530	67.4k	if (!ccm_cipher_internal(ctx, out, outl, in, inl)) {
531	66.5k	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
532	66.5k	return 0;
533	66.5k	}
534	908	return 1;
535	67.4k	}
536
537		int ossl_ccm_stream_final(void vctx, unsigned char out, size_t *outl,
538		size_t outsize)
539	0	{
540	0	PROV_CCM_CTX ctx = (PROV_CCM_CTX )vctx;
541	0	unsigned char dummy_in = 0, dummy_out = 0;
542
543	0	if (!ossl_prov_is_running())
544	0	return 0;
545
546		/*
547		* Encryption sets tag_set after processing the payload, while successful
548		* decryption clears iv_set. Use those transitions to avoid processing an
549		* operation twice.
550		*/
551	0	if (!ctx->key_set
552	0	\|\| (ctx->iv_set && (!ctx->enc \|\| !ctx->tag_set)
553	0	&& ccm_cipher_internal(ctx, &dummy_out, outl, &dummy_in, 0) <= 0))
554	0	return 0;
555
556	0	*outl = 0;
557	0	return 1;
558	0	}
559
560		int ossl_ccm_cipher(void vctx, unsigned char out, size_t *outl, size_t outsize,
561		const unsigned char *in, size_t inl)
562	0	{
563	0	PROV_CCM_CTX ctx = (PROV_CCM_CTX )vctx;
564
565	0	if (!ossl_prov_is_running())
566	0	return 0;
567
568	0	if (in == NULL)
569	0	return ossl_ccm_stream_final(vctx, out, outl, outsize);
570
571	0	if (outsize < inl) {
572	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
573	0	return 0;
574	0	}
575
576	0	if (ccm_cipher_internal(ctx, out, outl, in, inl) <= 0)
577	0	return 0;
578
579	0	*outl = inl;
580	0	return 1;
581	0	}
582
583		/* Copy the buffered iv */
584		static int ccm_set_iv(PROV_CCM_CTX *ctx, size_t mlen)
585	88.7k	{
586	88.7k	const PROV_CCM_HW *hw = ctx->hw;
587
588	88.7k	if (!hw->setiv(ctx, ctx->iv, ccm_get_ivlen(ctx), mlen))
589	0	return 0;
590	88.7k	ctx->len_set = 1;
591	88.7k	return 1;
592	88.7k	}
593
594		static int ccm_tls_cipher(PROV_CCM_CTX *ctx,
595		unsigned char out, size_t padlen,
596		const unsigned char *in, size_t len)
597	88.7k	{
598	88.7k	int rv = 0;
599	88.7k	size_t olen = 0;
600
601	88.7k	if (!ossl_prov_is_running())
602	0	goto err;
603
604		/* Encrypt/decrypt must be performed in place */
605	88.7k	if (in == NULL \|\| out != in \|\| len < EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m)
606	0	goto err;
607
608		/* If encrypting set explicit IV from sequence number (start of AAD) */
609	88.7k	if (ctx->enc)
610	1.01k	memcpy(out, ctx->buf, EVP_CCM_TLS_EXPLICIT_IV_LEN);
611		/* Get rest of IV from explicit IV */
612	88.7k	memcpy(ctx->iv + EVP_CCM_TLS_FIXED_IV_LEN, in, EVP_CCM_TLS_EXPLICIT_IV_LEN);
613		/* Correct length value */
614	88.7k	len -= EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m;
615	88.7k	if (!ccm_set_iv(ctx, len))
616	0	goto err;
617
618		/* Use saved AAD */
619	88.7k	if (!ctx->hw->setaad(ctx, ctx->buf, ctx->tls_aad_len))
620	0	goto err;
621
622		/* Fix buffer to point to payload */
623	88.7k	in += EVP_CCM_TLS_EXPLICIT_IV_LEN;
624	88.7k	out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
625	88.7k	if (ctx->enc) {
626	1.01k	if (!ctx->hw->auth_encrypt(ctx, in, out, len, out + len, ctx->m))
627	0	goto err;
628	1.01k	olen = len + EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m;
629	87.7k	} else {
630	87.7k	if (!ctx->hw->auth_decrypt(ctx, in, out, len,
631	87.7k	(unsigned char *)in + len, ctx->m))
632	87.6k	goto err;
633	120	olen = len;
634	120	}
635	1.13k	rv = 1;
636	88.7k	err:
637	88.7k	*padlen = olen;
638	88.7k	return rv;
639	1.13k	}
640
641		static int ccm_cipher_internal(PROV_CCM_CTX ctx, unsigned char out,
642		size_t padlen, const unsigned char in,
643		size_t len)
644	88.7k	{
645	88.7k	int rv = 0;
646	88.7k	size_t olen = 0;
647	88.7k	const PROV_CCM_HW *hw = ctx->hw;
648
649		/* If no key set, return error */
650	88.7k	if (!ctx->key_set)
651	0	return 0;
652
653	88.7k	if (ctx->tls_aad_len != UNINITIALISED_SIZET)
654	88.7k	return ccm_tls_cipher(ctx, out, padlen, in, len);
655
656		/* EVP_Final() doesn't return any data /
657	3	if (in == NULL && out != NULL)
658	0	goto finish;
659
660	3	if (!ctx->iv_set)
661	3	goto err;
662
663	0	if (out == NULL) {
664	0	if (in == NULL) {
665	0	if (!ccm_set_iv(ctx, len))
666	0	goto err;
667	0	} else {
668		/* If we have AAD, we need a message length */
669	0	if (!ctx->len_set && len)
670	0	goto err;
671	0	if (!hw->setaad(ctx, in, len))
672	0	goto err;
673	0	}
674	0	} else {
675		/* If not set length yet do it */
676	0	if (!ctx->len_set && !ccm_set_iv(ctx, len))
677	0	goto err;
678
679	0	if (ctx->enc) {
680	0	if (!hw->auth_encrypt(ctx, in, out, len, NULL, 0))
681	0	goto err;
682	0	ctx->tag_set = 1;
683	0	} else {
684		/* The tag must be set before actually decrypting data */
685	0	if (!ctx->tag_set)
686	0	goto err;
687
688	0	if (!hw->auth_decrypt(ctx, in, out, len, ctx->buf, ctx->m))
689	0	goto err;
690		/* Finished - reset flags so calling this method again will fail */
691	0	ctx->iv_set = 0;
692	0	ctx->tag_set = 0;
693	0	ctx->len_set = 0;
694	0	}
695	0	}
696	0	olen = len;
697	0	finish:
698	0	rv = 1;
699	3	err:
700	3	*padlen = olen;
701	3	return rv;
702	0	}
703
704		void ossl_ccm_initctx(PROV_CCM_CTX ctx, size_t keybits, const PROV_CCM_HW hw)
705	2.45k	{
706	2.45k	ctx->keylen = keybits / 8;
707	2.45k	ctx->key_set = 0;
708	2.45k	ctx->iv_set = 0;
709	2.45k	ctx->tag_set = 0;
710	2.45k	ctx->len_set = 0;
711	2.45k	ctx->l = 8;
712	2.45k	ctx->m = 12;
713	2.45k	ctx->tls_aad_len = UNINITIALISED_SIZET;
714	2.45k	ctx->hw = hw;
715	2.45k	}