crypto/openssh/key.c

   1 /* $OpenBSD: key.c,v 1.131 2017/05/30 14:16:41 markus Exp $ */
   2 /*
   3  * placed in the public domain
   4  */
   5
   6 #include "includes.h"
   7
   8 #include <sys/types.h>
   9 #include <errno.h>
  10 #include <stdarg.h>
  11 #include <stdio.h>
  12 #include <limits.h>
  13
  14 #define SSH_KEY_NO_DEFINE
  15 #include "key.h"
  16
  17 #include "compat.h"
  18 #include "sshkey.h"
  19 #include "ssherr.h"
  20 #include "log.h"
  21 #include "authfile.h"
  22
  23 static void
  24 fatal_on_fatal_errors(int r, const char *func, int extra_fatal)
  25 {
  26         if (r == SSH_ERR_INTERNAL_ERROR ||
  27             r == SSH_ERR_ALLOC_FAIL ||
  28             (extra_fatal != 0 && r == extra_fatal))
  29                 fatal("%s: %s", func, ssh_err(r));
  30 }
  31
  32 Key *
  33 key_from_blob(const u_char *blob, u_int blen)
  34 {
  35         int r;
  36         Key *ret = NULL;
  37
  38         if ((r = sshkey_from_blob(blob, blen, &ret)) != 0) {
  39                 fatal_on_fatal_errors(r, __func__, 0);
  40                 error("%s: %s", __func__, ssh_err(r));
  41                 return NULL;
  42         }
  43         return ret;
  44 }
  45
  46 int
  47 key_to_blob(const Key *key, u_char **blobp, u_int *lenp)
  48 {
  49         u_char *blob;
  50         size_t blen;
  51         int r;
  52
  53         if (blobp != NULL)
  54                 *blobp = NULL;
  55         if (lenp != NULL)
  56                 *lenp = 0;
  57         if ((r = sshkey_to_blob(key, &blob, &blen)) != 0) {
  58                 fatal_on_fatal_errors(r, __func__, 0);
  59                 error("%s: %s", __func__, ssh_err(r));
  60                 return 0;
  61         }
  62         if (blen > INT_MAX)
  63                 fatal("%s: giant len %zu", __func__, blen);
  64         if (blobp != NULL)
  65                 *blobp = blob;
  66         if (lenp != NULL)
  67                 *lenp = blen;
  68         return blen;
  69 }
  70
  71 int
  72 key_sign(const Key *key, u_char **sigp, u_int *lenp,
  73     const u_char *data, u_int datalen, const char *alg)
  74 {
  75         int r;
  76         u_char *sig;
  77         size_t siglen;
  78
  79         if (sigp != NULL)
  80                 *sigp = NULL;
  81         if (lenp != NULL)
  82                 *lenp = 0;
  83         if ((r = sshkey_sign(key, &sig, &siglen,
  84             data, datalen, alg, datafellows)) != 0) {
  85                 fatal_on_fatal_errors(r, __func__, 0);
  86                 error("%s: %s", __func__, ssh_err(r));
  87                 return -1;
  88         }
  89         if (siglen > INT_MAX)
  90                 fatal("%s: giant len %zu", __func__, siglen);
  91         if (sigp != NULL)
  92                 *sigp = sig;
  93         if (lenp != NULL)
  94                 *lenp = siglen;
  95         return 0;
  96 }
  97
  98 int
  99 key_verify(const Key *key, const u_char *signature, u_int signaturelen,
 100     const u_char *data, u_int datalen)
 101 {
 102         int r;
 103
 104         if ((r = sshkey_verify(key, signature, signaturelen,
 105             data, datalen, datafellows)) != 0) {
 106                 fatal_on_fatal_errors(r, __func__, 0);
 107                 error("%s: %s", __func__, ssh_err(r));
 108                 return r == SSH_ERR_SIGNATURE_INVALID ? 0 : -1;
 109         }
 110         return 1;
 111 }
 112
 113 Key *
 114 key_demote(const Key *k)
 115 {
 116         int r;
 117         Key *ret = NULL;
 118
 119         if ((r = sshkey_demote(k, &ret)) != 0)
 120                 fatal("%s: %s", __func__, ssh_err(r));
 121         return ret;
 122 }
 123
 124 int
 125 key_drop_cert(Key *k)
 126 {
 127         int r;
 128
 129         if ((r = sshkey_drop_cert(k)) != 0) {
 130                 fatal_on_fatal_errors(r, __func__, 0);
 131                 error("%s: %s", __func__, ssh_err(r));
 132                 return -1;
 133         }
 134         return 0;
 135 }
 136
 137 int
 138 key_cert_check_authority(const Key *k, int want_host, int require_principal,
 139     const char *name, const char **reason)
 140 {
 141         int r;
 142
 143         if ((r = sshkey_cert_check_authority(k, want_host, require_principal,
 144             name, reason)) != 0) {
 145                 fatal_on_fatal_errors(r, __func__, 0);
 146                 error("%s: %s", __func__, ssh_err(r));
 147                 return -1;
 148         }
 149         return 0;
 150 }
 151
 152 /* authfile.c */
 153
 154 Key *
 155 key_load_cert(const char *filename)
 156 {
 157         int r;
 158         Key *ret = NULL;
 159
 160         if ((r = sshkey_load_cert(filename, &ret)) != 0) {
 161                 fatal_on_fatal_errors(r, __func__, SSH_ERR_LIBCRYPTO_ERROR);
 162                 /* Old authfile.c ignored all file errors. */
 163                 if (r == SSH_ERR_SYSTEM_ERROR)
 164                         debug("%s: %s", __func__, ssh_err(r));
 165                 else
 166                         error("%s: %s", __func__, ssh_err(r));
 167                 return NULL;
 168         }
 169         return ret;
 170
 171 }
 172
 173 Key *
 174 key_load_public(const char *filename, char **commentp)
 175 {
 176         int r;
 177         Key *ret = NULL;
 178
 179         if ((r = sshkey_load_public(filename, &ret, commentp)) != 0) {
 180                 fatal_on_fatal_errors(r, __func__, SSH_ERR_LIBCRYPTO_ERROR);
 181                 /* Old authfile.c ignored all file errors. */
 182                 if (r == SSH_ERR_SYSTEM_ERROR)
 183                         debug("%s: %s", __func__, ssh_err(r));
 184                 else
 185                         error("%s: %s", __func__, ssh_err(r));
 186                 return NULL;
 187         }
 188         return ret;
 189 }
 190
 191 Key *
 192 key_load_private(const char *path, const char *passphrase,
 193     char **commentp)
 194 {
 195         int r;
 196         Key *ret = NULL;
 197
 198         if ((r = sshkey_load_private(path, passphrase, &ret, commentp)) != 0) {
 199                 fatal_on_fatal_errors(r, __func__, SSH_ERR_LIBCRYPTO_ERROR);
 200                 /* Old authfile.c ignored all file errors. */
 201                 if (r == SSH_ERR_SYSTEM_ERROR ||
 202                     r == SSH_ERR_KEY_WRONG_PASSPHRASE)
 203                         debug("%s: %s", __func__, ssh_err(r));
 204                 else
 205                         error("%s: %s", __func__, ssh_err(r));
 206                 return NULL;
 207         }
 208         return ret;
 209 }
 210
 211 Key *
 212 key_load_private_cert(int type, const char *filename, const char *passphrase,
 213     int *perm_ok)
 214 {
 215         int r;
 216         Key *ret = NULL;
 217
 218         if ((r = sshkey_load_private_cert(type, filename, passphrase,
 219             &ret, perm_ok)) != 0) {
 220                 fatal_on_fatal_errors(r, __func__, SSH_ERR_LIBCRYPTO_ERROR);
 221                 /* Old authfile.c ignored all file errors. */
 222                 if (r == SSH_ERR_SYSTEM_ERROR ||
 223                     r == SSH_ERR_KEY_WRONG_PASSPHRASE)
 224                         debug("%s: %s", __func__, ssh_err(r));
 225                 else
 226                         error("%s: %s", __func__, ssh_err(r));
 227                 return NULL;
 228         }
 229         return ret;
 230 }
 231
 232 Key *
 233 key_load_private_type(int type, const char *filename, const char *passphrase,
 234     char **commentp, int *perm_ok)
 235 {
 236         int r;
 237         Key *ret = NULL;
 238
 239         if ((r = sshkey_load_private_type(type, filename, passphrase,
 240             &ret, commentp, perm_ok)) != 0) {
 241                 fatal_on_fatal_errors(r, __func__, SSH_ERR_LIBCRYPTO_ERROR);
 242                 /* Old authfile.c ignored all file errors. */
 243                 if (r == SSH_ERR_SYSTEM_ERROR ||
 244                     (r == SSH_ERR_KEY_WRONG_PASSPHRASE))
 245                         debug("%s: %s", __func__, ssh_err(r));
 246                 else
 247                         error("%s: %s", __func__, ssh_err(r));
 248                 return NULL;
 249         }
 250         return ret;
 251 }