openssl.c

/* Copyright (C) Simon Josefsson
 * Copyright (C) The Written Word, Inc.
 * Copyright (C) Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
 * with or without modification, are permitted provided
 * that the following conditions are met:
 *
 *   Redistributions of source code must retain the above
 *   copyright notice, this list of conditions and the
 *   following disclaimer.
 *
 *   Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following
 *   disclaimer in the documentation and/or other materials
 *   provided with the distribution.
 *
 *   Neither the name of the copyright holder nor the names
 *   of any other contributors may be used to endorse or
 *   promote products derived from this software without
 *   specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#ifdef LIBSSH2_CRYPTO_C /* Compile this via crypto.c */

#include <stdlib.h>
#include <assert.h>

int _libssh2_hmac_ctx_init(libssh2_hmac_ctx *ctx)
{
#ifdef USE_OPENSSL_3
    *ctx = NULL;
    return 1;
#elif defined(HAVE_OPAQUE_STRUCTS)
    *ctx = HMAC_CTX_new();
    return *ctx ? 1 : 0;
#else
    HMAC_CTX_init(ctx);
    return 1;
#endif
}

#ifdef USE_OPENSSL_3
static int _libssh2_hmac_init(libssh2_hmac_ctx *ctx,
                              void *key, size_t keylen,
                              const char *digest_name)
{
    EVP_MAC* mac;
    OSSL_PARAM params[3];

    mac = EVP_MAC_fetch(NULL, OSSL_MAC_NAME_HMAC, NULL);
    if(!mac)
        return 0;

    *ctx = EVP_MAC_CTX_new(mac);
    EVP_MAC_free(mac);
    if(!*ctx)
        return 0;

    params[0] = OSSL_PARAM_construct_octet_string(
        OSSL_MAC_PARAM_KEY, (void *)key, keylen);
    params[1] = OSSL_PARAM_construct_utf8_string(
        OSSL_MAC_PARAM_DIGEST, (char *)digest_name, 0);
    params[2] = OSSL_PARAM_construct_end();

    return EVP_MAC_init(*ctx, NULL, 0, params);
}
#endif

#if LIBSSH2_MD5
int _libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
                           void *key, size_t keylen)
{
#ifdef USE_OPENSSL_3
    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_MD5);
#elif defined(HAVE_OPAQUE_STRUCTS)
    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_md5(), NULL);
#else
    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_md5(), NULL);
#endif
}
#endif

#if LIBSSH2_HMAC_RIPEMD
int _libssh2_hmac_ripemd160_init(libssh2_hmac_ctx *ctx,
                                 void *key, size_t keylen)
{
#ifdef USE_OPENSSL_3
    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_RIPEMD160);
#elif defined(HAVE_OPAQUE_STRUCTS)
    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_ripemd160(), NULL);
#else
    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_ripemd160(), NULL);
#endif
}
#endif

int _libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
                            void *key, size_t keylen)
{
#ifdef USE_OPENSSL_3
    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_SHA1);
#elif defined(HAVE_OPAQUE_STRUCTS)
    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_sha1(), NULL);
#else
    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_sha1(), NULL);
#endif
}

int _libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
                              void *key, size_t keylen)
{
#ifdef USE_OPENSSL_3
    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_SHA2_256);
#elif defined(HAVE_OPAQUE_STRUCTS)
    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_sha256(), NULL);
#else
    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_sha256(), NULL);
#endif
}

int _libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
                              void *key, size_t keylen)
{
#ifdef USE_OPENSSL_3
    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_SHA2_512);
#elif defined(HAVE_OPAQUE_STRUCTS)
    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_sha512(), NULL);
#else
    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_sha512(), NULL);
#endif
}

int _libssh2_hmac_update(libssh2_hmac_ctx *ctx,
                         const void *data, size_t datalen)
{
#ifdef USE_OPENSSL_3
    return EVP_MAC_update(*ctx, data, datalen);
#elif defined(HAVE_OPAQUE_STRUCTS)
/* FIXME: upstream bug as of v5.7.0: datalen is int instead of size_t */
#if defined(LIBSSH2_WOLFSSL)
    return HMAC_Update(*ctx, data, (int)datalen);
#else /* !LIBSSH2_WOLFSSL */
    return HMAC_Update(*ctx, data, datalen);
#endif /* LIBSSH2_WOLFSSL */
#else
    return HMAC_Update(ctx, data, datalen);
#endif
}

int _libssh2_hmac_final(libssh2_hmac_ctx *ctx, void *data)
{
#ifdef USE_OPENSSL_3
    return EVP_MAC_final(*ctx, data, NULL, MAX_MACSIZE);
#elif defined(HAVE_OPAQUE_STRUCTS)
    return HMAC_Final(*ctx, data, NULL);
#else
    return HMAC_Final(ctx, data, NULL);
#endif
}

void _libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx)
{
#ifdef USE_OPENSSL_3
    EVP_MAC_CTX_free(*ctx);
#elif defined(HAVE_OPAQUE_STRUCTS)
    HMAC_CTX_free(*ctx);
#else
    HMAC_cleanup(ctx);
#endif
}

static int
_libssh2_pub_priv_openssh_keyfilememory(LIBSSH2_SESSION *session,
                                        void **key_ctx,
                                        const char *key_type,
                                        unsigned char **method,
                                        size_t *method_len,
                                        unsigned char **pubkeydata,
                                        size_t *pubkeydata_len,
                                        const char *privatekeydata,
                                        size_t privatekeydata_len,
                                        unsigned const char *passphrase);

static int
_libssh2_sk_pub_openssh_keyfilememory(LIBSSH2_SESSION *session,
                                      void **key_ctx,
                                      const char *key_type,
                                      unsigned char **method,
                                      size_t *method_len,
                                      unsigned char **pubkeydata,
                                      size_t *pubkeydata_len,
                                      int *algorithm,
                                      unsigned char *flags,
                                      const char **application,
                                      const unsigned char **key_handle,
                                      size_t *handle_len,
                                      const char *privatekeydata,
                                      size_t privatekeydata_len,
                                      unsigned const char *passphrase);

#if LIBSSH2_RSA || LIBSSH2_DSA || LIBSSH2_ECDSA
static unsigned char *
write_bn(unsigned char *buf, const BIGNUM *bn, int bn_bytes)
{
    unsigned char *p = buf;

    /* Left space for bn size which will be written below. */
    p += 4;

    *p = 0;
    BN_bn2bin(bn, p + 1);
    if(!(*(p + 1) & 0x80)) {
        memmove(p, p + 1, --bn_bytes);
    }
    _libssh2_htonu32(p - 4, bn_bytes);  /* Post write bn size. */

    return p + bn_bytes;
}
#endif

static inline void
_libssh2_swap_bytes(unsigned char *buf, unsigned long len)
{
#if !defined(WORDS_BIGENDIAN) || !WORDS_BIGENDIAN
    unsigned long i, j;
    unsigned char temp;
    for(i = 0, j = len - 1; i < j; i++, j--) {
        temp = buf[i];
        buf[i] = buf[j];
        buf[j] = temp;
    }
#endif
}

int
_libssh2_openssl_random(void *buf, size_t len)
{
    if(len > INT_MAX) {
        return -1;
    }

    return RAND_bytes(buf, (int)len) == 1 ? 0 : -1;
}

#if LIBSSH2_RSA
int
_libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
                 const unsigned char *edata,
                 unsigned long elen,
                 const unsigned char *ndata,
                 unsigned long nlen,
                 const unsigned char *ddata,
                 unsigned long dlen,
                 const unsigned char *pdata,
                 unsigned long plen,
                 const unsigned char *qdata,
                 unsigned long qlen,
                 const unsigned char *e1data,
                 unsigned long e1len,
                 const unsigned char *e2data,
                 unsigned long e2len,
                 const unsigned char *coeffdata, unsigned long coefflen)
{
#ifdef USE_OPENSSL_3
    int ret = 0;
    EVP_PKEY_CTX *ctx;
    OSSL_PARAM params[4];
    int param_num = 0;
    unsigned char *nbuf = NULL;
    unsigned char *ebuf = NULL;
    unsigned char *dbuf = NULL;

    (void)pdata;
    (void)plen;
    (void)qdata;
    (void)qlen;
    (void)e1data;
    (void)e1len;
    (void)e2data;
    (void)e2len;
    (void)coeffdata;
    (void)coefflen;

    if(ndata && nlen > 0) {
        nbuf = OPENSSL_malloc(nlen);

        if(nbuf) {
            memcpy(nbuf, ndata, nlen);
            _libssh2_swap_bytes(nbuf, nlen);
            params[param_num++] =
                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_N, nbuf, nlen);
        }
    }

    if(edata && elen > 0) {
        ebuf = OPENSSL_malloc(elen);
        if(ebuf) {
            memcpy(ebuf, edata, elen);
            _libssh2_swap_bytes(ebuf, elen);
            params[param_num++] =
                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_E, ebuf, elen);
        }
    }

    if(ddata && dlen > 0) {
        dbuf = OPENSSL_malloc(dlen);
        if(dbuf) {
            memcpy(dbuf, ddata, dlen);
            _libssh2_swap_bytes(dbuf, dlen);
            params[param_num++] =
                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_D, dbuf, dlen);
        }
    }

    params[param_num] = OSSL_PARAM_construct_end();

    *rsa = NULL;
    ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);

    if(EVP_PKEY_fromdata_init(ctx) > 0) {
        ret = EVP_PKEY_fromdata(ctx, rsa, EVP_PKEY_KEYPAIR, params);
    }
    if(nbuf)
        OPENSSL_clear_free(nbuf, nlen);

    if(ebuf)
        OPENSSL_clear_free(ebuf, elen);

    if(dbuf)
        OPENSSL_clear_free(dbuf, dlen);

    EVP_PKEY_CTX_free(ctx);

    return (ret == 1) ? 0 : -1;
#else
    BIGNUM * e;
    BIGNUM * n;
    BIGNUM * d = 0;
    BIGNUM * p = 0;
    BIGNUM * q = 0;
    BIGNUM * dmp1 = 0;
    BIGNUM * dmq1 = 0;
    BIGNUM * iqmp = 0;

    e = BN_new();
    BN_bin2bn(edata, (int) elen, e);

    n = BN_new();
    BN_bin2bn(ndata, (int) nlen, n);

    if(ddata) {
        d = BN_new();
        BN_bin2bn(ddata, (int) dlen, d);

        p = BN_new();
        BN_bin2bn(pdata, (int) plen, p);

        q = BN_new();
        BN_bin2bn(qdata, (int) qlen, q);

        dmp1 = BN_new();
        BN_bin2bn(e1data, (int) e1len, dmp1);

        dmq1 = BN_new();
        BN_bin2bn(e2data, (int) e2len, dmq1);

        iqmp = BN_new();
        BN_bin2bn(coeffdata, (int) coefflen, iqmp);
    }

    *rsa = RSA_new();
#ifdef HAVE_OPAQUE_STRUCTS
    RSA_set0_key(*rsa, n, e, d);
#else
    (*rsa)->e = e;
    (*rsa)->n = n;
    (*rsa)->d = d;
#endif

#ifdef HAVE_OPAQUE_STRUCTS
    RSA_set0_factors(*rsa, p, q);
#else
    (*rsa)->p = p;
    (*rsa)->q = q;
#endif

#ifdef HAVE_OPAQUE_STRUCTS
    RSA_set0_crt_params(*rsa, dmp1, dmq1, iqmp);
#else
    (*rsa)->dmp1 = dmp1;
    (*rsa)->dmq1 = dmq1;
    (*rsa)->iqmp = iqmp;
#endif
    return 0;

#endif /* USE_OPENSSL_3 */
}

int
_libssh2_rsa_sha2_verify(libssh2_rsa_ctx * rsactx,
                         size_t hash_len,
                         const unsigned char *sig,
                         size_t sig_len,
                         const unsigned char *m, size_t m_len)
{
#ifdef USE_OPENSSL_3
    EVP_PKEY_CTX *ctx = NULL;
    const EVP_MD *md = NULL;
#endif

    int ret;
    int nid_type;
    unsigned char *hash = malloc(hash_len);
    if(!hash)
        return -1;

    if(hash_len == SHA_DIGEST_LENGTH) {
        nid_type = NID_sha1;
        ret = _libssh2_sha1(m, m_len, hash);
    }
    else if(hash_len == SHA256_DIGEST_LENGTH) {
        nid_type = NID_sha256;
        ret = _libssh2_sha256(m, m_len, hash);
    }
    else if(hash_len == SHA512_DIGEST_LENGTH) {
        nid_type = NID_sha512;
        ret = _libssh2_sha512(m, m_len, hash);
    }
    else {
/* silence:
   warning C4701: potentially uninitialized local variable 'nid_type' used */
#if defined(_MSC_VER)
        nid_type = 0;
#endif
        ret = -1; /* unsupported digest */
    }

    if(ret) {
        free(hash);
        return -1; /* failure */
    }

#ifdef USE_OPENSSL_3
    ctx = EVP_PKEY_CTX_new(rsactx, NULL);

    if(nid_type == NID_sha1) {
        md = EVP_sha1();
    }
    else if(nid_type == NID_sha256) {
        md = EVP_sha256();
    }
    else if(nid_type == NID_sha512) {
        md = EVP_sha512();
    }

    if(ctx && md) {
        if(EVP_PKEY_verify_init(ctx) > 0 &&
           EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) > 0 &&
           EVP_PKEY_CTX_set_signature_md(ctx, md) > 0) {
            ret = EVP_PKEY_verify(ctx, sig, sig_len, hash, hash_len);
        }
    }

    if(ctx) {
        EVP_PKEY_CTX_free(ctx);
    }

#else

    ret = RSA_verify(nid_type, hash, (unsigned int) hash_len,
                     (unsigned char *) sig,
                     (unsigned int) sig_len, rsactx);
#endif

    free(hash);

    return (ret == 1) ? 0 : -1;
}

#if LIBSSH2_RSA_SHA1
int
_libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,
                         const unsigned char *sig,
                         size_t sig_len,
                         const unsigned char *m, size_t m_len)
{
    return _libssh2_rsa_sha2_verify(rsactx, SHA_DIGEST_LENGTH, sig, sig_len, m,
                                    m_len);
}
#endif
#endif

#if LIBSSH2_DSA
int
_libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
                 const unsigned char *p,
                 unsigned long p_len,
                 const unsigned char *q,
                 unsigned long q_len,
                 const unsigned char *g,
                 unsigned long g_len,
                 const unsigned char *y,
                 unsigned long y_len,
                 const unsigned char *x, unsigned long x_len)
{
#ifdef USE_OPENSSL_3
    int ret = 0;
    EVP_PKEY_CTX *ctx = NULL;
    OSSL_PARAM params[6];
    int param_num = 0;
    unsigned char *p_buf = NULL;
    unsigned char *q_buf = NULL;
    unsigned char *g_buf = NULL;
    unsigned char *y_buf = NULL;
    unsigned char *x_buf = NULL;

    if(p && p_len > 0) {
        p_buf = OPENSSL_malloc(p_len);

        if(p_buf) {
            memcpy(p_buf, p, p_len);
            _libssh2_swap_bytes(p_buf, p_len);
            params[param_num++] =
                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_FFC_P, p_buf, p_len);
        }
    }

    if(q && q_len > 0) {
        q_buf = OPENSSL_malloc(q_len);

        if(q_buf) {
            memcpy(q_buf, q, q_len);
            _libssh2_swap_bytes(q_buf, q_len);
            params[param_num++] =
                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_FFC_Q, q_buf, q_len);
        }
    }

    if(g && g_len > 0) {
        g_buf = OPENSSL_malloc(g_len);

        if(g_buf) {
            memcpy(g_buf, g, g_len);
            _libssh2_swap_bytes(g_buf, g_len);
            params[param_num++] =
                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_FFC_G, g_buf, g_len);
        }
    }

    if(y && y_len > 0) {
        y_buf = OPENSSL_malloc(y_len);

        if(y_buf) {
            memcpy(y_buf, y, y_len);
            _libssh2_swap_bytes(y_buf, y_len);
            params[param_num++] =
                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_PUB_KEY, y_buf, y_len);
        }
    }

    if(x && x_len > 0) {
        x_buf = OPENSSL_malloc(x_len);

        if(x_buf) {
            memcpy(x_buf, x, x_len);
            _libssh2_swap_bytes(x_buf, x_len);
            params[param_num++] =
                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_PRIV_KEY,
                                        x_buf, x_len);
        }
    }

    params[param_num] = OSSL_PARAM_construct_end();

    *dsactx = NULL;
    ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_DSA, NULL);

    if(EVP_PKEY_fromdata_init(ctx) > 0) {
        ret = EVP_PKEY_fromdata(ctx, dsactx, EVP_PKEY_KEYPAIR, params);
    }

    if(p_buf)
        OPENSSL_clear_free(p_buf, p_len);
    if(q_buf)
        OPENSSL_clear_free(q_buf, q_len);
    if(g_buf)
        OPENSSL_clear_free(g_buf, g_len);
    if(x_buf)
        OPENSSL_clear_free(x_buf, x_len);
    if(y_buf)
        OPENSSL_clear_free(y_buf, y_len);

    return (ret == 1) ? 0 : -1;

#else

    BIGNUM * p_bn;
    BIGNUM * q_bn;
    BIGNUM * g_bn;
    BIGNUM * pub_key;
    BIGNUM * priv_key = NULL;

    p_bn = BN_new();
    BN_bin2bn(p, (int) p_len, p_bn);

    q_bn = BN_new();
    BN_bin2bn(q, (int) q_len, q_bn);

    g_bn = BN_new();
    BN_bin2bn(g, (int) g_len, g_bn);

    pub_key = BN_new();
    BN_bin2bn(y, (int) y_len, pub_key);

    if(x_len) {
        priv_key = BN_new();
        BN_bin2bn(x, (int) x_len, priv_key);
    }

    *dsactx = DSA_new();

#ifdef HAVE_OPAQUE_STRUCTS
    DSA_set0_pqg(*dsactx, p_bn, q_bn, g_bn);
#else
    (*dsactx)->p = p_bn;
    (*dsactx)->g = g_bn;
    (*dsactx)->q = q_bn;
#endif

#ifdef HAVE_OPAQUE_STRUCTS
    DSA_set0_key(*dsactx, pub_key, priv_key);
#else
    (*dsactx)->pub_key = pub_key;
    (*dsactx)->priv_key = priv_key;
#endif
    return 0;

#endif /* USE_OPENSSL_3 */
}

int
_libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
                         const unsigned char *sig,
                         const unsigned char *m, size_t m_len)
{
#ifdef USE_OPENSSL_3
    EVP_PKEY_CTX *ctx = NULL;
    unsigned char *der = NULL;
    int der_len = 0;
#endif

    unsigned char hash[SHA_DIGEST_LENGTH];
    DSA_SIG * dsasig;
    BIGNUM * r;
    BIGNUM * s;
    int ret = -1;

    r = BN_new();
    BN_bin2bn(sig, 20, r);
    s = BN_new();
    BN_bin2bn(sig + 20, 20, s);

    dsasig = DSA_SIG_new();
#ifdef HAVE_OPAQUE_STRUCTS
    DSA_SIG_set0(dsasig, r, s);
#else
    dsasig->r = r;
    dsasig->s = s;
#endif

#ifdef USE_OPENSSL_3
    ctx = EVP_PKEY_CTX_new(dsactx, NULL);
    der_len = i2d_DSA_SIG(dsasig, &der);

    if(ctx && !_libssh2_sha1(m, m_len, hash)) {
        /* _libssh2_sha1() succeeded */
        if(EVP_PKEY_verify_init(ctx) > 0) {
            ret = EVP_PKEY_verify(ctx, der, der_len, hash, SHA_DIGEST_LENGTH);
        }
    }

    if(ctx) {
        EVP_PKEY_CTX_free(ctx);
    }

    if(der) {
        OPENSSL_clear_free(der, der_len);
    }
#else
    if(!_libssh2_sha1(m, m_len, hash))
        /* _libssh2_sha1() succeeded */
        ret = DSA_do_verify(hash, SHA_DIGEST_LENGTH, dsasig, dsactx);
#endif

    DSA_SIG_free(dsasig);

    return (ret == 1) ? 0 : -1;
}
#endif /* LIBSSH_DSA */

#if LIBSSH2_ECDSA

/* _libssh2_ecdsa_get_curve_type
 *
 * returns key curve type that maps to libssh2_curve_type
 *
 */

libssh2_curve_type
_libssh2_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ec_ctx)
{
#ifdef USE_OPENSSL_3
    int bits = 0;
    EVP_PKEY_get_int_param(ec_ctx, OSSL_PKEY_PARAM_BITS, &bits);

    if(bits == 256) {
        return LIBSSH2_EC_CURVE_NISTP256;
    }
    else if(bits == 384) {
        return LIBSSH2_EC_CURVE_NISTP384;
    }
    else if(bits == 521) {
        return LIBSSH2_EC_CURVE_NISTP521;
    }

    return LIBSSH2_EC_CURVE_NISTP256;
#else
    const EC_GROUP *group = EC_KEY_get0_group(ec_ctx);
    return EC_GROUP_get_curve_name(group);
#endif
}

/* _libssh2_ecdsa_curve_type_from_name
 *
 * returns 0 for success, key curve type that maps to libssh2_curve_type
 *
 */

int
_libssh2_ecdsa_curve_type_from_name(const char *name,
                                    libssh2_curve_type *out_type)
{
    libssh2_curve_type type;

    if(!name || strlen(name) != 19)
        return -1;

    if(strcmp(name, "ecdsa-sha2-nistp256") == 0)
        type = LIBSSH2_EC_CURVE_NISTP256;
    else if(strcmp(name, "ecdsa-sha2-nistp384") == 0)
        type = LIBSSH2_EC_CURVE_NISTP384;
    else if(strcmp(name, "ecdsa-sha2-nistp521") == 0)
        type = LIBSSH2_EC_CURVE_NISTP521;
    else {
        return -1;
    }

    if(out_type) {
        *out_type = type;
    }

    return 0;
}

/* _libssh2_ecdsa_curve_name_with_octal_new
 *
 * Creates a new public key given an octal string, length and type
 *
 */

int
_libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx ** ec_ctx,
     const unsigned char *k,
     size_t k_len, libssh2_curve_type curve)
{
    int ret = 0;

#ifdef USE_OPENSSL_3
    EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
    const char *n = EC_curve_nid2nist(curve);
    char *group_name = NULL;
    unsigned char *data = NULL;

    if(!ctx)
        return -1;

    if(n) {
        group_name = OPENSSL_zalloc(strlen(n) + 1);
    }

    if(k_len > 0) {
        data = OPENSSL_malloc(k_len);
    }

    if(group_name && data) {
        OSSL_PARAM params[3] = { 0 };

        memcpy(group_name, n, strlen(n));
        memcpy(data, k, k_len);

        params[0] =
        OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
                                         group_name, 0);

        params[1] =
        OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
                                          data, k_len);

        params[2] = OSSL_PARAM_construct_end();

        if(EVP_PKEY_fromdata_init(ctx) > 0)
            ret = EVP_PKEY_fromdata(ctx, ec_ctx, EVP_PKEY_PUBLIC_KEY,
                                    params);
        else
            ret = -1;
    }
    else
        ret = -1;

    if(group_name)
        OPENSSL_clear_free(group_name, strlen(n));

    if(data)
        OPENSSL_clear_free(data, k_len);

    EVP_PKEY_CTX_free(ctx);
#else
    EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);

    if(ec_key) {
        const EC_GROUP *ec_group = NULL;
        EC_POINT *point = NULL;

        ec_group = EC_KEY_get0_group(ec_key);
        point = EC_POINT_new(ec_group);

        if(point) {
            ret = EC_POINT_oct2point(ec_group, point, k, k_len, NULL);
            if(ret == 1)
                ret = EC_KEY_set_public_key(ec_key, point);

            EC_POINT_free(point);
        }
        else
            ret = -1;

        if(ret == 1 && ec_ctx)
            *ec_ctx = ec_key;
        else {
            EC_KEY_free(ec_key);
            ret = -1;
        }
    }
    else
        ret = -1;
#endif

    return (ret == 1) ? 0 : -1;
}

#ifdef USE_OPENSSL_3
#define LIBSSH2_ECDSA_VERIFY(digest_type)                               \
    do {                                                                \
        unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];           \
        if(libssh2_sha##digest_type(m, m_len, hash) == 0) {             \
            ret = EVP_PKEY_verify_init(ctx);                            \
            if(ret > 0) {                                               \
                ret = EVP_PKEY_verify(ctx, der, der_len, hash,          \
                                     SHA##digest_type##_DIGEST_LENGTH); \
            }                                                           \
        }                                                               \
    } while(0)
#else
#define LIBSSH2_ECDSA_VERIFY(digest_type)                               \
    do {                                                                \
        unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];           \
        if(libssh2_sha##digest_type(m, m_len, hash) == 0) {             \
            ret = ECDSA_do_verify(hash,                                 \
                                  SHA##digest_type##_DIGEST_LENGTH,     \
                                  ecdsa_sig, ec_key);                   \
        }                                                               \
    } while(0)
#endif

int
_libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ecdsa_ctx,
                      const unsigned char *r, size_t r_len,
                      const unsigned char *s, size_t s_len,
                      const unsigned char *m, size_t m_len)
{
    int ret = 0;
    libssh2_curve_type type = _libssh2_ecdsa_get_curve_type(ecdsa_ctx);

#ifdef USE_OPENSSL_3
    EVP_PKEY_CTX *ctx = NULL;
    unsigned char *der = NULL;
    int der_len = 0;
#else
    EC_KEY *ec_key = (EC_KEY*)ecdsa_ctx;
#endif

#ifdef HAVE_OPAQUE_STRUCTS
    ECDSA_SIG *ecdsa_sig = ECDSA_SIG_new();
    BIGNUM *pr = BN_new();
    BIGNUM *ps = BN_new();

    BN_bin2bn(r, (int) r_len, pr);
    BN_bin2bn(s, (int) s_len, ps);
    ECDSA_SIG_set0(ecdsa_sig, pr, ps);
#else
    ECDSA_SIG ecdsa_sig_;
    ECDSA_SIG *ecdsa_sig = &ecdsa_sig_;
    ecdsa_sig_.r = BN_new();
    BN_bin2bn(r, (int) r_len, ecdsa_sig_.r);
    ecdsa_sig_.s = BN_new();
    BN_bin2bn(s, (int) s_len, ecdsa_sig_.s);
#endif

#ifdef USE_OPENSSL_3
    ctx = EVP_PKEY_CTX_new(ecdsa_ctx, NULL);
    if(!ctx) {
        ret = -1;
        goto cleanup;
    }

    der_len = i2d_ECDSA_SIG(ecdsa_sig, &der);
    if(der_len <= 0) {
        ret = -1;
        goto cleanup;
    }
#endif

    if(type == LIBSSH2_EC_CURVE_NISTP256) {
        LIBSSH2_ECDSA_VERIFY(256);
    }
    else if(type == LIBSSH2_EC_CURVE_NISTP384) {
        LIBSSH2_ECDSA_VERIFY(384);
    }
    else if(type == LIBSSH2_EC_CURVE_NISTP521) {
        LIBSSH2_ECDSA_VERIFY(512);
    }

#ifdef USE_OPENSSL_3
cleanup:

    if(ctx)
        EVP_PKEY_CTX_free(ctx);

    if(der)
        OPENSSL_free(der);
#endif

#ifdef HAVE_OPAQUE_STRUCTS
    if(ecdsa_sig)
        ECDSA_SIG_free(ecdsa_sig);
#else
    if(ecdsa_sig_.s)
        BN_clear_free(ecdsa_sig_.s);
    if(ecdsa_sig_.r)
        BN_clear_free(ecdsa_sig_.r);
#endif

    return (ret == 1) ? 0 : -1;
}

#endif /* LIBSSH2_ECDSA */

int
_libssh2_cipher_init(_libssh2_cipher_ctx * h,
                     _libssh2_cipher_type(algo),
                     unsigned char *iv, unsigned char *secret, int encrypt)
{
#ifdef HAVE_OPAQUE_STRUCTS
#if LIBSSH2_AES_GCM
    const int is_aesgcm = (algo == EVP_aes_128_gcm) ||
                          (algo == EVP_aes_256_gcm);
#endif /* LIBSSH2_AES_GCM */
    int rc;

    *h = EVP_CIPHER_CTX_new();
    rc = !EVP_CipherInit(*h, algo(), secret, iv, encrypt);