/src/openssl30/providers/implementations/ciphers/ciphercommon.c

Source (jump to first uncovered line)
/*
 * Copyright 2019-2021 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
 */

/*
 * Generic dispatch table functions for ciphers.
 */

/* For SSL3_VERSION */
#include <openssl/prov_ssl.h>
#include <openssl/proverr.h>
#include "ciphercommon_local.h"
#include "prov/provider_ctx.h"
#include "prov/providercommon.h"

/*-
 * Generic cipher functions for OSSL_PARAM gettables and settables
 */
static const OSSL_PARAM cipher_known_gettable_params[] = {
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL),
    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_BLOCK_SIZE, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_AEAD, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_CUSTOM_IV, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_CTS, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_HAS_RAND_KEY, NULL),
    OSSL_PARAM_END
};
const OSSL_PARAM *ossl_cipher_generic_gettable_params(ossl_unused void *provctx)
{
    return cipher_known_gettable_params;
}

int ossl_cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
                                   uint64_t flags,
                                   size_t kbits, size_t blkbits, size_t ivbits)
{
    OSSL_PARAM *p;

    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE);
    if (p != NULL && !OSSL_PARAM_set_uint(p, md)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD);
    if (p != NULL
        && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_AEAD) != 0)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CUSTOM_IV);
    if (p != NULL
        && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CUSTOM_IV) != 0)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CTS);
    if (p != NULL
        && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CTS) != 0)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK);
    if (p != NULL
        && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_TLS1_MULTIBLOCK) != 0)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_HAS_RAND_KEY);
    if (p != NULL
        && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_RAND_KEY) != 0)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
    if (p != NULL && !OSSL_PARAM_set_size_t(p, kbits / 8)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_BLOCK_SIZE);
    if (p != NULL && !OSSL_PARAM_set_size_t(p, blkbits / 8)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
    if (p != NULL && !OSSL_PARAM_set_size_t(p, ivbits / 8)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    return 1;
}

CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(ossl_cipher_generic)
{ OSSL_CIPHER_PARAM_TLS_MAC, OSSL_PARAM_OCTET_PTR, NULL, 0, OSSL_PARAM_UNMODIFIED },
CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(ossl_cipher_generic)

CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(ossl_cipher_generic)
OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(ossl_cipher_generic)

/*
 * Variable key length cipher functions for OSSL_PARAM settables
 */
int ossl_cipher_var_keylen_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
    PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
    const OSSL_PARAM *p;

    if (params == NULL)
        return 1;

    if (!ossl_cipher_generic_set_ctx_params(vctx, params))
        return 0;
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
    if (p != NULL) {
        size_t keylen;

        if (!OSSL_PARAM_get_size_t(p, &keylen)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        ctx->keylen = keylen;
    }
    return 1;
}

CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(ossl_cipher_var_keylen)
OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(ossl_cipher_var_keylen)

/*-
 * AEAD cipher functions for OSSL_PARAM gettables and settables
 */
static const OSSL_PARAM cipher_aead_known_gettable_ctx_params[] = {
    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),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, NULL, 0),
    OSSL_PARAM_END
};
const OSSL_PARAM *ossl_cipher_aead_gettable_ctx_params(
        ossl_unused void *cctx, ossl_unused void *provctx
    )
{
    return cipher_aead_known_gettable_ctx_params;
}

static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = {
    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_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, NULL, 0),
    OSSL_PARAM_END
};
const OSSL_PARAM *ossl_cipher_aead_settable_ctx_params(
        ossl_unused void *cctx, ossl_unused void *provctx
    )
{
    return cipher_aead_known_settable_ctx_params;
}

void ossl_cipher_generic_reset_ctx(PROV_CIPHER_CTX *ctx)
{
    if (ctx != NULL && ctx->alloced) {
        OPENSSL_free(ctx->tlsmac);
        ctx->alloced = 0;
        ctx->tlsmac = NULL;
    }
}

static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx,
                                        const unsigned char *key, size_t keylen,
                                        const unsigned char *iv, size_t ivlen,
                                        const OSSL_PARAM params[], int enc)
{
    ctx->num = 0;
    ctx->bufsz = 0;
    ctx->updated = 0;
    ctx->enc = enc ? 1 : 0;

    if (!ossl_prov_is_running())
        return 0;

    if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) {
        if (!ossl_cipher_generic_initiv(ctx, iv, ivlen))
            return 0;
    }
    if (iv == NULL && ctx->iv_set
        && (ctx->mode == EVP_CIPH_CBC_MODE
            || ctx->mode == EVP_CIPH_CFB_MODE
            || ctx->mode == EVP_CIPH_OFB_MODE))
        /* reset IV for these modes to keep compatibility with 1.1.1 */
        memcpy(ctx->iv, ctx->oiv, ctx->ivlen);

    if (key != NULL) {
        if (ctx->variable_keylength == 0) {
            if (keylen != ctx->keylen) {
                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
                return 0;
            }
        } else {
            ctx->keylen = keylen;
        }
        if (!ctx->hw->init(ctx, key, ctx->keylen))
            return 0;
    }
    return ossl_cipher_generic_set_ctx_params(ctx, params);
}

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

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

/* Max padding including padding length byte */
#define MAX_PADDING 256

int ossl_cipher_generic_block_update(void *vctx, unsigned char *out,
                                     size_t *outl, size_t outsize,
                                     const unsigned char *in, size_t inl)
{
    size_t outlint = 0;
    PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
    size_t blksz = ctx->blocksize;
    size_t nextblocks;

    if (ctx->tlsversion > 0) {
        /*
         * Each update call corresponds to a TLS record and is individually
         * padded
         */

        /* Sanity check inputs */
        if (in == NULL
                || in != out
                || outsize < inl
                || !ctx->pad) {
            ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
            return 0;
        }

        if (ctx->enc) {
            unsigned char padval;
            size_t padnum, loop;

            /* Add padding */

            padnum = blksz - (inl % blksz);

            if (outsize < inl + padnum) {
                ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
                return 0;
            }

            if (padnum > MAX_PADDING) {
                ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
                return 0;
            }
            padval = (unsigned char)(padnum - 1);
            if (ctx->tlsversion == SSL3_VERSION) {
                if (padnum > 1)
                    memset(out + inl, 0, padnum - 1);
                *(out + inl + padnum - 1) = padval;
            } else {
                /* we need to add 'padnum' padding bytes of value padval */
                for (loop = inl; loop < inl + padnum; loop++)
                    out[loop] = padval;
            }
            inl += padnum;
        }

        if ((inl % blksz) != 0) {
            ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
            return 0;
        }


        /* Shouldn't normally fail */
        if (!ctx->hw->cipher(ctx, out, in, inl)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
            return 0;
        }

        if (ctx->alloced) {
            OPENSSL_free(ctx->tlsmac);
            ctx->alloced = 0;
            ctx->tlsmac = NULL;
        }

        /* This only fails if padding is publicly invalid */
        *outl = inl;
        if (!ctx->enc
            && !ossl_cipher_tlsunpadblock(ctx->libctx, ctx->tlsversion,
                                          out, outl,
                                          blksz, &ctx->tlsmac, &ctx->alloced,
                                          ctx->tlsmacsize, 0)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
            return 0;
        }
        return 1;
    }

    if (ctx->bufsz != 0)
        nextblocks = ossl_cipher_fillblock(ctx->buf, &ctx->bufsz, blksz,
                                           &in, &inl);
    else
        nextblocks = inl & ~(blksz-1);

    /*
     * If we're decrypting and we end an update on a block boundary we hold
     * the last block back in case this is the last update call and the last
     * block is padded.
     */
    if (ctx->bufsz == blksz && (ctx->enc || inl > 0 || !ctx->pad)) {
        if (outsize < blksz) {
            ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
            return 0;
        }
        if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
            return 0;
        }
        ctx->bufsz = 0;
        outlint = blksz;
        out += blksz;
    }
    if (nextblocks > 0) {
        if (!ctx->enc && ctx->pad && nextblocks == inl) {
            if (!ossl_assert(inl >= blksz)) {
                ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
                return 0;
            }
            nextblocks -= blksz;
        }
        outlint += nextblocks;
        if (outsize < outlint) {
            ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
            return 0;
        }
    }
    if (nextblocks > 0) {
        if (!ctx->hw->cipher(ctx, out, in, nextblocks)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
            return 0;
        }
        in += nextblocks;
        inl -= nextblocks;
    }
    if (inl != 0
        && !ossl_cipher_trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) {
        /* ERR_raise already called */
        return 0;
    }

    *outl = outlint;
    return inl == 0;
}

int ossl_cipher_generic_block_final(void *vctx, unsigned char *out,
                                    size_t *outl, size_t outsize)
{
    PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
    size_t blksz = ctx->blocksize;

    if (!ossl_prov_is_running())
        return 0;

    if (ctx->tlsversion > 0) {
        /* We never finalize TLS, so this is an error */
        ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
        return 0;
    }

    if (ctx->enc) {
        if (ctx->pad) {
            ossl_cipher_padblock(ctx->buf, &ctx->bufsz, blksz);
        } else if (ctx->bufsz == 0) {
            *outl = 0;
            return 1;
        } else if (ctx->bufsz != blksz) {
            ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
            return 0;
        }

        if (outsize < blksz) {
            ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
            return 0;
        }
        if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
            return 0;
        }
        ctx->bufsz = 0;
        *outl = blksz;
        return 1;
    }

    /* Decrypting */
    if (ctx->bufsz != blksz) {
        if (ctx->bufsz == 0 && !ctx->pad) {
            *outl = 0;
            return 1;
        }
        ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
        return 0;
    }

    if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
        return 0;
    }

    if (ctx->pad && !ossl_cipher_unpadblock(ctx->buf, &ctx->bufsz, blksz)) {
        /* ERR_raise already called */
        return 0;
    }

    if (outsize < ctx->bufsz) {
        ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
        return 0;
    }
    memcpy(out, ctx->buf, ctx->bufsz);
    *outl = ctx->bufsz;
    ctx->bufsz = 0;
    return 1;
}

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

    if (inl == 0) {
        *outl = 0;
        return 1;
    }

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

    if (!ctx->hw->cipher(ctx, out, in, inl)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
        return 0;
    }

    *outl = inl;
    if (!ctx->enc && ctx->tlsversion > 0) {
        /*
        * Remove any TLS padding. Only used by cipher_aes_cbc_hmac_sha1_hw.c and
        * cipher_aes_cbc_hmac_sha256_hw.c
        */
        if (ctx->removetlspad) {
            /*
             * We should have already failed in the cipher() call above if this
             * isn't true.
             */
            if (!ossl_assert(*outl >= (size_t)(out[inl - 1] + 1)))
                return 0;
            /* The actual padding length */
            *outl -= out[inl - 1] + 1;
        }

        /* TLS MAC and explicit IV if relevant. We should have already failed
         * in the cipher() call above if *outl is too short.
         */
        if (!ossl_assert(*outl >= ctx->removetlsfixed))
            return 0;
        *outl -= ctx->removetlsfixed;

        /* Extract the MAC if there is one */
        if (ctx->tlsmacsize > 0) {
            if (*outl < ctx->tlsmacsize)
                return 0;

            ctx->tlsmac = out + *outl - ctx->tlsmacsize;
            *outl -= ctx->tlsmacsize;
        }
    }

    return 1;
}
int ossl_cipher_generic_stream_final(void *vctx, unsigned char *out,
                                     size_t *outl, size_t outsize)
{
    if (!ossl_prov_is_running())
        return 0;

    *outl = 0;
    return 1;
}

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

    if (!ossl_prov_is_running())
        return 0;

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

    if (!ctx->hw->cipher(ctx, out, in, inl)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
        return 0;
    }

    *outl = inl;
    return 1;
}

int ossl_cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[])
{
    PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
    OSSL_PARAM *p;

    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
    if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
    if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
    if (p != NULL
        && !OSSL_PARAM_set_octet_ptr(p, &ctx->oiv, ctx->ivlen)
        && !OSSL_PARAM_set_octet_string(p, &ctx->oiv, ctx->ivlen)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_UPDATED_IV);
    if (p != NULL
        && !OSSL_PARAM_set_octet_ptr(p, &ctx->iv, ctx->ivlen)
        && !OSSL_PARAM_set_octet_string(p, &ctx->iv, ctx->ivlen)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM);
    if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
    if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS_MAC);
    if (p != NULL
        && !OSSL_PARAM_set_octet_ptr(p, ctx->tlsmac, ctx->tlsmacsize)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    return 1;
}

int ossl_cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
    PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
    const OSSL_PARAM *p;

    if (params == NULL)
        return 1;

    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
    if (p != NULL) {
        unsigned int pad;

        if (!OSSL_PARAM_get_uint(p, &pad)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        ctx->pad = pad ? 1 : 0;
    }
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_USE_BITS);
    if (p != NULL) {
        unsigned int bits;

        if (!OSSL_PARAM_get_uint(p, &bits)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        ctx->use_bits = bits ? 1 : 0;
    }
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_VERSION);
    if (p != NULL) {
        if (!OSSL_PARAM_get_uint(p, &ctx->tlsversion)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
    }
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_MAC_SIZE);
    if (p != NULL) {
        if (!OSSL_PARAM_get_size_t(p, &ctx->tlsmacsize)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
    }
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM);
    if (p != NULL) {
        unsigned int num;

        if (!OSSL_PARAM_get_uint(p, &num)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        ctx->num = num;
    }
    return 1;
}

int ossl_cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv,
                               size_t ivlen)
{
    if (ivlen != ctx->ivlen
        || ivlen > sizeof(ctx->iv)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
        return 0;
    }
    ctx->iv_set = 1;
    memcpy(ctx->iv, iv, ivlen);
    memcpy(ctx->oiv, iv, ivlen);
    return 1;
}

void ossl_cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
                                 size_t ivbits, unsigned int mode,
                                 uint64_t flags, const PROV_CIPHER_HW *hw,
                                 void *provctx)
{
    PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;

    if ((flags & PROV_CIPHER_FLAG_INVERSE_CIPHER) != 0)
        ctx->inverse_cipher = 1;
    if ((flags & PROV_CIPHER_FLAG_VARIABLE_LENGTH) != 0)
        ctx->variable_keylength = 1;

    ctx->pad = 1;
    ctx->keylen = ((kbits) / 8);
    ctx->ivlen = ((ivbits) / 8);
    ctx->hw = hw;
    ctx->mode = mode;
    ctx->blocksize = blkbits / 8;
    if (provctx != NULL)
        ctx->libctx = PROV_LIBCTX_OF(provctx); /* used for rand */
}

Coverage Report

Created: 2023-06-08 06:41

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2019-2021 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
10		/*
11		* Generic dispatch table functions for ciphers.
12		*/
13
14		/* For SSL3_VERSION */
15		#include <openssl/prov_ssl.h>
16		#include <openssl/proverr.h>
17		#include "ciphercommon_local.h"
18		#include "prov/provider_ctx.h"
19		#include "prov/providercommon.h"
20
21		/*-
22		* Generic cipher functions for OSSL_PARAM gettables and settables
23		*/
24		static const OSSL_PARAM cipher_known_gettable_params[] = {
25		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL),
26		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
27		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
28		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_BLOCK_SIZE, NULL),
29		OSSL_PARAM_int(OSSL_CIPHER_PARAM_AEAD, NULL),
30		OSSL_PARAM_int(OSSL_CIPHER_PARAM_CUSTOM_IV, NULL),
31		OSSL_PARAM_int(OSSL_CIPHER_PARAM_CTS, NULL),
32		OSSL_PARAM_int(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK, NULL),
33		OSSL_PARAM_int(OSSL_CIPHER_PARAM_HAS_RAND_KEY, NULL),
34		OSSL_PARAM_END
35		};
36		const OSSL_PARAM ossl_cipher_generic_gettable_params(ossl_unused void provctx)
37	0	{
38	0	return cipher_known_gettable_params;
39	0	}
40
41		int ossl_cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
42		uint64_t flags,
43		size_t kbits, size_t blkbits, size_t ivbits)
44	124	{
45	124	OSSL_PARAM *p;
46
47	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE);
48	124	if (p != NULL && !OSSL_PARAM_set_uint(p, md)) {
49	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
50	0	return 0;
51	0	}
52	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD);
53	124	if (p != NULL
54	124	&& !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_AEAD) != 0)) {
55	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
56	0	return 0;
57	0	}
58	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CUSTOM_IV);
59	124	if (p != NULL
60	124	&& !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CUSTOM_IV) != 0)) {
61	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
62	0	return 0;
63	0	}
64	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CTS);
65	124	if (p != NULL
66	124	&& !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CTS) != 0)) {
67	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
68	0	return 0;
69	0	}
70	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK);
71	124	if (p != NULL
72	124	&& !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_TLS1_MULTIBLOCK) != 0)) {
73	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
74	0	return 0;
75	0	}
76	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_HAS_RAND_KEY);
77	124	if (p != NULL
78	124	&& !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_RAND_KEY) != 0)) {
79	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
80	0	return 0;
81	0	}
82	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
83	124	if (p != NULL && !OSSL_PARAM_set_size_t(p, kbits / 8)) {
84	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
85	0	return 0;
86	0	}
87	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_BLOCK_SIZE);
88	124	if (p != NULL && !OSSL_PARAM_set_size_t(p, blkbits / 8)) {
89	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
90	0	return 0;
91	0	}
92	124	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
93	124	if (p != NULL && !OSSL_PARAM_set_size_t(p, ivbits / 8)) {
94	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
95	0	return 0;
96	0	}
97	124	return 1;
98	124	}
99
100		CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(ossl_cipher_generic)
101		{ OSSL_CIPHER_PARAM_TLS_MAC, OSSL_PARAM_OCTET_PTR, NULL, 0, OSSL_PARAM_UNMODIFIED },
102		CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(ossl_cipher_generic)
103
104		CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(ossl_cipher_generic)
105		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
106		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
107		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
108		CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(ossl_cipher_generic)
109
110		/*
111		* Variable key length cipher functions for OSSL_PARAM settables
112		*/
113		int ossl_cipher_var_keylen_set_ctx_params(void *vctx, const OSSL_PARAM params[])
114	0	{
115	0	PROV_CIPHER_CTX ctx = (PROV_CIPHER_CTX )vctx;
116	0	const OSSL_PARAM *p;
117
118	0	if (params == NULL)
119	0	return 1;
120
121	0	if (!ossl_cipher_generic_set_ctx_params(vctx, params))
122	0	return 0;
123	0	p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
124	0	if (p != NULL) {
125	0	size_t keylen;
126
127	0	if (!OSSL_PARAM_get_size_t(p, &keylen)) {
128	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
129	0	return 0;
130	0	}
131	0	ctx->keylen = keylen;
132	0	}
133	0	return 1;
134	0	}
135
136		CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(ossl_cipher_var_keylen)
137		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
138		CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(ossl_cipher_var_keylen)
139
140		/*-
141		* AEAD cipher functions for OSSL_PARAM gettables and settables
142		*/
143		static const OSSL_PARAM cipher_aead_known_gettable_ctx_params[] = {
144		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
145		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
146		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
147		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
148		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
149		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
150		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
151		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, NULL, 0),
152		OSSL_PARAM_END
153		};
154		const OSSL_PARAM *ossl_cipher_aead_gettable_ctx_params(
155		ossl_unused void cctx, ossl_unused void provctx
156		)
157	12	{
158	12	return cipher_aead_known_gettable_ctx_params;
159	12	}
160
161		static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = {
162		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
163		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
164		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
165		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
166		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, NULL, 0),
167		OSSL_PARAM_END
168		};
169		const OSSL_PARAM *ossl_cipher_aead_settable_ctx_params(
170		ossl_unused void cctx, ossl_unused void provctx
171		)
172	0	{
173	0	return cipher_aead_known_settable_ctx_params;
174	0	}
175
176		void ossl_cipher_generic_reset_ctx(PROV_CIPHER_CTX *ctx)
177	1.18k	{
178	1.18k	if (ctx != NULL && ctx->alloced) {
179	94	OPENSSL_free(ctx->tlsmac);
180	94	ctx->alloced = 0;
181	94	ctx->tlsmac = NULL;
182	94	}
183	1.18k	}
184
185		static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx,
186		const unsigned char *key, size_t keylen,
187		const unsigned char *iv, size_t ivlen,
188		const OSSL_PARAM params[], int enc)
189	31.6k	{
190	31.6k	ctx->num = 0;
191	31.6k	ctx->bufsz = 0;
192	31.6k	ctx->updated = 0;
193	31.6k	ctx->enc = enc ? 1 : 0;
194
195	31.6k	if (!ossl_prov_is_running())
196	0	return 0;
197
198	31.6k	if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) {
199	29.5k	if (!ossl_cipher_generic_initiv(ctx, iv, ivlen))
200	0	return 0;
201	29.5k	}
202	31.6k	if (iv == NULL && ctx->iv_set
203	31.6k	&& (ctx->mode == EVP_CIPH_CBC_MODE
204	0	\|\| ctx->mode == EVP_CIPH_CFB_MODE
205	0	\|\| ctx->mode == EVP_CIPH_OFB_MODE))
206		/* reset IV for these modes to keep compatibility with 1.1.1 */
207	0	memcpy(ctx->iv, ctx->oiv, ctx->ivlen);
208
209	31.6k	if (key != NULL) {
210	1.85k	if (ctx->variable_keylength == 0) {
211	1.85k	if (keylen != ctx->keylen) {
212	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
213	0	return 0;
214	0	}
215	1.85k	} else {
216	0	ctx->keylen = keylen;
217	0	}
218	1.85k	if (!ctx->hw->init(ctx, key, ctx->keylen))
219	0	return 0;
220	1.85k	}
221	31.6k	return ossl_cipher_generic_set_ctx_params(ctx, params);
222	31.6k	}
223
224		int ossl_cipher_generic_einit(void vctx, const unsigned char key,
225		size_t keylen, const unsigned char *iv,
226		size_t ivlen, const OSSL_PARAM params[])
227	3.64k	{
228	3.64k	return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
229	3.64k	iv, ivlen, params, 1);
230	3.64k	}
231
232		int ossl_cipher_generic_dinit(void vctx, const unsigned char key,
233		size_t keylen, const unsigned char *iv,
234		size_t ivlen, const OSSL_PARAM params[])
235	28.0k	{
236	28.0k	return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
237	28.0k	iv, ivlen, params, 0);
238	28.0k	}
239
240		/* Max padding including padding length byte */
241	11	#define MAX_PADDING 256
242
243		int ossl_cipher_generic_block_update(void vctx, unsigned char out,
244		size_t *outl, size_t outsize,
245		const unsigned char *in, size_t inl)
246	267	{
247	267	size_t outlint = 0;
248	267	PROV_CIPHER_CTX ctx = (PROV_CIPHER_CTX )vctx;
249	267	size_t blksz = ctx->blocksize;
250	267	size_t nextblocks;
251
252	267	if (ctx->tlsversion > 0) {
253		/*
254		* Each update call corresponds to a TLS record and is individually
255		* padded
256		*/
257
258		/* Sanity check inputs */
259	113	if (in == NULL
260	113	\|\| in != out
261	113	\|\| outsize < inl
262	113	\|\| !ctx->pad) {
263	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
264	0	return 0;
265	0	}
266
267	113	if (ctx->enc) {
268	11	unsigned char padval;
269	11	size_t padnum, loop;
270
271		/* Add padding */
272
273	11	padnum = blksz - (inl % blksz);
274
275	11	if (outsize < inl + padnum) {
276	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
277	0	return 0;
278	0	}
279
280	11	if (padnum > MAX_PADDING) {
281	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
282	0	return 0;
283	0	}
284	11	padval = (unsigned char)(padnum - 1);
285	11	if (ctx->tlsversion == SSL3_VERSION) {
286	0	if (padnum > 1)
287	0	memset(out + inl, 0, padnum - 1);
288	0	*(out + inl + padnum - 1) = padval;
289	11	} else {
290		/* we need to add 'padnum' padding bytes of value padval */
291	181	for (loop = inl; loop < inl + padnum; loop++)
292	170	out[loop] = padval;
293	11	}
294	11	inl += padnum;
295	11	}
296
297	113	if ((inl % blksz) != 0) {
298	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
299	0	return 0;
300	0	}
301
302
303		/* Shouldn't normally fail */
304	113	if (!ctx->hw->cipher(ctx, out, in, inl)) {
305	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
306	0	return 0;
307	0	}
308
309	113	if (ctx->alloced) {
310	0	OPENSSL_free(ctx->tlsmac);
311	0	ctx->alloced = 0;
312	0	ctx->tlsmac = NULL;
313	0	}
314
315		/* This only fails if padding is publicly invalid */
316	113	*outl = inl;
317	113	if (!ctx->enc
318	113	&& !ossl_cipher_tlsunpadblock(ctx->libctx, ctx->tlsversion,
319	102	out, outl,
320	102	blksz, &ctx->tlsmac, &ctx->alloced,
321	102	ctx->tlsmacsize, 0)) {
322	8	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
323	8	return 0;
324	8	}
325	105	return 1;
326	113	}
327
328	154	if (ctx->bufsz != 0)
329	0	nextblocks = ossl_cipher_fillblock(ctx->buf, &ctx->bufsz, blksz,
330	0	&in, &inl);
331	154	else
332	154	nextblocks = inl & ~(blksz-1);
333
334		/*
335		* If we're decrypting and we end an update on a block boundary we hold
336		* the last block back in case this is the last update call and the last
337		* block is padded.
338		*/
339	154	if (ctx->bufsz == blksz && (ctx->enc \|\| inl > 0 \|\| !ctx->pad)) {
340	0	if (outsize < blksz) {
341	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
342	0	return 0;
343	0	}
344	0	if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
345	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
346	0	return 0;
347	0	}
348	0	ctx->bufsz = 0;
349	0	outlint = blksz;
350	0	out += blksz;
351	0	}
352	154	if (nextblocks > 0) {
353	151	if (!ctx->enc && ctx->pad && nextblocks == inl) {
354	150	if (!ossl_assert(inl >= blksz)) {
355	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
356	0	return 0;
357	0	}
358	150	nextblocks -= blksz;
359	150	}
360	151	outlint += nextblocks;
361	151	if (outsize < outlint) {
362	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
363	0	return 0;
364	0	}
365	151	}
366	154	if (nextblocks > 0) {
367	151	if (!ctx->hw->cipher(ctx, out, in, nextblocks)) {
368	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
369	0	return 0;
370	0	}
371	151	in += nextblocks;
372	151	inl -= nextblocks;
373	151	}
374	154	if (inl != 0
375	154	&& !ossl_cipher_trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) {
376		/* ERR_raise already called */
377	0	return 0;
378	0	}
379
380	154	*outl = outlint;
381	154	return inl == 0;
382	154	}
383
384		int ossl_cipher_generic_block_final(void vctx, unsigned char out,
385		size_t *outl, size_t outsize)
386	154	{
387	154	PROV_CIPHER_CTX ctx = (PROV_CIPHER_CTX )vctx;
388	154	size_t blksz = ctx->blocksize;
389
390	154	if (!ossl_prov_is_running())
391	0	return 0;
392
393	154	if (ctx->tlsversion > 0) {
394		/* We never finalize TLS, so this is an error */
395	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
396	0	return 0;
397	0	}
398
399	154	if (ctx->enc) {
400	0	if (ctx->pad) {
401	0	ossl_cipher_padblock(ctx->buf, &ctx->bufsz, blksz);
402	0	} else if (ctx->bufsz == 0) {
403	0	*outl = 0;
404	0	return 1;
405	0	} else if (ctx->bufsz != blksz) {
406	0	ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
407	0	return 0;
408	0	}
409
410	0	if (outsize < blksz) {
411	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
412	0	return 0;
413	0	}
414	0	if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
415	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
416	0	return 0;
417	0	}
418	0	ctx->bufsz = 0;
419	0	*outl = blksz;
420	0	return 1;
421	0	}
422
423		/* Decrypting */
424	154	if (ctx->bufsz != blksz) {
425	4	if (ctx->bufsz == 0 && !ctx->pad) {
426	0	*outl = 0;
427	0	return 1;
428	0	}
429	4	ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
430	4	return 0;
431	4	}
432
433	150	if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) {
434	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
435	0	return 0;
436	0	}
437
438	150	if (ctx->pad && !ossl_cipher_unpadblock(ctx->buf, &ctx->bufsz, blksz)) {
439		/* ERR_raise already called */
440	10	return 0;
441	10	}
442
443	140	if (outsize < ctx->bufsz) {
444	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
445	0	return 0;
446	0	}
447	140	memcpy(out, ctx->buf, ctx->bufsz);
448	140	*outl = ctx->bufsz;
449	140	ctx->bufsz = 0;
450	140	return 1;
451	140	}
452
453		int ossl_cipher_generic_stream_update(void vctx, unsigned char out,
454		size_t *outl, size_t outsize,
455		const unsigned char *in, size_t inl)
456	86	{
457	86	PROV_CIPHER_CTX ctx = (PROV_CIPHER_CTX )vctx;
458
459	86	if (inl == 0) {
460	0	*outl = 0;
461	0	return 1;
462	0	}
463
464	86	if (outsize < inl) {
465	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
466	0	return 0;
467	0	}
468
469	86	if (!ctx->hw->cipher(ctx, out, in, inl)) {
470	69	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
471	69	return 0;
472	69	}
473
474	17	*outl = inl;
475	17	if (!ctx->enc && ctx->tlsversion > 0) {
476		/*
477		* Remove any TLS padding. Only used by cipher_aes_cbc_hmac_sha1_hw.c and
478		* cipher_aes_cbc_hmac_sha256_hw.c
479		*/
480	0	if (ctx->removetlspad) {
481		/*
482		* We should have already failed in the cipher() call above if this
483		* isn't true.
484		*/
485	0	if (!ossl_assert(*outl >= (size_t)(out[inl - 1] + 1)))
486	0	return 0;
487		/* The actual padding length */
488	0	*outl -= out[inl - 1] + 1;
489	0	}
490
491		/* TLS MAC and explicit IV if relevant. We should have already failed
492		* in the cipher() call above if *outl is too short.
493		*/
494	0	if (!ossl_assert(*outl >= ctx->removetlsfixed))
495	0	return 0;
496	0	*outl -= ctx->removetlsfixed;
497
498		/* Extract the MAC if there is one */
499	0	if (ctx->tlsmacsize > 0) {
500	0	if (*outl < ctx->tlsmacsize)
501	0	return 0;
502
503	0	ctx->tlsmac = out + *outl - ctx->tlsmacsize;
504	0	*outl -= ctx->tlsmacsize;
505	0	}
506	0	}
507
508	17	return 1;
509	17	}
510		int ossl_cipher_generic_stream_final(void vctx, unsigned char out,
511		size_t *outl, size_t outsize)
512	0	{
513	0	if (!ossl_prov_is_running())
514	0	return 0;
515
516	0	*outl = 0;
517	0	return 1;
518	0	}
519
520		int ossl_cipher_generic_cipher(void vctx, unsigned char out, size_t *outl,
521		size_t outsize, const unsigned char *in,
522		size_t inl)
523	0	{
524	0	PROV_CIPHER_CTX ctx = (PROV_CIPHER_CTX )vctx;
525
526	0	if (!ossl_prov_is_running())
527	0	return 0;
528
529	0	if (outsize < inl) {
530	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
531	0	return 0;
532	0	}
533
534	0	if (!ctx->hw->cipher(ctx, out, in, inl)) {
535	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
536	0	return 0;
537	0	}
538
539	0	*outl = inl;
540	0	return 1;
541	0	}
542
543		int ossl_cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[])
544	794	{
545	794	PROV_CIPHER_CTX ctx = (PROV_CIPHER_CTX )vctx;
546	794	OSSL_PARAM *p;
547
548	794	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
549	794	if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) {
550	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
551	0	return 0;
552	0	}
553	794	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
554	794	if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) {
555	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
556	0	return 0;
557	0	}
558	794	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
559	794	if (p != NULL
560	794	&& !OSSL_PARAM_set_octet_ptr(p, &ctx->oiv, ctx->ivlen)
561	794	&& !OSSL_PARAM_set_octet_string(p, &ctx->oiv, ctx->ivlen)) {
562	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
563	0	return 0;
564	0	}
565	794	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_UPDATED_IV);
566	794	if (p != NULL
567	794	&& !OSSL_PARAM_set_octet_ptr(p, &ctx->iv, ctx->ivlen)
568	794	&& !OSSL_PARAM_set_octet_string(p, &ctx->iv, ctx->ivlen)) {
569	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
570	0	return 0;
571	0	}
572	794	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM);
573	794	if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) {
574	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
575	0	return 0;
576	0	}
577	794	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
578	794	if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
579	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
580	0	return 0;
581	0	}
582	794	p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS_MAC);
583	794	if (p != NULL
584	794	&& !OSSL_PARAM_set_octet_ptr(p, ctx->tlsmac, ctx->tlsmacsize)) {
585	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
586	0	return 0;
587	0	}
588	794	return 1;
589	794	}
590
591		int ossl_cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[])
592	31.9k	{
593	31.9k	PROV_CIPHER_CTX ctx = (PROV_CIPHER_CTX )vctx;
594	31.9k	const OSSL_PARAM *p;
595
596	31.9k	if (params == NULL)
597	31.7k	return 1;
598
599	165	p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
600	165	if (p != NULL) {
601	0	unsigned int pad;
602
603	0	if (!OSSL_PARAM_get_uint(p, &pad)) {
604	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
605	0	return 0;
606	0	}
607	0	ctx->pad = pad ? 1 : 0;
608	0	}
609	165	p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_USE_BITS);
610	165	if (p != NULL) {
611	0	unsigned int bits;
612
613	0	if (!OSSL_PARAM_get_uint(p, &bits)) {
614	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
615	0	return 0;
616	0	}
617	0	ctx->use_bits = bits ? 1 : 0;
618	0	}
619	165	p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_VERSION);
620	165	if (p != NULL) {
621	165	if (!OSSL_PARAM_get_uint(p, &ctx->tlsversion)) {
622	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
623	0	return 0;
624	0	}
625	165	}
626	165	p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_MAC_SIZE);
627	165	if (p != NULL) {
628	165	if (!OSSL_PARAM_get_size_t(p, &ctx->tlsmacsize)) {
629	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
630	0	return 0;
631	0	}
632	165	}
633	165	p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM);
634	165	if (p != NULL) {
635	0	unsigned int num;
636
637	0	if (!OSSL_PARAM_get_uint(p, &num)) {
638	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
639	0	return 0;
640	0	}
641	0	ctx->num = num;
642	0	}
643	165	return 1;
644	165	}
645
646		int ossl_cipher_generic_initiv(PROV_CIPHER_CTX ctx, const unsigned char iv,
647		size_t ivlen)
648	29.5k	{
649	29.5k	if (ivlen != ctx->ivlen
650	29.5k	\|\| ivlen > sizeof(ctx->iv)) {
651	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
652	0	return 0;
653	0	}
654	29.5k	ctx->iv_set = 1;
655	29.5k	memcpy(ctx->iv, iv, ivlen);
656	29.5k	memcpy(ctx->oiv, iv, ivlen);
657	29.5k	return 1;
658	29.5k	}
659
660		void ossl_cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
661		size_t ivbits, unsigned int mode,
662		uint64_t flags, const PROV_CIPHER_HW *hw,
663		void *provctx)
664	1.92k	{
665	1.92k	PROV_CIPHER_CTX ctx = (PROV_CIPHER_CTX )vctx;
666
667	1.92k	if ((flags & PROV_CIPHER_FLAG_INVERSE_CIPHER) != 0)
668	0	ctx->inverse_cipher = 1;
669	1.92k	if ((flags & PROV_CIPHER_FLAG_VARIABLE_LENGTH) != 0)
670	0	ctx->variable_keylength = 1;
671
672	1.92k	ctx->pad = 1;
673	1.92k	ctx->keylen = ((kbits) / 8);
674	1.92k	ctx->ivlen = ((ivbits) / 8);
675	1.92k	ctx->hw = hw;
676	1.92k	ctx->mode = mode;
677	1.92k	ctx->blocksize = blkbits / 8;
678	1.92k	if (provctx != NULL)
679	448	ctx->libctx = PROV_LIBCTX_OF(provctx); /* used for rand */
680	1.92k	}