key.c

   1 /* $OpenBSD: key.c,v 1.64 2006/03/25 13:17:02 djm Exp $ */
   2 /*
   3  * read_bignum():
   4  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   5  *
   6  * As far as I am concerned, the code I have written for this software
   7  * can be used freely for any purpose.  Any derived versions of this
   8  * software must be clearly marked as such, and if the derived work is
   9  * incompatible with the protocol description in the RFC file, it must be
  10  * called by a name other than "ssh" or "Secure Shell".
  11  *
  12  *
  13  * Copyright (c) 2000, 2001 Markus Friedl.  All rights reserved.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  25  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  27  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  28  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  29  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  33  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35 #include "includes.h"
  36
  37 #include <openssl/evp.h>
  38
  39 #include "xmalloc.h"
  40 #include "key.h"
  41 #include "rsa.h"
  42 #include "uuencode.h"
  43 #include "buffer.h"
  44 #include "bufaux.h"
  45 #include "log.h"
  46
  47 Key *
  48 key_new(int type)
  49 {
  50         Key *k;
  51         RSA *rsa;
  52         DSA *dsa;
  53         k = xcalloc(1, sizeof(*k));
  54         k->type = type;
  55         k->dsa = NULL;
  56         k->rsa = NULL;
  57         switch (k->type) {
  58         case KEY_RSA1:
  59         case KEY_RSA:
  60                 if ((rsa = RSA_new()) == NULL)
  61                         fatal("key_new: RSA_new failed");
  62                 if ((rsa->n = BN_new()) == NULL)
  63                         fatal("key_new: BN_new failed");
  64                 if ((rsa->e = BN_new()) == NULL)
  65                         fatal("key_new: BN_new failed");
  66                 k->rsa = rsa;
  67                 break;
  68         case KEY_DSA:
  69                 if ((dsa = DSA_new()) == NULL)
  70                         fatal("key_new: DSA_new failed");
  71                 if ((dsa->p = BN_new()) == NULL)
  72                         fatal("key_new: BN_new failed");
  73                 if ((dsa->q = BN_new()) == NULL)
  74                         fatal("key_new: BN_new failed");
  75                 if ((dsa->g = BN_new()) == NULL)
  76                         fatal("key_new: BN_new failed");
  77                 if ((dsa->pub_key = BN_new()) == NULL)
  78                         fatal("key_new: BN_new failed");
  79                 k->dsa = dsa;
  80                 break;
  81         case KEY_UNSPEC:
  82                 break;
  83         default:
  84                 fatal("key_new: bad key type %d", k->type);
  85                 break;
  86         }
  87         return k;
  88 }
  89
  90 Key *
  91 key_new_private(int type)
  92 {
  93         Key *k = key_new(type);
  94         switch (k->type) {
  95         case KEY_RSA1:
  96         case KEY_RSA:
  97                 if ((k->rsa->d = BN_new()) == NULL)
  98                         fatal("key_new_private: BN_new failed");
  99                 if ((k->rsa->iqmp = BN_new()) == NULL)
 100                         fatal("key_new_private: BN_new failed");
 101                 if ((k->rsa->q = BN_new()) == NULL)
 102                         fatal("key_new_private: BN_new failed");
 103                 if ((k->rsa->p = BN_new()) == NULL)
 104                         fatal("key_new_private: BN_new failed");
 105                 if ((k->rsa->dmq1 = BN_new()) == NULL)
 106                         fatal("key_new_private: BN_new failed");
 107                 if ((k->rsa->dmp1 = BN_new()) == NULL)
 108                         fatal("key_new_private: BN_new failed");
 109                 break;
 110         case KEY_DSA:
 111                 if ((k->dsa->priv_key = BN_new()) == NULL)
 112                         fatal("key_new_private: BN_new failed");
 113                 break;
 114         case KEY_UNSPEC:
 115                 break;
 116         default:
 117                 break;
 118         }
 119         return k;
 120 }
 121
 122 void
 123 key_free(Key *k)
 124 {
 125         if (k == NULL)
 126                 fatal("key_free: key is NULL");
 127         switch (k->type) {
 128         case KEY_RSA1:
 129         case KEY_RSA:
 130                 if (k->rsa != NULL)
 131                         RSA_free(k->rsa);
 132                 k->rsa = NULL;
 133                 break;
 134         case KEY_DSA:
 135                 if (k->dsa != NULL)
 136                         DSA_free(k->dsa);
 137                 k->dsa = NULL;
 138                 break;
 139         case KEY_UNSPEC:
 140                 break;
 141         default:
 142                 fatal("key_free: bad key type %d", k->type);
 143                 break;
 144         }
 145         xfree(k);
 146 }
 147
 148 int
 149 key_equal(const Key *a, const Key *b)
 150 {
 151         if (a == NULL || b == NULL || a->type != b->type)
 152                 return 0;
 153         switch (a->type) {
 154         case KEY_RSA1:
 155         case KEY_RSA:
 156                 return a->rsa != NULL && b->rsa != NULL &&
 157                     BN_cmp(a->rsa->e, b->rsa->e) == 0 &&
 158                     BN_cmp(a->rsa->n, b->rsa->n) == 0;
 159         case KEY_DSA:
 160                 return a->dsa != NULL && b->dsa != NULL &&
 161                     BN_cmp(a->dsa->p, b->dsa->p) == 0 &&
 162                     BN_cmp(a->dsa->q, b->dsa->q) == 0 &&
 163                     BN_cmp(a->dsa->g, b->dsa->g) == 0 &&
 164                     BN_cmp(a->dsa->pub_key, b->dsa->pub_key) == 0;
 165         default:
 166                 fatal("key_equal: bad key type %d", a->type);
 167                 break;
 168         }
 169         return 0;
 170 }
 171
 172 u_char*
 173 key_fingerprint_raw(const Key *k, enum fp_type dgst_type,
 174     u_int *dgst_raw_length)
 175 {
 176         const EVP_MD *md = NULL;
 177         EVP_MD_CTX ctx;
 178         u_char *blob = NULL;
 179         u_char *retval = NULL;
 180         u_int len = 0;
 181         int nlen, elen;
 182
 183         *dgst_raw_length = 0;
 184
 185         switch (dgst_type) {
 186         case SSH_FP_MD5:
 187                 md = EVP_md5();
 188                 break;
 189         case SSH_FP_SHA1:
 190                 md = EVP_sha1();
 191                 break;
 192         default:
 193                 fatal("key_fingerprint_raw: bad digest type %d",
 194                     dgst_type);
 195         }
 196         switch (k->type) {
 197         case KEY_RSA1:
 198                 nlen = BN_num_bytes(k->rsa->n);
 199                 elen = BN_num_bytes(k->rsa->e);
 200                 len = nlen + elen;
 201                 blob = xmalloc(len);
 202                 BN_bn2bin(k->rsa->n, blob);
 203                 BN_bn2bin(k->rsa->e, blob + nlen);
 204                 break;
 205         case KEY_DSA:
 206         case KEY_RSA:
 207                 key_to_blob(k, &blob, &len);
 208                 break;
 209         case KEY_UNSPEC:
 210                 return retval;
 211         default:
 212                 fatal("key_fingerprint_raw: bad key type %d", k->type);
 213                 break;
 214         }
 215         if (blob != NULL) {
 216                 retval = xmalloc(EVP_MAX_MD_SIZE);
 217                 EVP_DigestInit(&ctx, md);
 218                 EVP_DigestUpdate(&ctx, blob, len);
 219                 EVP_DigestFinal(&ctx, retval, dgst_raw_length);
 220                 memset(blob, 0, len);
 221                 xfree(blob);
 222         } else {
 223                 fatal("key_fingerprint_raw: blob is null");
 224         }
 225         return retval;
 226 }
 227
 228 static char *
 229 key_fingerprint_hex(u_char *dgst_raw, u_int dgst_raw_len)
 230 {
 231         char *retval;
 232         u_int i;
 233
 234         retval = xcalloc(1, dgst_raw_len * 3 + 1);
 235         for (i = 0; i < dgst_raw_len; i++) {
 236                 char hex[4];
 237                 snprintf(hex, sizeof(hex), "%02x:", dgst_raw[i]);
 238                 strlcat(retval, hex, dgst_raw_len * 3 + 1);
 239         }
 240
 241         /* Remove the trailing ':' character */
 242         retval[(dgst_raw_len * 3) - 1] = '\0';
 243         return retval;
 244 }
 245
 246 static char *
 247 key_fingerprint_bubblebabble(u_char *dgst_raw, u_int dgst_raw_len)
 248 {
 249         char vowels[] = { 'a', 'e', 'i', 'o', 'u', 'y' };
 250         char consonants[] = { 'b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm',
 251             'n', 'p', 'r', 's', 't', 'v', 'z', 'x' };
 252         u_int i, j = 0, rounds, seed = 1;
 253         char *retval;
 254
 255         rounds = (dgst_raw_len / 2) + 1;
 256         retval = xcalloc((rounds * 6), sizeof(char));
 257         retval[j++] = 'x';
 258         for (i = 0; i < rounds; i++) {
 259                 u_int idx0, idx1, idx2, idx3, idx4;
 260                 if ((i + 1 < rounds) || (dgst_raw_len % 2 != 0)) {
 261                         idx0 = (((((u_int)(dgst_raw[2 * i])) >> 6) & 3) +
 262                             seed) % 6;
 263                         idx1 = (((u_int)(dgst_raw[2 * i])) >> 2) & 15;
 264                         idx2 = ((((u_int)(dgst_raw[2 * i])) & 3) +
 265                             (seed / 6)) % 6;
 266                         retval[j++] = vowels[idx0];
 267                         retval[j++] = consonants[idx1];
 268                         retval[j++] = vowels[idx2];
 269                         if ((i + 1) < rounds) {
 270                                 idx3 = (((u_int)(dgst_raw[(2 * i) + 1])) >> 4) & 15;
 271                                 idx4 = (((u_int)(dgst_raw[(2 * i) + 1]))) & 15;
 272                                 retval[j++] = consonants[idx3];
 273                                 retval[j++] = '-';
 274                                 retval[j++] = consonants[idx4];
 275                                 seed = ((seed * 5) +
 276                                     ((((u_int)(dgst_raw[2 * i])) * 7) +
 277                                     ((u_int)(dgst_raw[(2 * i) + 1])))) % 36;
 278                         }
 279                 } else {
 280                         idx0 = seed % 6;
 281                         idx1 = 16;
 282                         idx2 = seed / 6;
 283                         retval[j++] = vowels[idx0];
 284                         retval[j++] = consonants[idx1];
 285                         retval[j++] = vowels[idx2];
 286                 }
 287         }
 288         retval[j++] = 'x';
 289         retval[j++] = '\0';
 290         return retval;
 291 }
 292
 293 char *
 294 key_fingerprint(const Key *k, enum fp_type dgst_type, enum fp_rep dgst_rep)
 295 {
 296         char *retval = NULL;
 297         u_char *dgst_raw;
 298         u_int dgst_raw_len;
 299
 300         dgst_raw = key_fingerprint_raw(k, dgst_type, &dgst_raw_len);
 301         if (!dgst_raw)
 302                 fatal("key_fingerprint: null from key_fingerprint_raw()");
 303         switch (dgst_rep) {
 304         case SSH_FP_HEX:
 305                 retval = key_fingerprint_hex(dgst_raw, dgst_raw_len);
 306                 break;
 307         case SSH_FP_BUBBLEBABBLE:
 308                 retval = key_fingerprint_bubblebabble(dgst_raw, dgst_raw_len);
 309                 break;
 310         default:
 311                 fatal("key_fingerprint_ex: bad digest representation %d",
 312                     dgst_rep);
 313                 break;
 314         }
 315         memset(dgst_raw, 0, dgst_raw_len);
 316         xfree(dgst_raw);
 317         return retval;
 318 }
 319
 320 /*
 321  * Reads a multiple-precision integer in decimal from the buffer, and advances
 322  * the pointer.  The integer must already be initialized.  This function is
 323  * permitted to modify the buffer.  This leaves *cpp to point just beyond the
 324  * last processed (and maybe modified) character.  Note that this may modify
 325  * the buffer containing the number.
 326  */
 327 static int
 328 read_bignum(char **cpp, BIGNUM * value)
 329 {
 330         char *cp = *cpp;
 331         int old;
 332
 333         /* Skip any leading whitespace. */
 334         for (; *cp == ' ' || *cp == '\t'; cp++)
 335                 ;
 336
 337         /* Check that it begins with a decimal digit. */
 338         if (*cp < '0' || *cp > '9')
 339                 return 0;
 340
 341         /* Save starting position. */
 342         *cpp = cp;
 343
 344         /* Move forward until all decimal digits skipped. */
 345         for (; *cp >= '0' && *cp <= '9'; cp++)
 346                 ;
 347
 348         /* Save the old terminating character, and replace it by \0. */
 349         old = *cp;
 350         *cp = 0;
 351
 352         /* Parse the number. */
 353         if (BN_dec2bn(&value, *cpp) == 0)
 354                 return 0;
 355
 356         /* Restore old terminating character. */
 357         *cp = old;
 358
 359         /* Move beyond the number and return success. */
 360         *cpp = cp;
 361         return 1;
 362 }
 363
 364 static int
 365 write_bignum(FILE *f, BIGNUM *num)
 366 {
 367         char *buf = BN_bn2dec(num);
 368         if (buf == NULL) {
 369                 error("write_bignum: BN_bn2dec() failed");
 370                 return 0;
 371         }
 372         fprintf(f, " %s", buf);
 373         OPENSSL_free(buf);
 374         return 1;
 375 }
 376
 377 /* returns 1 ok, -1 error */
 378 int
 379 key_read(Key *ret, char **cpp)
 380 {
 381         Key *k;
 382         int success = -1;
 383         char *cp, *space;
 384         int len, n, type;
 385         u_int bits;
 386         u_char *blob;
 387
 388         cp = *cpp;
 389
 390         switch (ret->type) {
 391         case KEY_RSA1:
 392                 /* Get number of bits. */
 393                 if (*cp < '0' || *cp > '9')
 394                         return -1;      /* Bad bit count... */
 395                 for (bits = 0; *cp >= '0' && *cp <= '9'; cp++)
 396                         bits = 10 * bits + *cp - '0';
 397                 if (bits == 0)
 398                         return -1;
 399                 *cpp = cp;
 400                 /* Get public exponent, public modulus. */
 401                 if (!read_bignum(cpp, ret->rsa->e))
 402                         return -1;
 403                 if (!read_bignum(cpp, ret->rsa->n))
 404                         return -1;
 405                 success = 1;
 406                 break;
 407         case KEY_UNSPEC:
 408         case KEY_RSA:
 409         case KEY_DSA:
 410                 space = strchr(cp, ' ');
 411                 if (space == NULL) {
 412                         debug3("key_read: missing whitespace");
 413                         return -1;
 414                 }
 415                 *space = '\0';
 416                 type = key_type_from_name(cp);
 417                 *space = ' ';
 418                 if (type == KEY_UNSPEC) {
 419                         debug3("key_read: missing keytype");
 420                         return -1;
 421                 }
 422                 cp = space+1;
 423                 if (*cp == '\0') {
 424                         debug3("key_read: short string");
 425                         return -1;
 426                 }
 427                 if (ret->type == KEY_UNSPEC) {
 428                         ret->type = type;
 429                 } else if (ret->type != type) {
 430                         /* is a key, but different type */
 431                         debug3("key_read: type mismatch");
 432                         return -1;
 433                 }
 434                 len = 2*strlen(cp);
 435                 blob = xmalloc(len);
 436                 n = uudecode(cp, blob, len);
 437                 if (n < 0) {
 438                         error("key_read: uudecode %s failed", cp);
 439                         xfree(blob);
 440                         return -1;
 441                 }
 442                 k = key_from_blob(blob, (u_int)n);
 443                 xfree(blob);
 444                 if (k == NULL) {
 445                         error("key_read: key_from_blob %s failed", cp);
 446                         return -1;
 447                 }
 448                 if (k->type != type) {
 449                         error("key_read: type mismatch: encoding error");
 450                         key_free(k);
 451                         return -1;
 452                 }
 453 /*XXXX*/
 454                 if (ret->type == KEY_RSA) {
 455                         if (ret->rsa != NULL)
 456                                 RSA_free(ret->rsa);
 457                         ret->rsa = k->rsa;
 458                         k->rsa = NULL;
 459                         success = 1;
 460 #ifdef DEBUG_PK
 461                         RSA_print_fp(stderr, ret->rsa, 8);
 462 #endif
 463                 } else {
 464                         if (ret->dsa != NULL)
 465                                 DSA_free(ret->dsa);
 466                         ret->dsa = k->dsa;
 467                         k->dsa = NULL;
 468                         success = 1;
 469 #ifdef DEBUG_PK
 470                         DSA_print_fp(stderr, ret->dsa, 8);
 471 #endif
 472                 }
 473 /*XXXX*/
 474                 key_free(k);
 475                 if (success != 1)
 476                         break;
 477                 /* advance cp: skip whitespace and data */
 478                 while (*cp == ' ' || *cp == '\t')
 479                         cp++;
 480                 while (*cp != '\0' && *cp != ' ' && *cp != '\t')
 481                         cp++;
 482                 *cpp = cp;
 483                 break;
 484         default:
 485                 fatal("key_read: bad key type: %d", ret->type);
 486                 break;
 487         }
 488         return success;
 489 }
 490
 491 int
 492 key_write(const Key *key, FILE *f)
 493 {
 494         int n, success = 0;
 495         u_int len, bits = 0;
 496         u_char *blob;
 497         char *uu;
 498
 499         if (key->type == KEY_RSA1 && key->rsa != NULL) {
 500                 /* size of modulus 'n' */
 501                 bits = BN_num_bits(key->rsa->n);
 502                 fprintf(f, "%u", bits);
 503                 if (write_bignum(f, key->rsa->e) &&
 504                     write_bignum(f, key->rsa->n)) {
 505                         success = 1;
 506                 } else {
 507                         error("key_write: failed for RSA key");
 508                 }
 509         } else if ((key->type == KEY_DSA && key->dsa != NULL) ||
 510             (key->type == KEY_RSA && key->rsa != NULL)) {
 511                 key_to_blob(key, &blob, &len);
 512                 uu = xmalloc(2*len);
 513                 n = uuencode(blob, len, uu, 2*len);
 514                 if (n > 0) {
 515                         fprintf(f, "%s %s", key_ssh_name(key), uu);
 516                         success = 1;
 517                 }
 518                 xfree(blob);
 519                 xfree(uu);
 520         }
 521         return success;
 522 }
 523
 524 const char *
 525 key_type(const Key *k)
 526 {
 527         switch (k->type) {
 528         case KEY_RSA1:
 529                 return "RSA1";
 530         case KEY_RSA:
 531                 return "RSA";
 532         case KEY_DSA:
 533                 return "DSA";
 534         }
 535         return "unknown";
 536 }
 537
 538 const char *
 539 key_ssh_name(const Key *k)
 540 {
 541         switch (k->type) {
 542         case KEY_RSA:
 543                 return "ssh-rsa";
 544         case KEY_DSA:
 545                 return "ssh-dss";
 546         }
 547         return "ssh-unknown";
 548 }
 549
 550 u_int
 551 key_size(const Key *k)
 552 {
 553         switch (k->type) {
 554         case KEY_RSA1:
 555         case KEY_RSA:
 556                 return BN_num_bits(k->rsa->n);
 557         case KEY_DSA:
 558                 return BN_num_bits(k->dsa->p);
 559         }
 560         return 0;
 561 }
 562
 563 static RSA *
 564 rsa_generate_private_key(u_int bits)
 565 {
 566         RSA *private;
 567
 568         private = RSA_generate_key(bits, 35, NULL, NULL);
 569         if (private == NULL)
 570                 fatal("rsa_generate_private_key: key generation failed.");
 571         return private;
 572 }
 573
 574 static DSA*
 575 dsa_generate_private_key(u_int bits)
 576 {
 577         DSA *private = DSA_generate_parameters(bits, NULL, 0, NULL, NULL, NULL, NULL);
 578
 579         if (private == NULL)
 580                 fatal("dsa_generate_private_key: DSA_generate_parameters failed");
 581         if (!DSA_generate_key(private))
 582                 fatal("dsa_generate_private_key: DSA_generate_key failed.");
 583         if (private == NULL)
 584                 fatal("dsa_generate_private_key: NULL.");
 585         return private;
 586 }
 587
 588 Key *
 589 key_generate(int type, u_int bits)
 590 {
 591         Key *k = key_new(KEY_UNSPEC);
 592         switch (type) {
 593         case KEY_DSA:
 594                 k->dsa = dsa_generate_private_key(bits);
 595                 break;
 596         case KEY_RSA:
 597         case KEY_RSA1:
 598                 k->rsa = rsa_generate_private_key(bits);
 599                 break;
 600         default:
 601                 fatal("key_generate: unknown type %d", type);
 602         }
 603         k->type = type;
 604         return k;
 605 }
 606
 607 Key *
 608 key_from_private(const Key *k)
 609 {
 610         Key *n = NULL;
 611         switch (k->type) {
 612         case KEY_DSA:
 613                 n = key_new(k->type);
 614                 BN_copy(n->dsa->p, k->dsa->p);
 615                 BN_copy(n->dsa->q, k->dsa->q);
 616                 BN_copy(n->dsa->g, k->dsa->g);
 617                 BN_copy(n->dsa->pub_key, k->dsa->pub_key);
 618                 break;
 619         case KEY_RSA:
 620         case KEY_RSA1:
 621                 n = key_new(k->type);
 622                 BN_copy(n->rsa->n, k->rsa->n);
 623                 BN_copy(n->rsa->e, k->rsa->e);
 624                 break;
 625         default:
 626                 fatal("key_from_private: unknown type %d", k->type);
 627                 break;
 628         }
 629         return n;
 630 }
 631
 632 int
 633 key_type_from_name(char *name)
 634 {
 635         if (strcmp(name, "rsa1") == 0) {
 636                 return KEY_RSA1;
 637         } else if (strcmp(name, "rsa") == 0) {
 638                 return KEY_RSA;
 639         } else if (strcmp(name, "dsa") == 0) {
 640                 return KEY_DSA;
 641         } else if (strcmp(name, "ssh-rsa") == 0) {
 642                 return KEY_RSA;
 643         } else if (strcmp(name, "ssh-dss") == 0) {
 644                 return KEY_DSA;
 645         }
 646         debug2("key_type_from_name: unknown key type '%s'", name);
 647         return KEY_UNSPEC;
 648 }
 649
 650 int
 651 key_names_valid2(const char *names)
 652 {
 653         char *s, *cp, *p;
 654
 655         if (names == NULL || strcmp(names, "") == 0)
 656                 return 0;
 657         s = cp = xstrdup(names);
 658         for ((p = strsep(&cp, ",")); p && *p != '\0';
 659             (p = strsep(&cp, ","))) {
 660                 switch (key_type_from_name(p)) {
 661                 case KEY_RSA1:
 662                 case KEY_UNSPEC:
 663                         xfree(s);
 664                         return 0;
 665                 }
 666         }
 667         debug3("key names ok: [%s]", names);
 668         xfree(s);
 669         return 1;
 670 }
 671
 672 Key *
 673 key_from_blob(const u_char *blob, u_int blen)
 674 {
 675         Buffer b;
 676         int rlen, type;
 677         char *ktype = NULL;
 678         Key *key = NULL;
 679
 680 #ifdef DEBUG_PK
 681         dump_base64(stderr, blob, blen);
 682 #endif
 683         buffer_init(&b);
 684         buffer_append(&b, blob, blen);
 685         if ((ktype = buffer_get_string_ret(&b, NULL)) == NULL) {
 686                 error("key_from_blob: can't read key type");
 687                 goto out;
 688         }
 689
 690         type = key_type_from_name(ktype);
 691
 692         switch (type) {
 693         case KEY_RSA:
 694                 key = key_new(type);
 695                 if (buffer_get_bignum2_ret(&b, key->rsa->e) == -1 ||
 696                     buffer_get_bignum2_ret(&b, key->rsa->n) == -1) {
 697                         error("key_from_blob: can't read rsa key");
 698                         key_free(key);
 699                         key = NULL;
 700                         goto out;
 701                 }
 702 #ifdef DEBUG_PK
 703                 RSA_print_fp(stderr, key->rsa, 8);
 704 #endif
 705                 break;
 706         case KEY_DSA:
 707                 key = key_new(type);
 708                 if (buffer_get_bignum2_ret(&b, key->dsa->p) == -1 ||
 709                     buffer_get_bignum2_ret(&b, key->dsa->q) == -1 ||
 710                     buffer_get_bignum2_ret(&b, key->dsa->g) == -1 ||
 711                     buffer_get_bignum2_ret(&b, key->dsa->pub_key) == -1) {
 712                         error("key_from_blob: can't read dsa key");
 713                         key_free(key);
 714                         key = NULL;
 715                         goto out;
 716                 }
 717 #ifdef DEBUG_PK
 718                 DSA_print_fp(stderr, key->dsa, 8);
 719 #endif
 720                 break;
 721         case KEY_UNSPEC:
 722                 key = key_new(type);
 723                 break;
 724         default:
 725                 error("key_from_blob: cannot handle type %s", ktype);
 726                 goto out;
 727         }
 728         rlen = buffer_len(&b);
 729         if (key != NULL && rlen != 0)
 730                 error("key_from_blob: remaining bytes in key blob %d", rlen);
 731  out:
 732         if (ktype != NULL)
 733                 xfree(ktype);
 734         buffer_free(&b);
 735         return key;
 736 }
 737
 738 int
 739 key_to_blob(const Key *key, u_char **blobp, u_int *lenp)
 740 {
 741         Buffer b;
 742         int len;
 743
 744         if (key == NULL) {
 745                 error("key_to_blob: key == NULL");
 746                 return 0;
 747         }
 748         buffer_init(&b);
 749         switch (key->type) {
 750         case KEY_DSA:
 751                 buffer_put_cstring(&b, key_ssh_name(key));
 752                 buffer_put_bignum2(&b, key->dsa->p);
 753                 buffer_put_bignum2(&b, key->dsa->q);
 754                 buffer_put_bignum2(&b, key->dsa->g);
 755                 buffer_put_bignum2(&b, key->dsa->pub_key);
 756                 break;
 757         case KEY_RSA:
 758                 buffer_put_cstring(&b, key_ssh_name(key));
 759                 buffer_put_bignum2(&b, key->rsa->e);
 760                 buffer_put_bignum2(&b, key->rsa->n);
 761                 break;
 762         default:
 763                 error("key_to_blob: unsupported key type %d", key->type);
 764                 buffer_free(&b);
 765                 return 0;
 766         }
 767         len = buffer_len(&b);
 768         if (lenp != NULL)
 769                 *lenp = len;
 770         if (blobp != NULL) {
 771                 *blobp = xmalloc(len);
 772                 memcpy(*blobp, buffer_ptr(&b), len);
 773         }
 774         memset(buffer_ptr(&b), 0, len);
 775         buffer_free(&b);
 776         return len;
 777 }
 778
 779 int
 780 key_sign(
 781     const Key *key,
 782     u_char **sigp, u_int *lenp,
 783     const u_char *data, u_int datalen)
 784 {
 785         switch (key->type) {
 786         case KEY_DSA:
 787                 return ssh_dss_sign(key, sigp, lenp, data, datalen);
 788         case KEY_RSA:
 789                 return ssh_rsa_sign(key, sigp, lenp, data, datalen);
 790         default:
 791                 error("key_sign: invalid key type %d", key->type);
 792                 return -1;
 793         }
 794 }
 795
 796 /*
 797  * key_verify returns 1 for a correct signature, 0 for an incorrect signature
 798  * and -1 on error.
 799  */
 800 int
 801 key_verify(
 802     const Key *key,
 803     const u_char *signature, u_int signaturelen,
 804     const u_char *data, u_int datalen)
 805 {
 806         if (signaturelen == 0)
 807                 return -1;
 808
 809         switch (key->type) {
 810         case KEY_DSA:
 811                 return ssh_dss_verify(key, signature, signaturelen, data, datalen);
 812         case KEY_RSA:
 813                 return ssh_rsa_verify(key, signature, signaturelen, data, datalen);
 814         default:
 815                 error("key_verify: invalid key type %d", key->type);
 816                 return -1;
 817         }
 818 }
 819
 820 /* Converts a private to a public key */
 821 Key *
 822 key_demote(const Key *k)
 823 {
 824         Key *pk;
 825
 826         pk = xcalloc(1, sizeof(*pk));
 827         pk->type = k->type;
 828         pk->flags = k->flags;
 829         pk->dsa = NULL;
 830         pk->rsa = NULL;
 831
 832         switch (k->type) {
 833         case KEY_RSA1:
 834         case KEY_RSA:
 835                 if ((pk->rsa = RSA_new()) == NULL)
 836                         fatal("key_demote: RSA_new failed");
 837                 if ((pk->rsa->e = BN_dup(k->rsa->e)) == NULL)
 838                         fatal("key_demote: BN_dup failed");
 839                 if ((pk->rsa->n = BN_dup(k->rsa->n)) == NULL)
 840                         fatal("key_demote: BN_dup failed");
 841                 break;
 842         case KEY_DSA:
 843                 if ((pk->dsa = DSA_new()) == NULL)
 844                         fatal("key_demote: DSA_new failed");
 845                 if ((pk->dsa->p = BN_dup(k->dsa->p)) == NULL)
 846                         fatal("key_demote: BN_dup failed");
 847                 if ((pk->dsa->q = BN_dup(k->dsa->q)) == NULL)
 848                         fatal("key_demote: BN_dup failed");
 849                 if ((pk->dsa->g = BN_dup(k->dsa->g)) == NULL)
 850                         fatal("key_demote: BN_dup failed");
 851                 if ((pk->dsa->pub_key = BN_dup(k->dsa->pub_key)) == NULL)
 852                         fatal("key_demote: BN_dup failed");
 853                 break;
 854         default:
 855                 fatal("key_free: bad key type %d", k->type);
 856                 break;
 857         }
 858
 859         return (pk);
 860 }