/src/openssl/providers/implementations/ciphers/ciphercommon_gcm.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
 */

/* Dispatch functions for gcm mode */

#include <openssl/rand.h>
#include <openssl/proverr.h>
#include "prov/ciphercommon.h"
#include "prov/ciphercommon_gcm.h"
#include "prov/providercommon.h"
#include "prov/provider_ctx.h"

#include "providers/implementations/ciphers/ciphercommon_gcm.inc"

static int gcm_tls_init(PROV_GCM_CTX *dat, unsigned char *aad, size_t aad_len);
static int gcm_tls_iv_set_fixed(PROV_GCM_CTX *ctx, unsigned char *iv,
    size_t len);
static int gcm_tls_cipher(PROV_GCM_CTX *ctx, unsigned char *out, size_t *padlen,
    const unsigned char *in, size_t len);
static int gcm_cipher_internal(PROV_GCM_CTX *ctx, unsigned char *out,
    size_t *padlen, const unsigned char *in,
    size_t len);
static int on_preupdate_generate_iv(PROV_GCM_CTX *ctx);

/*
 * Called from EVP_CipherInit when there is currently no context via
 * the new_ctx() function
 */
void ossl_gcm_initctx(void *provctx, PROV_GCM_CTX *ctx, size_t keybits,
    const PROV_GCM_HW *hw)
{
    ctx->pad = 1;
    ctx->mode = EVP_CIPH_GCM_MODE;
    ctx->taglen = UNINITIALISED_SIZET;
    ctx->tls_aad_len = UNINITIALISED_SIZET;
    ctx->ivlen = (EVP_GCM_TLS_FIXED_IV_LEN + EVP_GCM_TLS_EXPLICIT_IV_LEN);
    ctx->keylen = keybits / 8;
    ctx->hw = hw;
    ctx->libctx = PROV_LIBCTX_OF(provctx);
}

/*
 * Called by EVP_CipherInit via the _einit and _dinit functions
 */
static int gcm_init(void *vctx, const unsigned char *key, size_t keylen,
    const unsigned char *iv, size_t ivlen,
    const OSSL_PARAM params[], int enc)
{
    PROV_GCM_CTX *ctx = (PROV_GCM_CTX *)vctx;

    if (!ossl_prov_is_running())
        return 0;

    ctx->enc = enc;

    if (iv != NULL) {
        if (ivlen == 0 || ivlen > sizeof(ctx->iv)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
            return 0;
        }
        ctx->iv_gen_rand = 0;
        ctx->ivlen = ivlen;
        memcpy(ctx->iv, iv, ivlen);
        ctx->iv_state = IV_STATE_BUFFERED;
    }

    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, ctx->keylen))
            return 0;
        ctx->tls_enc_records = 0;
    }
    return ossl_gcm_set_ctx_params(ctx, params);
}

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

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

/* increment counter (64-bit int) by 1 */
static void ctr64_inc(unsigned char *counter)
{
    int n = 8;
    unsigned char c;

    do {
        --n;
        c = counter[n];
        ++c;
        counter[n] = c;
        if (c > 0)
            return;
    } while (n > 0);
}

static int getivgen(PROV_GCM_CTX *ctx, unsigned char *out, size_t olen)
{
    if (!ctx->iv_gen
        || !ctx->key_set
        || !ctx->hw->setiv(ctx, ctx->iv, ctx->ivlen))
        return 0;
    if (olen == 0 || olen > ctx->ivlen)
        olen = ctx->ivlen;
    memcpy(out, ctx->iv + ctx->ivlen - olen, olen);
    /*
     * Invocation field will be at least 8 bytes in size and so no need
     * to check wrap around or increment more than last 8 bytes.
     */
    ctr64_inc(ctx->iv + ctx->ivlen - 8);
    ctx->iv_state = IV_STATE_COPIED;
    return 1;
}

static int setivinv(PROV_GCM_CTX *ctx, unsigned char *in, size_t inl)
{
    if (!ctx->iv_gen
        || !ctx->key_set
        || ctx->enc)
        return 0;

    memcpy(ctx->iv + ctx->ivlen - inl, in, inl);
    if (!ctx->hw->setiv(ctx, ctx->iv, ctx->ivlen))
        return 0;
    ctx->iv_state = IV_STATE_COPIED;
    return 1;
}

const OSSL_PARAM *ossl_gcm_gettable_ctx_params(
    ossl_unused void *cctx, ossl_unused void *provctx)
{
    return ossl_cipher_gcm_get_ctx_params_list;
}

int ossl_gcm_get_ctx_params(void *vctx, OSSL_PARAM params[])
{
    PROV_GCM_CTX *ctx = (PROV_GCM_CTX *)vctx;
    size_t sz;
    struct ossl_cipher_gcm_get_ctx_params_st p;

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

    if (p.ivlen != NULL && !OSSL_PARAM_set_size_t(p.ivlen, ctx->ivlen)) {
        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.taglen != NULL) {
        size_t taglen = (ctx->taglen != UNINITIALISED_SIZET) ? ctx->taglen : GCM_TAG_MAX_SIZE;

        if (!OSSL_PARAM_set_size_t(p.taglen, taglen)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
            return 0;
        }
    }

    /*
     * Note p.updiv and p.iv are aliases that get the same information,
     * so any code changes should be duplicated below.
     */
    if (p.iv != NULL) {
        if (!on_preupdate_generate_iv(ctx))
            return 0;
        if (p.iv->data != NULL && ctx->ivlen > 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, ctx->ivlen)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
            return 0;
        }
    }
    if (p.updiv != NULL) {
        if (!on_preupdate_generate_iv(ctx))
            return 0;
        if (p.updiv->data != NULL && ctx->ivlen > 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, ctx->ivlen)) {
            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->taglen == UNINITIALISED_SIZET) {
            ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
            return 0;
        }
        if (p.tag->data == NULL) {
            /* size query: report the tag length, as for the iv above */
            sz = ctx->taglen;
        } else {
            sz = p.tag->data_size;
            if (sz > EVP_GCM_TLS_TAG_LEN || sz == 0) {
                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG);
                return 0;
            }
        }

        if (!OSSL_PARAM_set_octet_string(p.tag, ctx->buf, sz)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
            return 0;
        }
    }

    if (p.ivgen != NULL)
        if (p.ivgen->data == NULL
            || p.ivgen->data_type != OSSL_PARAM_OCTET_STRING
            || !getivgen(ctx, p.ivgen->data, p.ivgen->data_size))
            return 0;

    if (p.gen != NULL && !OSSL_PARAM_set_uint(p.gen, ctx->iv_gen_rand))
        return 0;

    return 1;
}

const OSSL_PARAM *ossl_gcm_settable_ctx_params(
    ossl_unused void *cctx, ossl_unused void *provctx)
{
    return ossl_cipher_gcm_set_ctx_params_list;
}

int ossl_gcm_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
    PROV_GCM_CTX *ctx = (PROV_GCM_CTX *)vctx;
    size_t sz;
    void *vp;
    struct ossl_cipher_gcm_set_ctx_params_st p;

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

    if (p.tag != NULL) {
        vp = ctx->buf;
        if (!OSSL_PARAM_get_octet_string(p.tag, &vp, EVP_GCM_TLS_TAG_LEN, &sz)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        if (ctx->enc) {
            ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_NEEDED);
            return 0;
        }
        if (sz == 0) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG);
            return 0;
        }
        ctx->taglen = sz;
    }

    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;
        }
        if (sz == 0 || sz > sizeof(ctx->iv)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
            return 0;
        }
        if (ctx->ivlen != sz) {
            /* If the iv was already set or autogenerated, it is invalid. */
            if (ctx->iv_state != IV_STATE_UNINITIALISED)
                ctx->iv_state = IV_STATE_FINISHED;
            ctx->ivlen = sz;
        }
    }

    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 = gcm_tls_init(ctx, p.aad->data, p.aad->data_size);
        if (sz == 0) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_AAD);
            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 (gcm_tls_iv_set_fixed(ctx, p.fixed->data, p.fixed->data_size) == 0) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
    }

    if (p.inviv != NULL)
        if (p.inviv->data == NULL
            || p.inviv->data_type != OSSL_PARAM_OCTET_STRING
            || !setivinv(ctx, p.inviv->data, p.inviv->data_size))
            return 0;

    return 1;
}

int ossl_gcm_stream_update(void *vctx, unsigned char *out, size_t *outl,
    size_t outsize, const unsigned char *in, size_t inl)
{
    PROV_GCM_CTX *ctx = (PROV_GCM_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 (gcm_cipher_internal(ctx, out, outl, in, inl) <= 0) {
        ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
        return 0;
    }
    return 1;
}

int ossl_gcm_stream_final(void *vctx, unsigned char *out, size_t *outl,
    size_t outsize)
{
    PROV_GCM_CTX *ctx = (PROV_GCM_CTX *)vctx;
    int i;

    if (!ossl_prov_is_running())
        return 0;

    i = gcm_cipher_internal(ctx, out, outl, NULL, 0);
    if (i <= 0)
        return 0;

    *outl = 0;
    return 1;
}

int ossl_gcm_cipher(void *vctx,
    unsigned char *out, size_t *outl, size_t outsize,
    const unsigned char *in, size_t inl)
{
    PROV_GCM_CTX *ctx = (PROV_GCM_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 (gcm_cipher_internal(ctx, out, outl, in, inl) <= 0)
        return 0;

    *outl = inl;
    return 1;
}

/*
 * See SP800-38D (GCM) Section 8 "Uniqueness requirement on IVS and keys"
 *
 * See also 8.2.2 RBG-based construction.
 * Random construction consists of a free field (which can be NULL) and a
 * random field which will use a DRBG that can return at least 96 bits of
 * entropy strength. (The DRBG must be seeded by the FIPS module).
 */
static int gcm_iv_generate(PROV_GCM_CTX *ctx, int offset)
{
    int sz = (int)(ctx->ivlen - offset);

    /* Must be at least 96 bits */
    if (sz <= 0 || ctx->ivlen < GCM_IV_DEFAULT_SIZE)
        return 0;

    /* Use DRBG to generate random iv */
    if (RAND_bytes_ex(ctx->libctx, ctx->iv + offset, sz, 0) <= 0)
        return 0;
    ctx->iv_state = IV_STATE_BUFFERED;
    ctx->iv_gen_rand = 1;
    return 1;
}

/*
 * If we try to grab the iv before the update - it wont be generated yet,
 * so we generate it here for this case.
 */
static int on_preupdate_generate_iv(PROV_GCM_CTX *ctx)
{
    if (ctx->iv_state == IV_STATE_UNINITIALISED) {
        if (ctx->tls_aad_len != UNINITIALISED_SIZET)
            return 0;
        if (!ctx->enc || !gcm_iv_generate(ctx, 0))
            return 0;
    }
    return 1;
}

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

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

    if (!ctx->key_set || ctx->iv_state == IV_STATE_FINISHED)
        goto err;

    /*
     * FIPS requires generation of AES-GCM IV's inside the FIPS module.
     * The IV can still be set externally (the security policy will state that
     * this is not FIPS compliant). There are some applications
     * where setting the IV externally is the only option available.
     */
    if (ctx->iv_state == IV_STATE_UNINITIALISED) {
        if (!ctx->enc || !gcm_iv_generate(ctx, 0))
            goto err;
    }

    if (ctx->iv_state == IV_STATE_BUFFERED) {
        if (!hw->setiv(ctx, ctx->iv, ctx->ivlen))
            goto err;
        ctx->iv_state = IV_STATE_COPIED;
    }

    if (in != NULL) {
        /*  The input is AAD if out is NULL */
        if (out == NULL) {
            if (!hw->aadupdate(ctx, in, len))
                goto err;
        } else {
            /* The input is ciphertext OR plaintext */
            if (!hw->cipherupdate(ctx, in, len, out))
                goto err;
        }
    } else {
        /* The tag must be set before actually decrypting data */
        if (!ctx->enc && ctx->taglen == UNINITIALISED_SIZET) {
            ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
            goto err;
        }
        if (hw->cipherfinal(ctx, ctx->buf) == 0) {
            if (ctx->enc == 0)
                ERR_raise(ERR_LIB_PROV, PROV_R_BAD_DECRYPT);
            goto err;
        }
        ctx->iv_state = IV_STATE_FINISHED; /* Don't reuse the IV */
        goto finish;
    }
    olen = len;
finish:
    rv = 1;
err:
    *padlen = olen;
    return rv;
}

static int gcm_tls_init(PROV_GCM_CTX *dat, unsigned char *aad, size_t aad_len)
{
    unsigned char *buf;
    size_t len;

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

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

    len = buf[aad_len - 2] << 8 | buf[aad_len - 1];
    /* Correct length for explicit iv. */
    if (len < EVP_GCM_TLS_EXPLICIT_IV_LEN)
        return 0;
    len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;

    /* If decrypting correct for tag too. */
    if (!dat->enc) {
        if (len < EVP_GCM_TLS_TAG_LEN)
            return 0;
        len -= EVP_GCM_TLS_TAG_LEN;
    }
    buf[aad_len - 2] = (unsigned char)(len >> 8);
    buf[aad_len - 1] = (unsigned char)(len & 0xff);
    /* Extra padding: tag appended to record. */
    return EVP_GCM_TLS_TAG_LEN;
}

static int gcm_tls_iv_set_fixed(PROV_GCM_CTX *ctx, unsigned char *iv,
    size_t len)
{
    /* Special case: -1 length restores whole IV */
    if (len == (size_t)-1) {
        memcpy(ctx->iv, iv, ctx->ivlen);
        ctx->iv_gen = 1;
        ctx->iv_state = IV_STATE_BUFFERED;
        return 1;
    }
    /* Fixed field must be at least 4 bytes and invocation field at least 8 */
    if (len < EVP_GCM_TLS_FIXED_IV_LEN
        || len > ctx->ivlen
        || (ctx->ivlen - len) < EVP_GCM_TLS_EXPLICIT_IV_LEN)
        return 0;
    if (len > 0)
        memcpy(ctx->iv, iv, len);
    if (ctx->enc) {
        if (RAND_bytes_ex(ctx->libctx, ctx->iv + len, ctx->ivlen - len, 0) <= 0)
            return 0;
        ctx->iv_gen_rand = 1;
    }
    ctx->iv_gen = 1;
    ctx->iv_state = IV_STATE_BUFFERED;
    return 1;
}

/*
 * Handle TLS GCM packet format. This consists of the last portion of the IV
 * followed by the payload and finally the tag. On encrypt generate IV,
 * encrypt payload and write the tag. On verify retrieve IV, decrypt payload
 * and verify tag.
 */
static int gcm_tls_cipher(PROV_GCM_CTX *ctx, unsigned char *out, size_t *padlen,
    const unsigned char *in, size_t len)
{
    int rv = 0;
    size_t arg = EVP_GCM_TLS_EXPLICIT_IV_LEN;
    size_t plen = 0;
    unsigned char *tag = NULL;

    if (!ossl_prov_is_running() || !ctx->key_set)
        goto err;

    /* Encrypt/decrypt must be performed in place */
    if (out != in || len < (EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN))
        goto err;

    /*
     * Check for too many keys as per FIPS 140-2 IG A.5 "Key/IV Pair Uniqueness
     * Requirements from SP 800-38D".  The requirements is for one party to the
     * communication to fail after 2^64 - 1 keys.  We do this on the encrypting
     * side only.
     */
    if (ctx->enc && ++ctx->tls_enc_records == 0) {
        ERR_raise(ERR_LIB_PROV, PROV_R_TOO_MANY_RECORDS);
        goto err;
    }

    /*
     * Set IV from start of buffer or generate IV and write to start of
     * buffer.
     */
    if (ctx->enc) {
        if (!getivgen(ctx, out, arg))
            goto err;
    } else {
        if (!setivinv(ctx, out, arg))
            goto err;
    }

    /* Fix buffer and length to point to payload */
    in += EVP_GCM_TLS_EXPLICIT_IV_LEN;
    out += EVP_GCM_TLS_EXPLICIT_IV_LEN;
    len -= EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;

    tag = ctx->enc ? out + len : (unsigned char *)in + len;
    if (!ctx->hw->oneshot(ctx, ctx->buf, ctx->tls_aad_len, in, len, out, tag,
            EVP_GCM_TLS_TAG_LEN)) {
        if (!ctx->enc)
            OPENSSL_cleanse(out, len);
        goto err;
    }
    if (ctx->enc)
        plen = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
    else
        plen = len;

    rv = 1;
err:
    ctx->iv_state = IV_STATE_FINISHED;
    ctx->tls_aad_len = UNINITIALISED_SIZET;
    *padlen = plen;
    return rv;
}

Coverage Report

Created: 2026-09-13 06:13

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
10		/* Dispatch functions for gcm mode */
11
12		#include <openssl/rand.h>
13		#include <openssl/proverr.h>
14		#include "prov/ciphercommon.h"
15		#include "prov/ciphercommon_gcm.h"
16		#include "prov/providercommon.h"
17		#include "prov/provider_ctx.h"
18
19		#include "providers/implementations/ciphers/ciphercommon_gcm.inc"
20
21		static int gcm_tls_init(PROV_GCM_CTX dat, unsigned char aad, size_t aad_len);
22		static int gcm_tls_iv_set_fixed(PROV_GCM_CTX ctx, unsigned char iv,
23		size_t len);
24		static int gcm_tls_cipher(PROV_GCM_CTX ctx, unsigned char out, size_t *padlen,
25		const unsigned char *in, size_t len);
26		static int gcm_cipher_internal(PROV_GCM_CTX ctx, unsigned char out,
27		size_t padlen, const unsigned char in,
28		size_t len);
29		static int on_preupdate_generate_iv(PROV_GCM_CTX *ctx);
30
31		/*
32		* Called from EVP_CipherInit when there is currently no context via
33		* the new_ctx() function
34		*/
35		void ossl_gcm_initctx(void provctx, PROV_GCM_CTX ctx, size_t keybits,
36		const PROV_GCM_HW *hw)
37	0	{
38	0	ctx->pad = 1;
39	0	ctx->mode = EVP_CIPH_GCM_MODE;
40	0	ctx->taglen = UNINITIALISED_SIZET;
41	0	ctx->tls_aad_len = UNINITIALISED_SIZET;
42	0	ctx->ivlen = (EVP_GCM_TLS_FIXED_IV_LEN + EVP_GCM_TLS_EXPLICIT_IV_LEN);
43	0	ctx->keylen = keybits / 8;
44	0	ctx->hw = hw;
45	0	ctx->libctx = PROV_LIBCTX_OF(provctx);
46	0	}
47
48		/*
49		* Called by EVP_CipherInit via the _einit and _dinit functions
50		*/
51		static int gcm_init(void vctx, const unsigned char key, size_t keylen,
52		const unsigned char *iv, size_t ivlen,
53		const OSSL_PARAM params[], int enc)
54	0	{
55	0	PROV_GCM_CTX ctx = (PROV_GCM_CTX )vctx;
56
57	0	if (!ossl_prov_is_running())
58	0	return 0;
59
60	0	ctx->enc = enc;
61
62	0	if (iv != NULL) {
63	0	if (ivlen == 0 \|\| ivlen > sizeof(ctx->iv)) {
64	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
65	0	return 0;
66	0	}
67	0	ctx->iv_gen_rand = 0;
68	0	ctx->ivlen = ivlen;
69	0	memcpy(ctx->iv, iv, ivlen);
70	0	ctx->iv_state = IV_STATE_BUFFERED;
71	0	}
72
73	0	if (key != NULL) {
74	0	if (keylen != ctx->keylen) {
75	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
76	0	return 0;
77	0	}
78	0	if (!ctx->hw->setkey(ctx, key, ctx->keylen))
79	0	return 0;
80	0	ctx->tls_enc_records = 0;
81	0	}
82	0	return ossl_gcm_set_ctx_params(ctx, params);
83	0	}
84
85		int ossl_gcm_einit(void vctx, const unsigned char key, size_t keylen,
86		const unsigned char *iv, size_t ivlen,
87		const OSSL_PARAM params[])
88	0	{
89	0	return gcm_init(vctx, key, keylen, iv, ivlen, params, 1);
90	0	}
91
92		int ossl_gcm_dinit(void vctx, const unsigned char key, size_t keylen,
93		const unsigned char *iv, size_t ivlen,
94		const OSSL_PARAM params[])
95	0	{
96	0	return gcm_init(vctx, key, keylen, iv, ivlen, params, 0);
97	0	}
98
99		/* increment counter (64-bit int) by 1 */
100		static void ctr64_inc(unsigned char *counter)
101	0	{
102	0	int n = 8;
103	0	unsigned char c;
104
105	0	do {
106	0	--n;
107	0	c = counter[n];
108	0	++c;
109	0	counter[n] = c;
110	0	if (c > 0)
111	0	return;
112	0	} while (n > 0);
113	0	}
114
115		static int getivgen(PROV_GCM_CTX ctx, unsigned char out, size_t olen)
116	0	{
117	0	if (!ctx->iv_gen
118	0	\|\| !ctx->key_set
119	0	\|\| !ctx->hw->setiv(ctx, ctx->iv, ctx->ivlen))
120	0	return 0;
121	0	if (olen == 0 \|\| olen > ctx->ivlen)
122	0	olen = ctx->ivlen;
123	0	memcpy(out, ctx->iv + ctx->ivlen - olen, olen);
124		/*
125		* Invocation field will be at least 8 bytes in size and so no need
126		* to check wrap around or increment more than last 8 bytes.
127		*/
128	0	ctr64_inc(ctx->iv + ctx->ivlen - 8);
129	0	ctx->iv_state = IV_STATE_COPIED;
130	0	return 1;
131	0	}
132
133		static int setivinv(PROV_GCM_CTX ctx, unsigned char in, size_t inl)
134	0	{
135	0	if (!ctx->iv_gen
136	0	\|\| !ctx->key_set
137	0	\|\| ctx->enc)
138	0	return 0;
139
140	0	memcpy(ctx->iv + ctx->ivlen - inl, in, inl);
141	0	if (!ctx->hw->setiv(ctx, ctx->iv, ctx->ivlen))
142	0	return 0;
143	0	ctx->iv_state = IV_STATE_COPIED;
144	0	return 1;
145	0	}
146
147		const OSSL_PARAM *ossl_gcm_gettable_ctx_params(
148		ossl_unused void cctx, ossl_unused void provctx)
149	7	{
150	7	return ossl_cipher_gcm_get_ctx_params_list;
151	7	}
152
153		int ossl_gcm_get_ctx_params(void *vctx, OSSL_PARAM params[])
154	0	{
155	0	PROV_GCM_CTX ctx = (PROV_GCM_CTX )vctx;
156	0	size_t sz;
157	0	struct ossl_cipher_gcm_get_ctx_params_st p;
158
159	0	if (ctx == NULL \|\| !ossl_cipher_gcm_get_ctx_params_decoder(params, &p))
160	0	return 0;
161
162	0	if (p.ivlen != NULL && !OSSL_PARAM_set_size_t(p.ivlen, ctx->ivlen)) {
163	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
164	0	return 0;
165	0	}
166
167	0	if (p.keylen != NULL && !OSSL_PARAM_set_size_t(p.keylen, ctx->keylen)) {
168	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
169	0	return 0;
170	0	}
171
172	0	if (p.taglen != NULL) {
173	0	size_t taglen = (ctx->taglen != UNINITIALISED_SIZET) ? ctx->taglen : GCM_TAG_MAX_SIZE;
174
175	0	if (!OSSL_PARAM_set_size_t(p.taglen, taglen)) {
176	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
177	0	return 0;
178	0	}
179	0	}
180
181		/*
182		* Note p.updiv and p.iv are aliases that get the same information,
183		* so any code changes should be duplicated below.
184		*/
185	0	if (p.iv != NULL) {
186	0	if (!on_preupdate_generate_iv(ctx))
187	0	return 0;
188	0	if (p.iv->data != NULL && ctx->ivlen > p.iv->data_size) {
189	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
190	0	return 0;
191	0	}
192	0	if (!OSSL_PARAM_set_octet_string_or_ptr(p.iv, ctx->iv, ctx->ivlen)) {
193	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
194	0	return 0;
195	0	}
196	0	}
197	0	if (p.updiv != NULL) {
198	0	if (!on_preupdate_generate_iv(ctx))
199	0	return 0;
200	0	if (p.updiv->data != NULL && ctx->ivlen > p.updiv->data_size) {
201	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
202	0	return 0;
203	0	}
204	0	if (!OSSL_PARAM_set_octet_string_or_ptr(p.updiv, ctx->iv, ctx->ivlen)) {
205	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
206	0	return 0;
207	0	}
208	0	}
209
210	0	if (p.pad != NULL && !OSSL_PARAM_set_size_t(p.pad, ctx->tls_aad_pad_sz)) {
211	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
212	0	return 0;
213	0	}
214
215	0	if (p.tag != NULL) {
216	0	if (!ctx->enc \|\| ctx->taglen == UNINITIALISED_SIZET) {
217	0	ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
218	0	return 0;
219	0	}
220	0	if (p.tag->data == NULL) {
221		/* size query: report the tag length, as for the iv above */
222	0	sz = ctx->taglen;
223	0	} else {
224	0	sz = p.tag->data_size;
225	0	if (sz > EVP_GCM_TLS_TAG_LEN \|\| sz == 0) {
226	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG);
227	0	return 0;
228	0	}
229	0	}
230
231	0	if (!OSSL_PARAM_set_octet_string(p.tag, ctx->buf, sz)) {
232	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
233	0	return 0;
234	0	}
235	0	}
236
237	0	if (p.ivgen != NULL)
238	0	if (p.ivgen->data == NULL
239	0	\|\| p.ivgen->data_type != OSSL_PARAM_OCTET_STRING
240	0	\|\| !getivgen(ctx, p.ivgen->data, p.ivgen->data_size))
241	0	return 0;
242
243	0	if (p.gen != NULL && !OSSL_PARAM_set_uint(p.gen, ctx->iv_gen_rand))
244	0	return 0;
245
246	0	return 1;
247	0	}
248
249		const OSSL_PARAM *ossl_gcm_settable_ctx_params(
250		ossl_unused void cctx, ossl_unused void provctx)
251	0	{
252	0	return ossl_cipher_gcm_set_ctx_params_list;
253	0	}
254
255		int ossl_gcm_set_ctx_params(void *vctx, const OSSL_PARAM params[])
256	0	{
257	0	PROV_GCM_CTX ctx = (PROV_GCM_CTX )vctx;
258	0	size_t sz;
259	0	void *vp;
260	0	struct ossl_cipher_gcm_set_ctx_params_st p;
261
262	0	if (ctx == NULL \|\| !ossl_cipher_gcm_set_ctx_params_decoder(params, &p))
263	0	return 0;
264
265	0	if (p.tag != NULL) {
266	0	vp = ctx->buf;
267	0	if (!OSSL_PARAM_get_octet_string(p.tag, &vp, EVP_GCM_TLS_TAG_LEN, &sz)) {
268	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
269	0	return 0;
270	0	}
271	0	if (ctx->enc) {
272	0	ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_NEEDED);
273	0	return 0;
274	0	}
275	0	if (sz == 0) {
276	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG);
277	0	return 0;
278	0	}
279	0	ctx->taglen = sz;
280	0	}
281
282	0	if (p.ivlen != NULL) {
283	0	if (!OSSL_PARAM_get_size_t(p.ivlen, &sz)) {
284	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
285	0	return 0;
286	0	}
287	0	if (sz == 0 \|\| sz > sizeof(ctx->iv)) {
288	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
289	0	return 0;
290	0	}
291	0	if (ctx->ivlen != sz) {
292		/* If the iv was already set or autogenerated, it is invalid. */
293	0	if (ctx->iv_state != IV_STATE_UNINITIALISED)
294	0	ctx->iv_state = IV_STATE_FINISHED;
295	0	ctx->ivlen = sz;
296	0	}
297	0	}
298
299	0	if (p.aad != NULL) {
300	0	if (p.aad->data_type != OSSL_PARAM_OCTET_STRING) {
301	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
302	0	return 0;
303	0	}
304	0	sz = gcm_tls_init(ctx, p.aad->data, p.aad->data_size);
305	0	if (sz == 0) {
306	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_AAD);
307	0	return 0;
308	0	}
309	0	ctx->tls_aad_pad_sz = sz;
310	0	}
311
312	0	if (p.fixed != NULL) {
313	0	if (p.fixed->data_type != OSSL_PARAM_OCTET_STRING) {
314	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
315	0	return 0;
316	0	}
317	0	if (gcm_tls_iv_set_fixed(ctx, p.fixed->data, p.fixed->data_size) == 0) {
318	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
319	0	return 0;
320	0	}
321	0	}
322
323	0	if (p.inviv != NULL)
324	0	if (p.inviv->data == NULL
325	0	\|\| p.inviv->data_type != OSSL_PARAM_OCTET_STRING
326	0	\|\| !setivinv(ctx, p.inviv->data, p.inviv->data_size))
327	0	return 0;
328
329	0	return 1;
330	0	}
331
332		int ossl_gcm_stream_update(void vctx, unsigned char out, size_t *outl,
333		size_t outsize, const unsigned char *in, size_t inl)
334	0	{
335	0	PROV_GCM_CTX ctx = (PROV_GCM_CTX )vctx;
336
337	0	if (inl == 0) {
338	0	*outl = 0;
339	0	return 1;
340	0	}
341
342	0	if (outsize < inl) {
343	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
344	0	return 0;
345	0	}
346
347	0	if (gcm_cipher_internal(ctx, out, outl, in, inl) <= 0) {
348	0	ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
349	0	return 0;
350	0	}
351	0	return 1;
352	0	}
353
354		int ossl_gcm_stream_final(void vctx, unsigned char out, size_t *outl,
355		size_t outsize)
356	0	{
357	0	PROV_GCM_CTX ctx = (PROV_GCM_CTX )vctx;
358	0	int i;
359
360	0	if (!ossl_prov_is_running())
361	0	return 0;
362
363	0	i = gcm_cipher_internal(ctx, out, outl, NULL, 0);
364	0	if (i <= 0)
365	0	return 0;
366
367	0	*outl = 0;
368	0	return 1;
369	0	}
370
371		int ossl_gcm_cipher(void *vctx,
372		unsigned char out, size_t outl, size_t outsize,
373		const unsigned char *in, size_t inl)
374	0	{
375	0	PROV_GCM_CTX ctx = (PROV_GCM_CTX )vctx;
376
377	0	if (!ossl_prov_is_running())
378	0	return 0;
379
380	0	if (outsize < inl) {
381	0	ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
382	0	return 0;
383	0	}
384
385	0	if (gcm_cipher_internal(ctx, out, outl, in, inl) <= 0)
386	0	return 0;
387
388	0	*outl = inl;
389	0	return 1;
390	0	}
391
392		/*
393		* See SP800-38D (GCM) Section 8 "Uniqueness requirement on IVS and keys"
394		*
395		* See also 8.2.2 RBG-based construction.
396		* Random construction consists of a free field (which can be NULL) and a
397		* random field which will use a DRBG that can return at least 96 bits of
398		* entropy strength. (The DRBG must be seeded by the FIPS module).
399		*/
400		static int gcm_iv_generate(PROV_GCM_CTX *ctx, int offset)
401	0	{
402	0	int sz = (int)(ctx->ivlen - offset);
403
404		/* Must be at least 96 bits */
405	0	if (sz <= 0 \|\| ctx->ivlen < GCM_IV_DEFAULT_SIZE)
406	0	return 0;
407
408		/* Use DRBG to generate random iv */
409	0	if (RAND_bytes_ex(ctx->libctx, ctx->iv + offset, sz, 0) <= 0)
410	0	return 0;
411	0	ctx->iv_state = IV_STATE_BUFFERED;
412	0	ctx->iv_gen_rand = 1;
413	0	return 1;
414	0	}
415
416		/*
417		* If we try to grab the iv before the update - it wont be generated yet,
418		* so we generate it here for this case.
419		*/
420		static int on_preupdate_generate_iv(PROV_GCM_CTX *ctx)
421	0	{
422	0	if (ctx->iv_state == IV_STATE_UNINITIALISED) {
423	0	if (ctx->tls_aad_len != UNINITIALISED_SIZET)
424	0	return 0;
425	0	if (!ctx->enc \|\| !gcm_iv_generate(ctx, 0))
426	0	return 0;
427	0	}
428	0	return 1;
429	0	}
430
431		static int gcm_cipher_internal(PROV_GCM_CTX ctx, unsigned char out,
432		size_t padlen, const unsigned char in,
433		size_t len)
434	0	{
435	0	size_t olen = 0;
436	0	int rv = 0;
437	0	const PROV_GCM_HW *hw = ctx->hw;
438
439	0	if (ctx->tls_aad_len != UNINITIALISED_SIZET)
440	0	return gcm_tls_cipher(ctx, out, padlen, in, len);
441
442	0	if (!ctx->key_set \|\| ctx->iv_state == IV_STATE_FINISHED)
443	0	goto err;
444
445		/*
446		* FIPS requires generation of AES-GCM IV's inside the FIPS module.
447		* The IV can still be set externally (the security policy will state that
448		* this is not FIPS compliant). There are some applications
449		* where setting the IV externally is the only option available.
450		*/
451	0	if (ctx->iv_state == IV_STATE_UNINITIALISED) {
452	0	if (!ctx->enc \|\| !gcm_iv_generate(ctx, 0))
453	0	goto err;
454	0	}
455
456	0	if (ctx->iv_state == IV_STATE_BUFFERED) {
457	0	if (!hw->setiv(ctx, ctx->iv, ctx->ivlen))
458	0	goto err;
459	0	ctx->iv_state = IV_STATE_COPIED;
460	0	}
461
462	0	if (in != NULL) {
463		/* The input is AAD if out is NULL */
464	0	if (out == NULL) {
465	0	if (!hw->aadupdate(ctx, in, len))
466	0	goto err;
467	0	} else {
468		/* The input is ciphertext OR plaintext */
469	0	if (!hw->cipherupdate(ctx, in, len, out))
470	0	goto err;
471	0	}
472	0	} else {
473		/* The tag must be set before actually decrypting data */
474	0	if (!ctx->enc && ctx->taglen == UNINITIALISED_SIZET) {
475	0	ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
476	0	goto err;
477	0	}
478	0	if (hw->cipherfinal(ctx, ctx->buf) == 0) {
479	0	if (ctx->enc == 0)
480	0	ERR_raise(ERR_LIB_PROV, PROV_R_BAD_DECRYPT);
481	0	goto err;
482	0	}
483	0	ctx->iv_state = IV_STATE_FINISHED; /* Don't reuse the IV */
484	0	goto finish;
485	0	}
486	0	olen = len;
487	0	finish:
488	0	rv = 1;
489	0	err:
490	0	*padlen = olen;
491	0	return rv;
492	0	}
493
494		static int gcm_tls_init(PROV_GCM_CTX dat, unsigned char aad, size_t aad_len)
495	0	{
496	0	unsigned char *buf;
497	0	size_t len;
498
499	0	if (!ossl_prov_is_running() \|\| aad_len != EVP_AEAD_TLS1_AAD_LEN)
500	0	return 0;
501
502		/* Save the aad for later use. */
503	0	buf = dat->buf;
504	0	memcpy(buf, aad, aad_len);
505	0	dat->tls_aad_len = aad_len;
506
507	0	len = buf[aad_len - 2] << 8 \| buf[aad_len - 1];
508		/* Correct length for explicit iv. */
509	0	if (len < EVP_GCM_TLS_EXPLICIT_IV_LEN)
510	0	return 0;
511	0	len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
512
513		/* If decrypting correct for tag too. */
514	0	if (!dat->enc) {
515	0	if (len < EVP_GCM_TLS_TAG_LEN)
516	0	return 0;
517	0	len -= EVP_GCM_TLS_TAG_LEN;
518	0	}
519	0	buf[aad_len - 2] = (unsigned char)(len >> 8);
520	0	buf[aad_len - 1] = (unsigned char)(len & 0xff);
521		/* Extra padding: tag appended to record. */
522	0	return EVP_GCM_TLS_TAG_LEN;
523	0	}
524
525		static int gcm_tls_iv_set_fixed(PROV_GCM_CTX ctx, unsigned char iv,
526		size_t len)
527	0	{
528		/* Special case: -1 length restores whole IV */
529	0	if (len == (size_t)-1) {
530	0	memcpy(ctx->iv, iv, ctx->ivlen);
531	0	ctx->iv_gen = 1;
532	0	ctx->iv_state = IV_STATE_BUFFERED;
533	0	return 1;
534	0	}
535		/* Fixed field must be at least 4 bytes and invocation field at least 8 */
536	0	if (len < EVP_GCM_TLS_FIXED_IV_LEN
537	0	\|\| len > ctx->ivlen
538	0	\|\| (ctx->ivlen - len) < EVP_GCM_TLS_EXPLICIT_IV_LEN)
539	0	return 0;
540	0	if (len > 0)
541	0	memcpy(ctx->iv, iv, len);
542	0	if (ctx->enc) {
543	0	if (RAND_bytes_ex(ctx->libctx, ctx->iv + len, ctx->ivlen - len, 0) <= 0)
544	0	return 0;
545	0	ctx->iv_gen_rand = 1;
546	0	}
547	0	ctx->iv_gen = 1;
548	0	ctx->iv_state = IV_STATE_BUFFERED;
549	0	return 1;
550	0	}
551
552		/*
553		* Handle TLS GCM packet format. This consists of the last portion of the IV
554		* followed by the payload and finally the tag. On encrypt generate IV,
555		* encrypt payload and write the tag. On verify retrieve IV, decrypt payload
556		* and verify tag.
557		*/
558		static int gcm_tls_cipher(PROV_GCM_CTX ctx, unsigned char out, size_t *padlen,
559		const unsigned char *in, size_t len)
560	0	{
561	0	int rv = 0;
562	0	size_t arg = EVP_GCM_TLS_EXPLICIT_IV_LEN;
563	0	size_t plen = 0;
564	0	unsigned char *tag = NULL;
565
566	0	if (!ossl_prov_is_running() \|\| !ctx->key_set)
567	0	goto err;
568
569		/* Encrypt/decrypt must be performed in place */
570	0	if (out != in \|\| len < (EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN))
571	0	goto err;
572
573		/*
574		* Check for too many keys as per FIPS 140-2 IG A.5 "Key/IV Pair Uniqueness
575		* Requirements from SP 800-38D". The requirements is for one party to the
576		* communication to fail after 2^64 - 1 keys. We do this on the encrypting
577		* side only.
578		*/
579	0	if (ctx->enc && ++ctx->tls_enc_records == 0) {
580	0	ERR_raise(ERR_LIB_PROV, PROV_R_TOO_MANY_RECORDS);
581	0	goto err;
582	0	}
583
584		/*
585		* Set IV from start of buffer or generate IV and write to start of
586		* buffer.
587		*/
588	0	if (ctx->enc) {
589	0	if (!getivgen(ctx, out, arg))
590	0	goto err;
591	0	} else {
592	0	if (!setivinv(ctx, out, arg))
593	0	goto err;
594	0	}
595
596		/* Fix buffer and length to point to payload */
597	0	in += EVP_GCM_TLS_EXPLICIT_IV_LEN;
598	0	out += EVP_GCM_TLS_EXPLICIT_IV_LEN;
599	0	len -= EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
600
601	0	tag = ctx->enc ? out + len : (unsigned char *)in + len;
602	0	if (!ctx->hw->oneshot(ctx, ctx->buf, ctx->tls_aad_len, in, len, out, tag,
603	0	EVP_GCM_TLS_TAG_LEN)) {
604	0	if (!ctx->enc)
605	0	OPENSSL_cleanse(out, len);
606	0	goto err;
607	0	}
608	0	if (ctx->enc)
609	0	plen = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
610	0	else
611	0	plen = len;
612
613	0	rv = 1;
614	0	err:
615	0	ctx->iv_state = IV_STATE_FINISHED;
616	0	ctx->tls_aad_len = UNINITIALISED_SIZET;
617	0	*padlen = plen;
618	0	return rv;
619	0	}