pageant.c

   1 /*
   2  * pageant.c: cross-platform code to implement Pageant.
   3  */
   4
   5 #include <stddef.h>
   6 #include <stdlib.h>
   7 #include <assert.h>
   8
   9 #include "putty.h"
  10 #include "ssh.h"
  11 #include "pageant.h"
  12
  13 /*
  14  * We need this to link with the RSA code, because rsaencrypt()
  15  * pads its data with random bytes. Since we only use rsadecrypt()
  16  * and the signing functions, which are deterministic, this should
  17  * never be called.
  18  *
  19  * If it _is_ called, there is a _serious_ problem, because it
  20  * won't generate true random numbers. So we must scream, panic,
  21  * and exit immediately if that should happen.
  22  */
  23 int random_byte(void)
  24 {
  25     modalfatalbox("Internal error: attempt to use random numbers in Pageant");
  26     exit(0);
  27     return 0;                 /* unreachable, but placate optimiser */
  28 }
  29
  30 static int pageant_local = FALSE;
  31
  32 /*
  33  * rsakeys stores SSH-1 RSA keys. ssh2keys stores all SSH-2 keys.
  34  */
  35 static tree234 *rsakeys, *ssh2keys;
  36
  37 /*
  38  * Blob structure for passing to the asymmetric SSH-2 key compare
  39  * function, prototyped here.
  40  */
  41 struct blob {
  42     const unsigned char *blob;
  43     int len;
  44 };
  45 static int cmpkeys_ssh2_asymm(void *av, void *bv);
  46
  47 /*
  48  * Key comparison function for the 2-3-4 tree of RSA keys.
  49  */
  50 static int cmpkeys_rsa(void *av, void *bv)
  51 {
  52     struct RSAKey *a = (struct RSAKey *) av;
  53     struct RSAKey *b = (struct RSAKey *) bv;
  54     Bignum am, bm;
  55     int alen, blen;
  56
  57     am = a->modulus;
  58     bm = b->modulus;
  59     /*
  60      * Compare by length of moduli.
  61      */
  62     alen = bignum_bitcount(am);
  63     blen = bignum_bitcount(bm);
  64     if (alen > blen)
  65         return +1;
  66     else if (alen < blen)
  67         return -1;
  68     /*
  69      * Now compare by moduli themselves.
  70      */
  71     alen = (alen + 7) / 8;             /* byte count */
  72     while (alen-- > 0) {
  73         int abyte, bbyte;
  74         abyte = bignum_byte(am, alen);
  75         bbyte = bignum_byte(bm, alen);
  76         if (abyte > bbyte)
  77             return +1;
  78         else if (abyte < bbyte)
  79             return -1;
  80     }
  81     /*
  82      * Give up.
  83      */
  84     return 0;
  85 }
  86
  87 /*
  88  * Key comparison function for the 2-3-4 tree of SSH-2 keys.
  89  */
  90 static int cmpkeys_ssh2(void *av, void *bv)
  91 {
  92     struct ssh2_userkey *a = (struct ssh2_userkey *) av;
  93     struct ssh2_userkey *b = (struct ssh2_userkey *) bv;
  94     int i;
  95     int alen, blen;
  96     unsigned char *ablob, *bblob;
  97     int c;
  98
  99     /*
 100      * Compare purely by public blob.
 101      */
 102     ablob = a->alg->public_blob(a->data, &alen);
 103     bblob = b->alg->public_blob(b->data, &blen);
 104
 105     c = 0;
 106     for (i = 0; i < alen && i < blen; i++) {
 107         if (ablob[i] < bblob[i]) {
 108             c = -1;
 109             break;
 110         } else if (ablob[i] > bblob[i]) {
 111             c = +1;
 112             break;
 113         }
 114     }
 115     if (c == 0 && i < alen)
 116         c = +1;                        /* a is longer */
 117     if (c == 0 && i < blen)
 118         c = -1;                        /* a is longer */
 119
 120     sfree(ablob);
 121     sfree(bblob);
 122
 123     return c;
 124 }
 125
 126 /*
 127  * Key comparison function for looking up a blob in the 2-3-4 tree
 128  * of SSH-2 keys.
 129  */
 130 static int cmpkeys_ssh2_asymm(void *av, void *bv)
 131 {
 132     struct blob *a = (struct blob *) av;
 133     struct ssh2_userkey *b = (struct ssh2_userkey *) bv;
 134     int i;
 135     int alen, blen;
 136     const unsigned char *ablob;
 137     unsigned char *bblob;
 138     int c;
 139
 140     /*
 141      * Compare purely by public blob.
 142      */
 143     ablob = a->blob;
 144     alen = a->len;
 145     bblob = b->alg->public_blob(b->data, &blen);
 146
 147     c = 0;
 148     for (i = 0; i < alen && i < blen; i++) {
 149         if (ablob[i] < bblob[i]) {
 150             c = -1;
 151             break;
 152         } else if (ablob[i] > bblob[i]) {
 153             c = +1;
 154             break;
 155         }
 156     }
 157     if (c == 0 && i < alen)
 158         c = +1;                        /* a is longer */
 159     if (c == 0 && i < blen)
 160         c = -1;                        /* a is longer */
 161
 162     sfree(bblob);
 163
 164     return c;
 165 }
 166
 167 /*
 168  * Create an SSH-1 key list in a malloc'ed buffer; return its
 169  * length.
 170  */
 171 void *pageant_make_keylist1(int *length)
 172 {
 173     int i, nkeys, len;
 174     struct RSAKey *key;
 175     unsigned char *blob, *p, *ret;
 176     int bloblen;
 177
 178     /*
 179      * Count up the number and length of keys we hold.
 180      */
 181     len = 4;
 182     nkeys = 0;
 183     for (i = 0; NULL != (key = index234(rsakeys, i)); i++) {
 184         nkeys++;
 185         blob = rsa_public_blob(key, &bloblen);
 186         len += bloblen;
 187         sfree(blob);
 188         len += 4 + strlen(key->comment);
 189     }
 190
 191     /* Allocate the buffer. */
 192     p = ret = snewn(len, unsigned char);
 193     if (length) *length = len;
 194
 195     PUT_32BIT(p, nkeys);
 196     p += 4;
 197     for (i = 0; NULL != (key = index234(rsakeys, i)); i++) {
 198         blob = rsa_public_blob(key, &bloblen);
 199         memcpy(p, blob, bloblen);
 200         p += bloblen;
 201         sfree(blob);
 202         PUT_32BIT(p, strlen(key->comment));
 203         memcpy(p + 4, key->comment, strlen(key->comment));
 204         p += 4 + strlen(key->comment);
 205     }
 206
 207     assert(p - ret == len);
 208     return ret;
 209 }
 210
 211 /*
 212  * Create an SSH-2 key list in a malloc'ed buffer; return its
 213  * length.
 214  */
 215 void *pageant_make_keylist2(int *length)
 216 {
 217     struct ssh2_userkey *key;
 218     int i, len, nkeys;
 219     unsigned char *blob, *p, *ret;
 220     int bloblen;
 221
 222     /*
 223      * Count up the number and length of keys we hold.
 224      */
 225     len = 4;
 226     nkeys = 0;
 227     for (i = 0; NULL != (key = index234(ssh2keys, i)); i++) {
 228         nkeys++;
 229         len += 4;              /* length field */
 230         blob = key->alg->public_blob(key->data, &bloblen);
 231         len += bloblen;
 232         sfree(blob);
 233         len += 4 + strlen(key->comment);
 234     }
 235
 236     /* Allocate the buffer. */
 237     p = ret = snewn(len, unsigned char);
 238     if (length) *length = len;
 239
 240     /*
 241      * Packet header is the obvious five bytes, plus four
 242      * bytes for the key count.
 243      */
 244     PUT_32BIT(p, nkeys);
 245     p += 4;
 246     for (i = 0; NULL != (key = index234(ssh2keys, i)); i++) {
 247         blob = key->alg->public_blob(key->data, &bloblen);
 248         PUT_32BIT(p, bloblen);
 249         p += 4;
 250         memcpy(p, blob, bloblen);
 251         p += bloblen;
 252         sfree(blob);
 253         PUT_32BIT(p, strlen(key->comment));
 254         memcpy(p + 4, key->comment, strlen(key->comment));
 255         p += 4 + strlen(key->comment);
 256     }
 257
 258     assert(p - ret == len);
 259     return ret;
 260 }
 261
 262 static void plog(void *logctx, pageant_logfn_t logfn, const char *fmt, ...)
 263 #ifdef __GNUC__
 264 __attribute__ ((format (printf, 3, 4)))
 265 #endif
 266     ;
 267
 268 static void plog(void *logctx, pageant_logfn_t logfn, const char *fmt, ...)
 269 {
 270     /*
 271      * This is the wrapper that takes a variadic argument list and
 272      * turns it into the va_list that the log function really expects.
 273      * It's safe to call this with logfn==NULL, because we
 274      * double-check that below; but if you're going to do lots of work
 275      * before getting here (such as looping, or hashing things) then
 276      * you should probably check logfn manually before doing that.
 277      */
 278     if (logfn) {
 279         va_list ap;
 280         va_start(ap, fmt);
 281         logfn(logctx, fmt, ap);
 282         va_end(ap);
 283     }
 284 }
 285
 286 void *pageant_handle_msg(const void *msg, int msglen, int *outlen,
 287                          void *logctx, pageant_logfn_t logfn)
 288 {
 289     const unsigned char *p = msg;
 290     const unsigned char *msgend;
 291     unsigned char *ret = snewn(AGENT_MAX_MSGLEN, unsigned char);
 292     int type;
 293     const char *fail_reason;
 294
 295     msgend = p + msglen;
 296
 297     /*
 298      * Get the message type.
 299      */
 300     if (msgend < p+1) {
 301         fail_reason = "message contained no type code";
 302         goto failure;
 303     }
 304     type = *p++;
 305
 306     switch (type) {
 307       case SSH1_AGENTC_REQUEST_RSA_IDENTITIES:
 308         /*
 309          * Reply with SSH1_AGENT_RSA_IDENTITIES_ANSWER.
 310          */
 311         {
 312             int len;
 313             void *keylist;
 314
 315             plog(logctx, logfn, "request: SSH1_AGENTC_REQUEST_RSA_IDENTITIES");
 316
 317             ret[4] = SSH1_AGENT_RSA_IDENTITIES_ANSWER;
 318             keylist = pageant_make_keylist1(&len);
 319             if (len + 5 > AGENT_MAX_MSGLEN) {
 320                 sfree(keylist);
 321                 fail_reason = "output would exceed max msglen";
 322                 goto failure;
 323             }
 324             PUT_32BIT(ret, len + 1);
 325             memcpy(ret + 5, keylist, len);
 326
 327             plog(logctx, logfn, "reply: SSH1_AGENT_RSA_IDENTITIES_ANSWER");
 328             if (logfn) {               /* skip this loop if not logging */
 329                 int i;
 330                 struct RSAKey *rkey;
 331                 for (i = 0; NULL != (rkey = pageant_nth_ssh1_key(i)); i++) {
 332                     char fingerprint[128];
 333                     rsa_fingerprint(fingerprint, sizeof(fingerprint), rkey);
 334                     plog(logctx, logfn, "returned key: %s", fingerprint);
 335                 }
 336             }
 337             sfree(keylist);
 338         }
 339         break;
 340       case SSH2_AGENTC_REQUEST_IDENTITIES:
 341         /*
 342          * Reply with SSH2_AGENT_IDENTITIES_ANSWER.
 343          */
 344         {
 345             int len;
 346             void *keylist;
 347
 348             plog(logctx, logfn, "request: SSH2_AGENTC_REQUEST_IDENTITIES");
 349
 350             ret[4] = SSH2_AGENT_IDENTITIES_ANSWER;
 351             keylist = pageant_make_keylist2(&len);
 352             if (len + 5 > AGENT_MAX_MSGLEN) {
 353                 sfree(keylist);
 354                 fail_reason = "output would exceed max msglen";
 355                 goto failure;
 356             }
 357             PUT_32BIT(ret, len + 1);
 358             memcpy(ret + 5, keylist, len);
 359
 360             plog(logctx, logfn, "reply: SSH2_AGENT_IDENTITIES_ANSWER");
 361             if (logfn) {               /* skip this loop if not logging */
 362                 int i;
 363                 struct ssh2_userkey *skey;
 364                 for (i = 0; NULL != (skey = pageant_nth_ssh2_key(i)); i++) {
 365                     char *fingerprint = ssh2_fingerprint(skey->alg,
 366                                                          skey->data);
 367                     plog(logctx, logfn, "returned key: %s %s",
 368                          fingerprint, skey->comment);
 369                     sfree(fingerprint);
 370                 }
 371             }
 372
 373             sfree(keylist);
 374         }
 375         break;
 376       case SSH1_AGENTC_RSA_CHALLENGE:
 377         /*
 378          * Reply with either SSH1_AGENT_RSA_RESPONSE or
 379          * SSH_AGENT_FAILURE, depending on whether we have that key
 380          * or not.
 381          */
 382         {
 383             struct RSAKey reqkey, *key;
 384             Bignum challenge, response;
 385             unsigned char response_source[48], response_md5[16];
 386             struct MD5Context md5c;
 387             int i, len;
 388
 389             plog(logctx, logfn, "request: SSH1_AGENTC_RSA_CHALLENGE");
 390
 391             p += 4;
 392             i = ssh1_read_bignum(p, msgend - p, &reqkey.exponent);
 393             if (i < 0) {
 394                 fail_reason = "request truncated before key exponent";
 395                 goto failure;
 396             }
 397             p += i;
 398             i = ssh1_read_bignum(p, msgend - p, &reqkey.modulus);
 399             if (i < 0) {
 400                 freebn(reqkey.exponent);
 401                 fail_reason = "request truncated before key modulus";
 402                 goto failure;
 403             }
 404             p += i;
 405             i = ssh1_read_bignum(p, msgend - p, &challenge);
 406             if (i < 0) {
 407                 freebn(reqkey.exponent);
 408                 freebn(reqkey.modulus);
 409                 fail_reason = "request truncated before challenge";
 410                 goto failure;
 411             }
 412             p += i;
 413             if (msgend < p+16) {
 414                 freebn(reqkey.exponent);
 415                 freebn(reqkey.modulus);
 416                 freebn(challenge);
 417                 fail_reason = "request truncated before session id";
 418                 goto failure;
 419             }
 420             memcpy(response_source + 32, p, 16);
 421             p += 16;
 422             if (msgend < p+4) {
 423                 freebn(reqkey.exponent);
 424                 freebn(reqkey.modulus);
 425                 freebn(challenge);
 426                 fail_reason = "request truncated before response type";
 427                 goto failure;
 428             }
 429             if (GET_32BIT(p) != 1) {
 430                 freebn(reqkey.exponent);
 431                 freebn(reqkey.modulus);
 432                 freebn(challenge);
 433                 fail_reason = "response type other than 1 not supported";
 434                 goto failure;
 435             }
 436             if (logfn) {
 437                 char fingerprint[128];
 438                 reqkey.comment = NULL;
 439                 rsa_fingerprint(fingerprint, sizeof(fingerprint), &reqkey);
 440                 plog(logctx, logfn, "requested key: %s", fingerprint);
 441             }
 442             if ((key = find234(rsakeys, &reqkey, NULL)) == NULL) {
 443                 freebn(reqkey.exponent);
 444                 freebn(reqkey.modulus);
 445                 freebn(challenge);
 446                 fail_reason = "key not found";
 447                 goto failure;
 448             }
 449             response = rsadecrypt(challenge, key);
 450             for (i = 0; i < 32; i++)
 451                 response_source[i] = bignum_byte(response, 31 - i);
 452
 453             MD5Init(&md5c);
 454             MD5Update(&md5c, response_source, 48);
 455             MD5Final(response_md5, &md5c);
 456             smemclr(response_source, 48);       /* burn the evidence */
 457             freebn(response);          /* and that evidence */
 458             freebn(challenge);         /* yes, and that evidence */
 459             freebn(reqkey.exponent);   /* and free some memory ... */
 460             freebn(reqkey.modulus);    /* ... while we're at it. */
 461
 462             /*
 463              * Packet is the obvious five byte header, plus sixteen
 464              * bytes of MD5.
 465              */
 466             len = 5 + 16;
 467             PUT_32BIT(ret, len - 4);
 468             ret[4] = SSH1_AGENT_RSA_RESPONSE;
 469             memcpy(ret + 5, response_md5, 16);
 470
 471             plog(logctx, logfn, "reply: SSH1_AGENT_RSA_RESPONSE");
 472         }
 473         break;
 474       case SSH2_AGENTC_SIGN_REQUEST:
 475         /*
 476          * Reply with either SSH2_AGENT_SIGN_RESPONSE or
 477          * SSH_AGENT_FAILURE, depending on whether we have that key
 478          * or not.
 479          */
 480         {
 481             struct ssh2_userkey *key;
 482             struct blob b;
 483             const unsigned char *data;
 484             unsigned char *signature;
 485             int datalen, siglen, len;
 486
 487             plog(logctx, logfn, "request: SSH2_AGENTC_SIGN_REQUEST");
 488
 489             if (msgend < p+4) {
 490                 fail_reason = "request truncated before public key";
 491                 goto failure;
 492             }
 493             b.len = toint(GET_32BIT(p));
 494             if (b.len < 0 || b.len > msgend - (p+4)) {
 495                 fail_reason = "request truncated before public key";
 496                 goto failure;
 497             }
 498             p += 4;
 499             b.blob = p;
 500             p += b.len;
 501             if (msgend < p+4) {
 502                 fail_reason = "request truncated before string to sign";
 503                 goto failure;
 504             }
 505             datalen = toint(GET_32BIT(p));
 506             p += 4;
 507             if (datalen < 0 || datalen > msgend - p) {
 508                 fail_reason = "request truncated before string to sign";
 509                 goto failure;
 510             }
 511             data = p;
 512             if (logfn) {
 513                 char *fingerprint = ssh2_fingerprint_blob(b.blob, b.len);
 514                 plog(logctx, logfn, "requested key: %s", fingerprint);
 515                 sfree(fingerprint);
 516             }
 517             key = find234(ssh2keys, &b, cmpkeys_ssh2_asymm);
 518             if (!key) {
 519                 fail_reason = "key not found";
 520                 goto failure;
 521             }
 522             signature = key->alg->sign(key->data, (const char *)data,
 523                                        datalen, &siglen);
 524             len = 5 + 4 + siglen;
 525             PUT_32BIT(ret, len - 4);
 526             ret[4] = SSH2_AGENT_SIGN_RESPONSE;
 527             PUT_32BIT(ret + 5, siglen);
 528             memcpy(ret + 5 + 4, signature, siglen);
 529             sfree(signature);
 530
 531             plog(logctx, logfn, "reply: SSH2_AGENT_SIGN_RESPONSE");
 532         }
 533         break;
 534       case SSH1_AGENTC_ADD_RSA_IDENTITY:
 535         /*
 536          * Add to the list and return SSH_AGENT_SUCCESS, or
 537          * SSH_AGENT_FAILURE if the key was malformed.
 538          */
 539         {
 540             struct RSAKey *key;
 541             char *comment;
 542             int n, commentlen;
 543
 544             plog(logctx, logfn, "request: SSH1_AGENTC_ADD_RSA_IDENTITY");
 545
 546             key = snew(struct RSAKey);
 547             memset(key, 0, sizeof(struct RSAKey));
 548
 549             n = makekey(p, msgend - p, key, NULL, 1);
 550             if (n < 0) {
 551                 freersakey(key);
 552                 sfree(key);
 553                 fail_reason = "request truncated before public key";
 554                 goto failure;
 555             }
 556             p += n;
 557
 558             n = makeprivate(p, msgend - p, key);
 559             if (n < 0) {
 560                 freersakey(key);
 561                 sfree(key);
 562                 fail_reason = "request truncated before private key";
 563                 goto failure;
 564             }
 565             p += n;
 566
 567             /* SSH-1 names p and q the other way round, i.e. we have
 568              * the inverse of p mod q and not of q mod p. We swap the
 569              * names, because our internal RSA wants iqmp. */
 570
 571             n = ssh1_read_bignum(p, msgend - p, &key->iqmp);  /* p^-1 mod q */
 572             if (n < 0) {
 573                 freersakey(key);
 574                 sfree(key);
 575                 fail_reason = "request truncated before iqmp";
 576                 goto failure;
 577             }
 578             p += n;
 579
 580             n = ssh1_read_bignum(p, msgend - p, &key->q);  /* p */
 581             if (n < 0) {
 582                 freersakey(key);
 583                 sfree(key);
 584                 fail_reason = "request truncated before p";
 585                 goto failure;
 586             }
 587             p += n;
 588
 589             n = ssh1_read_bignum(p, msgend - p, &key->p);  /* q */
 590             if (n < 0) {
 591                 freersakey(key);
 592                 sfree(key);
 593                 fail_reason = "request truncated before q";
 594                 goto failure;
 595             }
 596             p += n;
 597
 598             if (msgend < p+4) {
 599                 freersakey(key);
 600                 sfree(key);
 601                 fail_reason = "request truncated before key comment";
 602                 goto failure;
 603             }
 604             commentlen = toint(GET_32BIT(p));
 605
 606             if (commentlen < 0 || commentlen > msgend - p) {
 607                 freersakey(key);
 608                 sfree(key);
 609                 fail_reason = "request truncated before key comment";
 610                 goto failure;
 611             }
 612
 613             comment = snewn(commentlen+1, char);
 614             if (comment) {
 615                 memcpy(comment, p + 4, commentlen);
 616                 comment[commentlen] = '\0';
 617                 key->comment = comment;
 618             }
 619
 620             if (logfn) {
 621                 char fingerprint[128];
 622                 rsa_fingerprint(fingerprint, sizeof(fingerprint), key);
 623                 plog(logctx, logfn, "submitted key: %s", fingerprint);
 624             }
 625
 626             if (add234(rsakeys, key) == key) {
 627                 keylist_update();
 628                 PUT_32BIT(ret, 1);
 629                 ret[4] = SSH_AGENT_SUCCESS;
 630
 631                 plog(logctx, logfn, "reply: SSH_AGENT_SUCCESS");
 632             } else {
 633                 freersakey(key);
 634                 sfree(key);
 635
 636                 fail_reason = "key already present";
 637                 goto failure;
 638             }
 639         }
 640         break;
 641       case SSH2_AGENTC_ADD_IDENTITY:
 642         /*
 643          * Add to the list and return SSH_AGENT_SUCCESS, or
 644          * SSH_AGENT_FAILURE if the key was malformed.
 645          */
 646         {
 647             struct ssh2_userkey *key;
 648             char *comment;
 649             const char *alg;
 650             int alglen, commlen;
 651             int bloblen;
 652
 653             plog(logctx, logfn, "request: SSH2_AGENTC_ADD_IDENTITY");
 654
 655             if (msgend < p+4) {
 656                 fail_reason = "request truncated before key algorithm";
 657                 goto failure;
 658             }
 659             alglen = toint(GET_32BIT(p));
 660             p += 4;
 661             if (alglen < 0 || alglen > msgend - p) {
 662                 fail_reason = "request truncated before key algorithm";
 663                 goto failure;
 664             }
 665             alg = (const char *)p;
 666             p += alglen;
 667
 668             key = snew(struct ssh2_userkey);
 669             key->alg = find_pubkey_alg_len(alglen, alg);
 670             if (!key->alg) {
 671                 sfree(key);
 672                 fail_reason = "algorithm unknown";
 673                 goto failure;
 674             }
 675
 676             bloblen = msgend - p;
 677             key->data = key->alg->openssh_createkey(key->alg, &p, &bloblen);
 678             if (!key->data) {
 679                 sfree(key);
 680                 fail_reason = "key setup failed";
 681                 goto failure;
 682             }
 683
 684             /*
 685              * p has been advanced by openssh_createkey, but
 686              * certainly not _beyond_ the end of the buffer.
 687              */
 688             assert(p <= msgend);
 689
 690             if (msgend < p+4) {
 691                 key->alg->freekey(key->data);
 692                 sfree(key);
 693                 fail_reason = "request truncated before key comment";
 694                 goto failure;
 695             }
 696             commlen = toint(GET_32BIT(p));
 697             p += 4;
 698
 699             if (commlen < 0 || commlen > msgend - p) {
 700                 key->alg->freekey(key->data);
 701                 sfree(key);
 702                 fail_reason = "request truncated before key comment";
 703                 goto failure;
 704             }
 705             comment = snewn(commlen + 1, char);
 706             if (comment) {
 707                 memcpy(comment, p, commlen);
 708                 comment[commlen] = '\0';
 709             }
 710             key->comment = comment;
 711
 712             if (logfn) {
 713                 char *fingerprint = ssh2_fingerprint(key->alg, key->data);
 714                 plog(logctx, logfn, "submitted key: %s %s",
 715                      fingerprint, key->comment);
 716                 sfree(fingerprint);
 717             }
 718
 719             if (add234(ssh2keys, key) == key) {
 720                 keylist_update();
 721                 PUT_32BIT(ret, 1);
 722                 ret[4] = SSH_AGENT_SUCCESS;
 723
 724                 plog(logctx, logfn, "reply: SSH_AGENT_SUCCESS");
 725             } else {
 726                 key->alg->freekey(key->data);
 727                 sfree(key->comment);
 728                 sfree(key);
 729
 730                 fail_reason = "key already present";
 731                 goto failure;
 732             }
 733         }
 734         break;
 735       case SSH1_AGENTC_REMOVE_RSA_IDENTITY:
 736         /*
 737          * Remove from the list and return SSH_AGENT_SUCCESS, or
 738          * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
 739          * start with.
 740          */
 741         {
 742             struct RSAKey reqkey, *key;
 743             int n;
 744
 745             plog(logctx, logfn, "request: SSH1_AGENTC_REMOVE_RSA_IDENTITY");
 746
 747             n = makekey(p, msgend - p, &reqkey, NULL, 0);
 748             if (n < 0) {
 749                 fail_reason = "request truncated before public key";
 750                 goto failure;
 751             }
 752
 753             if (logfn) {
 754                 char fingerprint[128];
 755                 reqkey.comment = NULL;
 756                 rsa_fingerprint(fingerprint, sizeof(fingerprint), &reqkey);
 757                 plog(logctx, logfn, "unwanted key: %s", fingerprint);
 758             }
 759
 760             key = find234(rsakeys, &reqkey, NULL);
 761             freebn(reqkey.exponent);
 762             freebn(reqkey.modulus);
 763             PUT_32BIT(ret, 1);
 764             if (key) {
 765                 plog(logctx, logfn, "found with comment: %s", key->comment);
 766
 767                 del234(rsakeys, key);
 768                 keylist_update();
 769                 freersakey(key);
 770                 sfree(key);
 771                 ret[4] = SSH_AGENT_SUCCESS;
 772
 773                 plog(logctx, logfn, "reply: SSH_AGENT_SUCCESS");
 774             } else {
 775                 fail_reason = "key not found";
 776                 goto failure;
 777             }
 778         }
 779         break;
 780       case SSH2_AGENTC_REMOVE_IDENTITY:
 781         /*
 782          * Remove from the list and return SSH_AGENT_SUCCESS, or
 783          * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
 784          * start with.
 785          */
 786         {
 787             struct ssh2_userkey *key;
 788             struct blob b;
 789
 790             plog(logctx, logfn, "request: SSH2_AGENTC_REMOVE_IDENTITY");
 791
 792             if (msgend < p+4) {
 793                 fail_reason = "request truncated before public key";
 794                 goto failure;
 795             }
 796             b.len = toint(GET_32BIT(p));
 797             p += 4;
 798
 799             if (b.len < 0 || b.len > msgend - p) {
 800                 fail_reason = "request truncated before public key";
 801                 goto failure;
 802             }
 803             b.blob = p;
 804             p += b.len;
 805
 806             if (logfn) {
 807                 char *fingerprint = ssh2_fingerprint_blob(b.blob, b.len);
 808                 plog(logctx, logfn, "unwanted key: %s", fingerprint);
 809                 sfree(fingerprint);
 810             }
 811
 812             key = find234(ssh2keys, &b, cmpkeys_ssh2_asymm);
 813             if (!key) {
 814                 fail_reason = "key not found";
 815                 goto failure;
 816             }
 817
 818             plog(logctx, logfn, "found with comment: %s", key->comment);
 819
 820             del234(ssh2keys, key);
 821             keylist_update();
 822             key->alg->freekey(key->data);
 823             sfree(key);
 824             PUT_32BIT(ret, 1);
 825             ret[4] = SSH_AGENT_SUCCESS;
 826
 827             plog(logctx, logfn, "reply: SSH_AGENT_SUCCESS");
 828         }
 829         break;
 830       case SSH1_AGENTC_REMOVE_ALL_RSA_IDENTITIES:
 831         /*
 832          * Remove all SSH-1 keys. Always returns success.
 833          */
 834         {
 835             struct RSAKey *rkey;
 836
 837             plog(logctx, logfn, "request:"
 838                 " SSH1_AGENTC_REMOVE_ALL_RSA_IDENTITIES");
 839
 840             while ((rkey = index234(rsakeys, 0)) != NULL) {
 841                 del234(rsakeys, rkey);
 842                 freersakey(rkey);
 843                 sfree(rkey);
 844             }
 845             keylist_update();
 846
 847             PUT_32BIT(ret, 1);
 848             ret[4] = SSH_AGENT_SUCCESS;
 849
 850             plog(logctx, logfn, "reply: SSH_AGENT_SUCCESS");
 851         }
 852         break;
 853       case SSH2_AGENTC_REMOVE_ALL_IDENTITIES:
 854         /*
 855          * Remove all SSH-2 keys. Always returns success.
 856          */
 857         {
 858             struct ssh2_userkey *skey;
 859
 860             plog(logctx, logfn, "request: SSH2_AGENTC_REMOVE_ALL_IDENTITIES");
 861
 862             while ((skey = index234(ssh2keys, 0)) != NULL) {
 863                 del234(ssh2keys, skey);
 864                 skey->alg->freekey(skey->data);
 865                 sfree(skey);
 866             }
 867             keylist_update();
 868
 869             PUT_32BIT(ret, 1);
 870             ret[4] = SSH_AGENT_SUCCESS;
 871
 872             plog(logctx, logfn, "reply: SSH_AGENT_SUCCESS");
 873         }
 874         break;
 875       default:
 876         plog(logctx, logfn, "request: unknown message type %d", type);
 877
 878         fail_reason = "unrecognised message";
 879         /* fall through */
 880       failure:
 881         /*
 882          * Unrecognised message. Return SSH_AGENT_FAILURE.
 883          */
 884         PUT_32BIT(ret, 1);
 885         ret[4] = SSH_AGENT_FAILURE;
 886         plog(logctx, logfn, "reply: SSH_AGENT_FAILURE (%s)", fail_reason);
 887         break;
 888     }
 889
 890     *outlen = 4 + GET_32BIT(ret);
 891     return ret;
 892 }
 893
 894 void *pageant_failure_msg(int *outlen)
 895 {
 896     unsigned char *ret = snewn(5, unsigned char);
 897     PUT_32BIT(ret, 1);
 898     ret[4] = SSH_AGENT_FAILURE;
 899     *outlen = 5;
 900     return ret;
 901 }
 902
 903 void pageant_init(void)
 904 {
 905     pageant_local = TRUE;
 906     rsakeys = newtree234(cmpkeys_rsa);
 907     ssh2keys = newtree234(cmpkeys_ssh2);
 908 }
 909
 910 struct RSAKey *pageant_nth_ssh1_key(int i)
 911 {
 912     return index234(rsakeys, i);
 913 }
 914
 915 struct ssh2_userkey *pageant_nth_ssh2_key(int i)
 916 {
 917     return index234(ssh2keys, i);
 918 }
 919
 920 int pageant_count_ssh1_keys(void)
 921 {
 922     return count234(rsakeys);
 923 }
 924
 925 int pageant_count_ssh2_keys(void)
 926 {
 927     return count234(ssh2keys);
 928 }
 929
 930 int pageant_add_ssh1_key(struct RSAKey *rkey)
 931 {
 932     return add234(rsakeys, rkey) == rkey;
 933 }
 934
 935 int pageant_add_ssh2_key(struct ssh2_userkey *skey)
 936 {
 937     return add234(ssh2keys, skey) == skey;
 938 }
 939
 940 int pageant_delete_ssh1_key(struct RSAKey *rkey)
 941 {
 942     struct RSAKey *deleted = del234(rsakeys, rkey);
 943     if (!deleted)
 944         return FALSE;
 945     assert(deleted == rkey);
 946     return TRUE;
 947 }
 948
 949 int pageant_delete_ssh2_key(struct ssh2_userkey *skey)
 950 {
 951     struct ssh2_userkey *deleted = del234(ssh2keys, skey);
 952     if (!deleted)
 953         return FALSE;
 954     assert(deleted == skey);
 955     return TRUE;
 956 }
 957
 958 /* ----------------------------------------------------------------------
 959  * The agent plug.
 960  */
 961
 962 /*
 963  * Coroutine macros similar to, but simplified from, those in ssh.c.
 964  */
 965 #define crBegin(v)      { int *crLine = &v; switch(v) { case 0:;
 966 #define crFinish(z)     } *crLine = 0; return (z); }
 967 #define crGetChar(c) do                                         \
 968     {                                                           \
 969         while (len == 0) {                                      \
 970             *crLine =__LINE__; return 1; case __LINE__:;        \
 971         }                                                       \
 972         len--;                                                  \
 973         (c) = (unsigned char)*data++;                           \
 974     } while (0)
 975
 976 struct pageant_conn_state {
 977     const struct plug_function_table *fn;
 978     /* the above variable absolutely *must* be the first in this structure */
 979
 980     Socket connsock;
 981     void *logctx;
 982     pageant_logfn_t logfn;
 983     unsigned char lenbuf[4], pktbuf[AGENT_MAX_MSGLEN];
 984     unsigned len, got;
 985     int real_packet;
 986     int crLine;            /* for coroutine in pageant_conn_receive */
 987 };
 988
 989 static int pageant_conn_closing(Plug plug, const char *error_msg,
 990                                 int error_code, int calling_back)
 991 {
 992     struct pageant_conn_state *pc = (struct pageant_conn_state *)plug;
 993     if (error_msg)
 994         plog(pc->logctx, pc->logfn, "%p: error: %s", pc, error_msg);
 995     else
 996         plog(pc->logctx, pc->logfn, "%p: connection closed", pc);
 997     sk_close(pc->connsock);
 998     sfree(pc);
 999     return 1;
1000 }
1001
1002 static void pageant_conn_sent(Plug plug, int bufsize)
1003 {
1004     /* struct pageant_conn_state *pc = (struct pageant_conn_state *)plug; */
1005
1006     /*
1007      * We do nothing here, because we expect that there won't be a
1008      * need to throttle and unthrottle the connection to an agent -
1009      * clients will typically not send many requests, and will wait
1010      * until they receive each reply before sending a new request.
1011      */
1012 }
1013
1014 static void pageant_conn_log(void *logctx, const char *fmt, va_list ap)
1015 {
1016     /* Wrapper on pc->logfn that prefixes the connection identifier */
1017     struct pageant_conn_state *pc = (struct pageant_conn_state *)logctx;
1018     char *formatted = dupvprintf(fmt, ap);
1019     plog(pc->logctx, pc->logfn, "%p: %s", pc, formatted);
1020     sfree(formatted);
1021 }
1022
1023 static int pageant_conn_receive(Plug plug, int urgent, char *data, int len)
1024 {
1025     struct pageant_conn_state *pc = (struct pageant_conn_state *)plug;
1026     char c;
1027
1028     crBegin(pc->crLine);
1029
1030     while (len > 0) {
1031         pc->got = 0;
1032         while (pc->got < 4) {
1033             crGetChar(c);
1034             pc->lenbuf[pc->got++] = c;
1035         }
1036
1037         pc->len = GET_32BIT(pc->lenbuf);
1038         pc->got = 0;
1039         pc->real_packet = (pc->len < AGENT_MAX_MSGLEN-4);
1040
1041         while (pc->got < pc->len) {
1042             crGetChar(c);
1043             if (pc->real_packet)
1044                 pc->pktbuf[pc->got] = c;
1045             pc->got++;
1046         }
1047
1048         {
1049             void *reply;
1050             int replylen;
1051
1052             if (pc->real_packet) {
1053                 reply = pageant_handle_msg(pc->pktbuf, pc->len, &replylen, pc,
1054                                            pc->logfn?pageant_conn_log:NULL);
1055             } else {
1056                 plog(pc->logctx, pc->logfn, "%p: overlong message (%u)",
1057                      pc, pc->len);
1058                 plog(pc->logctx, pc->logfn, "%p: reply: SSH_AGENT_FAILURE "
1059                      "(message too long)", pc);
1060                 reply = pageant_failure_msg(&replylen);
1061             }
1062             sk_write(pc->connsock, reply, replylen);
1063             smemclr(reply, replylen);
1064         }
1065     }
1066
1067     crFinish(1);
1068 }
1069
1070 struct pageant_listen_state {
1071     const struct plug_function_table *fn;
1072     /* the above variable absolutely *must* be the first in this structure */
1073
1074     Socket listensock;
1075     void *logctx;
1076     pageant_logfn_t logfn;
1077 };
1078
1079 static int pageant_listen_closing(Plug plug, const char *error_msg,
1080                                   int error_code, int calling_back)
1081 {
1082     struct pageant_listen_state *pl = (struct pageant_listen_state *)plug;
1083     if (error_msg)
1084         plog(pl->logctx, pl->logfn, "listening socket: error: %s", error_msg);
1085     sk_close(pl->listensock);
1086     pl->listensock = NULL;
1087     return 1;
1088 }
1089
1090 static int pageant_listen_accepting(Plug plug,
1091                                     accept_fn_t constructor, accept_ctx_t ctx)
1092 {
1093     static const struct plug_function_table connection_fn_table = {
1094         NULL, /* no log function, because that's for outgoing connections */
1095         pageant_conn_closing,
1096         pageant_conn_receive,
1097         pageant_conn_sent,
1098         NULL /* no accepting function, because we've already done it */
1099     };
1100     struct pageant_listen_state *pl = (struct pageant_listen_state *)plug;
1101     struct pageant_conn_state *pc;
1102     const char *err;
1103
1104     pc = snew(struct pageant_conn_state);
1105     pc->fn = &connection_fn_table;
1106     pc->logfn = pl->logfn;
1107     pc->logctx = pl->logctx;
1108     pc->crLine = 0;
1109
1110     pc->connsock = constructor(ctx, (Plug) pc);
1111     if ((err = sk_socket_error(pc->connsock)) != NULL) {
1112         sk_close(pc->connsock);
1113         sfree(pc);
1114         return TRUE;
1115     }
1116
1117     sk_set_frozen(pc->connsock, 0);
1118
1119     /* FIXME: can we get any useful peer id info? */
1120     plog(pl->logctx, pl->logfn, "%p: new connection", pc);
1121
1122     return 0;
1123 }
1124
1125 struct pageant_listen_state *pageant_listener_new(void)
1126 {
1127     static const struct plug_function_table listener_fn_table = {
1128         NULL, /* no log function, because that's for outgoing connections */
1129         pageant_listen_closing,
1130         NULL, /* no receive function on a listening socket */
1131         NULL, /* no sent function on a listening socket */
1132         pageant_listen_accepting
1133     };
1134
1135     struct pageant_listen_state *pl = snew(struct pageant_listen_state);
1136     pl->fn = &listener_fn_table;
1137     pl->logctx = NULL;
1138     pl->logfn = NULL;
1139     pl->listensock = NULL;
1140     return pl;
1141 }
1142
1143 void pageant_listener_got_socket(struct pageant_listen_state *pl, Socket sock)
1144 {
1145     pl->listensock = sock;
1146 }
1147
1148 void pageant_listener_set_logfn(struct pageant_listen_state *pl,
1149                                 void *logctx, pageant_logfn_t logfn)
1150 {
1151     pl->logctx = logctx;
1152     pl->logfn = logfn;
1153 }
1154
1155 void pageant_listener_free(struct pageant_listen_state *pl)
1156 {
1157     if (pl->listensock)
1158         sk_close(pl->listensock);
1159     sfree(pl);
1160 }
1161
1162 /* ----------------------------------------------------------------------
1163  * Code to perform agent operations either as a client, or within the
1164  * same process as the running agent.
1165  */
1166
1167 static tree234 *passphrases = NULL;
1168
1169 /*
1170  * After processing a list of filenames, we want to forget the
1171  * passphrases.
1172  */
1173 void pageant_forget_passphrases(void)
1174 {
1175     if (!passphrases)                  /* in case we never set it up at all */
1176         return;
1177
1178     while (count234(passphrases) > 0) {
1179         char *pp = index234(passphrases, 0);
1180         smemclr(pp, strlen(pp));
1181         delpos234(passphrases, 0);
1182         free(pp);
1183     }
1184 }
1185
1186 void *pageant_get_keylist1(int *length)
1187 {
1188     void *ret;
1189
1190     if (!pageant_local) {
1191         unsigned char request[5], *response;
1192         void *vresponse;
1193         int resplen, retval;
1194         request[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES;
1195         PUT_32BIT(request, 1);
1196
1197         retval = agent_query(request, 5, &vresponse, &resplen, NULL, NULL);
1198         assert(retval == 1);
1199         response = vresponse;
1200         if (resplen < 5 || response[4] != SSH1_AGENT_RSA_IDENTITIES_ANSWER) {
1201             sfree(response);
1202             return NULL;
1203         }
1204
1205         ret = snewn(resplen-5, unsigned char);
1206         memcpy(ret, response+5, resplen-5);
1207         sfree(response);
1208
1209         if (length)
1210             *length = resplen-5;
1211     } else {
1212         ret = pageant_make_keylist1(length);
1213     }
1214     return ret;
1215 }
1216
1217 void *pageant_get_keylist2(int *length)
1218 {
1219     void *ret;
1220
1221     if (!pageant_local) {
1222         unsigned char request[5], *response;
1223         void *vresponse;
1224         int resplen, retval;
1225
1226         request[4] = SSH2_AGENTC_REQUEST_IDENTITIES;
1227         PUT_32BIT(request, 1);
1228
1229         retval = agent_query(request, 5, &vresponse, &resplen, NULL, NULL);
1230         assert(retval == 1);
1231         response = vresponse;
1232         if (resplen < 5 || response[4] != SSH2_AGENT_IDENTITIES_ANSWER) {
1233             sfree(response);
1234             return NULL;
1235         }
1236
1237         ret = snewn(resplen-5, unsigned char);
1238         memcpy(ret, response+5, resplen-5);
1239         sfree(response);
1240
1241         if (length)
1242             *length = resplen-5;
1243     } else {
1244         ret = pageant_make_keylist2(length);
1245     }
1246     return ret;
1247 }
1248
1249 int pageant_add_keyfile(Filename *filename, const char *passphrase,
1250                         char **retstr)
1251 {
1252     struct RSAKey *rkey = NULL;
1253     struct ssh2_userkey *skey = NULL;
1254     int needs_pass;
1255     int ret;
1256     int attempts;
1257     char *comment;
1258     const char *this_passphrase;
1259     const char *error = NULL;
1260     int type;
1261
1262     if (!passphrases) {
1263         passphrases = newtree234(NULL);
1264     }
1265
1266     *retstr = NULL;
1267
1268     type = key_type(filename);
1269     if (type != SSH_KEYTYPE_SSH1 && type != SSH_KEYTYPE_SSH2) {
1270         *retstr = dupprintf("Couldn't load this key (%s)",
1271                             key_type_to_str(type));
1272         return PAGEANT_ACTION_FAILURE;
1273     }
1274
1275     /*
1276      * See if the key is already loaded (in the primary Pageant,
1277      * which may or may not be us).
1278      */
1279     {
1280         void *blob;
1281         unsigned char *keylist, *p;
1282         int i, nkeys, bloblen, keylistlen;
1283
1284         if (type == SSH_KEYTYPE_SSH1) {
1285             if (!rsakey_pubblob(filename, &blob, &bloblen, NULL, &error)) {
1286                 *retstr = dupprintf("Couldn't load private key (%s)", error);
1287                 return PAGEANT_ACTION_FAILURE;
1288             }
1289             keylist = pageant_get_keylist1(&keylistlen);
1290         } else {
1291             unsigned char *blob2;
1292             blob = ssh2_userkey_loadpub(filename, NULL, &bloblen,
1293                                         NULL, &error);
1294             if (!blob) {
1295                 *retstr = dupprintf("Couldn't load private key (%s)", error);
1296                 return PAGEANT_ACTION_FAILURE;
1297             }
1298             /* For our purposes we want the blob prefixed with its length */
1299             blob2 = snewn(bloblen+4, unsigned char);
1300             PUT_32BIT(blob2, bloblen);
1301             memcpy(blob2 + 4, blob, bloblen);
1302             sfree(blob);
1303             blob = blob2;
1304
1305             keylist = pageant_get_keylist2(&keylistlen);
1306         }
1307         if (keylist) {
1308             if (keylistlen < 4) {
1309                 *retstr = dupstr("Received broken key list from agent");
1310                 return PAGEANT_ACTION_FAILURE;
1311             }
1312             nkeys = toint(GET_32BIT(keylist));
1313             if (nkeys < 0) {
1314                 *retstr = dupstr("Received broken key list from agent");
1315                 return PAGEANT_ACTION_FAILURE;
1316             }
1317             p = keylist + 4;
1318             keylistlen -= 4;
1319
1320             for (i = 0; i < nkeys; i++) {
1321                 if (!memcmp(blob, p, bloblen)) {
1322                     /* Key is already present; we can now leave. */
1323                     sfree(keylist);
1324                     sfree(blob);
1325                     return PAGEANT_ACTION_OK;
1326                 }
1327                 /* Now skip over public blob */
1328                 if (type == SSH_KEYTYPE_SSH1) {
1329                     int n = rsa_public_blob_len(p, keylistlen);
1330                     if (n < 0) {
1331                         *retstr = dupstr("Received broken key list from agent");
1332                         return PAGEANT_ACTION_FAILURE;
1333                     }
1334                     p += n;
1335                     keylistlen -= n;
1336                 } else {
1337                     int n;
1338                     if (keylistlen < 4) {
1339                         *retstr = dupstr("Received broken key list from agent");
1340                         return PAGEANT_ACTION_FAILURE;
1341                     }
1342                     n = toint(4 + GET_32BIT(p));
1343                     if (n < 0 || keylistlen < n) {
1344                         *retstr = dupstr("Received broken key list from agent");
1345                         return PAGEANT_ACTION_FAILURE;
1346                     }
1347                     p += n;
1348                     keylistlen -= n;
1349                 }
1350                 /* Now skip over comment field */
1351                 {
1352                     int n;
1353                     if (keylistlen < 4) {
1354                         *retstr = dupstr("Received broken key list from agent");
1355                         return PAGEANT_ACTION_FAILURE;
1356                     }
1357                     n = toint(4 + GET_32BIT(p));
1358                     if (n < 0 || keylistlen < n) {
1359                         *retstr = dupstr("Received broken key list from agent");
1360                         return PAGEANT_ACTION_FAILURE;
1361                     }
1362                     p += n;
1363                     keylistlen -= n;
1364                 }
1365             }
1366
1367             sfree(keylist);
1368         }
1369
1370         sfree(blob);
1371     }
1372
1373     error = NULL;
1374     if (type == SSH_KEYTYPE_SSH1)
1375         needs_pass = rsakey_encrypted(filename, &comment);
1376     else
1377         needs_pass = ssh2_userkey_encrypted(filename, &comment);
1378     attempts = 0;
1379     if (type == SSH_KEYTYPE_SSH1)
1380         rkey = snew(struct RSAKey);
1381
1382     /*
1383      * Loop round repeatedly trying to load the key, until we either
1384      * succeed, fail for some serious reason, or run out of
1385      * passphrases to try.
1386      */
1387     while (1) {
1388         if (needs_pass) {
1389
1390             /*
1391              * If we've been given a passphrase on input, try using
1392              * it. Otherwise, try one from our tree234 of previously
1393              * useful passphrases.
1394              */
1395             if (passphrase) {
1396                 this_passphrase = (attempts == 0 ? passphrase : NULL);
1397             } else {
1398                 this_passphrase = (const char *)index234(passphrases, attempts);
1399             }
1400
1401             if (!this_passphrase) {
1402                 /*
1403                  * Run out of passphrases to try.
1404                  */
1405                 *retstr = comment;
1406                 return PAGEANT_ACTION_NEED_PP;
1407             }
1408         } else
1409             this_passphrase = "";
1410
1411         if (type == SSH_KEYTYPE_SSH1)
1412             ret = loadrsakey(filename, rkey, this_passphrase, &error);
1413         else {
1414             skey = ssh2_load_userkey(filename, this_passphrase, &error);
1415             if (skey == SSH2_WRONG_PASSPHRASE)
1416                 ret = -1;
1417             else if (!skey)
1418                 ret = 0;
1419             else
1420                 ret = 1;
1421         }
1422
1423         if (ret == 0) {
1424             /*
1425              * Failed to load the key file, for some reason other than
1426              * a bad passphrase.
1427              */
1428             *retstr = dupstr(error);
1429             return PAGEANT_ACTION_FAILURE;
1430         } else if (ret == 1) {
1431             /*
1432              * Successfully loaded the key file.
1433              */
1434             break;
1435         } else {
1436             /*
1437              * Passphrase wasn't right; go round again.
1438              */
1439             attempts++;
1440         }
1441     }
1442
1443     /*
1444      * If we get here, we've succesfully loaded the key into
1445      * rkey/skey, but not yet added it to the agent.
1446      */
1447
1448     /*
1449      * If the key was successfully decrypted, save the passphrase for
1450      * use with other keys we try to load.
1451      */
1452     {
1453         char *pp_copy = dupstr(this_passphrase);
1454         if (addpos234(passphrases, pp_copy, 0) != pp_copy) {
1455             /* No need; it was already there. */
1456             smemclr(pp_copy, strlen(pp_copy));
1457             sfree(pp_copy);
1458         }
1459     }
1460
1461     if (comment)
1462         sfree(comment);
1463
1464     if (type == SSH_KEYTYPE_SSH1) {
1465         if (!pageant_local) {
1466             unsigned char *request, *response;
1467             void *vresponse;
1468             int reqlen, clen, resplen, ret;
1469
1470             clen = strlen(rkey->comment);
1471
1472             reqlen = 4 + 1 +           /* length, message type */
1473                 4 +                    /* bit count */
1474                 ssh1_bignum_length(rkey->modulus) +
1475                 ssh1_bignum_length(rkey->exponent) +
1476                 ssh1_bignum_length(rkey->private_exponent) +
1477                 ssh1_bignum_length(rkey->iqmp) +
1478                 ssh1_bignum_length(rkey->p) +
1479                 ssh1_bignum_length(rkey->q) + 4 + clen  /* comment */
1480                 ;
1481
1482             request = snewn(reqlen, unsigned char);
1483
1484             request[4] = SSH1_AGENTC_ADD_RSA_IDENTITY;
1485             reqlen = 5;
1486             PUT_32BIT(request + reqlen, bignum_bitcount(rkey->modulus));
1487             reqlen += 4;
1488             reqlen += ssh1_write_bignum(request + reqlen, rkey->modulus);
1489             reqlen += ssh1_write_bignum(request + reqlen, rkey->exponent);
1490             reqlen +=
1491                 ssh1_write_bignum(request + reqlen,
1492                                   rkey->private_exponent);
1493             reqlen += ssh1_write_bignum(request + reqlen, rkey->iqmp);
1494             reqlen += ssh1_write_bignum(request + reqlen, rkey->p);
1495             reqlen += ssh1_write_bignum(request + reqlen, rkey->q);
1496             PUT_32BIT(request + reqlen, clen);
1497             memcpy(request + reqlen + 4, rkey->comment, clen);
1498             reqlen += 4 + clen;
1499             PUT_32BIT(request, reqlen - 4);
1500
1501             ret = agent_query(request, reqlen, &vresponse, &resplen,
1502                               NULL, NULL);
1503             assert(ret == 1);
1504             response = vresponse;
1505             if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS) {
1506                 *retstr = dupstr("The already running Pageant "
1507                                  "refused to add the key.");
1508                 return PAGEANT_ACTION_FAILURE;
1509             }
1510             sfree(request);
1511             sfree(response);
1512         } else {
1513             if (!pageant_add_ssh1_key(rkey)) {
1514                 sfree(rkey);           /* already present, don't waste RAM */
1515             }
1516         }
1517     } else {
1518         if (!pageant_local) {
1519             unsigned char *request, *response;
1520             void *vresponse;
1521             int reqlen, alglen, clen, keybloblen, resplen, ret;
1522             alglen = strlen(skey->alg->name);
1523             clen = strlen(skey->comment);
1524
1525             keybloblen = skey->alg->openssh_fmtkey(skey->data, NULL, 0);
1526
1527             reqlen = 4 + 1 +           /* length, message type */
1528                 4 + alglen +           /* algorithm name */
1529                 keybloblen +           /* key data */
1530                 4 + clen               /* comment */
1531                 ;
1532
1533             request = snewn(reqlen, unsigned char);
1534
1535             request[4] = SSH2_AGENTC_ADD_IDENTITY;
1536             reqlen = 5;
1537             PUT_32BIT(request + reqlen, alglen);
1538             reqlen += 4;
1539             memcpy(request + reqlen, skey->alg->name, alglen);
1540             reqlen += alglen;
1541             reqlen += skey->alg->openssh_fmtkey(skey->data,
1542                                                 request + reqlen,
1543                                                 keybloblen);
1544             PUT_32BIT(request + reqlen, clen);
1545             memcpy(request + reqlen + 4, skey->comment, clen);
1546             reqlen += clen + 4;
1547             PUT_32BIT(request, reqlen - 4);
1548
1549             ret = agent_query(request, reqlen, &vresponse, &resplen,
1550                               NULL, NULL);
1551             assert(ret == 1);
1552             response = vresponse;
1553             if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS) {
1554                 *retstr = dupstr("The already running Pageant "
1555                                  "refused to add the key.");
1556                 return PAGEANT_ACTION_FAILURE;
1557             }
1558
1559             sfree(request);
1560             sfree(response);
1561         } else {
1562             if (!pageant_add_ssh2_key(skey)) {
1563                 skey->alg->freekey(skey->data);
1564                 sfree(skey);           /* already present, don't waste RAM */
1565             }
1566         }
1567     }
1568     return PAGEANT_ACTION_OK;
1569 }
1570
1571 int pageant_enum_keys(pageant_key_enum_fn_t callback, void *callback_ctx,
1572                       char **retstr)
1573 {
1574     unsigned char *keylist, *p;
1575     int i, nkeys, keylistlen;
1576     char *comment;
1577     struct pageant_pubkey cbkey;
1578
1579     keylist = pageant_get_keylist1(&keylistlen);
1580     if (keylistlen < 4) {
1581         *retstr = dupstr("Received broken SSH-1 key list from agent");
1582         sfree(keylist);
1583         return PAGEANT_ACTION_FAILURE;
1584     }
1585     nkeys = toint(GET_32BIT(keylist));
1586     if (nkeys < 0) {
1587         *retstr = dupstr("Received broken SSH-1 key list from agent");
1588         sfree(keylist);
1589         return PAGEANT_ACTION_FAILURE;
1590     }
1591     p = keylist + 4;
1592     keylistlen -= 4;
1593
1594     for (i = 0; i < nkeys; i++) {
1595         struct RSAKey rkey;
1596         char fingerprint[128];
1597         int n;
1598
1599         /* public blob and fingerprint */
1600         memset(&rkey, 0, sizeof(rkey));
1601         n = makekey(p, keylistlen, &rkey, NULL, 0);
1602         if (n < 0 || n > keylistlen) {
1603             freersakey(&rkey);
1604             *retstr = dupstr("Received broken SSH-1 key list from agent");
1605             sfree(keylist);
1606             return PAGEANT_ACTION_FAILURE;
1607         }
1608         p += n, keylistlen -= n;
1609         rsa_fingerprint(fingerprint, sizeof(fingerprint), &rkey);
1610
1611         /* comment */
1612         if (keylistlen < 4) {
1613             *retstr = dupstr("Received broken SSH-1 key list from agent");
1614             freersakey(&rkey);
1615             sfree(keylist);
1616             return PAGEANT_ACTION_FAILURE;
1617         }
1618         n = toint(GET_32BIT(p));
1619         p += 4, keylistlen -= 4;
1620         if (n < 0 || keylistlen < n) {
1621             *retstr = dupstr("Received broken SSH-1 key list from agent");
1622             freersakey(&rkey);
1623             sfree(keylist);
1624             return PAGEANT_ACTION_FAILURE;
1625         }
1626         comment = dupprintf("%.*s", (int)n, (const char *)p);
1627         p += n, keylistlen -= n;
1628
1629         cbkey.blob = rsa_public_blob(&rkey, &cbkey.bloblen);
1630         cbkey.comment = comment;
1631         cbkey.ssh_version = 1;
1632         callback(callback_ctx, fingerprint, comment, &cbkey);
1633         sfree(cbkey.blob);
1634         freersakey(&rkey);
1635         sfree(comment);
1636     }
1637
1638     sfree(keylist);
1639
1640     if (keylistlen != 0) {
1641         *retstr = dupstr("Received broken SSH-1 key list from agent");
1642         return PAGEANT_ACTION_FAILURE;
1643     }
1644
1645     keylist = pageant_get_keylist2(&keylistlen);
1646     if (keylistlen < 4) {
1647         *retstr = dupstr("Received broken SSH-2 key list from agent");
1648         sfree(keylist);
1649         return PAGEANT_ACTION_FAILURE;
1650     }
1651     nkeys = toint(GET_32BIT(keylist));
1652     if (nkeys < 0) {
1653         *retstr = dupstr("Received broken SSH-2 key list from agent");
1654         sfree(keylist);
1655         return PAGEANT_ACTION_FAILURE;
1656     }
1657     p = keylist + 4;
1658     keylistlen -= 4;
1659
1660     for (i = 0; i < nkeys; i++) {
1661         char *fingerprint;
1662         int n;
1663
1664         /* public blob */
1665         if (keylistlen < 4) {
1666             *retstr = dupstr("Received broken SSH-2 key list from agent");
1667             sfree(keylist);
1668             return PAGEANT_ACTION_FAILURE;
1669         }
1670         n = toint(GET_32BIT(p));
1671         p += 4, keylistlen -= 4;
1672         if (n < 0 || keylistlen < n) {
1673             *retstr = dupstr("Received broken SSH-2 key list from agent");
1674             sfree(keylist);
1675             return PAGEANT_ACTION_FAILURE;
1676         }
1677         fingerprint = ssh2_fingerprint_blob(p, n);
1678         cbkey.blob = p;
1679         cbkey.bloblen = n;
1680         p += n, keylistlen -= n;
1681
1682         /* comment */
1683         if (keylistlen < 4) {
1684             *retstr = dupstr("Received broken SSH-2 key list from agent");
1685             sfree(fingerprint);
1686             sfree(keylist);
1687             return PAGEANT_ACTION_FAILURE;
1688         }
1689         n = toint(GET_32BIT(p));
1690         p += 4, keylistlen -= 4;
1691         if (n < 0 || keylistlen < n) {
1692             *retstr = dupstr("Received broken SSH-2 key list from agent");
1693             sfree(fingerprint);
1694             sfree(keylist);
1695             return PAGEANT_ACTION_FAILURE;
1696         }
1697         comment = dupprintf("%.*s", (int)n, (const char *)p);
1698         p += n, keylistlen -= n;
1699
1700         cbkey.ssh_version = 2;
1701         cbkey.comment = comment;
1702         callback(callback_ctx, fingerprint, comment, &cbkey);
1703         sfree(fingerprint);
1704         sfree(comment);
1705     }
1706
1707     sfree(keylist);
1708
1709     if (keylistlen != 0) {
1710         *retstr = dupstr("Received broken SSH-1 key list from agent");
1711         return PAGEANT_ACTION_FAILURE;
1712     }
1713
1714     return PAGEANT_ACTION_OK;
1715 }
1716
1717 int pageant_delete_key(struct pageant_pubkey *key, char **retstr)
1718 {
1719     unsigned char *request, *response;
1720     int reqlen, resplen, ret;
1721     void *vresponse;
1722
1723     if (key->ssh_version == 1) {
1724         reqlen = 5 + key->bloblen;
1725         request = snewn(reqlen, unsigned char);
1726         PUT_32BIT(request, reqlen - 4);
1727         request[4] = SSH1_AGENTC_REMOVE_RSA_IDENTITY;
1728         memcpy(request + 5, key->blob, key->bloblen);
1729     } else {
1730         reqlen = 9 + key->bloblen;
1731         request = snewn(reqlen, unsigned char);
1732         PUT_32BIT(request, reqlen - 4);
1733         request[4] = SSH2_AGENTC_REMOVE_IDENTITY;
1734         PUT_32BIT(request + 5, key->bloblen);
1735         memcpy(request + 9, key->blob, key->bloblen);
1736     }
1737
1738     ret = agent_query(request, reqlen, &vresponse, &resplen, NULL, NULL);
1739     assert(ret == 1);
1740     response = vresponse;
1741     if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS) {
1742         *retstr = dupstr("Agent failed to delete key");
1743         ret = PAGEANT_ACTION_FAILURE;
1744     } else {
1745         *retstr = NULL;
1746         ret = PAGEANT_ACTION_OK;
1747     }
1748     sfree(request);
1749     sfree(response);
1750     return ret;
1751 }
1752
1753 int pageant_delete_all_keys(char **retstr)
1754 {
1755     unsigned char request[5], *response;
1756     int reqlen, resplen, success, ret;
1757     void *vresponse;
1758
1759     PUT_32BIT(request, 1);
1760     request[4] = SSH2_AGENTC_REMOVE_ALL_IDENTITIES;
1761     reqlen = 5;
1762     ret = agent_query(request, reqlen, &vresponse, &resplen, NULL, NULL);
1763     assert(ret == 1);
1764     response = vresponse;
1765     success = (resplen >= 4 && response[4] == SSH_AGENT_SUCCESS);
1766     sfree(response);
1767     if (!success) {
1768         *retstr = dupstr("Agent failed to delete SSH-2 keys");
1769         return PAGEANT_ACTION_FAILURE;
1770     }
1771
1772     PUT_32BIT(request, 1);
1773     request[4] = SSH1_AGENTC_REMOVE_ALL_RSA_IDENTITIES;
1774     reqlen = 5;
1775     ret = agent_query(request, reqlen, &vresponse, &resplen, NULL, NULL);
1776     assert(ret == 1);
1777     response = vresponse;
1778     success = (resplen >= 4 && response[4] == SSH_AGENT_SUCCESS);
1779     sfree(response);
1780     if (!success) {
1781         *retstr = dupstr("Agent failed to delete SSH-1 keys");
1782         return PAGEANT_ACTION_FAILURE;
1783     }
1784
1785     *retstr = NULL;
1786     return PAGEANT_ACTION_OK;
1787 }
1788
1789 struct pageant_pubkey *pageant_pubkey_copy(struct pageant_pubkey *key)
1790 {
1791     struct pageant_pubkey *ret = snew(struct pageant_pubkey);
1792     ret->blob = snewn(key->bloblen, unsigned char);
1793     memcpy(ret->blob, key->blob, key->bloblen);
1794     ret->bloblen = key->bloblen;
1795     ret->comment = key->comment ? dupstr(key->comment) : NULL;
1796     ret->ssh_version = key->ssh_version;
1797     return ret;
1798 }
1799
1800 void pageant_pubkey_free(struct pageant_pubkey *key)
1801 {
1802     sfree(key->comment);
1803     sfree(key->blob);
1804     sfree(key);
1805 }