/*      $OpenBSD: sshbuf-getput-crypto.c,v 1.12 2024/08/15 00:51:51 djm Exp $   */
/*
 * Copyright (c) 2011 Damien Miller
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#define SSHBUF_INTERNAL
#include "includes.h"

#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#ifdef WITH_OPENSSL
#include <openssl/bn.h>
#ifdef OPENSSL_HAS_ECC
# include <openssl/ec.h>
#endif /* OPENSSL_HAS_ECC */

#include "ssherr.h"
#include "sshbuf.h"

int
sshbuf_get_bignum2(struct sshbuf *buf, BIGNUM **valp)
{
        BIGNUM *v;
        const u_char *d;
        size_t len;
        int r;

        if (valp != NULL)
                *valp = NULL;
        if ((r = sshbuf_get_bignum2_bytes_direct(buf, &d, &len)) != 0)
                return r;
        if (valp != NULL) {
                if ((v = BN_new()) == NULL ||
                    BN_bin2bn(d, len, v) == NULL) {
                        BN_clear_free(v);
                        return SSH_ERR_ALLOC_FAIL;
                }
                *valp = v;
        }
        return 0;
}

#ifdef OPENSSL_HAS_ECC
static int
get_ec(const u_char *d, size_t len, EC_POINT *v, const EC_GROUP *g)
{
        /* Refuse overlong bignums */
        if (len == 0 || len > SSHBUF_MAX_ECPOINT)
                return SSH_ERR_ECPOINT_TOO_LARGE;
        /* Only handle uncompressed points */
        if (*d != POINT_CONVERSION_UNCOMPRESSED)
                return SSH_ERR_INVALID_FORMAT;
        if (v != NULL && EC_POINT_oct2point(g, v, d, len, NULL) != 1)
                return SSH_ERR_INVALID_FORMAT; /* XXX assumption */
        return 0;
}

int
sshbuf_get_ec(struct sshbuf *buf, EC_POINT *v, const EC_GROUP *g)
{
        const u_char *d;
        size_t len;
        int r;

        if ((r = sshbuf_peek_string_direct(buf, &d, &len)) < 0)
                return r;
        if ((r = get_ec(d, len, v, g)) != 0)
                return r;
        /* Skip string */
        if (sshbuf_get_string_direct(buf, NULL, NULL) != 0) {
                /* Shouldn't happen */
                SSHBUF_DBG(("SSH_ERR_INTERNAL_ERROR"));
                SSHBUF_ABORT();
                return SSH_ERR_INTERNAL_ERROR;
        }
        return 0;
}

int
sshbuf_get_eckey(struct sshbuf *buf, EC_KEY *v)
{
        EC_POINT *pt = EC_POINT_new(EC_KEY_get0_group(v));
        int r;
        const u_char *d;
        size_t len;

        if (pt == NULL) {
                SSHBUF_DBG(("SSH_ERR_ALLOC_FAIL"));
                return SSH_ERR_ALLOC_FAIL;
        }
        if ((r = sshbuf_peek_string_direct(buf, &d, &len)) < 0) {
                EC_POINT_free(pt);
                return r;
        }
        if ((r = get_ec(d, len, pt, EC_KEY_get0_group(v))) != 0) {
                EC_POINT_free(pt);
                return r;
        }
        if (EC_KEY_set_public_key(v, pt) != 1) {
                EC_POINT_free(pt);
                return SSH_ERR_ALLOC_FAIL; /* XXX assumption */
        }
        EC_POINT_free(pt);
        /* Skip string */
        if (sshbuf_get_string_direct(buf, NULL, NULL) != 0) {
                /* Shouldn't happen */
                SSHBUF_DBG(("SSH_ERR_INTERNAL_ERROR"));
                SSHBUF_ABORT();
                return SSH_ERR_INTERNAL_ERROR;
        }
        return 0;
}
#endif /* OPENSSL_HAS_ECC */

int
sshbuf_put_bignum2(struct sshbuf *buf, const BIGNUM *v)
{
        u_char d[SSHBUF_MAX_BIGNUM + 1];
        int len = BN_num_bytes(v), prepend = 0, r;

        if (len < 0 || len > SSHBUF_MAX_BIGNUM)
                return SSH_ERR_INVALID_ARGUMENT;
        *d = '\0';
        if (BN_bn2bin(v, d + 1) != len)
                return SSH_ERR_INTERNAL_ERROR; /* Shouldn't happen */
        /* If MSB is set, prepend a \0 */
        if (len > 0 && (d[1] & 0x80) != 0)
                prepend = 1;
        if ((r = sshbuf_put_string(buf, d + 1 - prepend, len + prepend)) < 0) {
                explicit_bzero(d, sizeof(d));
                return r;
        }
        explicit_bzero(d, sizeof(d));
        return 0;
}

#ifdef OPENSSL_HAS_ECC
int
sshbuf_put_ec(struct sshbuf *buf, const EC_POINT *v, const EC_GROUP *g)
{
        u_char d[SSHBUF_MAX_ECPOINT];
        size_t len;
        int ret;

        if ((len = EC_POINT_point2oct(g, v, POINT_CONVERSION_UNCOMPRESSED,
            NULL, 0, NULL)) > SSHBUF_MAX_ECPOINT) {
                return SSH_ERR_INVALID_ARGUMENT;
        }
        if (EC_POINT_point2oct(g, v, POINT_CONVERSION_UNCOMPRESSED,
            d, len, NULL) != len) {
                return SSH_ERR_INTERNAL_ERROR; /* Shouldn't happen */
        }
        ret = sshbuf_put_string(buf, d, len);
        explicit_bzero(d, len);
        return ret;
}

int
sshbuf_put_eckey(struct sshbuf *buf, const EC_KEY *v)
{
        return sshbuf_put_ec(buf, EC_KEY_get0_public_key(v),
            EC_KEY_get0_group(v));
}

int
sshbuf_put_ec_pkey(struct sshbuf *buf, EVP_PKEY *pkey)
{
        const EC_KEY *ec;

        if ((ec = EVP_PKEY_get0_EC_KEY(pkey)) == NULL)
                return SSH_ERR_LIBCRYPTO_ERROR;
        return sshbuf_put_eckey(buf, ec);
}
#endif /* OPENSSL_HAS_ECC */
#endif /* WITH_OPENSSL */