ttssh2/ttxssh/key.c

/*
(C) 2011 TeraTerm Project
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.

The name of Robert O'Callahan may not 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 REGENTS 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.
*/
#include "key.h"
#include "kex.h"
#include "resource.h"

#include <openssl/rsa.h>
#include <openssl/dsa.h>
#include <openssl/ecdsa.h>
#include <openssl/buffer.h>

#define INTBLOB_LEN 20
#define SIGBLOB_LEN (2*INTBLOB_LEN)


struct hostkeys_update_ctx {
        /* The hostname and (optionally) IP address string for the server */
        char *host_str, *ip_str;

        /*
        * Keys received from the server and a flag for each indicating
        * whether they already exist in known_hosts.
        * keys_seen is filled in by hostkeys_find() and later (for new
        * keys) by client_global_hostkeys_private_confirm().
        */
        Key **keys;
        int *keys_seen;
        size_t nkeys;

        size_t nnew;

        /*
        * Keys that are in known_hosts, but were not present in the update
        * from the server (i.e. scheduled to be deleted).
        * Filled in by hostkeys_find().
        */
        Key **old_keys;
        size_t nold;
};


//////////////////////////////////////////////////////////////////////////////
//
// Key verify function
//
//////////////////////////////////////////////////////////////////////////////

//
// DSS
//

int ssh_dss_verify(DSA *key,
                   u_char *signature, u_int signaturelen,
                   u_char *data, u_int datalen)
{
        DSA_SIG *sig;
        const EVP_MD *evp_md = EVP_sha1();
        EVP_MD_CTX md;
        unsigned char digest[EVP_MAX_MD_SIZE], *sigblob;
        unsigned int len, dlen;
        int ret;
        char *ptr;

        OpenSSL_add_all_digests();

        if (key == NULL) {
                return -2;
        }

        ptr = signature;

        // step1
        if (signaturelen == 0x28) {
                // workaround for SSH-2.0-2.0* and SSH-2.0-2.1* (2006.11.18 maya)
                ptr -= 4;
        }
        else {
                len = get_uint32_MSBfirst(ptr);
                ptr += 4;
                if (strncmp("ssh-dss", ptr, len) != 0) {
                        return -3;
                }
                ptr += len;
        }

        // step2
        len = get_uint32_MSBfirst(ptr);
        ptr += 4;
        sigblob = ptr;
        ptr += len;

        if (len != SIGBLOB_LEN) {
                return -4;
        }

        /* parse signature */
        if ((sig = DSA_SIG_new()) == NULL)
                return -5;
        if ((sig->r = BN_new()) == NULL)
                return -6;
        if ((sig->s = BN_new()) == NULL)
                return -7;
        BN_bin2bn(sigblob, INTBLOB_LEN, sig->r);
        BN_bin2bn(sigblob+ INTBLOB_LEN, INTBLOB_LEN, sig->s);

        /* sha1 the data */
        EVP_DigestInit(&md, evp_md);
        EVP_DigestUpdate(&md, data, datalen);
        EVP_DigestFinal(&md, digest, &dlen);

        ret = DSA_do_verify(digest, dlen, sig, key);
        SecureZeroMemory(digest, sizeof(digest));

        DSA_SIG_free(sig);

        return ret;
}


//
// RSA
//

/*
* See:
* http://www.rsasecurity.com/rsalabs/pkcs/pkcs-1/
* ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1.asn
*/
/*
* id-sha1 OBJECT IDENTIFIER ::= { iso(1) identified-organization(3)
*       oiw(14) secsig(3) algorithms(2) 26 }
*/
static const u_char id_sha1[] = {
        0x30, 0x21, /* type Sequence, length 0x21 (33) */
                0x30, 0x09, /* type Sequence, length 0x09 */
                0x06, 0x05, /* type OID, length 0x05 */
                0x2b, 0x0e, 0x03, 0x02, 0x1a, /* id-sha1 OID */
                0x05, 0x00, /* NULL */
                0x04, 0x14  /* Octet string, length 0x14 (20), followed by sha1 hash */
};
/*
* id-md5 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840)
*       rsadsi(113549) digestAlgorithm(2) 5 }
*/
static const u_char id_md5[] = {
        0x30, 0x20, /* type Sequence, length 0x20 (32) */
                0x30, 0x0c, /* type Sequence, length 0x09 */
                0x06, 0x08, /* type OID, length 0x05 */
                0x2a, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x02, 0x05, /* id-md5 */
                0x05, 0x00, /* NULL */
                0x04, 0x10  /* Octet string, length 0x10 (16), followed by md5 hash */
};

static int openssh_RSA_verify(int type, u_char *hash, u_int hashlen,
                              u_char *sigbuf, u_int siglen, RSA *rsa)
{
        u_int ret, rsasize, oidlen = 0, hlen = 0;
        int len;
        const u_char *oid = NULL;
        u_char *decrypted = NULL;

        ret = 0;
        switch (type) {
        case NID_sha1:
                oid = id_sha1;
                oidlen = sizeof(id_sha1);
                hlen = 20;
                break;
        case NID_md5:
                oid = id_md5;
                oidlen = sizeof(id_md5);
                hlen = 16;
                break;
        default:
                goto done;
                break;
        }
        if (hashlen != hlen) {
                //error("bad hashlen");
                goto done;
        }
        rsasize = RSA_size(rsa);
        if (siglen == 0 || siglen > rsasize) {
                //error("bad siglen");
                goto done;
        }
        decrypted = malloc(rsasize);
        if (decrypted == NULL)
                return 1; // error

        if ((len = RSA_public_decrypt(siglen, sigbuf, decrypted, rsa,
                                      RSA_PKCS1_PADDING)) < 0) {
                        //error("RSA_public_decrypt failed: %s",
                        //    ERR_error_string(ERR_get_error(), NULL));
                        goto done;
                }
                if (len != hlen + oidlen) {
                        //error("bad decrypted len: %d != %d + %d", len, hlen, oidlen);
                        goto done;
                }
                if (memcmp(decrypted, oid, oidlen) != 0) {
                        //error("oid mismatch");
                        goto done;
                }
                if (memcmp(decrypted + oidlen, hash, hlen) != 0) {
                        //error("hash mismatch");
                        goto done;
                }
                ret = 1;
done:
                if (decrypted)
                        free(decrypted);
                return ret;
}

int ssh_rsa_verify(RSA *key,
                   u_char *signature, u_int signaturelen,
                   u_char *data, u_int datalen)
{
        const EVP_MD *evp_md;
        EVP_MD_CTX md;
        //      char *ktype;
        u_char digest[EVP_MAX_MD_SIZE], *sigblob;
        u_int len, dlen, modlen;
//      int rlen, ret, nid;
        int ret, nid;
        char *ptr;

        OpenSSL_add_all_digests();

        if (key == NULL) {
                return -2;
        }
        if (BN_num_bits(key->n) < SSH_RSA_MINIMUM_MODULUS_SIZE) {
                return -3;
        }
        //debug_print(41, signature, signaturelen);
        ptr = signature;

        // step1
        len = get_uint32_MSBfirst(ptr);
        ptr += 4;
        if (strncmp("ssh-rsa", ptr, len) != 0) {
                return -4;
        }
        ptr += len;

        // step2
        len = get_uint32_MSBfirst(ptr);
        ptr += 4;
        sigblob = ptr;
        ptr += len;
#if 0
        rlen = get_uint32_MSBfirst(ptr);
        if (rlen != 0) {
                return -1;
        }
#endif

        /* RSA_verify expects a signature of RSA_size */
        modlen = RSA_size(key);
        if (len > modlen) {
                return -5;

        } else if (len < modlen) {
                u_int diff = modlen - len;
                sigblob = realloc(sigblob, modlen);
                memmove(sigblob + diff, sigblob, len);
                memset(sigblob, 0, diff);
                len = modlen;
        }
        
        /* sha1 the data */
        //      nid = (datafellows & SSH_BUG_RSASIGMD5) ? NID_md5 : NID_sha1;
        nid = NID_sha1;
        if ((evp_md = EVP_get_digestbynid(nid)) == NULL) {
                //error("ssh_rsa_verify: EVP_get_digestbynid %d failed", nid);
                return -6;
        }
        EVP_DigestInit(&md, evp_md);
        EVP_DigestUpdate(&md, data, datalen);
        EVP_DigestFinal(&md, digest, &dlen);

        ret = openssh_RSA_verify(nid, digest, dlen, sigblob, len, key);

        SecureZeroMemory(digest, sizeof(digest));
        SecureZeroMemory(sigblob, len);
        //free(sigblob);
        //debug("ssh_rsa_verify: signature %scorrect", (ret==0) ? "in" : "");

        return ret;
}

int ssh_ecdsa_verify(EC_KEY *key, ssh_keytype keytype,
                     u_char *signature, u_int signaturelen,
                     u_char *data, u_int datalen)
{
        ECDSA_SIG *sig;
        const EVP_MD *evp_md;
        EVP_MD_CTX md;
        unsigned char digest[EVP_MAX_MD_SIZE], *sigblob;
        unsigned int len, dlen;
        int ret, nid = NID_undef;
        char *ptr;

        OpenSSL_add_all_digests();

        if (key == NULL) {
                return -2;
        }

        ptr = signature;

        len = get_uint32_MSBfirst(ptr);
        ptr += 4;
        if (strncmp(get_ssh_keytype_name(keytype), ptr, len) != 0) {
                return -3;
        }
        ptr += len;

        len = get_uint32_MSBfirst(ptr);
        ptr += 4;
        sigblob = ptr;
        ptr += len;

        /* parse signature */
        if ((sig = ECDSA_SIG_new()) == NULL)
                return -4;
        if ((sig->r = BN_new()) == NULL)
                return -5;
        if ((sig->s = BN_new()) == NULL)
                return -6;

        buffer_get_bignum2(&sigblob, sig->r);
        buffer_get_bignum2(&sigblob, sig->s);
        if (sigblob != ptr) {
                return -7;
        }

        /* hash the data */
        nid = keytype_to_hash_nid(keytype);
        if ((evp_md = EVP_get_digestbynid(nid)) == NULL) {
                return -8;
        }
        EVP_DigestInit(&md, evp_md);
        EVP_DigestUpdate(&md, data, datalen);
        EVP_DigestFinal(&md, digest, &dlen);

        ret = ECDSA_do_verify(digest, dlen, sig, key);
        SecureZeroMemory(digest, sizeof(digest));

        ECDSA_SIG_free(sig);

        return ret;
}

static int ssh_ed25519_verify(Key *key, unsigned char *signature, unsigned int signaturelen, 
                                                          unsigned char *data, unsigned int datalen)
{
        buffer_t *b;
        char *ktype = NULL;
        unsigned char *sigblob = NULL, *sm = NULL, *m = NULL;
        unsigned int len;
        unsigned long long smlen, mlen;
        int rlen, ret;
        char *bptr;

        ret = -1;
        b = buffer_init();
        if (b == NULL)
                goto error;

        buffer_append(b, signature, signaturelen);
        bptr = buffer_ptr(b);
        ktype = buffer_get_string(&bptr, NULL);
        if (strcmp("ssh-ed25519", ktype) != 0) {
                goto error;
        }
        sigblob = buffer_get_string(&bptr, &len);
        rlen = buffer_remain_len(b);
        if (rlen != 0) {
                goto error;
        }
        if (len > crypto_sign_ed25519_BYTES) {
                goto error;
        }

        smlen = len + datalen;
        sm = malloc((size_t)smlen);
        memcpy(sm, sigblob, len);
        memcpy(sm+len, data, datalen);
        mlen = smlen;
        m = malloc((size_t)mlen);

        if ((ret = crypto_sign_ed25519_open(m, &mlen, sm, smlen,
            key->ed25519_pk)) != 0) {
                //debug2("%s: crypto_sign_ed25519_open failed: %d",
                //    __func__, ret);
        }
        if (ret == 0 && mlen != datalen) {
                //debug2("%s: crypto_sign_ed25519_open "
                //    "mlen != datalen (%llu != %u)", __func__, mlen, datalen);
                ret = -1;
        }
        /* XXX compare 'm' and 'data' ? */

error:
        buffer_free(b);
        free(ktype);

        if (sigblob) {
                SecureZeroMemory(sigblob, len);
                free(sigblob);
        }
        if (sm) {
                SecureZeroMemory(sm, (size_t)smlen);
                free(sm);
        }
        if (m) {
                SecureZeroMemory(m, (size_t)smlen); /* NB. mlen may be invalid if ret != 0 */
                free(m);
        }

        /* translate return code carefully */
        return (ret == 0) ? 1 : -1;
}

int key_verify(Key *key,
               unsigned char *signature, unsigned int signaturelen,
               unsigned char *data, unsigned int datalen)
{
        int ret = 0;

        switch (key->type) {
        case KEY_RSA:
                ret = ssh_rsa_verify(key->rsa, signature, signaturelen, data, datalen);
                break;
        case KEY_DSA:
                ret = ssh_dss_verify(key->dsa, signature, signaturelen, data, datalen);
                break;
        case KEY_ECDSA256:
        case KEY_ECDSA384:
        case KEY_ECDSA521:
                ret = ssh_ecdsa_verify(key->ecdsa, key->type, signature, signaturelen, data, datalen);
                break;
        case KEY_ED25519:
                ret = ssh_ed25519_verify(key, signature, signaturelen, data, datalen);
                break;
        default:
                return -1;
        }

        return (ret);   // success
}

static char *copy_mp_int(char *num)
{
        int len = (get_ushort16_MSBfirst(num) + 7) / 8 + 2;
        char *result = (char *) malloc(len);

        if (result != NULL) {
                memcpy(result, num, len);
        }

        return result;
}

//
// RSA�\����������
//
RSA *duplicate_RSA(RSA *src)
{
        RSA *rsa = NULL;

        rsa = RSA_new();
        if (rsa == NULL)
                goto error;
        rsa->n = BN_new();
        rsa->e = BN_new();
        if (rsa->n == NULL || rsa->e == NULL) {
                RSA_free(rsa);
                goto error;
        }

        // �[���R�s�[(deep copy)���s���B�����R�s�[(shallow copy)��NG�B
        BN_copy(rsa->n, src->n);
        BN_copy(rsa->e, src->e);

error:
        return (rsa);
}


//
// DSA�\����������
//
DSA *duplicate_DSA(DSA *src)
{
        DSA *dsa = NULL;

        dsa = DSA_new();
        if (dsa == NULL)
                goto error;
        dsa->p = BN_new();
        dsa->q = BN_new();
        dsa->g = BN_new();
        dsa->pub_key = BN_new();
        if (dsa->p == NULL ||
            dsa->q == NULL ||
            dsa->g == NULL ||
            dsa->pub_key == NULL) {
                DSA_free(dsa);
                goto error;
        }

        // �[���R�s�[(deep copy)���s���B�����R�s�[(shallow copy)��NG�B
        BN_copy(dsa->p, src->p);
        BN_copy(dsa->q, src->q);
        BN_copy(dsa->g, src->g);
        BN_copy(dsa->pub_key, src->pub_key);

error:
        return (dsa);
}

unsigned char *duplicate_ED25519_PK(unsigned char *src)
{
        unsigned char *ptr = NULL;

        ptr = malloc(ED25519_PK_SZ);
        if (ptr) {
                memcpy(ptr, src, ED25519_PK_SZ);
        }
        return (ptr);
}

BOOL key_copy(Key *dest, Key *src)
{
        key_init(dest);
        switch (src->type) {
        case KEY_RSA1: // SSH1
                dest->type = KEY_RSA1;
                dest->bits = src->bits;
                dest->exp = copy_mp_int(src->exp);
                dest->mod = copy_mp_int(src->mod);
                break;
        case KEY_RSA: // SSH2 RSA
                dest->type = KEY_RSA;
                dest->rsa = duplicate_RSA(src->rsa);
                break;
        case KEY_DSA: // SSH2 DSA
                dest->type = KEY_DSA;
                dest->dsa = duplicate_DSA(src->dsa);
                break;
        case KEY_ECDSA256:
        case KEY_ECDSA384:
        case KEY_ECDSA521:
                dest->type = src->type;
                dest->ecdsa = EC_KEY_dup(src->ecdsa);
                break;
        case KEY_ED25519:
                dest->type = src->type;
                dest->ed25519_pk = duplicate_ED25519_PK(src->ed25519_pk);
                break;
        default:
                return FALSE;
        }
        return TRUE;
}

char* key_fingerprint_raw(Key *k, enum digest_algorithm dgst_alg, int *dgst_raw_length)
{
        const EVP_MD *md = NULL;
        EVP_MD_CTX ctx;
        char *blob = NULL;
        char *retval = NULL;
        int len = 0;
        int nlen, elen;
        RSA *rsa;

        *dgst_raw_length = 0;

        switch (dgst_alg) {
        case SSH_DIGEST_MD5:
                md = EVP_md5();
                break;
        case SSH_DIGEST_SHA1:
                md = EVP_sha1();
                break;
        case SSH_DIGEST_SHA256:
                md = EVP_sha256();
                break;
        default:
                md = EVP_md5();
        }

        switch (k->type) {
        case KEY_RSA1:
                rsa = make_key(NULL, k->bits, k->exp, k->mod);
                nlen = BN_num_bytes(rsa->n);
                elen = BN_num_bytes(rsa->e);
                len = nlen + elen;
                blob = malloc(len);
                if (blob == NULL) {
                        // TODO:
                }
                BN_bn2bin(rsa->n, blob);
                BN_bn2bin(rsa->e, blob + nlen);
                RSA_free(rsa);
                break;

        case KEY_DSA:
        case KEY_RSA:
        case KEY_ECDSA256:
        case KEY_ECDSA384:
        case KEY_ECDSA521:
        case KEY_ED25519:
                key_to_blob(k, &blob, &len);
                break;

        case KEY_UNSPEC:
                return retval;
                break;

        default:
                //fatal("key_fingerprint_raw: bad key type %d", dgst_alg);
                break;
        }

        if (blob != NULL) {
                retval = malloc(EVP_MAX_MD_SIZE);
                if (retval == NULL) {
                        // TODO:
                }
                EVP_DigestInit(&ctx, md);
                EVP_DigestUpdate(&ctx, blob, len);
                EVP_DigestFinal(&ctx, retval, dgst_raw_length);
                SecureZeroMemory(blob, len);
                free(blob);
        } else {
                //fatal("key_fingerprint_raw: blob is null");
        }
        return retval;
}


const char *
ssh_key_type(ssh_keytype type)
{
        switch (type) {
        case KEY_RSA1:
                return "RSA1";
        case KEY_RSA:
                return "RSA";
        case KEY_DSA:
                return "DSA";
        case KEY_ECDSA256:
        case KEY_ECDSA384:
        case KEY_ECDSA521:
                return "ECDSA";
        case KEY_ED25519:
                return "ED25519";
        }
        return "unknown";
}

unsigned int
key_size(const Key *k)
{
        switch (k->type) {
        case KEY_RSA1:
                // SSH1�������� key->rsa �� key->dsa �� NULL �����������A�g�������B
                return k->bits;
        case KEY_RSA:
                return BN_num_bits(k->rsa->n);
        case KEY_DSA:
                return BN_num_bits(k->dsa->p);
        case KEY_ECDSA256:
                return 256;
        case KEY_ECDSA384:
                return 384;
        case KEY_ECDSA521:
                return 521;
        case KEY_ED25519:
                return 256;     /* XXX */
        }
        return 0;
}

// based on OpenSSH 7.1
static char *
key_fingerprint_b64(const char *alg, u_char *dgst_raw, u_int dgst_raw_len)
{
        char *retval;
        unsigned int i, retval_len;
        BIO *bio, *b64;
        BUF_MEM *bufferPtr;

        retval_len = strlen(alg) + 1 + ((dgst_raw_len + 2) / 3) * 4 + 1;
        retval = malloc(retval_len);
        retval[0] = '\0';

        strncat_s(retval, retval_len, alg, _TRUNCATE);
        strncat_s(retval, retval_len, ":", _TRUNCATE);

        b64 = BIO_new(BIO_f_base64());
        bio = BIO_new(BIO_s_mem());
        bio = BIO_push(b64, bio);

        BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
        BIO_write(bio, dgst_raw, dgst_raw_len);
        BIO_flush(bio);
        BIO_get_mem_ptr(bio, &bufferPtr);
        strncat_s(retval, retval_len, bufferPtr->data, _TRUNCATE);
        BIO_set_close(bio, BIO_NOCLOSE);
        BIO_free_all(bio);

        /* Remove the trailing '=' character */
        for (i = strlen(retval) - 1; retval[i] == '='; i--) {
                retval[i] = '\0';
        }

        return (retval);
}

static char *
key_fingerprint_hex(const char *alg, u_char *dgst_raw, u_int dgst_raw_len)
{
        char *retval;
        unsigned int i, retval_len;

        retval_len = strlen(alg) + 1 + dgst_raw_len * 3 + 1;
        retval = malloc(retval_len);
        retval[0] = '\0';

        strncat_s(retval, retval_len, alg, _TRUNCATE);
        strncat_s(retval, retval_len, ":", _TRUNCATE);

        for (i = 0; i < dgst_raw_len; i++) {
                char hex[4];
                _snprintf_s(hex, sizeof(hex), _TRUNCATE, "%02x:", dgst_raw[i]);
                strncat_s(retval, retval_len, hex, _TRUNCATE);
        }

        /* Remove the trailing ':' character */
        retval[retval_len - 2] = '\0';

        return (retval);
}

#define FLDBASE         8
#define FLDSIZE_Y       (FLDBASE + 1)
#define FLDSIZE_X       (FLDBASE * 2 + 1)
static char *
key_fingerprint_randomart(const char *alg, u_char *dgst_raw, u_int dgst_raw_len, const Key *k)
{
        /*
        * Chars to be used after each other every time the worm
        * intersects with itself.  Matter of taste.
        */
        char    *augmentation_string = " .o+=*BOX@%&#/^SE";
        char    *retval, *p, title[FLDSIZE_X], hash[FLDSIZE_X];
        unsigned char    field[FLDSIZE_X][FLDSIZE_Y];
        size_t   i, tlen, hlen;
        unsigned int     b;
        int      x, y, r;
        size_t   len = strlen(augmentation_string) - 1;

        retval = calloc((FLDSIZE_X + 3 + 1), (FLDSIZE_Y + 2));

        /* initialize field */
        memset(field, 0, FLDSIZE_X * FLDSIZE_Y * sizeof(char));
        x = FLDSIZE_X / 2;
        y = FLDSIZE_Y / 2;

        /* process raw key */
        for (i = 0; i < dgst_raw_len; i++) {
                int input;
                /* each byte conveys four 2-bit move commands */
                input = dgst_raw[i];
                for (b = 0; b < 4; b++) {
                        /* evaluate 2 bit, rest is shifted later */
                        x += (input & 0x1) ? 1 : -1;
                        y += (input & 0x2) ? 1 : -1;

                        /* assure we are still in bounds */
                        x = max(x, 0);
                        y = max(y, 0);
                        x = min(x, FLDSIZE_X - 1);
                        y = min(y, FLDSIZE_Y - 1);

                        /* augment the field */
                        if (field[x][y] < len - 2)
                                field[x][y]++;
                        input = input >> 2;
                }
        }

        /* mark starting point and end point*/
        field[FLDSIZE_X / 2][FLDSIZE_Y / 2] = (unsigned char)(len - 1);
        field[x][y] = (unsigned char)len;

        /* assemble title */
        r = _snprintf_s(title, sizeof(title), _TRUNCATE, "[%s %u]",
                        ssh_key_type(k->type), key_size(k));
        /* If [type size] won't fit, then try [type]; fits "[ED25519-CERT]" */
        if (r < 0 || r >(int)sizeof(title))
                r = _snprintf_s(title, sizeof(title), _TRUNCATE, "[%s]",
                                ssh_key_type(k->type));
        tlen = (r <= 0) ? 0 : strlen(title);

        /* assemble hash ID. */
        r = _snprintf_s(hash, sizeof(hash), _TRUNCATE, "[%s]", alg);
        hlen = (r <= 0) ? 0 : strlen(hash);

        /* output upper border */
        p = retval;
        *p++ = '+';
        for (i = 0; i < (FLDSIZE_X - tlen) / 2; i++)
                *p++ = '-';
        memcpy(p, title, tlen);
        p += tlen;
        for (i += tlen; i < FLDSIZE_X; i++)
                *p++ = '-';
        *p++ = '+';
        *p++ = '\r';
        *p++ = '\n';

        /* output content */
        for (y = 0; y < FLDSIZE_Y; y++) {
                *p++ = '|';
                for (x = 0; x < FLDSIZE_X; x++)
                        *p++ = augmentation_string[min(field[x][y], len)];
                *p++ = '|';
                *p++ = '\r';
                *p++ = '\n';
        }

        /* output lower border */
        *p++ = '+';
        for (i = 0; i < (FLDSIZE_X - hlen) / 2; i++)
                *p++ = '-';
        memcpy(p, hash, hlen);
        p += hlen;
        for (i += hlen; i < FLDSIZE_X; i++)
                *p++ = '-';
        *p++ = '+';

        return retval;
}
#undef  FLDBASE 
#undef  FLDSIZE_Y
#undef  FLDSIZE_X

//
// fingerprint�i�w���F�z�X�g���J�����n�b�V���j����������
//
char *key_fingerprint(Key *key, enum fp_rep dgst_rep, enum digest_algorithm dgst_alg)
{
        char *retval = NULL, *alg;
        unsigned char *dgst_raw;
        int dgst_raw_len;

        // fingerprint���n�b�V���l�i�o�C�i���j��������
        dgst_raw = key_fingerprint_raw(key, dgst_alg, &dgst_raw_len);
        if (dgst_raw == NULL)
                return NULL;

        alg = get_digest_algorithm_name(dgst_alg);

        switch (dgst_rep) {
        case SSH_FP_HEX:
                retval = key_fingerprint_hex(alg, dgst_raw, dgst_raw_len);
                break;
        case SSH_FP_BASE64:
                retval = key_fingerprint_b64(alg, dgst_raw, dgst_raw_len);
                break;
        case SSH_FP_RANDOMART:
                retval = key_fingerprint_randomart(alg, dgst_raw, dgst_raw_len, key);
                break;
        }

        SecureZeroMemory(dgst_raw, dgst_raw_len);
        free(dgst_raw);

        return (retval);
}

//
// �L�[�������������m��
//
static void key_add_private(Key *k)
{
        switch (k->type) {
                case KEY_RSA1:
                case KEY_RSA:
                        k->rsa->d = BN_new();
                        k->rsa->iqmp = BN_new();
                        k->rsa->q = BN_new();
                        k->rsa->p = BN_new();
                        k->rsa->dmq1 = BN_new();
                        k->rsa->dmp1 = BN_new();
                        if (k->rsa->d == NULL || k->rsa->iqmp == NULL || k->rsa->q == NULL ||
                                k->rsa->p == NULL || k->rsa->dmq1 == NULL || k->rsa->dmp1 == NULL)
                                goto error;
                        break;

                case KEY_DSA:
                        k->dsa->priv_key = BN_new();
                        if (k->dsa->priv_key == NULL)
                                goto error;
                        break;

                case KEY_ECDSA256:
                case KEY_ECDSA384:
                case KEY_ECDSA521:
                        /* Cannot do anything until we know the group */
                        break;

                case KEY_ED25519:
                        /* no need to prealloc */       
                        break;

                case KEY_UNSPEC:
                        break;

                default:
                        goto error;
                        break;
        }
        return;

error:
        if (k->rsa->d) {
                BN_free(k->rsa->d);
                k->rsa->d = NULL;
        }
        if (k->rsa->iqmp) {
                BN_free(k->rsa->iqmp);
                k->rsa->iqmp = NULL;
        }
        if (k->rsa->q) {
                BN_free(k->rsa->q);
                k->rsa->q = NULL;
        }
        if (k->rsa->p) {
                BN_free(k->rsa->p);
                k->rsa->p = NULL;
        }
        if (k->rsa->dmq1) {
                BN_free(k->rsa->dmq1);
                k->rsa->dmq1 = NULL;
        }
        if (k->rsa->dmp1) {
                BN_free(k->rsa->dmp1);
                k->rsa->dmp1 = NULL;
        }


        if (k->dsa->priv_key == NULL) {
                BN_free(k->dsa->priv_key);
                k->dsa->priv_key = NULL;
        }

}

Key *key_new_private(int type)
{
        Key *k = key_new(type);

        key_add_private(k);
        return (k);
}


Key *key_new(int type)
{
        int success = 0;
        Key *k = NULL;
        RSA *rsa;
        DSA *dsa;

        k = calloc(1, sizeof(Key));
        if (k == NULL)
                goto error;
        k->type = type;
        k->ecdsa = NULL;
        k->dsa = NULL;
        k->rsa = NULL;
        k->ed25519_pk = NULL;
        k->ed25519_sk = NULL;

        switch (k->type) {
                case KEY_RSA1:
                case KEY_RSA:
                        rsa = RSA_new();
                        if (rsa == NULL)
                                goto error;
                        rsa->n = BN_new();
                        rsa->e = BN_new();
                        if (rsa->n == NULL || rsa->e == NULL)
                                goto error;
                        k->rsa = rsa;
                        break;

                case KEY_DSA:
                        dsa = DSA_new();
                        if (dsa == NULL)
                                goto error;
                        dsa->p = BN_new();
                        dsa->q = BN_new();
                        dsa->g = BN_new();
                        dsa->pub_key = BN_new();
                        if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL || dsa->pub_key == NULL)
                                goto error;
                        k->dsa = dsa;
                        break;

                case KEY_ECDSA256:
                case KEY_ECDSA384:
                case KEY_ECDSA521:
                        /* Cannot do anything until we know the group */
                        break;

                case KEY_ED25519:
                        /* no need to prealloc */       
                        break;

                case KEY_UNSPEC:
                        break;

                default:
                        goto error;
                        break;
        }
        success = 1;

error:
        if (success == 0) {
                key_free(k);
                k = NULL;
        }
        return (k);
}


//
// Key �\�����������o�������������� key ��������������
//   key_new() ������ malloc �������������|�C���^���n��
//   Key �\�������n��������������
//
void key_free(Key *key)
{
        if (key == NULL) {
                return;
        }

        key_init(key);

        free(key);
}

//
// Key �\�����������o����������������
//   �����o�������������Akey ����������������
//
void key_init(Key *key)
{
        key->type = KEY_UNSPEC;

        // SSH1
        key->bits = 0;
        if (key->exp != NULL) {
                free(key->exp);
                key->exp = NULL;
        }
        if (key->mod != NULL) {
                free(key->mod);
                key->mod = NULL;
        }

        // SSH2
        if (key->dsa != NULL) {
                DSA_free(key->dsa);
                key->dsa = NULL;
        }
        if (key->rsa != NULL) {
                RSA_free(key->rsa);
                key->rsa = NULL;
        }
        if (key->ecdsa != NULL) {
                EC_KEY_free(key->ecdsa);
                key->ecdsa = NULL;
        }
        if (key->ed25519_pk != NULL) {
                SecureZeroMemory(key->ed25519_pk, ED25519_PK_SZ);
                free(key->ed25519_pk);
                key->ed25519_pk = NULL;
        }
        if (key->ed25519_sk) {
                SecureZeroMemory(key->ed25519_sk, ED25519_SK_SZ);
                free(key->ed25519_sk);
                key->ed25519_sk = NULL;
        }
}

//
// �L�[���������������p����
//
char *get_sshname_from_key(Key *key)
{
        return get_ssh_keytype_name(key->type);
}

//
// �L�[������������������������
//
ssh_keytype get_keytype_from_name(char *name)
{
        if (strcmp(name, "rsa1") == 0) {
                return KEY_RSA1;
        } else if (strcmp(name, "rsa") == 0) {
                return KEY_RSA;
        } else if (strcmp(name, "dsa") == 0) {
                return KEY_DSA;
        } else if (strcmp(name, "ssh-rsa") == 0) {
                return KEY_RSA;
        } else if (strcmp(name, "ssh-dss") == 0) {
                return KEY_DSA;
        } else if (strcmp(name, "ecdsa-sha2-nistp256") == 0) {
                return KEY_ECDSA256;
        } else if (strcmp(name, "ecdsa-sha2-nistp384") == 0) {
                return KEY_ECDSA384;
        } else if (strcmp(name, "ecdsa-sha2-nistp521") == 0) {
                return KEY_ECDSA521;
        } else if (strcmp(name, "ssh-ed25519") == 0) {
                return KEY_ED25519;
        }
        return KEY_UNSPEC;
}


ssh_keytype key_curve_name_to_keytype(char *name)
{
        if (strcmp(name, "nistp256") == 0) {
                return KEY_ECDSA256;
        } else if (strcmp(name, "nistp384") == 0) {
                return KEY_ECDSA384;
        } else if (strcmp(name, "nistp521") == 0) {
                return KEY_ECDSA521;
        }
        return KEY_UNSPEC;
}

char *curve_keytype_to_name(ssh_keytype type)
{
        switch (type) {
                case KEY_ECDSA256:
                        return "nistp256";
                        break;
                case KEY_ECDSA384:
                        return "nistp384";
                        break;
                case KEY_ECDSA521:
                        return "nistp521";
                        break;
        }
        return NULL;
}

//
// �L�[���������o�b�t�@���������� (for SSH2)
// NOTE:
//
int key_to_blob(Key *key, char **blobp, int *lenp)
{
        buffer_t *b;
        char *sshname, *tmp;
        int len;
        int ret = 1;  // success

        b = buffer_init();
        sshname = get_sshname_from_key(key);

        switch (key->type) {
        case KEY_RSA:
                buffer_put_string(b, sshname, strlen(sshname));
                buffer_put_bignum2(b, key->rsa->e);
                buffer_put_bignum2(b, key->rsa->n);
                break;
        case KEY_DSA:
                buffer_put_string(b, sshname, strlen(sshname));
                buffer_put_bignum2(b, key->dsa->p);
                buffer_put_bignum2(b, key->dsa->q);
                buffer_put_bignum2(b, key->dsa->g);
                buffer_put_bignum2(b, key->dsa->pub_key);
                break;
        case KEY_ECDSA256:
        case KEY_ECDSA384:
        case KEY_ECDSA521:
                buffer_put_string(b, sshname, strlen(sshname));
                tmp = curve_keytype_to_name(key->type);
                buffer_put_string(b, tmp, strlen(tmp));
                buffer_put_ecpoint(b, EC_KEY_get0_group(key->ecdsa),
                                      EC_KEY_get0_public_key(key->ecdsa));
                break;
        case KEY_ED25519:
                buffer_put_cstring(b, sshname);
                buffer_put_string(b, key->ed25519_pk, ED25519_PK_SZ);
                break;

        default:
                ret = 0;
                goto error;
        }

        len = buffer_len(b);
        if (lenp != NULL)
                *lenp = len;
        if (blobp != NULL) {
                *blobp = malloc(len);
                if (*blobp == NULL) {
                        ret = 0;
                        goto error;
                }
                memcpy(*blobp, buffer_ptr(b), len);
        }

error:
        buffer_free(b);

        return (ret);
}


//
// �o�b�t�@�����L�[�����������o��(for SSH2)
// NOTE: ���l���A���P�[�g���������������A�����o�������������������B
//
Key *key_from_blob(char *data, int blen)
{
        int keynamelen, len;
        char key[128];
        RSA *rsa = NULL;
        DSA *dsa = NULL;
        EC_KEY *ecdsa = NULL;
        EC_POINT *q = NULL;
        char *curve = NULL;
        Key *hostkey = NULL;  // hostkey
        ssh_keytype type;
        unsigned char *pk = NULL;

        if (data == NULL)
                goto error;

        hostkey = malloc(sizeof(Key));
        if (hostkey == NULL)
                goto error;

        memset(hostkey, 0, sizeof(Key));

        keynamelen = get_uint32_MSBfirst(data);
        if (keynamelen >= sizeof(key)) {
                goto error;
        }
        data += 4;
        memcpy(key, data, keynamelen);
        key[keynamelen] = 0;
        data += keynamelen;

        type = get_keytype_from_name(key);

        switch (type) {
        case KEY_RSA: // RSA key
                rsa = RSA_new();
                if (rsa == NULL) {
                        goto error;
                }
                rsa->n = BN_new();
                rsa->e = BN_new();
                if (rsa->n == NULL || rsa->e == NULL) {
                        goto error;
                }

                buffer_get_bignum2(&data, rsa->e);
                buffer_get_bignum2(&data, rsa->n);

                hostkey->type = type;
                hostkey->rsa = rsa;
                break;

        case KEY_DSA: // DSA key
                dsa = DSA_new();
                if (dsa == NULL) {
                        goto error;
                }
                dsa->p = BN_new();
                dsa->q = BN_new();
                dsa->g = BN_new();
                dsa->pub_key = BN_new();
                if (dsa->p == NULL ||
                    dsa->q == NULL ||
                    dsa->g == NULL ||
                    dsa->pub_key == NULL) {
                        goto error;
                }

                buffer_get_bignum2(&data, dsa->p);
                buffer_get_bignum2(&data, dsa->q);
                buffer_get_bignum2(&data, dsa->g);
                buffer_get_bignum2(&data, dsa->pub_key);

                hostkey->type = type;
                hostkey->dsa = dsa;
                break;

        case KEY_ECDSA256: // ECDSA
        case KEY_ECDSA384:
        case KEY_ECDSA521:
                curve = buffer_get_string(&data, NULL);
                if (type != key_curve_name_to_keytype(curve)) {
                        goto error;
                }

                ecdsa = EC_KEY_new_by_curve_name(keytype_to_cipher_nid(type));
                if (ecdsa == NULL) {
                        goto error;
                }

                q = EC_POINT_new(EC_KEY_get0_group(ecdsa));
                if (q == NULL) {
                        goto error;
                }

                buffer_get_ecpoint(&data, EC_KEY_get0_group(ecdsa), q);
                if (key_ec_validate_public(EC_KEY_get0_group(ecdsa), q) == -1) {
                        goto error;
                }

                if (EC_KEY_set_public_key(ecdsa, q) != 1) {
                        goto error;
                }

                hostkey->type = type;
                hostkey->ecdsa = ecdsa;
                break;

        case KEY_ED25519:
                pk = buffer_get_string(&data, &len);
                if (pk == NULL)
                        goto error;
                if (len != ED25519_PK_SZ)
                        goto error;

                hostkey->type = type;
                hostkey->ed25519_pk = pk;
                pk = NULL;
                break;

        default: // unknown key
                goto error;
        }

        return (hostkey);

error:
        if (rsa != NULL)
                RSA_free(rsa);
        if (dsa != NULL)
                DSA_free(dsa);
        if (ecdsa != NULL)
                EC_KEY_free(ecdsa);

        free(hostkey);

        return NULL;
}


static int ssh_ed25519_sign(Key *key, char **sigp, int *lenp, char *data, int datalen)
{
        char *sig;
        int slen, len;
        unsigned long long smlen;
        int ret;
        buffer_t *b;

        smlen = slen = datalen + crypto_sign_ed25519_BYTES;
        sig = malloc(slen);

        if ((ret = crypto_sign_ed25519(sig, &smlen, data, datalen,
            key->ed25519_sk)) != 0 || smlen <= datalen) {
                //error("%s: crypto_sign_ed25519 failed: %d", __func__, ret);
                free(sig);
                return -1;
        }
        /* encode signature */
        b = buffer_init();
        buffer_put_cstring(b, "ssh-ed25519");
        buffer_put_string(b, sig, (int)(smlen - datalen));
        len = buffer_len(b);
        if (lenp != NULL)
                *lenp = len;
        if (sigp != NULL) {
                *sigp = malloc(len);
                memcpy(*sigp, buffer_ptr(b), len);
        }
        buffer_free(b);
        SecureZeroMemory(sig, slen);
        free(sig);

        return 0;
}


BOOL generate_SSH2_keysign(Key *keypair, char **sigptr, int *siglen, char *data, int datalen)
{
        buffer_t *msg = NULL;
        char *s;
        int ret;

        msg = buffer_init();
        if (msg == NULL) {
                // TODO: error check
                return FALSE;
        }

        switch (keypair->type) {
        case KEY_RSA: // RSA
        {
                const EVP_MD *evp_md = EVP_sha1();
                EVP_MD_CTX md;
                u_char digest[EVP_MAX_MD_SIZE], *sig;
                u_int slen, dlen, len;
                int ok, nid = NID_sha1;

                // �_�C�W�F�X�g�l���v�Z
                EVP_DigestInit(&md, evp_md);
                EVP_DigestUpdate(&md, data, datalen);
                EVP_DigestFinal(&md, digest, &dlen);

                slen = RSA_size(keypair->rsa);
                sig = malloc(slen);
                if (sig == NULL)
                        goto error;

                // �d�q�������v�Z
                ok = RSA_sign(nid, digest, dlen, sig, &len, keypair->rsa);
                SecureZeroMemory(digest, sizeof(digest));
                if (ok != 1) { // error
                        free(sig);
                        goto error;
                }
                // �������T�C�Y���o�b�t�@���������������A�������������B�������[�����������B
                if (len < slen) {
                        u_int diff = slen - len;
                        memmove(sig + diff, sig, len);
                        memset(sig, 0, diff);

                } else if (len > slen) {
                        free(sig);
                        goto error;

                } else {
                        // do nothing

                }

                s = get_sshname_from_key(keypair);
                buffer_put_string(msg, s, strlen(s));
                buffer_append_length(msg, sig, slen);
                len = buffer_len(msg);

                // setting
                *siglen = len;
                *sigptr = malloc(len);
                if (*sigptr == NULL) {
                        free(sig);
                        goto error;
                }
                memcpy(*sigptr, buffer_ptr(msg), len);
                free(sig);
                
                break;
        }
        case KEY_DSA: // DSA
        {
                DSA_SIG *sig;
                const EVP_MD *evp_md = EVP_sha1();
                EVP_MD_CTX md;
                u_char digest[EVP_MAX_MD_SIZE], sigblob[SIGBLOB_LEN];
                u_int rlen, slen, len, dlen;

                // �_�C�W�F�X�g���v�Z
                EVP_DigestInit(&md, evp_md);
                EVP_DigestUpdate(&md, data, datalen);
                EVP_DigestFinal(&md, digest, &dlen);

                // DSA�d�q�������v�Z
                sig = DSA_do_sign(digest, dlen, keypair->dsa);
                SecureZeroMemory(digest, sizeof(digest));
                if (sig == NULL) {
                        goto error;
                }

                // BIGNUM�����o�C�i���l��������
                rlen = BN_num_bytes(sig->r);
                slen = BN_num_bytes(sig->s);
                if (rlen > INTBLOB_LEN || slen > INTBLOB_LEN) {
                        DSA_SIG_free(sig);
                        goto error;
                }
                memset(sigblob, 0, SIGBLOB_LEN);
                BN_bn2bin(sig->r, sigblob+ SIGBLOB_LEN - INTBLOB_LEN - rlen);
                BN_bn2bin(sig->s, sigblob+ SIGBLOB_LEN - slen);
                DSA_SIG_free(sig);

                // setting
                s = get_sshname_from_key(keypair);
                buffer_put_string(msg, s, strlen(s));
                buffer_append_length(msg, sigblob, sizeof(sigblob));
                len = buffer_len(msg);

                // setting
                *siglen = len;
                *sigptr = malloc(len);
                if (*sigptr == NULL) {
                        goto error;
                }
                memcpy(*sigptr, buffer_ptr(msg), len);

                break;
        }
        case KEY_ECDSA256: // ECDSA
        case KEY_ECDSA384:
        case KEY_ECDSA521:
        {
                ECDSA_SIG *sig;
                const EVP_MD *evp_md;
                EVP_MD_CTX md;
                u_char digest[EVP_MAX_MD_SIZE];
                u_int len, dlen, nid;
                buffer_t *buf2 = NULL;

                nid = keytype_to_hash_nid(keypair->type);
                if ((evp_md = EVP_get_digestbynid(nid)) == NULL) {
                        goto error;
                }
                EVP_DigestInit(&md, evp_md);
                EVP_DigestUpdate(&md, data, datalen);
                EVP_DigestFinal(&md, digest, &dlen);

                sig = ECDSA_do_sign(digest, dlen, keypair->ecdsa);
                SecureZeroMemory(digest, sizeof(digest));

                if (sig == NULL) {
                        goto error;
                }

                buf2 = buffer_init();
                if (buf2 == NULL) {
                        // TODO: error check
                        goto error;
                }
                buffer_put_bignum2(buf2, sig->r);
                buffer_put_bignum2(buf2, sig->s);
                ECDSA_SIG_free(sig);

                s = get_sshname_from_key(keypair);
                buffer_put_string(msg, s, strlen(s));
                buffer_put_string(msg, buffer_ptr(buf2), buffer_len(buf2));
                buffer_free(buf2);
                len = buffer_len(msg);

                *siglen = len;
                *sigptr = malloc(len);
                if (*sigptr == NULL) {
                        goto error;
                }
                memcpy(*sigptr, buffer_ptr(msg), len);

                break;
        }

        case KEY_ED25519:
                ret = ssh_ed25519_sign(keypair, sigptr, siglen, data, datalen);
                if (ret != 0) 
                        goto error;
                break;

        default:
                buffer_free(msg);
                return FALSE;
                break;
        }

        buffer_free(msg);
        return TRUE;

error:
        buffer_free(msg);

        return FALSE;
}


BOOL get_SSH2_publickey_blob(PTInstVar pvar, buffer_t **blobptr, int *bloblen)
{
        buffer_t *msg = NULL;
        Key *keypair;
        char *s, *tmp;

        msg = buffer_init();
        if (msg == NULL) {
                // TODO: error check
                return FALSE;
        }

        keypair = pvar->auth_state.cur_cred.key_pair;

        switch (keypair->type) {
        case KEY_RSA: // RSA
                s = get_sshname_from_key(keypair);
                buffer_put_string(msg, s, strlen(s));
                buffer_put_bignum2(msg, keypair->rsa->e); // ���J�w��
                buffer_put_bignum2(msg, keypair->rsa->n); // p�~q
                break;
        case KEY_DSA: // DSA
                s = get_sshname_from_key(keypair);
                buffer_put_string(msg, s, strlen(s));
                buffer_put_bignum2(msg, keypair->dsa->p); // �f��
                buffer_put_bignum2(msg, keypair->dsa->q); // (p-1)���f����
                buffer_put_bignum2(msg, keypair->dsa->g); // ����
                buffer_put_bignum2(msg, keypair->dsa->pub_key); // ���J��
                break;
        case KEY_ECDSA256: // ECDSA
        case KEY_ECDSA384:
        case KEY_ECDSA521:
                s = get_sshname_from_key(keypair);
                buffer_put_string(msg, s, strlen(s));
                tmp = curve_keytype_to_name(keypair->type);
                buffer_put_string(msg, tmp, strlen(tmp));
                buffer_put_ecpoint(msg, EC_KEY_get0_group(keypair->ecdsa),
                                        EC_KEY_get0_public_key(keypair->ecdsa));
                break;
        case KEY_ED25519:
                s = get_sshname_from_key(keypair);
                buffer_put_cstring(msg, s);
                buffer_put_string(msg, keypair->ed25519_pk, ED25519_PK_SZ);
                break;
        default:
                return FALSE;
        }

        *blobptr = msg;
        *bloblen = buffer_len(msg);

        return TRUE;
}

int kextype_to_cipher_nid(kex_algorithm type)
{
        switch (type) {
                case KEX_ECDH_SHA2_256:
                        return NID_X9_62_prime256v1;
                case KEX_ECDH_SHA2_384:
                        return NID_secp384r1;
                case KEX_ECDH_SHA2_521:
                        return NID_secp521r1;
        }
        return NID_undef;
}

int keytype_to_hash_nid(ssh_keytype type)
{
        switch (type) {
                case KEY_ECDSA256:
                        return NID_sha256;
                case KEY_ECDSA384:
                        return NID_sha384;
                case KEY_ECDSA521:
                        return NID_sha512;
        }
        return NID_undef;
}

int keytype_to_cipher_nid(ssh_keytype type)
{
        switch (type) {
                case KEY_ECDSA256:
                        return NID_X9_62_prime256v1;
                case KEY_ECDSA384:
                        return NID_secp384r1;
                case KEY_ECDSA521:
                        return NID_secp521r1;
        }
        return NID_undef;
}

ssh_keytype nid_to_keytype(int nid)
{
        switch (nid) {
                case NID_X9_62_prime256v1:
                        return KEY_ECDSA256;
                case NID_secp384r1:
                        return KEY_ECDSA384;
                case NID_secp521r1:
                        return KEY_ECDSA521;
        }
        return KEY_UNSPEC;
}

void key_private_serialize(Key *key, buffer_t *b)
{
        char *s;
        
        s = get_sshname_from_key(key);
        buffer_put_cstring(b, s);

        switch (key->type) {
                case KEY_RSA:
                        buffer_put_bignum2(b, key->rsa->n);
                        buffer_put_bignum2(b, key->rsa->e);
                        buffer_put_bignum2(b, key->rsa->d);
                        buffer_put_bignum2(b, key->rsa->iqmp);
                        buffer_put_bignum2(b, key->rsa->p);
                        buffer_put_bignum2(b, key->rsa->q);
                        break;

                case KEY_DSA:
                        buffer_put_bignum2(b, key->dsa->p);
                        buffer_put_bignum2(b, key->dsa->q);
                        buffer_put_bignum2(b, key->dsa->g);
                        buffer_put_bignum2(b, key->dsa->pub_key);
                        buffer_put_bignum2(b, key->dsa->priv_key);
                        break;

                case KEY_ECDSA256:
                case KEY_ECDSA384:
                case KEY_ECDSA521:
                        buffer_put_cstring(b, curve_keytype_to_name(key->type));
                        buffer_put_ecpoint(b, EC_KEY_get0_group(key->ecdsa),
                                EC_KEY_get0_public_key(key->ecdsa));
                        buffer_put_bignum2(b, (BIGNUM *)EC_KEY_get0_private_key(key->ecdsa));
                        break;

                case KEY_ED25519:
                        buffer_put_string(b, key->ed25519_pk, ED25519_PK_SZ);
                        buffer_put_string(b, key->ed25519_sk, ED25519_SK_SZ);
                        break;

                default:
                        break;
        }
}

/* calculate p-1 and q-1 */
static void rsa_generate_additional_parameters(RSA *rsa)
{
        BIGNUM *aux = NULL;
        BN_CTX *ctx = NULL;

        if ((aux = BN_new()) == NULL)
                goto error;
        if ((ctx = BN_CTX_new()) == NULL)
                goto error;

        if ((BN_sub(aux, rsa->q, BN_value_one()) == 0) ||
            (BN_mod(rsa->dmq1, rsa->d, aux, ctx) == 0) ||
            (BN_sub(aux, rsa->p, BN_value_one()) == 0) ||
            (BN_mod(rsa->dmp1, rsa->d, aux, ctx) == 0))
                goto error;

error:
        if (aux)
                BN_clear_free(aux);
        if (ctx)
                BN_CTX_free(ctx);
}

static int key_ec_validate_private(EC_KEY *key)
{
        BN_CTX *bnctx = NULL;
        BIGNUM *order, *tmp;
        int ret = -1;

        if ((bnctx = BN_CTX_new()) == NULL)
                goto out;
        BN_CTX_start(bnctx);

        if ((order = BN_CTX_get(bnctx)) == NULL ||
            (tmp = BN_CTX_get(bnctx)) == NULL)
                goto out;

        /* log2(private) > log2(order)/2 */
        if (EC_GROUP_get_order(EC_KEY_get0_group(key), order, bnctx) != 1)
                goto out;
        if (BN_num_bits(EC_KEY_get0_private_key(key)) <=
            BN_num_bits(order) / 2) {
                goto out;
        }

        /* private < order - 1 */
        if (!BN_sub(tmp, order, BN_value_one()))
                goto out;
        if (BN_cmp(EC_KEY_get0_private_key(key), tmp) >= 0) {
                goto out;
        }
        ret = 0;

out:
        if (bnctx)
                BN_CTX_free(bnctx);
        return ret;
}

Key *key_private_deserialize(buffer_t *blob)
{
        int success = 0;
        char *type_name = NULL;
        Key *k = NULL;
        unsigned int pklen, sklen;
        int type;

        type_name = buffer_get_string_msg(blob, NULL);
        if (type_name == NULL)
                goto error;
        type = get_keytype_from_name(type_name);

        k = key_new_private(type);

        switch (type) {
                case KEY_RSA:
                        buffer_get_bignum2_msg(blob, k->rsa->n);
                        buffer_get_bignum2_msg(blob, k->rsa->e);
                        buffer_get_bignum2_msg(blob, k->rsa->d);
                        buffer_get_bignum2_msg(blob, k->rsa->iqmp);
                        buffer_get_bignum2_msg(blob, k->rsa->p);
                        buffer_get_bignum2_msg(blob, k->rsa->q);

                        /* Generate additional parameters */
                        rsa_generate_additional_parameters(k->rsa);
                        break;

                case KEY_DSA:
                        buffer_get_bignum2_msg(blob, k->dsa->p);
                        buffer_get_bignum2_msg(blob, k->dsa->q);
                        buffer_get_bignum2_msg(blob, k->dsa->g);
                        buffer_get_bignum2_msg(blob, k->dsa->pub_key);
                        buffer_get_bignum2_msg(blob, k->dsa->priv_key);
                        break;

                case KEY_ECDSA256:
                case KEY_ECDSA384:
                case KEY_ECDSA521:
                        {
                        int success = 0;
                        unsigned int nid;
                        char *curve = NULL;
                        ssh_keytype skt;
                        BIGNUM *exponent = NULL;
                        EC_POINT *q = NULL;

                        nid = keytype_to_cipher_nid(type);
                        curve = buffer_get_string_msg(blob, NULL);
                        skt = key_curve_name_to_keytype(curve);
                        if (nid != keytype_to_cipher_nid(skt))
                                goto ecdsa_error;

                        k->ecdsa = EC_KEY_new_by_curve_name(nid);
                        if (k->ecdsa == NULL)
                                goto ecdsa_error;

                        q = EC_POINT_new(EC_KEY_get0_group(k->ecdsa));
                        if (q == NULL)
                                goto ecdsa_error;

                        if ((exponent = BN_new()) == NULL)
                                goto ecdsa_error;
                        buffer_get_ecpoint_msg(blob,
                                EC_KEY_get0_group(k->ecdsa), q);
                        buffer_get_bignum2_msg(blob, exponent);
                        if (EC_KEY_set_public_key(k->ecdsa, q) != 1)
                                goto ecdsa_error;
                        if (EC_KEY_set_private_key(k->ecdsa, exponent) != 1)
                                goto ecdsa_error;
                        if (key_ec_validate_public(EC_KEY_get0_group(k->ecdsa),
                                EC_KEY_get0_public_key(k->ecdsa)) != 0)
                                goto ecdsa_error;
                        if (key_ec_validate_private(k->ecdsa) != 0)
                                goto ecdsa_error;

                        success = 1;

ecdsa_error:
                        free(curve);
                        if (exponent)
                                BN_clear_free(exponent);
                        if (q)
                                EC_POINT_free(q);
                        if (success == 0)
                                goto error;
                        }
                        break;

                case KEY_ED25519:
                        k->ed25519_pk = buffer_get_string_msg(blob, &pklen);
                        k->ed25519_sk = buffer_get_string_msg(blob, &sklen);
                        if (pklen != ED25519_PK_SZ) 
                                goto error;
                        if (sklen != ED25519_SK_SZ)
                                goto error;
                        break;

                default:
                        goto error;
                        break;
        }

        /* enable blinding */
        switch (k->type) {
                case KEY_RSA1:
                case KEY_RSA:
                        if (RSA_blinding_on(k->rsa, NULL) != 1) 
                                goto error;
                        break;
        }

        success = 1;

error:
        free(type_name);

        if (success == 0) {
                key_free(k);
                k = NULL;
        }

        return (k);
}


static void hostkeys_update_ctx_free(struct hostkeys_update_ctx *ctx)
{
        size_t i;

        if (ctx == NULL)
                return;
        for (i = 0; i < ctx->nkeys; i++)
                key_free(ctx->keys[i]);
        free(ctx->keys);
        free(ctx->keys_seen);
        for (i = 0; i < ctx->nold; i++)
                key_free(ctx->old_keys[i]);
        free(ctx->old_keys);
        free(ctx->host_str);
        free(ctx->ip_str);
        free(ctx);
}


// �����������z�X�g���A���S���Y�������`�F�b�N�����B
//
// return 1: matched
//        0: not matched
//
static int check_hostkey_algorithm(PTInstVar pvar, Key *key)
{
        int ret = 0;
        int i, index;

        for (i = 0; pvar->settings.HostKeyOrder[i] != 0; i++) {
                index = pvar->settings.HostKeyOrder[i] - '0';
                if (index == KEY_NONE) // disabled line
                        break;

                if (strcmp(get_sshname_from_key(key), get_ssh_keytype_name(index)) == 0)
                        return 1;
        }

        return (ret);
}

// Callback function
//
// argument:
//   key: known_hosts���o�^������������
//   _ctx: �T�[�o�����������������������Q
//
// return:
//   1: deprecated key�������A��������key�������������~�B
//   0: ����������key�������������K�v�B
static int hostkeys_find(Key *key, void *_ctx)
{
        struct hostkeys_update_ctx *ctx = (struct hostkeys_update_ctx *)_ctx;
        int ret = 0;
        size_t i;
        Key **tmp;

        // SSH1�������O�B
        if (key->type == KEY_RSA1)
                goto error;

        // �������o�^�������������������T���B
        for (i = 0; i < ctx->nkeys; i++) {
                if (HOSTS_compare_public_key(key, ctx->keys[i]) == 1) {
                        ctx->keys_seen[i] = 1;
                        goto error;
                }
        }

        // deprecated�������A�����������X�g�������������B
        tmp = realloc(ctx->old_keys, (ctx->nold + 1)*sizeof(*ctx->old_keys));
        if (tmp != NULL) {
                ctx->old_keys = tmp;
                ctx->old_keys[ctx->nold++] = key;
        }

        ret = 1;

error:
        return (ret);
}

static void hosts_updatekey_dlg_set_fingerprint(PTInstVar pvar, HWND dlg, digest_algorithm dgst_alg)
{
        char *fp, *buf;
        size_t i;
        int buf_len;
        struct hostkeys_update_ctx *ctx;
        
        ctx = pvar->hostkey_ctx;

        if (ctx->nkeys > 0) {
                buf_len = 100 * ctx->nkeys;
                buf = calloc(100, ctx->nkeys);
                for (i = 0; i < ctx->nkeys; i++) {
                        if (ctx->keys_seen[i])
                                continue;
                        switch (dgst_alg) {
                        case SSH_DIGEST_MD5:
                                fp = key_fingerprint(ctx->keys[i], SSH_FP_HEX, dgst_alg);
                                break;
                        case SSH_DIGEST_SHA256:
                        default:
                                fp = key_fingerprint(ctx->keys[i], SSH_FP_BASE64, SSH_DIGEST_SHA256);
                                break;
                        }
                        strncat_s(buf, buf_len, get_sshname_from_key(ctx->keys[i]), _TRUNCATE);
                        strncat_s(buf, buf_len, " ", _TRUNCATE);
                        if (fp != NULL) {
                                strncat_s(buf, buf_len, fp, _TRUNCATE);
                                free(fp);
                        }
                        if (i < ctx->nkeys - 1) {
                                strncat_s(buf, buf_len, "\r\n", _TRUNCATE);
                        }
                }
                SendDlgItemMessage(dlg, IDC_ADDKEY_EDIT, WM_SETTEXT, 0, (LPARAM)(char *)buf);
                free(buf);
        }

        if (ctx->nold > 0) {
                buf_len = 100 * ctx->nold;
                buf = calloc(100, ctx->nold);
                SendDlgItemMessage(dlg, IDC_REMOVEKEY_EDIT, WM_SETTEXT, 0, (LPARAM)(char *)"");
                for (i = 0; i < ctx->nold; i++) {
                        switch (dgst_alg) {
                        case SSH_DIGEST_MD5:
                                fp = key_fingerprint(ctx->old_keys[i], SSH_FP_HEX, dgst_alg);
                                break;
                        case SSH_DIGEST_SHA256:
                        default:
                                fp = key_fingerprint(ctx->old_keys[i], SSH_FP_BASE64, SSH_DIGEST_SHA256);
                                break;
                        }
                        strncat_s(buf, buf_len, get_sshname_from_key(ctx->old_keys[i]), _TRUNCATE);
                        strncat_s(buf, buf_len, " ", _TRUNCATE);
                        if (fp != NULL) {
                                strncat_s(buf, buf_len, fp, _TRUNCATE);
                                free(fp);
                        }
                        if (i < ctx->nold - 1) {
                                strncat_s(buf, buf_len, "\r\n", _TRUNCATE);
                        }
                }
                SendDlgItemMessage(dlg, IDC_REMOVEKEY_EDIT, WM_SETTEXT, 0, (LPARAM)(char *)buf);
                free(buf);
        }
}

static BOOL CALLBACK hosts_updatekey_dlg_proc(HWND dlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
        static HFONT DlgHostsAddFont;
        PTInstVar pvar;
        LOGFONT logfont;
        HFONT font;
        char buf[1024];
        char *host;
        struct hostkeys_update_ctx *ctx;
        char uimsg[MAX_UIMSG];

        switch (msg) {
        case WM_INITDIALOG:
                pvar = (PTInstVar)lParam;
                SetWindowLong(dlg, DWL_USER, lParam);

                GetWindowText(dlg, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOSTKEY_ROTATION_TITLE", pvar, uimsg);
                SetWindowText(dlg, pvar->ts->UIMsg);

                host = pvar->ssh_state.hostname;
                ctx = pvar->hostkey_ctx;
                
                GetDlgItemText(dlg, IDC_HOSTKEY_MESSAGE, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOSTKEY_ROTATION_WARNING", pvar, uimsg);
                _snprintf_s(buf, sizeof(buf), _TRUNCATE,
                        pvar->ts->UIMsg, host, ctx->nnew, ctx->nold
                        );
                SetDlgItemText(dlg, IDC_HOSTKEY_MESSAGE, buf);

                GetDlgItemText(dlg, IDC_FP_HASH_ALG, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOSTKEY_ROTATION_FP_HASH_ALGORITHM", pvar, uimsg);
                SetDlgItemText(dlg, IDC_FP_HASH_ALG, pvar->ts->UIMsg);

                GetDlgItemText(dlg, IDC_ADDKEY_TEXT, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOSTKEY_ROTATION_ADD", pvar, uimsg);
                _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, ctx->nnew);
                SetDlgItemText(dlg, IDC_ADDKEY_TEXT, buf);

                GetDlgItemText(dlg, IDC_REMOVEKEY_TEXT, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOSTKEY_ROTATION_REMOVE", pvar, uimsg);
                _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, ctx->nold);
                SetDlgItemText(dlg, IDC_REMOVEKEY_TEXT, buf);

                CheckDlgButton(dlg, IDC_FP_HASH_ALG_SHA256, TRUE);
                hosts_updatekey_dlg_set_fingerprint(pvar, dlg, SSH_DIGEST_SHA256);

                GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("BTN_YES", pvar, uimsg);
                SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("BTN_NO", pvar, uimsg);
                SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);

                font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
                GetObject(font, sizeof(LOGFONT), &logfont);
                if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgHostsAddFont, pvar)) {
                        SendDlgItemMessage(dlg, IDC_HOSTKEY_MESSAGE, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDC_ADDKEY_TEXT, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDC_FP_HASH_ALG, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDC_FP_HASH_ALG_MD5, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDC_FP_HASH_ALG_SHA256, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDC_ADDKEY_EDIT, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDC_REMOVEKEY_TEXT, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDC_REMOVEKEY_EDIT, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                        SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgHostsAddFont, MAKELPARAM(TRUE, 0));
                }
                else {
                        DlgHostsAddFont = NULL;
                }

                return TRUE;                    /* because we do not set the focus */

        case WM_COMMAND:
                pvar = (PTInstVar)GetWindowLong(dlg, DWL_USER);

                switch (LOWORD(wParam)) {
                case IDOK:

                        EndDialog(dlg, 1);

                        if (DlgHostsAddFont != NULL) {
                                DeleteObject(DlgHostsAddFont);
                        }

                        return TRUE;

                case IDCANCEL:                  /* kill the connection */
                        EndDialog(dlg, 0);

                        if (DlgHostsAddFont != NULL) {
                                DeleteObject(DlgHostsAddFont);
                        }

                        return TRUE;

                case IDC_FP_HASH_ALG_MD5:
                        hosts_updatekey_dlg_set_fingerprint(pvar, dlg, SSH_DIGEST_MD5);
                        return TRUE;

                case IDC_FP_HASH_ALG_SHA256:
                        hosts_updatekey_dlg_set_fingerprint(pvar, dlg, SSH_DIGEST_SHA256);
                        return TRUE;

                default:
                        return FALSE;
                }

        default:
                return FALSE;
        }
}

static void update_known_hosts(PTInstVar pvar, struct hostkeys_update_ctx *ctx)
{
        size_t i;
        int dlgresult;
        char *host;

        host = pvar->ssh_state.hostname;

        // "/nosecuritywarning"���w�����������������A�X�V�������s�������B
        if (pvar->nocheck_known_hosts) {
                logputs(LOG_LEVEL_VERBOSE, "Hostkey was not updated because `/nosecuritywarning' option was specified.");
                goto error;
        }

        // known_hosts�t�@�C�����X�V���s�������A���[�U���������������s���B
        if (pvar->settings.UpdateHostkeys == SSH_UPDATE_HOSTKEYS_ASK) {
                HWND cur_active = GetActiveWindow();

                pvar->hostkey_ctx = ctx;
                dlgresult = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHUPDATE_HOSTKEY),
                        cur_active != NULL ? cur_active : pvar->NotificationWindow,
                        hosts_updatekey_dlg_proc, (LPARAM)pvar);
                if (dlgresult != 1) {
                        logputs(LOG_LEVEL_VERBOSE, "Hostkey was not updated because a user cancelled.");
                        goto error;
                }
        }

        // �����L�[�����������������B
        HOSTS_delete_all_hostkeys(pvar);

        // �V�����L�[���������o�^�����B
        for (i = 0; i < ctx->nkeys; i++) {
                HOSTS_add_host_key(pvar, ctx->keys[i]);
        }
        logputs(LOG_LEVEL_VERBOSE, "Hostkey was successfully updated to known_hosts file.");

error:
        return;
}

static void client_global_hostkeys_private_confirm(PTInstVar pvar, int type, u_int32_t seq, void *_ctx)
{
        struct hostkeys_update_ctx *ctx = (struct hostkeys_update_ctx *)_ctx;
        char *data;
        int len;
        unsigned char *blob = NULL;
        int bloblen;
        buffer_t *b = NULL;
        buffer_t *bsig = NULL;
        char *cp, *sig;
        size_t i, ndone, siglen;
        int ret;

        // SSH2 packet format:
        // [size(4) + padding size(1) + type(1)] + [payload(N) + padding(X)]
        //  header                                     body
        //                                         ^data
        //            <-----------------size------------------------------->
        //                              <---------len-------->
        //
        // data = payload(N) + padding(X): �p�f�B���O���������{�f�B���������w���B
        data = pvar->ssh_state.payload;
        // len = size - (padding size + 1): �p�f�B���O�������{�f�B�Btype�����������������B
        len = pvar->ssh_state.payloadlen;
        len--;   // type ��������

        bsig = buffer_init();
        if (bsig == NULL)
                goto error;
        cp = buffer_append_space(bsig, len);
        memcpy(cp, data, len);

        if (ctx->nnew == 0) {
                logprintf(LOG_LEVEL_FATAL,
                        "Hostkey can not be updated because ctx->nnew %d(program bug).", ctx->nnew);
                goto error;
        }
        if (type != SSH2_MSG_REQUEST_SUCCESS) {
                logprintf(LOG_LEVEL_ERROR,
                        "Server failed to confirm ownership of private host keys(type %d)", type);
                goto error;
        }
        if (pvar->session_id_len == 0) {
                logprintf(LOG_LEVEL_FATAL,
                        "Hostkey can not be updated because pvar->session_id_len %d(program bug).",
                        pvar->session_id_len);
                goto error;
        }

        b = buffer_init();
        if (b == NULL)
                goto error;

        ndone = 0;
        for (i = 0; i < ctx->nkeys; i++) {
                if (ctx->keys_seen[i])
                        continue;

                buffer_clear(b);
                buffer_put_cstring(b, "hostkeys-prove-00@openssh.com");
                buffer_put_string(b, pvar->session_id, pvar->session_id_len);
                key_to_blob(ctx->keys[i], &blob, &bloblen);
                buffer_put_string(b, blob, bloblen);
                free(blob);
                blob = NULL;

                sig = buffer_get_string_msg(bsig, &siglen);
                // Verify signature
                ret = key_verify(ctx->keys[i], sig, siglen, buffer_ptr(b), buffer_len(b));
                free(sig);
                sig = NULL;
                if (ret != 1) {
                        logprintf(LOG_LEVEL_ERROR,
                                "server gave bad signature for %s key %u",
                                get_sshname_from_key(ctx->keys[i]), i);
                        goto error;
                }
                ndone++;
        }

        if (ndone != ctx->nnew) {
                logprintf(LOG_LEVEL_FATAL,
                        "Hostkey can not be updated because ndone != ctx->nnew (%u / %u)(program bug).",
                        ndone, ctx->nnew);
                goto error;
        }

        update_known_hosts(pvar, ctx);

error:
        buffer_free(b);
        buffer_free(bsig);
        hostkeys_update_ctx_free(ctx);
}

//
// SSH�T�[�o�z�X�g��(known_hosts)�������X�V(OpenSSH 6.8 or later: host key rotation support)
//
// return 1: success
//        0: fail
//
int update_client_input_hostkeys(PTInstVar pvar, char *dataptr, int datalen)
{
        int success = 1;  // OpenSSH 6.8�����������A�����������������������������������A
                          // �������������� Tera Term �������������������������B
        int len;
        size_t i;
        char *cp, *fp;
        unsigned char *blob = NULL;
        buffer_t *b = NULL;
        struct hostkeys_update_ctx *ctx = NULL;
        Key *key = NULL, **tmp;
        unsigned char *outmsg;

        // Tera Term���������A���Y�@�\���I���I�t�����������������������B
        if (pvar->settings.UpdateHostkeys == SSH_UPDATE_HOSTKEYS_NO) {
                logputs(LOG_LEVEL_VERBOSE, "Hostkey was not updated because ts.UpdateHostkeys is disabled.");
                return 1;
        }

        ctx = calloc(1, sizeof(struct hostkeys_update_ctx));
        if (ctx == NULL)
                goto error;

        b = buffer_init();
        if (b == NULL)
                goto error;

        cp = buffer_append_space(b, datalen);
        memcpy(cp, dataptr, datalen);

        while (buffer_remain_len(b) > 0) {
                key_free(key);
                key = NULL;

                blob = buffer_get_string_msg(b, &len);
                key = key_from_blob(blob, len);
                if (key == NULL) {
                        logprintf(LOG_LEVEL_ERROR, "Not found host key into blob %p (%d)", blob, len);
                        goto error;
                }
                free(blob);
                blob = NULL;

                fp = key_fingerprint(key, SSH_FP_HEX, SSH_DIGEST_MD5);
                logprintf(LOG_LEVEL_VERBOSE, "Received %s host key %s", get_sshname_from_key(key), fp);
                free(fp);

                // �����������z�X�g�L�[�A���S���Y�������`�F�b�N�����B
                if (check_hostkey_algorithm(pvar, key) == 0) {
                        logprintf(LOG_LEVEL_VERBOSE, "%s host key is not permitted by ts.HostKeyOrder",
                                get_sshname_from_key(key));
                        continue;
                }

                // Skip certs: Tera Term�����������F�������T�|�[�g�B

                // �d�������L�[�����M�������G���[�������B
                for (i = 0; i < ctx->nkeys; i++) {
                        if (HOSTS_compare_public_key(key, ctx->keys[i]) == 1) {
                                logprintf(LOG_LEVEL_ERROR, "Received duplicated %s host key",
                                        get_sshname_from_key(key));
                                goto error;
                        }
                }

                // �L�[���o�^�����B
                tmp = realloc(ctx->keys, (ctx->nkeys + 1)*sizeof(*ctx->keys));
                if (tmp == NULL) {
                        logprintf(LOG_LEVEL_FATAL, "Not memory: realloc ctx->keys %d",