crypto/openssh/ssh-ecdsa.c

   1 /* $OpenBSD: ssh-ecdsa.c,v 1.12 2015/12/11 04:21:12 mmcc Exp $ */
   2 /*
   3  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
   4  * Copyright (c) 2010 Damien Miller.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "includes.h"
  28
  29 #if defined(WITH_OPENSSL) && defined(OPENSSL_HAS_ECC)
  30
  31 #include <sys/types.h>
  32
  33 #include <openssl/bn.h>
  34 #include <openssl/ec.h>
  35 #include <openssl/ecdsa.h>
  36 #include <openssl/evp.h>
  37
  38 #include <string.h>
  39
  40 #include "sshbuf.h"
  41 #include "ssherr.h"
  42 #include "digest.h"
  43 #define SSHKEY_INTERNAL
  44 #include "sshkey.h"
  45
  46 /* ARGSUSED */
  47 int
  48 ssh_ecdsa_sign(const struct sshkey *key, u_char **sigp, size_t *lenp,
  49     const u_char *data, size_t datalen, u_int compat)
  50 {
  51         ECDSA_SIG *sig = NULL;
  52         int hash_alg;
  53         u_char digest[SSH_DIGEST_MAX_LENGTH];
  54         size_t len, dlen;
  55         struct sshbuf *b = NULL, *bb = NULL;
  56         int ret = SSH_ERR_INTERNAL_ERROR;
  57
  58         if (lenp != NULL)
  59                 *lenp = 0;
  60         if (sigp != NULL)
  61                 *sigp = NULL;
  62
  63         if (key == NULL || key->ecdsa == NULL ||
  64             sshkey_type_plain(key->type) != KEY_ECDSA)
  65                 return SSH_ERR_INVALID_ARGUMENT;
  66
  67         if ((hash_alg = sshkey_ec_nid_to_hash_alg(key->ecdsa_nid)) == -1 ||
  68             (dlen = ssh_digest_bytes(hash_alg)) == 0)
  69                 return SSH_ERR_INTERNAL_ERROR;
  70         if ((ret = ssh_digest_memory(hash_alg, data, datalen,
  71             digest, sizeof(digest))) != 0)
  72                 goto out;
  73
  74         if ((sig = ECDSA_do_sign(digest, dlen, key->ecdsa)) == NULL) {
  75                 ret = SSH_ERR_LIBCRYPTO_ERROR;
  76                 goto out;
  77         }
  78
  79         if ((bb = sshbuf_new()) == NULL || (b = sshbuf_new()) == NULL) {
  80                 ret = SSH_ERR_ALLOC_FAIL;
  81                 goto out;
  82         }
  83         if ((ret = sshbuf_put_bignum2(bb, sig->r)) != 0 ||
  84             (ret = sshbuf_put_bignum2(bb, sig->s)) != 0)
  85                 goto out;
  86         if ((ret = sshbuf_put_cstring(b, sshkey_ssh_name_plain(key))) != 0 ||
  87             (ret = sshbuf_put_stringb(b, bb)) != 0)
  88                 goto out;
  89         len = sshbuf_len(b);
  90         if (sigp != NULL) {
  91                 if ((*sigp = malloc(len)) == NULL) {
  92                         ret = SSH_ERR_ALLOC_FAIL;
  93                         goto out;
  94                 }
  95                 memcpy(*sigp, sshbuf_ptr(b), len);
  96         }
  97         if (lenp != NULL)
  98                 *lenp = len;
  99         ret = 0;
 100  out:
 101         explicit_bzero(digest, sizeof(digest));
 102         sshbuf_free(b);
 103         sshbuf_free(bb);
 104         if (sig != NULL)
 105                 ECDSA_SIG_free(sig);
 106         return ret;
 107 }
 108
 109 /* ARGSUSED */
 110 int
 111 ssh_ecdsa_verify(const struct sshkey *key,
 112     const u_char *signature, size_t signaturelen,
 113     const u_char *data, size_t datalen, u_int compat)
 114 {
 115         ECDSA_SIG *sig = NULL;
 116         int hash_alg;
 117         u_char digest[SSH_DIGEST_MAX_LENGTH];
 118         size_t dlen;
 119         int ret = SSH_ERR_INTERNAL_ERROR;
 120         struct sshbuf *b = NULL, *sigbuf = NULL;
 121         char *ktype = NULL;
 122
 123         if (key == NULL || key->ecdsa == NULL ||
 124             sshkey_type_plain(key->type) != KEY_ECDSA)
 125                 return SSH_ERR_INVALID_ARGUMENT;
 126
 127         if ((hash_alg = sshkey_ec_nid_to_hash_alg(key->ecdsa_nid)) == -1 ||
 128             (dlen = ssh_digest_bytes(hash_alg)) == 0)
 129                 return SSH_ERR_INTERNAL_ERROR;
 130
 131         /* fetch signature */
 132         if ((b = sshbuf_from(signature, signaturelen)) == NULL)
 133                 return SSH_ERR_ALLOC_FAIL;
 134         if (sshbuf_get_cstring(b, &ktype, NULL) != 0 ||
 135             sshbuf_froms(b, &sigbuf) != 0) {
 136                 ret = SSH_ERR_INVALID_FORMAT;
 137                 goto out;
 138         }
 139         if (strcmp(sshkey_ssh_name_plain(key), ktype) != 0) {
 140                 ret = SSH_ERR_KEY_TYPE_MISMATCH;
 141                 goto out;
 142         }
 143         if (sshbuf_len(b) != 0) {
 144                 ret = SSH_ERR_UNEXPECTED_TRAILING_DATA;
 145                 goto out;
 146         }
 147
 148         /* parse signature */
 149         if ((sig = ECDSA_SIG_new()) == NULL) {
 150                 ret = SSH_ERR_ALLOC_FAIL;
 151                 goto out;
 152         }
 153         if (sshbuf_get_bignum2(sigbuf, sig->r) != 0 ||
 154             sshbuf_get_bignum2(sigbuf, sig->s) != 0) {
 155                 ret = SSH_ERR_INVALID_FORMAT;
 156                 goto out;
 157         }
 158         if (sshbuf_len(sigbuf) != 0) {
 159                 ret = SSH_ERR_UNEXPECTED_TRAILING_DATA;
 160                 goto out;
 161         }
 162         if ((ret = ssh_digest_memory(hash_alg, data, datalen,
 163             digest, sizeof(digest))) != 0)
 164                 goto out;
 165
 166         switch (ECDSA_do_verify(digest, dlen, sig, key->ecdsa)) {
 167         case 1:
 168                 ret = 0;
 169                 break;
 170         case 0:
 171                 ret = SSH_ERR_SIGNATURE_INVALID;
 172                 goto out;
 173         default:
 174                 ret = SSH_ERR_LIBCRYPTO_ERROR;
 175                 goto out;
 176         }
 177
 178  out:
 179         explicit_bzero(digest, sizeof(digest));
 180         sshbuf_free(sigbuf);
 181         sshbuf_free(b);
 182         if (sig != NULL)
 183                 ECDSA_SIG_free(sig);
 184         free(ktype);
 185         return ret;
 186 }
 187
 188 #endif /* WITH_OPENSSL && OPENSSL_HAS_ECC */