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);
memset(sig, 's', slen);
free(sig);
return 0;
}
int
crypto_sign(unsigned char *sm, unsigned long long *smlen_p,
const unsigned char *m, unsigned long long mlen,
const unsigned char *sk)
{
return crypto_sign_ed25519(sm, smlen_p, m, mlen, sk);
}
SODIUM_EXPORT int
crypto_sign_ed25519_ref(unsigned char *sm, unsigned long long *smlen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *sk)
{
return crypto_sign_ed25519(sm, smlen, m, mlen, sk);
}
ssh_string SshAgentSignEd25519(uint8_t* data, int dataSize, ssh_key key, uint32_t flags)
{
// Prepare a buffer for the signature in a blob of the form:
// blobLength[ typeNameLength[ typeName ] signatureLength[ signature ] ]
uint32_t typeNameLength = 11;
unsigned long long signatureLength = dataSize + 64;
uint32_t blobLength = 8 + typeNameLength + (uint32_t)signatureLength;
uint8_t* signature = malloc(blobLength + 4);
if (signature == NULL)
{
return NULL;
}
// Sign the data in place in the blob buffer.
int signatureIndex = 12 + typeNameLength;
int result = crypto_sign_ed25519(signature + signatureIndex, &signatureLength, data, dataSize, (uint8_t*)key->ed25519_privkey);
if (result != 0)
{
free(signature);
return NULL;
}
// Recalculate the blob length now that we have the final length of the ED25519 signature and format the rest of the blob.
blobLength = 8 + typeNameLength + (uint32_t)signatureLength;
pack32(signature, blobLength);
int index = 4;
pack32(signature + index, typeNameLength);
index += 4;
memcpy(signature + index, "ssh-ed25519", typeNameLength);
index += typeNameLength;
pack32(signature + index, (uint32_t)signatureLength);
return (ssh_string)signature;
}
int
ssh_ed25519_sign(const struct sshkey *key, u_char **sigp, size_t *lenp,
const u_char *data, size_t datalen, u_int compat)
{
u_char *sig = NULL;
size_t slen = 0, len;
unsigned long long smlen;
int r, ret;
struct sshbuf *b = NULL;
if (lenp != NULL)
*lenp = 0;
if (sigp != NULL)
*sigp = NULL;
if (key == NULL ||
sshkey_type_plain(key->type) != KEY_ED25519 ||
key->ed25519_sk == NULL ||
datalen >= INT_MAX - crypto_sign_ed25519_BYTES)
return SSH_ERR_INVALID_ARGUMENT;
smlen = slen = datalen + crypto_sign_ed25519_BYTES;
if ((sig = malloc(slen)) == NULL)
return SSH_ERR_ALLOC_FAIL;
if ((ret = crypto_sign_ed25519(sig, &smlen, data, datalen,
key->ed25519_sk)) != 0 || smlen <= datalen) {
r = SSH_ERR_INVALID_ARGUMENT; /* XXX better error? */
goto out;
}
/* encode signature */
if ((b = sshbuf_new()) == NULL) {
r = SSH_ERR_ALLOC_FAIL;
goto out;
}
if ((r = sshbuf_put_cstring(b, "ssh-ed25519")) != 0 ||
(r = sshbuf_put_string(b, sig, smlen - datalen)) != 0)
goto out;
len = sshbuf_len(b);
if (sigp != NULL) {
if ((*sigp = malloc(len)) == NULL) {
r = SSH_ERR_ALLOC_FAIL;
goto out;
}
memcpy(*sigp, sshbuf_ptr(b), len);
}
if (lenp != NULL)
*lenp = len;
/* success */
r = 0;
out:
sshbuf_free(b);
if (sig != NULL) {
explicit_bzero(sig, slen);
free(sig);
}
return r;
}
/*
* wrapper around crypto_sign to generate detached signatures
*/
static void
signmsg(uint8_t *seckey, uint8_t *msg, unsigned long long msglen,
uint8_t *sig)
{
unsigned long long siglen;
uint8_t *sigbuf;
sigbuf = xmalloc(msglen + SIGBYTES);
crypto_sign_ed25519(sigbuf, &siglen, msg, msglen, seckey);
memcpy(sig, sigbuf, SIGBYTES);
free(sigbuf);
}
int
ssh_ed25519_sign(const Key *key, u_char **sigp, u_int *lenp,
const u_char *data, u_int datalen)
{
u_char *sig;
u_int slen, len;
unsigned long long smlen;
int ret;
Buffer b;
if (key == NULL || key_type_plain(key->type) != KEY_ED25519 ||
key->ed25519_sk == NULL) {
error("%s: no ED25519 key", __func__);
return -1;
}
if (datalen >= UINT_MAX - crypto_sign_ed25519_BYTES) {
error("%s: datalen %u too long", __func__, datalen);
return -1;
}
smlen = slen = datalen + crypto_sign_ed25519_BYTES;
sig = xmalloc(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 */
buffer_init(&b);
buffer_put_cstring(&b, "ssh-ed25519");
buffer_put_string(&b, sig, smlen - datalen);
len = buffer_len(&b);
if (lenp != NULL)
*lenp = len;
if (sigp != NULL) {
*sigp = xmalloc(len);
memcpy(*sigp, buffer_ptr(&b), len);
}
buffer_free(&b);
explicit_bzero(sig, slen);
free(sig);
return 0;
}
int pki_ed25519_sign(const ssh_key privkey,
ssh_signature sig,
const unsigned char *hash,
size_t hlen)
{
int rc;
uint8_t *buffer;
unsigned long long dlen = 0;
buffer = malloc(hlen + ED25519_SIG_LEN);
if (buffer == NULL) {
return SSH_ERROR;
}
rc = crypto_sign_ed25519(buffer,
&dlen,
hash,
hlen,
*privkey->ed25519_privkey);
if (rc != 0) {
goto error;
}
/* This shouldn't happen */
if (dlen - hlen != ED25519_SIG_LEN) {
goto error;
}
sig->ed25519_sig = malloc(ED25519_SIG_LEN);
if (sig->ed25519_sig == NULL) {
goto error;
}
memcpy(sig->ed25519_sig, buffer, ED25519_SIG_LEN);
SAFE_FREE(buffer);
return SSH_OK;
error:
SAFE_FREE(buffer);
return SSH_ERROR;
}
int main(int argc, char *argv[])
{
unsigned char pk[crypto_sign_ed25519_PUBLICKEYBYTES];
unsigned char sk[crypto_sign_ed25519_SECRETKEYBYTES];
if (argc == 2 && argv[1][0] == 'g') {
crypto_sign_ed25519_keypair(pk, sk);
printf("Public key:\n");
int i;
for (i = 0; i < crypto_sign_ed25519_PUBLICKEYBYTES; i++) {
printf("%02hhX", pk[i]);
}
printf("\nSecret key:\n");
for (i = 0; i < crypto_sign_ed25519_SECRETKEYBYTES; i++) {
printf("%02hhX", sk[i]);
}
printf("\n");
}
if (argc == 5 && argv[1][0] == 's') {
unsigned char *secret_key = hex_string_to_bin(argv[2]);
char *data;
int size = load_file(argv[3], &data);
if (size < 0)
goto fail;
unsigned long long smlen;
char *sm = malloc(size + crypto_sign_ed25519_BYTES * 2);
crypto_sign_ed25519(sm, &smlen, data, size, secret_key);
if (smlen - size != crypto_sign_ed25519_BYTES)
goto fail;
FILE *f = fopen(argv[4], "wb");
if (f == NULL)
goto fail;
memcpy(sm + smlen, sm, crypto_sign_ed25519_BYTES); // Move signature from beginning to end of file.
if (fwrite(sm + (smlen - size), 1, smlen, f) != smlen)
goto fail;
fclose(f);
printf("Signed successfully.\n");
}
if (argc == 4 && argv[1][0] == 'c') {
unsigned char *public_key = hex_string_to_bin(argv[2]);
char *data;
int size = load_file(argv[3], &data);
if (size < 0)
goto fail;
char *signe = malloc(size + crypto_sign_ed25519_BYTES);
memcpy(signe, data + size - crypto_sign_ed25519_BYTES,
crypto_sign_ed25519_BYTES); // Move signature from end to beginning of file.
memcpy(signe + crypto_sign_ed25519_BYTES, data, size - crypto_sign_ed25519_BYTES);
unsigned long long smlen;
char *m = malloc(size);
unsigned long long mlen;
if (crypto_sign_ed25519_open(m, &mlen, signe, size, public_key) == -1) {
printf("Failed checking sig.\n");
goto fail;
}
printf("Checked successfully.\n");
}
return 0;
fail:
printf("FAIL\n");
return 1;
}
int
kex_ecdh(struct per_session_data__sshd *pss, uint8_t *reply, uint32_t *plen)
{
uint8_t pri_key[64], temp[64], payload_sig[64 + 32], a, *lp, kbi[64];
struct lws_kex *kex = pss->kex;
struct lws_genhash_ctx ctx;
unsigned long long smlen;
uint8_t *p = reply + 5;
uint32_t be, kbi_len;
uint8_t servkey[256];
char keyt[33];
int r, c;
r = get_gen_server_key_25519(pss, servkey, sizeof(servkey));
if (!r) {
lwsl_err("%s: Failed to get or gen server key\n", __func__);
return 1;
}
r = ed25519_key_parse(servkey, r, keyt, sizeof(keyt),
pss->K_S /* public key */, pri_key);
if (r) {
lwsl_notice("%s: server key parse failed: %d\n", __func__, r);
return 1;
}
keyt[32] = '\0';
lwsl_info("Server key type: %s\n", keyt);
/*
* 1) Generate ephemeral key pair [ eph_pri_key | kex->Q_S ]
* 2) Compute shared secret.
* 3) Generate and sign exchange hash.
*
* 1) A 32 bytes private key should be generated for each new
* connection, using a secure PRNG. The following actions
* must be done on the private key:
*
* mysecret[0] &= 248;
* mysecret[31] &= 127;
* mysecret[31] |= 64;
*/
lws_get_random(pss->vhd->context, kex->eph_pri_key, LWS_SIZE_EC25519);
kex->eph_pri_key[0] &= 248;
kex->eph_pri_key[31] &= 127;
kex->eph_pri_key[31] |= 64;
/*
* 2) The public key is calculated using the cryptographic scalar
* multiplication:
*
* const unsigned char privkey[32];
* unsigned char pubkey[32];
*
* crypto_scalarmult (pubkey, privkey, basepoint);
*/
crypto_scalarmult_curve25519(kex->Q_S, kex->eph_pri_key, basepoint);
a = 0;
for (r = 0; r < sizeof(kex->Q_S); r++)
a |= kex->Q_S[r];
if (!a) {
lwsl_notice("all zero pubkey\n");
return SSH_DISCONNECT_KEY_EXCHANGE_FAILED;
}
/*
* The shared secret, k, is defined in SSH specifications to be a big
* integer. This number is calculated using the following procedure:
*
* X is the 32 bytes point obtained by the scalar multiplication of
* the other side's public key and the local private key scalar.
*/
crypto_scalarmult_curve25519(pss->K, kex->eph_pri_key, kex->Q_C);
/*
* The whole 32 bytes of the number X are then converted into a big
* integer k. This conversion follows the network byte order. This
* step differs from RFC5656.
*/
kbi_len = lws_mpint_rfc4251(kbi, pss->K, LWS_SIZE_EC25519, 1);
/*
* The exchange hash H is computed as the hash of the concatenation of
* the following:
*
* string V_C, the client's identification string (CR and LF
* excluded)
* string V_S, the server's identification string (CR and LF
* excluded)
* string I_C, the payload of the client's SSH_MSG_KEXINIT
* string I_S, the payload of the server's SSH_MSG_KEXINIT
* string K_S, the host key
* mpint Q_C, exchange value sent by the client
* mpint Q_S, exchange value sent by the server
* mpint K, the shared secret
*
* However there are a lot of unwritten details in the hash
* definition...
*/
if (lws_genhash_init(&ctx, LWS_GENHASH_TYPE_SHA256)) {
lwsl_notice("genhash init failed\n");
return 1;
}
if (_genhash_update_len(&ctx, pss->V_C, strlen(pss->V_C)))
goto hash_probs;
if (_genhash_update_len(&ctx, pss->vhd->ops->server_string, /* aka V_S */
strlen(pss->vhd->ops->server_string)))
goto hash_probs;
if (_genhash_update_len(&ctx, kex->I_C, kex->I_C_payload_len))
goto hash_probs;
if (_genhash_update_len(&ctx, kex->I_S, kex->I_S_payload_len))
goto hash_probs;
/*
* K_S (host public key)
*
* sum of name + key lengths and headers
* name length: name
* key length: key
* ---> */
lws_p32((uint8_t *)&be, 8 + strlen(keyt) + LWS_SIZE_EC25519);
if (lws_genhash_update(&ctx, (void *)&be, 4))
goto hash_probs;
if (_genhash_update_len(&ctx, keyt, strlen(keyt)))
goto hash_probs;
if (_genhash_update_len(&ctx, pss->K_S, LWS_SIZE_EC25519))
goto hash_probs;
/* <---- */
if (_genhash_update_len(&ctx, kex->Q_C, LWS_SIZE_EC25519))
goto hash_probs;
if (_genhash_update_len(&ctx, kex->Q_S, LWS_SIZE_EC25519))
goto hash_probs;
if (lws_genhash_update(&ctx, kbi, kbi_len))
goto hash_probs;
if (lws_genhash_destroy(&ctx, temp))
goto hash_probs;
/*
* Sign the 32-byte SHA256 "exchange hash" in temp
* The signature is itself 64 bytes
*/
smlen = LWS_SIZE_EC25519 + 64;
if (crypto_sign_ed25519(payload_sig, &smlen, temp, LWS_SIZE_EC25519,
pri_key))
return 1;
#if 0
l = LWS_SIZE_EC25519;
n = crypto_sign_ed25519_open(temp, &l, payload_sig, smlen, pss->K_S);
lwsl_notice("own sig sanity check says %d\n", n);
#endif
/* sig [64] and payload [32] concatenated in payload_sig
*
* The server then responds with the following
*
* uint32 packet length (exl self + mac)
* byte padding len
* byte SSH_MSG_KEX_ECDH_REPLY
* string server public host key and certificates (K_S)
* string Q_S (exchange value sent by the server)
* string signature of H
* padding
*/
*p++ = SSH_MSG_KEX_ECDH_REPLY;
/* server public host key and certificates (K_S) */
lp = p;
p +=4;
lws_sized_blob(&p, keyt, strlen(keyt));
lws_sized_blob(&p, pss->K_S, LWS_SIZE_EC25519);
lws_p32(lp, p - lp - 4);
/* Q_S (exchange value sent by the server) */
lws_sized_blob(&p, kex->Q_S, LWS_SIZE_EC25519);
/* signature of H */
lp = p;
p +=4;
lws_sized_blob(&p, keyt, strlen(keyt));
lws_sized_blob(&p, payload_sig, 64);
lws_p32(lp, p - lp - 4);
/* end of message */
lws_pad_set_length(pss, reply, &p, &pss->active_keys_stc);
*plen = p - reply;
if (!pss->active_keys_stc.valid)
memcpy(pss->session_id, temp, LWS_SIZE_EC25519);
/* RFC4253 7.2:
*
* The key exchange produces two values: a shared secret K,
* and an exchange hash H. Encryption and authentication
* keys are derived from these. The exchange hash H from the
* first key exchange is additionally used as the session
* identifier, which is a unique identifier for this connection.
* It is used by authentication methods as a part of the data
* that is signed as a proof of possession of a private key.
* Once computed, the session identifier is not changed,
* even if keys are later re-exchanged.
*
* The hash alg used in the KEX must be used for key derivation.
*
* 1) Initial IV client to server:
*
* HASH(K || H || "A" || session_id)
*
* (Here K is encoded as mpint and "A" as byte and session_id
* as raw data. "A" means the single character A, ASCII 65).
*
*
*/
for (c = 0; c < 3; c++) {
kex_ecdh_dv(kex->keys_next_cts.key[c], LWS_SIZE_CHACHA256_KEY,
kbi, kbi_len, temp, 'A' + (c * 2), pss->session_id);
kex_ecdh_dv(kex->keys_next_stc.key[c], LWS_SIZE_CHACHA256_KEY,
kbi, kbi_len, temp, 'B' + (c * 2), pss->session_id);
}
explicit_bzero(temp, sizeof(temp));
return 0;
hash_probs:
lws_genhash_destroy(&ctx, NULL);
return 1;
}
