Some notable changes, from upstream's release notes: - sshd(8): Remove support for obsolete "host/port" syntax. - ssh(1): When prompting whether to record a new host key, accept the key fingerprint as a synonym for "yes". - ssh-keygen(1): when acting as a CA and signing certificates with an RSA key, default to using the rsa-sha2-512 signature algorithm. - ssh(1), sshd(8), ssh-keygen(1): this release removes the "ssh-rsa" (RSA/SHA1) algorithm from those accepted for certificate signatures. - ssh-sk-helper(8): this is a new binary. It is used by the FIDO/U2F support to provide address-space isolation for token middleware libraries (including the internal one). - ssh(1): this release enables UpdateHostkeys by default subject to some conservative preconditions. - scp(1): this release changes the behaviour of remote to remote copies (e.g. "scp host-a:/path host-b:") to transfer through the local host by default. - scp(1): experimental support for transfers using the SFTP protocol as a replacement for the venerable SCP/RCP protocol that it has traditionally used. Additional integration work is needed to support FIDO/U2F in the base system. Deprecation Notice ------------------ OpenSSH will disable the ssh-rsa signature scheme by default in the next release. Reviewed by: imp MFC after: 1 month Relnotes: Yes Sponsored by: The FreeBSD Foundation Differential Revision: https://reviews.freebsd.org/D29985
200 lines
5.7 KiB
C
200 lines
5.7 KiB
C
/* $OpenBSD: kexc25519.c,v 1.17 2019/01/21 10:40:11 djm Exp $ */
|
|
/*
|
|
* Copyright (c) 2019 Markus Friedl. All rights reserved.
|
|
* Copyright (c) 2010 Damien Miller. All rights reserved.
|
|
* Copyright (c) 2013 Aris Adamantiadis. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. 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.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 "includes.h"
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <signal.h>
|
|
|
|
#include "sshkey.h"
|
|
#include "kex.h"
|
|
#include "sshbuf.h"
|
|
#include "digest.h"
|
|
#include "ssherr.h"
|
|
#include "ssh2.h"
|
|
|
|
extern int crypto_scalarmult_curve25519(u_char a[CURVE25519_SIZE],
|
|
const u_char b[CURVE25519_SIZE], const u_char c[CURVE25519_SIZE])
|
|
__attribute__((__bounded__(__minbytes__, 1, CURVE25519_SIZE)))
|
|
__attribute__((__bounded__(__minbytes__, 2, CURVE25519_SIZE)))
|
|
__attribute__((__bounded__(__minbytes__, 3, CURVE25519_SIZE)));
|
|
|
|
void
|
|
kexc25519_keygen(u_char key[CURVE25519_SIZE], u_char pub[CURVE25519_SIZE])
|
|
{
|
|
static const u_char basepoint[CURVE25519_SIZE] = {9};
|
|
|
|
arc4random_buf(key, CURVE25519_SIZE);
|
|
crypto_scalarmult_curve25519(pub, key, basepoint);
|
|
}
|
|
|
|
int
|
|
kexc25519_shared_key_ext(const u_char key[CURVE25519_SIZE],
|
|
const u_char pub[CURVE25519_SIZE], struct sshbuf *out, int raw)
|
|
{
|
|
u_char shared_key[CURVE25519_SIZE];
|
|
u_char zero[CURVE25519_SIZE];
|
|
int r;
|
|
|
|
crypto_scalarmult_curve25519(shared_key, key, pub);
|
|
|
|
/* Check for all-zero shared secret */
|
|
explicit_bzero(zero, CURVE25519_SIZE);
|
|
if (timingsafe_bcmp(zero, shared_key, CURVE25519_SIZE) == 0)
|
|
return SSH_ERR_KEY_INVALID_EC_VALUE;
|
|
|
|
#ifdef DEBUG_KEXECDH
|
|
dump_digest("shared secret", shared_key, CURVE25519_SIZE);
|
|
#endif
|
|
if (raw)
|
|
r = sshbuf_put(out, shared_key, CURVE25519_SIZE);
|
|
else
|
|
r = sshbuf_put_bignum2_bytes(out, shared_key, CURVE25519_SIZE);
|
|
explicit_bzero(shared_key, CURVE25519_SIZE);
|
|
return r;
|
|
}
|
|
|
|
int
|
|
kexc25519_shared_key(const u_char key[CURVE25519_SIZE],
|
|
const u_char pub[CURVE25519_SIZE], struct sshbuf *out)
|
|
{
|
|
return kexc25519_shared_key_ext(key, pub, out, 0);
|
|
}
|
|
|
|
int
|
|
kex_c25519_keypair(struct kex *kex)
|
|
{
|
|
struct sshbuf *buf = NULL;
|
|
u_char *cp = NULL;
|
|
int r;
|
|
|
|
if ((buf = sshbuf_new()) == NULL)
|
|
return SSH_ERR_ALLOC_FAIL;
|
|
if ((r = sshbuf_reserve(buf, CURVE25519_SIZE, &cp)) != 0)
|
|
goto out;
|
|
kexc25519_keygen(kex->c25519_client_key, cp);
|
|
#ifdef DEBUG_KEXECDH
|
|
dump_digest("client public key c25519:", cp, CURVE25519_SIZE);
|
|
#endif
|
|
kex->client_pub = buf;
|
|
buf = NULL;
|
|
out:
|
|
sshbuf_free(buf);
|
|
return r;
|
|
}
|
|
|
|
int
|
|
kex_c25519_enc(struct kex *kex, const struct sshbuf *client_blob,
|
|
struct sshbuf **server_blobp, struct sshbuf **shared_secretp)
|
|
{
|
|
struct sshbuf *server_blob = NULL;
|
|
struct sshbuf *buf = NULL;
|
|
const u_char *client_pub;
|
|
u_char *server_pub;
|
|
u_char server_key[CURVE25519_SIZE];
|
|
int r;
|
|
|
|
*server_blobp = NULL;
|
|
*shared_secretp = NULL;
|
|
|
|
if (sshbuf_len(client_blob) != CURVE25519_SIZE) {
|
|
r = SSH_ERR_SIGNATURE_INVALID;
|
|
goto out;
|
|
}
|
|
client_pub = sshbuf_ptr(client_blob);
|
|
#ifdef DEBUG_KEXECDH
|
|
dump_digest("client public key 25519:", client_pub, CURVE25519_SIZE);
|
|
#endif
|
|
/* allocate space for encrypted KEM key and ECDH pub key */
|
|
if ((server_blob = sshbuf_new()) == NULL) {
|
|
r = SSH_ERR_ALLOC_FAIL;
|
|
goto out;
|
|
}
|
|
if ((r = sshbuf_reserve(server_blob, CURVE25519_SIZE, &server_pub)) != 0)
|
|
goto out;
|
|
kexc25519_keygen(server_key, server_pub);
|
|
/* allocate shared secret */
|
|
if ((buf = sshbuf_new()) == NULL) {
|
|
r = SSH_ERR_ALLOC_FAIL;
|
|
goto out;
|
|
}
|
|
if ((r = kexc25519_shared_key_ext(server_key, client_pub, buf, 0)) < 0)
|
|
goto out;
|
|
#ifdef DEBUG_KEXECDH
|
|
dump_digest("server public key 25519:", server_pub, CURVE25519_SIZE);
|
|
dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));
|
|
#endif
|
|
*server_blobp = server_blob;
|
|
*shared_secretp = buf;
|
|
server_blob = NULL;
|
|
buf = NULL;
|
|
out:
|
|
explicit_bzero(server_key, sizeof(server_key));
|
|
sshbuf_free(server_blob);
|
|
sshbuf_free(buf);
|
|
return r;
|
|
}
|
|
|
|
int
|
|
kex_c25519_dec(struct kex *kex, const struct sshbuf *server_blob,
|
|
struct sshbuf **shared_secretp)
|
|
{
|
|
struct sshbuf *buf = NULL;
|
|
const u_char *server_pub;
|
|
int r;
|
|
|
|
*shared_secretp = NULL;
|
|
|
|
if (sshbuf_len(server_blob) != CURVE25519_SIZE) {
|
|
r = SSH_ERR_SIGNATURE_INVALID;
|
|
goto out;
|
|
}
|
|
server_pub = sshbuf_ptr(server_blob);
|
|
#ifdef DEBUG_KEXECDH
|
|
dump_digest("server public key c25519:", server_pub, CURVE25519_SIZE);
|
|
#endif
|
|
/* shared secret */
|
|
if ((buf = sshbuf_new()) == NULL) {
|
|
r = SSH_ERR_ALLOC_FAIL;
|
|
goto out;
|
|
}
|
|
if ((r = kexc25519_shared_key_ext(kex->c25519_client_key, server_pub,
|
|
buf, 0)) < 0)
|
|
goto out;
|
|
#ifdef DEBUG_KEXECDH
|
|
dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));
|
|
#endif
|
|
*shared_secretp = buf;
|
|
buf = NULL;
|
|
out:
|
|
sshbuf_free(buf);
|
|
return r;
|
|
}
|