lib/silcclient/protocol.c

   1 /*
   2
   3   protocol.c
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 1997 - 2001 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /*
  21  * Client side of the protocols.
  22  */
  23 /* $Id$ */
  24
  25 #include "silcincludes.h"
  26 #include "silcclient.h"
  27 #include "client_internal.h"
  28
  29 SILC_TASK_CALLBACK(silc_client_protocol_connection_auth);
  30 SILC_TASK_CALLBACK(silc_client_protocol_key_exchange);
  31 SILC_TASK_CALLBACK(silc_client_protocol_rekey);
  32
  33 /*
  34  * Key Exhange protocol functions
  35  */
  36
  37 /* Function that is called when SKE protocol sends packets to network. */
  38
  39 void silc_client_protocol_ke_send_packet(SilcSKE ske,
  40                                          SilcBuffer packet,
  41                                          SilcPacketType type,
  42                                          void *context)
  43 {
  44   SilcProtocol protocol = (SilcProtocol)context;
  45   SilcClientKEInternalContext *ctx =
  46     (SilcClientKEInternalContext *)protocol->context;
  47   SilcClient client = (SilcClient)ctx->client;
  48
  49   /* Send the packet immediately */
  50   silc_client_packet_send(client, ske->sock, type, NULL, 0, NULL, NULL,
  51                           packet->data, packet->len, TRUE);
  52 }
  53
  54 /* Public key verification callback. Called by the application. */
  55
  56 typedef struct {
  57   SilcSKE ske;
  58   SilcSKEVerifyCbCompletion completion;
  59   void *completion_context;
  60 } *VerifyKeyContext;
  61
  62 static void silc_client_verify_key_cb(bool success, void *context)
  63 {
  64   VerifyKeyContext verify = (VerifyKeyContext)context;
  65
  66   SILC_LOG_DEBUG(("Start"));
  67
  68   /* Call the completion callback back to the SKE */
  69   verify->completion(verify->ske, success ? SILC_SKE_STATUS_OK :
  70                      SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY,
  71                      verify->completion_context);
  72
  73   silc_free(verify);
  74 }
  75
  76 /* Callback that is called when we have received KE payload from
  77    responder. We try to verify the public key now. */
  78
  79 void silc_client_protocol_ke_verify_key(SilcSKE ske,
  80                                         unsigned char *pk_data,
  81                                         SilcUInt32 pk_len,
  82                                         SilcSKEPKType pk_type,
  83                                         void *context,
  84                                         SilcSKEVerifyCbCompletion completion,
  85                                         void *completion_context)
  86 {
  87   SilcProtocol protocol = (SilcProtocol)context;
  88   SilcClientKEInternalContext *ctx =
  89     (SilcClientKEInternalContext *)protocol->context;
  90   SilcClient client = (SilcClient)ctx->client;
  91   VerifyKeyContext verify;
  92
  93   SILC_LOG_DEBUG(("Start"));
  94
  95   verify = silc_calloc(1, sizeof(*verify));
  96   verify->ske = ske;
  97   verify->completion = completion;
  98   verify->completion_context = completion_context;
  99
 100   /* Verify public key from user. */
 101   client->internal->ops->verify_public_key(client, ctx->sock->user_data,
 102                                            ctx->sock->type,
 103                                            pk_data, pk_len, pk_type,
 104                                            silc_client_verify_key_cb, verify);
 105 }
 106
 107 /* Sets the negotiated key material into use for particular connection. */
 108
 109 void silc_client_protocol_ke_set_keys(SilcSKE ske,
 110                                       SilcSocketConnection sock,
 111                                       SilcSKEKeyMaterial *keymat,
 112                                       SilcCipher cipher,
 113                                       SilcPKCS pkcs,
 114                                       SilcHash hash,
 115                                       SilcHmac hmac,
 116                                       SilcSKEDiffieHellmanGroup group,
 117                                       bool is_responder)
 118 {
 119   SilcClientConnection conn = (SilcClientConnection)sock->user_data;
 120   const char *cname = silc_cipher_get_name(cipher);
 121
 122   SILC_LOG_DEBUG(("Setting new keys into use"));
 123
 124   /* Allocate cipher to be used in the communication */
 125   silc_cipher_alloc((char *)cname, &conn->internal->send_key);
 126   silc_cipher_alloc((char *)cname, &conn->internal->receive_key);
 127   silc_hmac_alloc((char *)silc_hmac_get_name(hmac), NULL,
 128                   &conn->internal->hmac_send);
 129   silc_hmac_alloc((char *)silc_hmac_get_name(hmac), NULL,
 130                   &conn->internal->hmac_receive);
 131
 132   if (is_responder == TRUE) {
 133     silc_cipher_set_key(conn->internal->send_key, keymat->receive_enc_key,
 134                         keymat->enc_key_len);
 135     silc_cipher_set_iv(conn->internal->send_key, keymat->receive_iv);
 136     silc_cipher_set_key(conn->internal->receive_key, keymat->send_enc_key,
 137                         keymat->enc_key_len);
 138     silc_cipher_set_iv(conn->internal->receive_key, keymat->send_iv);
 139     silc_hmac_set_key(conn->internal->hmac_send, keymat->receive_hmac_key,
 140                       keymat->hmac_key_len);
 141     silc_hmac_set_key(conn->internal->hmac_receive, keymat->send_hmac_key,
 142                       keymat->hmac_key_len);
 143   } else {
 144     silc_cipher_set_key(conn->internal->send_key, keymat->send_enc_key,
 145                         keymat->enc_key_len);
 146     silc_cipher_set_iv(conn->internal->send_key, keymat->send_iv);
 147     silc_cipher_set_key(conn->internal->receive_key, keymat->receive_enc_key,
 148                         keymat->enc_key_len);
 149     silc_cipher_set_iv(conn->internal->receive_key, keymat->receive_iv);
 150     silc_hmac_set_key(conn->internal->hmac_send, keymat->send_hmac_key,
 151                       keymat->hmac_key_len);
 152     silc_hmac_set_key(conn->internal->hmac_receive, keymat->receive_hmac_key,
 153                       keymat->hmac_key_len);
 154   }
 155
 156   /* Rekey stuff */
 157   conn->internal->rekey = silc_calloc(1, sizeof(*conn->internal->rekey));
 158   conn->internal->rekey->send_enc_key = silc_memdup(keymat->send_enc_key,
 159                                                     keymat->enc_key_len / 8);
 160   conn->internal->rekey->enc_key_len = keymat->enc_key_len / 8;
 161
 162   if (ske->start_payload->flags & SILC_SKE_SP_FLAG_PFS)
 163     conn->internal->rekey->pfs = TRUE;
 164   conn->internal->rekey->ske_group = silc_ske_group_get_number(group);
 165
 166   /* Save the HASH function */
 167   silc_hash_alloc(silc_hash_get_name(hash), &conn->internal->hash);
 168 }
 169
 170 /* Checks the version string of the server. */
 171
 172 SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
 173                                      SilcUInt32 len, void *context)
 174 {
 175   SilcClientConnection conn = (SilcClientConnection)ske->sock->user_data;
 176   SilcClient client = (SilcClient)ske->user_data;
 177   SilcUInt32 l_protocol_version = 0, r_protocol_version = 0;
 178
 179   if (!silc_parse_version_string(version, &r_protocol_version, NULL, NULL,
 180                                  NULL, NULL)) {
 181     client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 182                                "We don't support server version `%s'",
 183                                version);
 184     return SILC_SKE_STATUS_BAD_VERSION;
 185   }
 186
 187   if (!silc_parse_version_string(client->internal->silc_client_version,
 188                                  &l_protocol_version, NULL, NULL,
 189                                  NULL, NULL)) {
 190     client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 191                                "We don't support server version `%s'",
 192                                version);
 193     return SILC_SKE_STATUS_BAD_VERSION;
 194   }
 195
 196   /* If remote is too new, don't connect */
 197   if (l_protocol_version < r_protocol_version) {
 198     client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 199                                "We don't support server version `%s'",
 200                                version);
 201     return SILC_SKE_STATUS_BAD_VERSION;
 202   }
 203
 204   ske->sock->version = r_protocol_version;
 205
 206   return SILC_SKE_STATUS_OK;
 207 }
 208
 209 /* Callback that is called by the SKE to indicate that it is safe to
 210    continue the execution of the protocol. Is given as argument to the
 211    silc_ske_initiator_finish or silc_ske_responder_phase_2 functions.
 212    This is called due to the fact that the public key verification
 213    process is asynchronous and we must not continue the protocl until
 214    the public key has been verified and this callback is called. */
 215
 216 static void silc_client_protocol_ke_continue(SilcSKE ske,
 217                                              void *context)
 218 {
 219   SilcProtocol protocol = (SilcProtocol)context;
 220   SilcClientKEInternalContext *ctx =
 221     (SilcClientKEInternalContext *)protocol->context;
 222   SilcClient client = (SilcClient)ctx->client;
 223   SilcClientConnection conn = ctx->sock->user_data;
 224
 225   SILC_LOG_DEBUG(("Start"));
 226
 227   if (ske->status != SILC_SKE_STATUS_OK) {
 228     /* Call failure client operation */
 229     client->internal->ops->failure(client, conn, protocol,
 230                                    (void *)ske->status);
 231     protocol->state = SILC_PROTOCOL_STATE_ERROR;
 232     silc_protocol_execute(protocol, client->schedule, 0, 0);
 233     return;
 234   }
 235
 236   /* Send Ok to the other end. We will end the protocol as server
 237      sends Ok to us when we will take the new keys into use. Do this
 238      if we are initiator. This is happens when this callback was sent
 239      to silc_ske_initiator_finish function. */
 240   if (ctx->responder == FALSE) {
 241     silc_ske_end(ctx->ske);
 242
 243     /* End the protocol on the next round */
 244     protocol->state = SILC_PROTOCOL_STATE_END;
 245   }
 246
 247   /* Advance protocol state and call the next state if we are responder.
 248      This happens when this callback was sent to silc_ske_responder_phase_2
 249      function. */
 250   if (ctx->responder == TRUE) {
 251     protocol->state++;
 252     silc_protocol_execute(protocol, client->schedule, 0, 1);
 253   }
 254 }
 255
 256 /* Performs key exchange protocol. This is used for both initiator
 257    and responder key exchange. This may be called recursively. */
 258
 259 SILC_TASK_CALLBACK(silc_client_protocol_key_exchange)
 260 {
 261   SilcProtocol protocol = (SilcProtocol)context;
 262   SilcClientKEInternalContext *ctx =
 263     (SilcClientKEInternalContext *)protocol->context;
 264   SilcClient client = (SilcClient)ctx->client;
 265   SilcClientConnection conn = ctx->sock->user_data;
 266   SilcSKEStatus status = SILC_SKE_STATUS_OK;
 267
 268   SILC_LOG_DEBUG(("Start"));
 269
 270   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 271     protocol->state = SILC_PROTOCOL_STATE_START;
 272
 273   switch(protocol->state) {
 274   case SILC_PROTOCOL_STATE_START:
 275     {
 276       /*
 277        * Start Protocol
 278        */
 279       SilcSKE ske;
 280
 281       /* Allocate Key Exchange object */
 282       ctx->ske = ske = silc_ske_alloc(client->rng, client);
 283
 284       silc_ske_set_callbacks(ske, ctx->send_packet, NULL,
 285                              ctx->verify,
 286                              silc_client_protocol_ke_continue,
 287                              silc_ske_check_version,
 288                              context);
 289
 290       if (ctx->responder == TRUE) {
 291         /* Start the key exchange by processing the received security
 292            properties packet from initiator. */
 293         status =
 294           silc_ske_responder_start(ske, ctx->rng, ctx->sock,
 295                                    client->internal->silc_client_version,
 296                                    ctx->packet->buffer, TRUE);
 297       } else {
 298         SilcSKEStartPayload *start_payload;
 299
 300         /* Assemble security properties. */
 301         silc_ske_assemble_security_properties(
 302                                   ske, SILC_SKE_SP_FLAG_MUTUAL,
 303                                   client->internal->silc_client_version,
 304                                   &start_payload);
 305
 306         /* Start the key exchange by sending our security properties
 307            to the remote end. */
 308         status = silc_ske_initiator_start(ske, ctx->rng, ctx->sock,
 309                                           start_payload);
 310       }
 311
 312       /* Return now if the procedure is pending */
 313       if (status == SILC_SKE_STATUS_PENDING)
 314         return;
 315
 316       if (status != SILC_SKE_STATUS_OK) {
 317         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 318                           status));
 319         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 320                         status));
 321
 322         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 323         silc_protocol_execute(protocol, client->schedule, 0, 0);
 324         return;
 325       }
 326
 327       /* Advance protocol state and call the next state if we are responder */
 328       protocol->state++;
 329       if (ctx->responder == TRUE)
 330         silc_protocol_execute(protocol, client->schedule, 0, 1);
 331     }
 332     break;
 333   case 2:
 334     {
 335       /*
 336        * Phase 1
 337        */
 338       if (ctx->responder == TRUE) {
 339         /* Sends the selected security properties to the initiator. */
 340         status = silc_ske_responder_phase_1(ctx->ske);
 341       } else {
 342         /* Call Phase-1 function. This processes the Key Exchange Start
 343            paylaod reply we just got from the responder. The callback
 344            function will receive the processed payload where we will
 345            save it. */
 346         status = silc_ske_initiator_phase_1(ctx->ske, ctx->packet->buffer);
 347       }
 348
 349       if (status != SILC_SKE_STATUS_OK) {
 350         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 351                           status));
 352         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 353                         status));
 354
 355         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 356         silc_protocol_execute(protocol, client->schedule, 0, 0);
 357         return;
 358       }
 359
 360       /* Advance protocol state and call next state if we are initiator */
 361       protocol->state++;
 362       if (ctx->responder == FALSE)
 363         silc_protocol_execute(protocol, client->schedule, 0, 1);
 364     }
 365     break;
 366   case 3:
 367     {
 368       /*
 369        * Phase 2
 370        */
 371       if (ctx->responder == TRUE) {
 372         /* Process the received Key Exchange 1 Payload packet from
 373            the initiator. This also creates our parts of the Diffie
 374            Hellman algorithm. The silc_client_protocol_ke_continue will
 375            be called after the public key has been verified. */
 376         status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer);
 377       } else {
 378         /* Call the Phase-2 function. This creates Diffie Hellman
 379            key exchange parameters and sends our public part inside
 380            Key Exhange 1 Payload to the responder. */
 381         status = silc_ske_initiator_phase_2(ctx->ske,
 382                                             client->public_key,
 383                                             client->private_key,
 384                                             SILC_SKE_PK_TYPE_SILC);
 385         protocol->state++;
 386       }
 387
 388       /* Return now if the procedure is pending */
 389       if (status == SILC_SKE_STATUS_PENDING)
 390         return;
 391
 392       if (status != SILC_SKE_STATUS_OK) {
 393         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 394                           status));
 395         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 396                         status));
 397
 398         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 399         silc_protocol_execute(protocol, client->schedule, 0, 0);
 400         return;
 401       }
 402     }
 403     break;
 404   case 4:
 405     {
 406       /*
 407        * Finish protocol
 408        */
 409       if (ctx->responder == TRUE) {
 410         /* This creates the key exchange material and sends our
 411            public parts to the initiator inside Key Exchange 2 Payload. */
 412         status =
 413           silc_ske_responder_finish(ctx->ske,
 414                                     client->public_key, client->private_key,
 415                                     SILC_SKE_PK_TYPE_SILC);
 416
 417         /* End the protocol on the next round */
 418         protocol->state = SILC_PROTOCOL_STATE_END;
 419       } else {
 420         /* Finish the protocol. This verifies the Key Exchange 2 payload
 421            sent by responder. The silc_client_protocol_ke_continue will
 422            be called after the public key has been verified. */
 423         status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer);
 424       }
 425
 426       /* Return now if the procedure is pending */
 427       if (status == SILC_SKE_STATUS_PENDING)
 428         return;
 429
 430       if (status != SILC_SKE_STATUS_OK) {
 431         if (status == SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY) {
 432           client->internal->ops->say(
 433                              client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 434                              "Received unsupported server %s public key",
 435                              ctx->sock->hostname);
 436         } else {
 437           client->internal->ops->say(
 438                            client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 439                            "Error during key exchange protocol with server %s",
 440                            ctx->sock->hostname);
 441         }
 442         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 443         silc_protocol_execute(protocol, client->schedule, 0, 0);
 444         return;
 445       }
 446     }
 447     break;
 448
 449   case SILC_PROTOCOL_STATE_END:
 450     {
 451       /*
 452        * End protocol
 453        */
 454       SilcSKEKeyMaterial *keymat;
 455       int key_len = silc_cipher_get_key_len(ctx->ske->prop->cipher);
 456       int hash_len = silc_hash_len(ctx->ske->prop->hash);
 457
 458       /* Process the key material */
 459       keymat = silc_calloc(1, sizeof(*keymat));
 460       status = silc_ske_process_key_material(ctx->ske, 16, key_len, hash_len,
 461                                              keymat);
 462       if (status != SILC_SKE_STATUS_OK) {
 463         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 464         silc_protocol_execute(protocol, client->schedule, 0, 300000);
 465         silc_ske_free_key_material(keymat);
 466         return;
 467       }
 468       ctx->keymat = keymat;
 469
 470       /* Send Ok to the other end if we are responder. If we are initiator
 471          we have sent this already. */
 472       if (ctx->responder == TRUE)
 473         silc_ske_end(ctx->ske);
 474
 475       /* Unregister the timeout task since the protocol has ended.
 476          This was the timeout task to be executed if the protocol is
 477          not completed fast enough. */
 478       if (ctx->timeout_task)
 479         silc_schedule_task_del(client->schedule, ctx->timeout_task);
 480
 481       /* Protocol has ended, call the final callback */
 482       if (protocol->final_callback)
 483         silc_protocol_execute_final(protocol, client->schedule);
 484       else
 485         silc_protocol_free(protocol);
 486     }
 487     break;
 488
 489   case SILC_PROTOCOL_STATE_ERROR:
 490     /*
 491      * Error during protocol
 492      */
 493
 494     /* Send abort notification */
 495     silc_ske_abort(ctx->ske, ctx->ske->status);
 496
 497     /* On error the final callback is always called. */
 498     if (protocol->final_callback)
 499       silc_protocol_execute_final(protocol, client->schedule);
 500     else
 501       silc_protocol_free(protocol);
 502     break;
 503
 504   case SILC_PROTOCOL_STATE_FAILURE:
 505     /*
 506      * Received failure from remote.
 507      */
 508
 509     /* Unregister the timeout task since the protocol has ended.
 510        This was the timeout task to be executed if the protocol is
 511        not completed fast enough. */
 512     if (ctx->timeout_task)
 513       silc_schedule_task_del(client->schedule, ctx->timeout_task);
 514
 515     /* On error the final callback is always called. */
 516     if (protocol->final_callback)
 517       silc_protocol_execute_final(protocol, client->schedule);
 518     else
 519       silc_protocol_free(protocol);
 520     break;
 521   case SILC_PROTOCOL_STATE_UNKNOWN:
 522     break;
 523   }
 524 }
 525
 526 /*
 527  * Connection Authentication protocol functions
 528  */
 529
 530 static int
 531 silc_client_get_public_key_auth(SilcClient client,
 532                                 SilcClientConnection conn,
 533                                 unsigned char *auth_data,
 534                                 SilcUInt32 *auth_data_len,
 535                                 SilcSKE ske)
 536 {
 537   int len;
 538   SilcPKCS pkcs;
 539   SilcBuffer auth;
 540
 541   /* Use our default key */
 542   pkcs = client->pkcs;
 543
 544   /* Make the authentication data. Protocol says it is HASH plus
 545      KE Start Payload. */
 546   len = ske->hash_len + ske->start_payload_copy->len;
 547   auth = silc_buffer_alloc(len);
 548   silc_buffer_pull_tail(auth, len);
 549   silc_buffer_format(auth,
 550                      SILC_STR_UI_XNSTRING(ske->hash, ske->hash_len),
 551                      SILC_STR_UI_XNSTRING(ske->start_payload_copy->data,
 552                                           ske->start_payload_copy->len),
 553                      SILC_STR_END);
 554
 555   if (silc_pkcs_sign_with_hash(pkcs, ske->prop->hash, auth->data,
 556                                auth->len, auth_data, auth_data_len)) {
 557     silc_buffer_free(auth);
 558     return TRUE;
 559   }
 560
 561   silc_buffer_free(auth);
 562   return FALSE;
 563 }
 564
 565 /* Continues the connection authentication protocol. This funtion may
 566    be called directly or used as SilcAskPassphrase callback. */
 567
 568 static void
 569 silc_client_conn_auth_continue(unsigned char *auth_data,
 570                                SilcUInt32 auth_data_len, void *context)
 571 {
 572   SilcProtocol protocol = (SilcProtocol)context;
 573   SilcClientConnAuthInternalContext *ctx =
 574     (SilcClientConnAuthInternalContext *)protocol->context;
 575   SilcClient client = (SilcClient)ctx->client;
 576   SilcBuffer packet;
 577   int payload_len = 0;
 578   unsigned char *autf8 = NULL;
 579
 580   SILC_LOG_DEBUG(("Sending authentication to server"));
 581
 582   /* Passphrase must be UTF-8 encoded, if it isn't encode it */
 583   if (ctx->auth_meth == SILC_AUTH_PASSWORD &&
 584       !silc_utf8_valid(auth_data, auth_data_len)) {
 585     payload_len = silc_utf8_encoded_len(auth_data, auth_data_len,
 586                                         SILC_STRING_ASCII);
 587     autf8 = silc_calloc(payload_len, sizeof(*autf8));
 588     auth_data_len = silc_utf8_encode(auth_data, auth_data_len,
 589                                      SILC_STRING_ASCII, autf8, payload_len);
 590     auth_data = autf8;
 591   }
 592
 593   payload_len = 4 + auth_data_len;
 594   packet = silc_buffer_alloc(payload_len);
 595   silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
 596   silc_buffer_format(packet,
 597                      SILC_STR_UI_SHORT(payload_len),
 598                      SILC_STR_UI_SHORT(SILC_SOCKET_TYPE_CLIENT),
 599                      SILC_STR_UI_XNSTRING(auth_data, auth_data_len),
 600                      SILC_STR_END);
 601
 602   /* Send the packet to server */
 603   silc_client_packet_send(client, ctx->sock,
 604                           SILC_PACKET_CONNECTION_AUTH,
 605                           NULL, 0, NULL, NULL,
 606                           packet->data, packet->len, TRUE);
 607   silc_buffer_free(packet);
 608   silc_free(autf8);
 609
 610   /* Next state is end of protocol */
 611   protocol->state = SILC_PROTOCOL_STATE_END;
 612 }
 613
 614 SILC_TASK_CALLBACK(silc_client_protocol_connection_auth)
 615 {
 616   SilcProtocol protocol = (SilcProtocol)context;
 617   SilcClientConnAuthInternalContext *ctx =
 618     (SilcClientConnAuthInternalContext *)protocol->context;
 619   SilcClient client = (SilcClient)ctx->client;
 620   SilcClientConnection conn = ctx->sock->user_data;
 621
 622   SILC_LOG_DEBUG(("Start"));
 623
 624   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 625     protocol->state = SILC_PROTOCOL_STATE_START;
 626
 627   switch(protocol->state) {
 628   case SILC_PROTOCOL_STATE_START:
 629     {
 630       /*
 631        * Start protocol. We send authentication data to the server
 632        * to be authenticated.
 633        */
 634       unsigned char *auth_data = NULL;
 635       SilcUInt32 auth_data_len = 0;
 636       unsigned char sign[1024];
 637
 638       switch(ctx->auth_meth) {
 639       case SILC_AUTH_NONE:
 640         /* No authentication required */
 641         break;
 642
 643       case SILC_AUTH_PASSWORD:
 644         /* Password authentication */
 645         if (ctx->auth_data && ctx->auth_data_len) {
 646           auth_data = ctx->auth_data;
 647           auth_data_len = ctx->auth_data_len;
 648           break;
 649         }
 650
 651         client->internal->ops->say(
 652                         client, conn, SILC_CLIENT_MESSAGE_INFO,
 653                         "Password authentication required by server %s",
 654                         ctx->sock->hostname);
 655         client->internal->ops->ask_passphrase(client, conn,
 656                                               silc_client_conn_auth_continue,
 657                                               protocol);
 658         return;
 659         break;
 660
 661       case SILC_AUTH_PUBLIC_KEY:
 662         if (!ctx->auth_data) {
 663           /* Public key authentication */
 664           silc_client_get_public_key_auth(client, conn, sign, &auth_data_len,
 665                                           ctx->ske);
 666           auth_data = sign;
 667         } else {
 668           auth_data = ctx->auth_data;
 669           auth_data_len = ctx->auth_data_len;
 670         }
 671
 672         break;
 673       }
 674
 675       silc_client_conn_auth_continue(auth_data,
 676                                      auth_data_len, protocol);
 677     }
 678     break;
 679
 680   case SILC_PROTOCOL_STATE_END:
 681     {
 682       /*
 683        * End protocol. Nothing special to be done here.
 684        */
 685
 686       /* Protocol has ended, call the final callback */
 687       if (protocol->final_callback)
 688         silc_protocol_execute_final(protocol, client->schedule);
 689       else
 690         silc_protocol_free(protocol);
 691     }
 692     break;
 693
 694   case SILC_PROTOCOL_STATE_ERROR:
 695     {
 696       /*
 697        * Error. Send notify to remote.
 698        */
 699       unsigned char error[4];
 700
 701       SILC_PUT32_MSB(SILC_AUTH_FAILED, error);
 702
 703       /* Error in protocol. Send FAILURE packet. Although I don't think
 704          this could ever happen on client side. */
 705       silc_client_packet_send(client, ctx->sock, SILC_PACKET_FAILURE,
 706                               NULL, 0, NULL, NULL, error, 4, TRUE);
 707
 708       /* On error the final callback is always called. */
 709       if (protocol->final_callback)
 710         silc_protocol_execute_final(protocol, client->schedule);
 711       else
 712         silc_protocol_free(protocol);
 713     }
 714
 715   case SILC_PROTOCOL_STATE_FAILURE:
 716     /*
 717      * Received failure from remote.
 718      */
 719
 720     /* On error the final callback is always called. */
 721     if (protocol->final_callback)
 722       silc_protocol_execute_final(protocol, client->schedule);
 723     else
 724       silc_protocol_free(protocol);
 725     break;
 726
 727   case SILC_PROTOCOL_STATE_UNKNOWN:
 728     break;
 729   }
 730 }
 731
 732 /*
 733  * Re-key protocol routines
 734  */
 735
 736 /* Actually takes the new keys into use. */
 737
 738 static void
 739 silc_client_protocol_rekey_validate(SilcClient client,
 740                                     SilcClientRekeyInternalContext *ctx,
 741                                     SilcSocketConnection sock,
 742                                     SilcSKEKeyMaterial *keymat,
 743                                     bool send)
 744 {
 745   SilcClientConnection conn = (SilcClientConnection)sock->user_data;
 746
 747   if (ctx->responder == TRUE) {
 748     if (send) {
 749       silc_cipher_set_key(conn->internal->send_key, keymat->receive_enc_key,
 750                           keymat->enc_key_len);
 751       silc_cipher_set_iv(conn->internal->send_key, keymat->receive_iv);
 752       silc_hmac_set_key(conn->internal->hmac_send, keymat->receive_hmac_key,
 753                         keymat->hmac_key_len);
 754     } else {
 755       silc_cipher_set_key(conn->internal->receive_key, keymat->send_enc_key,
 756                           keymat->enc_key_len);
 757       silc_cipher_set_iv(conn->internal->receive_key, keymat->send_iv);
 758       silc_hmac_set_key(conn->internal->hmac_receive, keymat->send_hmac_key,
 759                         keymat->hmac_key_len);
 760     }
 761   } else {
 762     if (send) {
 763       silc_cipher_set_key(conn->internal->send_key, keymat->send_enc_key,
 764                           keymat->enc_key_len);
 765       silc_cipher_set_iv(conn->internal->send_key, keymat->send_iv);
 766       silc_hmac_set_key(conn->internal->hmac_send, keymat->send_hmac_key,
 767                         keymat->hmac_key_len);
 768     } else {
 769       silc_cipher_set_key(conn->internal->receive_key,
 770                           keymat->receive_enc_key, keymat->enc_key_len);
 771       silc_cipher_set_iv(conn->internal->receive_key, keymat->receive_iv);
 772       silc_hmac_set_key(conn->internal->hmac_receive,
 773                         keymat->receive_hmac_key, keymat->hmac_key_len);
 774     }
 775   }
 776
 777   /* Save the current sending encryption key */
 778   if (!send) {
 779     memset(conn->internal->rekey->send_enc_key, 0,
 780            conn->internal->rekey->enc_key_len);
 781     silc_free(conn->internal->rekey->send_enc_key);
 782     conn->internal->rekey->send_enc_key = silc_memdup(keymat->send_enc_key,
 783                                                       keymat->enc_key_len / 8);
 784     conn->internal->rekey->enc_key_len = keymat->enc_key_len / 8;
 785   }
 786 }
 787
 788 /* This function actually re-generates (when not using PFS) the keys and
 789    takes them into use. */
 790
 791 static void
 792 silc_client_protocol_rekey_generate(SilcClient client,
 793                                     SilcClientRekeyInternalContext *ctx,
 794                                     bool send)
 795 {
 796   SilcClientConnection conn = (SilcClientConnection)ctx->sock->user_data;
 797   SilcSKEKeyMaterial *keymat;
 798   SilcUInt32 key_len = silc_cipher_get_key_len(conn->internal->send_key);
 799   SilcUInt32 hash_len = silc_hash_len(conn->internal->hash);
 800
 801   SILC_LOG_DEBUG(("Generating new %s session keys (no PFS)",
 802                   send ? "sending" : "receiving"));
 803
 804   /* Generate the new key */
 805   keymat = silc_calloc(1, sizeof(*keymat));
 806   silc_ske_process_key_material_data(conn->internal->rekey->send_enc_key,
 807                                      conn->internal->rekey->enc_key_len,
 808                                      16, key_len, hash_len,
 809                                      conn->internal->hash, keymat);
 810
 811   /* Set the keys into use */
 812   silc_client_protocol_rekey_validate(client, ctx, ctx->sock, keymat, send);
 813
 814   silc_ske_free_key_material(keymat);
 815 }
 816
 817 /* This function actually re-generates (with PFS) the keys and
 818    takes them into use. */
 819
 820 static void
 821 silc_client_protocol_rekey_generate_pfs(SilcClient client,
 822                                         SilcClientRekeyInternalContext *ctx,
 823                                         bool send)
 824 {
 825   SilcClientConnection conn = (SilcClientConnection)ctx->sock->user_data;
 826   SilcSKEKeyMaterial *keymat;
 827   SilcUInt32 key_len = silc_cipher_get_key_len(conn->internal->send_key);
 828   SilcUInt32 hash_len = silc_hash_len(conn->internal->hash);
 829   unsigned char *tmpbuf;
 830   SilcUInt32 klen;
 831
 832   SILC_LOG_DEBUG(("Generating new %s session keys (with PFS)",
 833                   send ? "sending" : "receiving"));
 834
 835   /* Encode KEY to binary data */
 836   tmpbuf = silc_mp_mp2bin(ctx->ske->KEY, 0, &klen);
 837
 838   /* Generate the new key */
 839   keymat = silc_calloc(1, sizeof(*keymat));
 840   silc_ske_process_key_material_data(tmpbuf, klen, 16, key_len, hash_len,
 841                                      conn->internal->hash, keymat);
 842
 843   /* Set the keys into use */
 844   silc_client_protocol_rekey_validate(client, ctx, ctx->sock, keymat, send);
 845
 846   memset(tmpbuf, 0, klen);
 847   silc_free(tmpbuf);
 848   silc_ske_free_key_material(keymat);
 849 }
 850
 851 /* Packet sending callback. This function is provided as packet sending
 852    routine to the Key Exchange functions. */
 853
 854 static void
 855 silc_client_protocol_rekey_send_packet(SilcSKE ske,
 856                                        SilcBuffer packet,
 857                                        SilcPacketType type,
 858                                        void *context)
 859 {
 860   SilcProtocol protocol = (SilcProtocol)context;
 861   SilcClientRekeyInternalContext *ctx =
 862     (SilcClientRekeyInternalContext *)protocol->context;
 863   SilcClient client = (SilcClient)ctx->client;
 864
 865   /* Send the packet immediately */
 866   silc_client_packet_send(client, ctx->sock, type, NULL, 0, NULL, NULL,
 867                           packet->data, packet->len, FALSE);
 868 }
 869
 870 /* Performs re-key as defined in the SILC protocol specification. */
 871
 872 SILC_TASK_CALLBACK(silc_client_protocol_rekey)
 873 {
 874   SilcProtocol protocol = (SilcProtocol)context;
 875   SilcClientRekeyInternalContext *ctx =
 876     (SilcClientRekeyInternalContext *)protocol->context;
 877   SilcClient client = (SilcClient)ctx->client;
 878   SilcClientConnection conn = (SilcClientConnection)ctx->sock->user_data;
 879   SilcSKEStatus status;
 880
 881   SILC_LOG_DEBUG(("Start"));
 882
 883   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 884     protocol->state = SILC_PROTOCOL_STATE_START;
 885
 886   SILC_LOG_DEBUG(("State=%d", protocol->state));
 887
 888   switch(protocol->state) {
 889   case SILC_PROTOCOL_STATE_START:
 890     {
 891       /*
 892        * Start protocol.
 893        */
 894
 895       if (ctx->responder == TRUE) {
 896         /*
 897          * We are receiving party
 898          */
 899
 900         if (ctx->pfs == TRUE) {
 901           /*
 902            * Use Perfect Forward Secrecy, ie. negotiate the key material
 903            * using the SKE protocol.
 904            */
 905
 906           if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_1) {
 907             /* Error in protocol */
 908             protocol->state = SILC_PROTOCOL_STATE_ERROR;
 909             silc_protocol_execute(protocol, client->schedule, 0, 300000);
 910           }
 911
 912           ctx->ske = silc_ske_alloc(client->rng, client);
 913           ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
 914           silc_ske_group_get_by_number(conn->internal->rekey->ske_group,
 915                                        &ctx->ske->prop->group);
 916
 917           silc_ske_set_callbacks(ctx->ske,
 918                                  silc_client_protocol_rekey_send_packet,
 919                                  NULL,  NULL, NULL, silc_ske_check_version,
 920                                  context);
 921
 922           status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer);
 923           if (status != SILC_SKE_STATUS_OK) {
 924             SILC_LOG_WARNING(("Error (type %d) during Re-key (PFS)",
 925                               status));
 926
 927             protocol->state = SILC_PROTOCOL_STATE_ERROR;
 928             silc_protocol_execute(protocol, client->schedule, 0, 300000);
 929             return;
 930           }
 931
 932           /* Advance the protocol state */
 933           protocol->state++;
 934           silc_protocol_execute(protocol, client->schedule, 0, 0);
 935         } else {
 936           /*
 937            * Do normal and simple re-key.
 938            */
 939
 940           /* Send the REKEY_DONE to indicate we will take new keys into use */
 941           silc_client_packet_send(client, ctx->sock,
 942                                   SILC_PACKET_REKEY_DONE,
 943                                   NULL, 0, NULL, NULL, NULL, 0, FALSE);
 944
 945           /* After we send REKEY_DONE we must set the sending encryption
 946              key to the new key since all packets after this packet must
 947              encrypted with the new key. */
 948           silc_client_protocol_rekey_generate(client, ctx, TRUE);
 949
 950           /* The protocol ends in next stage. */
 951           protocol->state = SILC_PROTOCOL_STATE_END;
 952         }
 953
 954       } else {
 955         /*
 956          * We are the initiator of this protocol
 957          */
 958
 959         /* Start the re-key by sending the REKEY packet */
 960         silc_client_packet_send(client, ctx->sock, SILC_PACKET_REKEY,
 961                                 NULL, 0, NULL, NULL, NULL, 0, FALSE);
 962
 963         if (ctx->pfs == TRUE) {
 964           /*
 965            * Use Perfect Forward Secrecy, ie. negotiate the key material
 966            * using the SKE protocol.
 967            */
 968           ctx->ske = silc_ske_alloc(client->rng, client);
 969           ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
 970           silc_ske_group_get_by_number(conn->internal->rekey->ske_group,
 971                                        &ctx->ske->prop->group);
 972
 973           silc_ske_set_callbacks(ctx->ske,
 974                                  silc_client_protocol_rekey_send_packet,
 975                                  NULL,  NULL, NULL, silc_ske_check_version,
 976                                  context);
 977
 978           status =  silc_ske_initiator_phase_2(ctx->ske, NULL, NULL, 0);
 979           if (status != SILC_SKE_STATUS_OK) {
 980             SILC_LOG_WARNING(("Error (type %d) during Re-key (PFS)",
 981                               status));
 982
 983             protocol->state = SILC_PROTOCOL_STATE_ERROR;
 984             silc_protocol_execute(protocol, client->schedule, 0, 300000);
 985             return;
 986           }
 987
 988           /* Advance the protocol state */
 989           protocol->state++;
 990         } else {
 991           /*
 992            * Do normal and simple re-key.
 993            */
 994
 995           /* Send the REKEY_DONE to indicate we will take new keys into use
 996              now. */
 997           silc_client_packet_send(client, ctx->sock,
 998                                   SILC_PACKET_REKEY_DONE,
 999                                   NULL, 0, NULL, NULL, NULL, 0, FALSE);
1000
1001           /* After we send REKEY_DONE we must set the sending encryption
1002              key to the new key since all packets after this packet must
1003              encrypted with the new key. */
1004           silc_client_protocol_rekey_generate(client, ctx, TRUE);
1005
1006           /* The protocol ends in next stage. */
1007           protocol->state = SILC_PROTOCOL_STATE_END;
1008         }
1009       }
1010     }
1011     break;
1012
1013   case 2:
1014     /*
1015      * Second state, used only when oding re-key with PFS.
1016      */
1017     if (ctx->responder == TRUE) {
1018       if (ctx->pfs == TRUE) {
1019         /*
1020          * Send our KE packe to the initiator now that we've processed
1021          * the initiator's KE packet.
1022          */
1023         status = silc_ske_responder_finish(ctx->ske, NULL, NULL,
1024                                            SILC_SKE_PK_TYPE_SILC);
1025
1026           if (status != SILC_SKE_STATUS_OK) {
1027             SILC_LOG_WARNING(("Error (type %d) during Re-key (PFS)",
1028                               status));
1029
1030             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1031             silc_protocol_execute(protocol, client->schedule, 0, 300000);
1032             return;
1033           }
1034       }
1035
1036     } else {
1037       if (ctx->pfs == TRUE) {
1038         /*
1039          * The packet type must be KE packet
1040          */
1041         if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_2) {
1042           /* Error in protocol */
1043           protocol->state = SILC_PROTOCOL_STATE_ERROR;
1044           silc_protocol_execute(protocol, client->schedule, 0, 300000);
1045         }
1046
1047         status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer);
1048         if (status != SILC_SKE_STATUS_OK) {
1049           SILC_LOG_WARNING(("Error (type %d) during Re-key (PFS)",
1050                             status));
1051
1052           protocol->state = SILC_PROTOCOL_STATE_ERROR;
1053           silc_protocol_execute(protocol, client->schedule, 0, 300000);
1054           return;
1055         }
1056       }
1057     }
1058
1059     /* Send the REKEY_DONE to indicate we will take new keys into use
1060        now. */
1061     silc_client_packet_send(client, ctx->sock, SILC_PACKET_REKEY_DONE,
1062                             NULL, 0, NULL, NULL, NULL, 0, FALSE);
1063
1064     /* After we send REKEY_DONE we must set the sending encryption
1065        key to the new key since all packets after this packet must
1066        encrypted with the new key. */
1067     silc_client_protocol_rekey_generate_pfs(client, ctx, TRUE);
1068
1069     /* The protocol ends in next stage. */
1070     protocol->state = SILC_PROTOCOL_STATE_END;
1071     break;
1072
1073   case SILC_PROTOCOL_STATE_END:
1074     /*
1075      * End protocol
1076      */
1077
1078     if (ctx->packet->type != SILC_PACKET_REKEY_DONE) {
1079       /* Error in protocol */
1080       protocol->state = SILC_PROTOCOL_STATE_ERROR;
1081       silc_protocol_execute(protocol, client->schedule, 0, 0);
1082     }
1083
1084     /* We received the REKEY_DONE packet and all packets after this is
1085        encrypted with the new key so set the decryption key to the new key */
1086     if (ctx->pfs == TRUE)
1087       silc_client_protocol_rekey_generate_pfs(client, ctx, FALSE);
1088     else
1089       silc_client_protocol_rekey_generate(client, ctx, FALSE);
1090
1091     /* Protocol has ended, call the final callback */
1092     if (protocol->final_callback)
1093       silc_protocol_execute_final(protocol, client->schedule);
1094     else
1095       silc_protocol_free(protocol);
1096     break;
1097
1098   case SILC_PROTOCOL_STATE_ERROR:
1099     /*
1100      * Error occured
1101      */
1102
1103     if (ctx->pfs == TRUE) {
1104       /* Send abort notification */
1105       silc_ske_abort(ctx->ske, ctx->ske->status);
1106     }
1107
1108     /* On error the final callback is always called. */
1109     if (protocol->final_callback)
1110       silc_protocol_execute_final(protocol, client->schedule);
1111     else
1112       silc_protocol_free(protocol);
1113     break;
1114
1115   case SILC_PROTOCOL_STATE_FAILURE:
1116     /*
1117      * We have received failure from remote
1118      */
1119
1120     /* On error the final callback is always called. */
1121     if (protocol->final_callback)
1122       silc_protocol_execute_final(protocol, client->schedule);
1123     else
1124       silc_protocol_free(protocol);
1125     break;
1126
1127   case SILC_PROTOCOL_STATE_UNKNOWN:
1128     break;
1129   }
1130
1131 }
1132
1133 /* Registers protocols used in client */
1134
1135 void silc_client_protocols_register(void)
1136 {
1137   silc_protocol_register(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
1138                          silc_client_protocol_connection_auth);
1139   silc_protocol_register(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
1140                          silc_client_protocol_key_exchange);
1141   silc_protocol_register(SILC_PROTOCOL_CLIENT_REKEY,
1142                          silc_client_protocol_rekey);
1143 }
1144
1145 /* Unregisters protocols */
1146
1147 void silc_client_protocols_unregister(void)
1148 {
1149   silc_protocol_unregister(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
1150                            silc_client_protocol_connection_auth);
1151   silc_protocol_unregister(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
1152                            silc_client_protocol_key_exchange);
1153   silc_protocol_unregister(SILC_PROTOCOL_CLIENT_REKEY,
1154                            silc_client_protocol_rekey);
1155 }