apps/silcd/protocol.c

   1 /*
   2
   3   protocol.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2002 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  * Server side of the protocols.
  22  */
  23 /* $Id$ */
  24
  25 #include "serverincludes.h"
  26 #include "server_internal.h"
  27
  28 SILC_TASK_CALLBACK(silc_server_protocol_connection_auth);
  29 SILC_TASK_CALLBACK(silc_server_protocol_key_exchange);
  30 SILC_TASK_CALLBACK(silc_server_protocol_rekey);
  31
  32 extern char *silc_version_string;
  33
  34 /*
  35  * Key Exhange protocol functions
  36  */
  37
  38 static bool
  39 silc_verify_public_key_internal(SilcServer server, SilcSocketConnection sock,
  40                                 SilcSocketType conn_type,
  41                                 unsigned char *pk, SilcUInt32 pk_len,
  42                                 SilcSKEPKType pk_type)
  43 {
  44   char file[256], filename[256], *fingerprint;
  45   struct stat st;
  46
  47   if (pk_type != SILC_SKE_PK_TYPE_SILC) {
  48     SILC_LOG_WARNING(("We don't support %s (%s) port %d public key type %d",
  49                       sock->hostname, sock->ip, sock->port, pk_type));
  50     return FALSE;
  51   }
  52
  53   /* Accept client keys without verification */
  54   if (conn_type == SILC_SOCKET_TYPE_CLIENT) {
  55     SILC_LOG_DEBUG(("Accepting client public key without verification"));
  56     return TRUE;
  57   }
  58
  59   /* XXX For now, accept server keys without verification too. We are
  60      currently always doing mutual authentication so the proof of posession
  61      of the private key is verified, and if server is authenticated in
  62      conn auth protocol with public key we MUST have the key already. */
  63   return TRUE;
  64   /* Rest is unreachable code! */
  65
  66   memset(filename, 0, sizeof(filename));
  67   memset(file, 0, sizeof(file));
  68   snprintf(file, sizeof(file) - 1, "serverkey_%s_%d.pub", sock->hostname,
  69            sock->port);
  70   snprintf(filename, sizeof(filename) - 1, SILC_ETCDIR "/serverkeys/%s",
  71            file);
  72
  73   /* Create serverkeys directory if it doesn't exist. */
  74   if (stat(SILC_ETCDIR "/serverkeys", &st) < 0) {
  75     /* If dir doesn't exist */
  76     if (errno == ENOENT) {
  77       if (mkdir(SILC_ETCDIR "/serverkeys", 0755) < 0) {
  78         SILC_LOG_ERROR(("Couldn't create `%s' directory\n",
  79                         SILC_ETCDIR "/serverkeys"));
  80         return TRUE;
  81       }
  82     } else {
  83       SILC_LOG_ERROR(("%s\n", strerror(errno)));
  84       return TRUE;
  85     }
  86   }
  87
  88   /* Take fingerprint of the public key */
  89   fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
  90   SILC_LOG_DEBUG(("Received server %s (%s) port %d public key (%s)",
  91                   sock->hostname, sock->ip, sock->port, fingerprint));
  92   silc_free(fingerprint);
  93
  94   /* Check whether this key already exists */
  95   if (stat(filename, &st) < 0) {
  96     /* We don't have it, then cache it. */
  97     SILC_LOG_DEBUG(("New public key from server"));
  98
  99     silc_pkcs_save_public_key_data(filename, pk, pk_len,
 100                                    SILC_PKCS_FILE_PEM);
 101     return TRUE;
 102   } else {
 103     /* The key already exists, verify it. */
 104     SilcPublicKey public_key;
 105     unsigned char *encpk;
 106     SilcUInt32 encpk_len;
 107
 108     SILC_LOG_DEBUG(("We have the public key saved locally"));
 109
 110     /* Load the key file */
 111     if (!silc_pkcs_load_public_key(filename, &public_key,
 112                                    SILC_PKCS_FILE_PEM))
 113       if (!silc_pkcs_load_public_key(filename, &public_key,
 114                                      SILC_PKCS_FILE_BIN)) {
 115         SILC_LOG_WARNING(("Could not load local copy of the %s (%s) port %d "
 116                           "server public key", sock->hostname, sock->ip,
 117                           sock->port));
 118
 119         /* Save the key for future checking */
 120         unlink(filename);
 121         silc_pkcs_save_public_key_data(filename, pk, pk_len,
 122                                        SILC_PKCS_FILE_PEM);
 123         return TRUE;
 124       }
 125
 126     /* Encode the key data */
 127     encpk = silc_pkcs_public_key_encode(public_key, &encpk_len);
 128     if (!encpk) {
 129       SILC_LOG_WARNING(("Local copy of the server %s (%s) port %d public key "
 130                         "is malformed", sock->hostname, sock->ip, sock->port));
 131
 132       /* Save the key for future checking */
 133       unlink(filename);
 134       silc_pkcs_save_public_key_data(filename, pk, pk_len, SILC_PKCS_FILE_PEM);
 135       return TRUE;
 136     }
 137
 138     if (memcmp(pk, encpk, encpk_len)) {
 139       SILC_LOG_WARNING(("%s (%s) port %d server public key does not match "
 140                         "with local copy", sock->hostname, sock->ip,
 141                         sock->port));
 142       SILC_LOG_WARNING(("It is possible that the key has expired or changed"));
 143       SILC_LOG_WARNING(("It is also possible that some one is performing "
 144                         "man-in-the-middle attack"));
 145       SILC_LOG_WARNING(("Will not accept the server %s (%s) port %d public "
 146                         "key",
 147                         sock->hostname, sock->ip, sock->port));
 148       return FALSE;
 149     }
 150
 151     /* Local copy matched */
 152     return TRUE;
 153   }
 154 }
 155
 156 /* Callback that is called when we have received KE2 payload from
 157    responder. We try to verify the public key now. */
 158
 159 static void
 160 silc_server_protocol_ke_verify_key(SilcSKE ske,
 161                                    unsigned char *pk_data,
 162                                    SilcUInt32 pk_len,
 163                                    SilcSKEPKType pk_type,
 164                                    void *context,
 165                                    SilcSKEVerifyCbCompletion completion,
 166                                    void *completion_context)
 167 {
 168   SilcProtocol protocol = (SilcProtocol)context;
 169   SilcServerKEInternalContext *ctx =
 170     (SilcServerKEInternalContext *)protocol->context;
 171   SilcServer server = (SilcServer)ctx->server;
 172
 173   SILC_LOG_DEBUG(("Verifying received public key"));
 174
 175   if (silc_verify_public_key_internal(
 176                   server, ctx->sock,
 177                   (ctx->responder == FALSE ?
 178                    SILC_SOCKET_TYPE_ROUTER:
 179                    ctx->sconfig.ref_ptr ? SILC_SOCKET_TYPE_SERVER :
 180                    ctx->rconfig.ref_ptr ? SILC_SOCKET_TYPE_ROUTER :
 181                    SILC_SOCKET_TYPE_CLIENT),
 182                   pk_data, pk_len, pk_type))
 183     completion(ske, SILC_SKE_STATUS_OK, completion_context);
 184   else
 185     completion(ske, SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY,
 186                completion_context);
 187 }
 188
 189 /* Packet sending callback. This function is provided as packet sending
 190    routine to the Key Exchange functions. */
 191
 192 static void silc_server_protocol_ke_send_packet(SilcSKE ske,
 193                                                 SilcBuffer packet,
 194                                                 SilcPacketType type,
 195                                                 void *context)
 196 {
 197   SilcProtocol protocol = (SilcProtocol)context;
 198   SilcServerKEInternalContext *ctx =
 199     (SilcServerKEInternalContext *)protocol->context;
 200   SilcServer server = (SilcServer)ctx->server;
 201
 202   /* Send the packet immediately */
 203   silc_server_packet_send(server, ske->sock,
 204                           type, 0, packet->data, packet->len, TRUE);
 205 }
 206
 207 /* Sets the negotiated key material into use for particular connection. */
 208
 209 int silc_server_protocol_ke_set_keys(SilcServer server,
 210                                      SilcSKE ske,
 211                                      SilcSocketConnection sock,
 212                                      SilcSKEKeyMaterial *keymat,
 213                                      SilcCipher cipher,
 214                                      SilcPKCS pkcs,
 215                                      SilcHash hash,
 216                                      SilcHmac hmac,
 217                                      SilcSKEDiffieHellmanGroup group,
 218                                      bool is_responder)
 219 {
 220   SilcUnknownEntry conn_data;
 221   SilcIDListData idata;
 222
 223   SILC_LOG_DEBUG(("Setting new keys into use"));
 224
 225   conn_data = silc_calloc(1, sizeof(*conn_data));
 226   idata = (SilcIDListData)conn_data;
 227
 228   /* Allocate cipher to be used in the communication */
 229   if (!silc_cipher_alloc(cipher->cipher->name, &idata->send_key)) {
 230     silc_free(conn_data);
 231     SILC_LOG_ERROR(("Cannot allocate algorithm: %s", cipher->cipher->name));
 232     return FALSE;
 233   }
 234   if (!silc_cipher_alloc(cipher->cipher->name, &idata->receive_key)) {
 235     silc_free(conn_data);
 236     SILC_LOG_ERROR(("Cannot allocate algorithm: %s", cipher->cipher->name));
 237     return FALSE;
 238   }
 239
 240   if (!silc_hmac_alloc((char *)silc_hmac_get_name(hmac), NULL,
 241                        &idata->hmac_send)) {
 242     silc_cipher_free(idata->send_key);
 243     silc_cipher_free(idata->receive_key);
 244     silc_free(conn_data);
 245     SILC_LOG_ERROR(("Cannot allocate algorithm: %s",
 246                     silc_hmac_get_name(hmac)));
 247     return FALSE;
 248   }
 249
 250   if (!silc_hmac_alloc((char *)silc_hmac_get_name(hmac), NULL,
 251                        &idata->hmac_receive)) {
 252     silc_cipher_free(idata->send_key);
 253     silc_cipher_free(idata->receive_key);
 254     silc_hmac_free(idata->hmac_send);
 255     silc_free(conn_data);
 256     SILC_LOG_ERROR(("Cannot allocate algorithm: %s",
 257                     silc_hmac_get_name(hmac)));
 258     return FALSE;
 259   }
 260
 261   if (is_responder == TRUE) {
 262     silc_cipher_set_key(idata->send_key, keymat->receive_enc_key,
 263                         keymat->enc_key_len);
 264     silc_cipher_set_iv(idata->send_key, keymat->receive_iv);
 265     silc_cipher_set_key(idata->receive_key, keymat->send_enc_key,
 266                         keymat->enc_key_len);
 267     silc_cipher_set_iv(idata->receive_key, keymat->send_iv);
 268     silc_hmac_set_key(idata->hmac_send, keymat->receive_hmac_key,
 269                       keymat->hmac_key_len);
 270     silc_hmac_set_key(idata->hmac_receive, keymat->send_hmac_key,
 271                       keymat->hmac_key_len);
 272   } else {
 273     silc_cipher_set_key(idata->send_key, keymat->send_enc_key,
 274                         keymat->enc_key_len);
 275     silc_cipher_set_iv(idata->send_key, keymat->send_iv);
 276     silc_cipher_set_key(idata->receive_key, keymat->receive_enc_key,
 277                         keymat->enc_key_len);
 278     silc_cipher_set_iv(idata->receive_key, keymat->receive_iv);
 279     silc_hmac_set_key(idata->hmac_send, keymat->send_hmac_key,
 280                       keymat->hmac_key_len);
 281     silc_hmac_set_key(idata->hmac_receive, keymat->receive_hmac_key,
 282                       keymat->hmac_key_len);
 283   }
 284
 285   idata->rekey = silc_calloc(1, sizeof(*idata->rekey));
 286   idata->rekey->send_enc_key = silc_memdup(keymat->send_enc_key,
 287                                            keymat->enc_key_len / 8);
 288   idata->rekey->enc_key_len = keymat->enc_key_len / 8;
 289
 290   if (ske->prop->flags & SILC_SKE_SP_FLAG_PFS)
 291     idata->rekey->pfs = TRUE;
 292   idata->rekey->ske_group = silc_ske_group_get_number(group);
 293
 294   /* Save the hash */
 295   if (!silc_hash_alloc(silc_hash_get_name(hash), &idata->hash)) {
 296     silc_cipher_free(idata->send_key);
 297     silc_cipher_free(idata->receive_key);
 298     silc_hmac_free(idata->hmac_send);
 299     silc_hmac_free(idata->hmac_receive);
 300     silc_free(conn_data);
 301     SILC_LOG_ERROR(("Cannot allocate algorithm: %s",
 302                     silc_hash_get_name(hash)));
 303     return FALSE;
 304   }
 305
 306   /* Save the remote host's public key */
 307   silc_pkcs_public_key_decode(ske->ke1_payload->pk_data,
 308                               ske->ke1_payload->pk_len, &idata->public_key);
 309   if (ske->prop->flags & SILC_SKE_SP_FLAG_MUTUAL)
 310     silc_hash_make(server->sha1hash, ske->ke1_payload->pk_data,
 311                    ske->ke1_payload->pk_len, idata->fingerprint);
 312
 313   sock->user_data = (void *)conn_data;
 314
 315   SILC_LOG_INFO(("%s (%s) security properties: %s %s %s %s",
 316                  sock->hostname, sock->ip,
 317                  idata->send_key->cipher->name,
 318                  (char *)silc_hmac_get_name(idata->hmac_send),
 319                  silc_hash_get_name(idata->hash),
 320                  ske->prop->flags & SILC_SKE_SP_FLAG_PFS ? "PFS" : ""));
 321
 322   return TRUE;
 323 }
 324
 325 /* Check remote host version string */
 326
 327 SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
 328                                      SilcUInt32 len, void *context)
 329 {
 330   SilcUInt32 l_protocol_version = 0, r_protocol_version = 0;
 331
 332   SILC_LOG_INFO(("%s (%s) is version %s", ske->sock->hostname,
 333                  ske->sock->ip, version));
 334
 335   if (!silc_parse_version_string(version, &r_protocol_version, NULL, NULL,
 336                                  NULL, NULL)) {
 337     SILC_LOG_ERROR(("%s (%s) %s is not allowed/supported version",
 338                     ske->sock->hostname, ske->sock->ip, version));
 339     return SILC_SKE_STATUS_BAD_VERSION;
 340   }
 341
 342   if (!silc_parse_version_string(silc_version_string,
 343                                  &l_protocol_version, NULL, NULL,
 344                                  NULL, NULL)) {
 345     SILC_LOG_ERROR(("%s (%s) %s is not allowed/supported version",
 346                     ske->sock->hostname, ske->sock->ip, version));
 347     return SILC_SKE_STATUS_BAD_VERSION;
 348   }
 349
 350   /* If remote is too new, don't connect */
 351   if (l_protocol_version < r_protocol_version) {
 352     SILC_LOG_ERROR(("%s (%s) %s is not allowed/supported version",
 353                     ske->sock->hostname, ske->sock->ip, version));
 354     return SILC_SKE_STATUS_BAD_VERSION;
 355   }
 356
 357   ske->sock->version = r_protocol_version;
 358
 359   return SILC_SKE_STATUS_OK;
 360 }
 361
 362 /* Callback that is called by the SKE to indicate that it is safe to
 363    continue the execution of the protocol. This is used only if we are
 364    initiator.  Is given as argument to the silc_ske_initiator_finish or
 365    silc_ske_responder_phase_2 functions. This is called due to the fact
 366    that the public key verification process is asynchronous and we must
 367    not continue the protocl until the public key has been verified and
 368    this callback is called. */
 369
 370 static void silc_server_protocol_ke_continue(SilcSKE ske, void *context)
 371 {
 372   SilcProtocol protocol = (SilcProtocol)context;
 373   SilcServerKEInternalContext *ctx =
 374     (SilcServerKEInternalContext *)protocol->context;
 375   SilcServer server = (SilcServer)ctx->server;
 376
 377   if (ske->status != SILC_SKE_STATUS_OK) {
 378     SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
 379                     silc_ske_map_status(ske->status)));
 380
 381     protocol->state = SILC_PROTOCOL_STATE_ERROR;
 382     silc_protocol_execute(protocol, server->schedule, 0, 300000);
 383     return;
 384   }
 385
 386   /* Send Ok to the other end. We will end the protocol as responder
 387      sends Ok to us when we will take the new keys into use. */
 388   if (ctx->responder == FALSE) {
 389     SILC_LOG_DEBUG(("Ending key exchange protocol"));
 390     silc_ske_end(ctx->ske);
 391
 392     /* End the protocol on the next round */
 393     protocol->state = SILC_PROTOCOL_STATE_END;
 394   }
 395
 396   /* Advance protocol state and call the next state if we are responder.
 397      This happens when this callback was sent to silc_ske_responder_phase_2
 398      function. */
 399   if (ctx->responder == TRUE) {
 400     protocol->state++;
 401     silc_protocol_execute(protocol, server->schedule, 0, 100000);
 402   }
 403 }
 404
 405 /* Performs key exchange protocol. This is used for both initiator
 406    and responder key exchange. This is performed always when accepting
 407    new connection to the server. This may be called recursively. */
 408
 409 SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
 410 {
 411   SilcProtocol protocol = (SilcProtocol)context;
 412   SilcServerKEInternalContext *ctx =
 413     (SilcServerKEInternalContext *)protocol->context;
 414   SilcServer server = (SilcServer)ctx->server;
 415   SilcSKEStatus status = SILC_SKE_STATUS_OK;
 416
 417   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 418     protocol->state = SILC_PROTOCOL_STATE_START;
 419
 420   SILC_LOG_DEBUG(("Current protocol state %d", protocol->state));
 421
 422   switch(protocol->state) {
 423   case SILC_PROTOCOL_STATE_START:
 424     {
 425       /*
 426        * Start protocol
 427        */
 428       SilcSKE ske;
 429
 430       /* Allocate Key Exchange object */
 431       ctx->ske = ske = silc_ske_alloc(server->rng, server);
 432
 433       silc_ske_set_callbacks(ske, silc_server_protocol_ke_send_packet, NULL,
 434                              silc_server_protocol_ke_verify_key,
 435                              silc_server_protocol_ke_continue,
 436                              silc_ske_check_version, context);
 437
 438       if (ctx->responder == TRUE) {
 439         /* Start the key exchange by processing the received security
 440            properties packet from initiator. */
 441         SILC_LOG_DEBUG(("Process security property list (KE)"));
 442         status = silc_ske_responder_start(ske, ctx->rng, ctx->sock,
 443                                           silc_version_string,
 444                                           ctx->packet->buffer, ctx->flags);
 445       } else {
 446         SilcSKEStartPayload *start_payload;
 447
 448         SILC_LOG_DEBUG(("Send security property list (KE)"));
 449
 450         /* Assemble security properties. */
 451         silc_ske_assemble_security_properties(ske, ctx->flags,
 452                                               silc_version_string,
 453                                               &start_payload);
 454
 455         /* Start the key exchange by sending our security properties
 456            to the remote end. */
 457         status = silc_ske_initiator_start(ske, ctx->rng, ctx->sock,
 458                                           start_payload);
 459       }
 460
 461       /* Return now if the procedure is pending. */
 462       if (status == SILC_SKE_STATUS_PENDING)
 463         return;
 464
 465       if (status != SILC_SKE_STATUS_OK) {
 466         SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
 467                         silc_ske_map_status(status)));
 468
 469         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 470         silc_protocol_execute(protocol, server->schedule, 0, 300000);
 471         return;
 472       }
 473
 474       /* Advance protocol state and call the next state if we are responder */
 475       protocol->state++;
 476       if (ctx->responder == TRUE)
 477         silc_protocol_execute(protocol, server->schedule, 0, 100000);
 478     }
 479     break;
 480   case 2:
 481     {
 482       /*
 483        * Phase 1
 484        */
 485       if (ctx->responder == TRUE) {
 486         /* Sends the selected security properties to the initiator. */
 487         SILC_LOG_DEBUG(("Send security property list reply (KE)"));
 488         status = silc_ske_responder_phase_1(ctx->ske);
 489       } else {
 490         /* Call Phase-1 function. This processes the Key Exchange Start
 491            paylaod reply we just got from the responder. The callback
 492            function will receive the processed payload where we will
 493            save it. */
 494         SILC_LOG_DEBUG(("Process security property list reply (KE)"));
 495         status = silc_ske_initiator_phase_1(ctx->ske, ctx->packet->buffer);
 496       }
 497
 498       /* Return now if the procedure is pending. */
 499       if (status == SILC_SKE_STATUS_PENDING)
 500         return;
 501
 502       if (status != SILC_SKE_STATUS_OK) {
 503         SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
 504                         silc_ske_map_status(status)));
 505
 506         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 507         silc_protocol_execute(protocol, server->schedule, 0, 300000);
 508         return;
 509       }
 510
 511       /* Advance protocol state and call next state if we are initiator */
 512       protocol->state++;
 513       if (ctx->responder == FALSE)
 514         silc_protocol_execute(protocol, server->schedule, 0, 100000);
 515     }
 516     break;
 517   case 3:
 518     {
 519       /*
 520        * Phase 2
 521        */
 522       if (ctx->responder == TRUE) {
 523         /* Process the received Key Exchange 1 Payload packet from
 524            the initiator. This also creates our parts of the Diffie
 525            Hellman algorithm. The silc_server_protocol_ke_continue
 526            will be called after the public key has been verified. */
 527         SILC_LOG_DEBUG(("Process KE1 packet"));
 528         status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer);
 529       } else {
 530         /* Call the Phase-2 function. This creates Diffie Hellman
 531            key exchange parameters and sends our public part inside
 532            Key Exhange 1 Payload to the responder. */
 533         SILC_LOG_DEBUG(("Send KE1 packet"));
 534         status = silc_ske_initiator_phase_2(ctx->ske,
 535                                             server->public_key,
 536                                             server->private_key,
 537                                             SILC_SKE_PK_TYPE_SILC);
 538         protocol->state++;
 539       }
 540
 541       /* Return now if the procedure is pending. */
 542       if (status == SILC_SKE_STATUS_PENDING)
 543         return;
 544
 545       if (status != SILC_SKE_STATUS_OK) {
 546         SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
 547                         silc_ske_map_status(status)));
 548
 549         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 550         silc_protocol_execute(protocol, server->schedule, 0, 300000);
 551         return;
 552       }
 553     }
 554     break;
 555   case 4:
 556     {
 557       /*
 558        * Finish protocol
 559        */
 560       if (ctx->responder == TRUE) {
 561         /* This creates the key exchange material and sends our
 562            public parts to the initiator inside Key Exchange 2 Payload. */
 563         SILC_LOG_DEBUG(("Process KE2 packet"));
 564         status = silc_ske_responder_finish(ctx->ske,
 565                                            server->public_key,
 566                                            server->private_key,
 567                                            SILC_SKE_PK_TYPE_SILC);
 568
 569         /* End the protocol on the next round */
 570         protocol->state = SILC_PROTOCOL_STATE_END;
 571       } else {
 572         /* Finish the protocol. This verifies the Key Exchange 2 payload
 573            sent by responder. The silc_server_protocol_ke_continue will
 574            be called after the public key has been verified. */
 575         SILC_LOG_DEBUG(("Send KE2 packet"));
 576         status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer);
 577       }
 578
 579       /* Return now if the procedure is pending. */
 580       if (status == SILC_SKE_STATUS_PENDING)
 581         return;
 582
 583       if (status != SILC_SKE_STATUS_OK) {
 584         SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
 585                         silc_ske_map_status(status)));
 586
 587         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 588         silc_protocol_execute(protocol, server->schedule, 0, 300000);
 589         return;
 590       }
 591     }
 592     break;
 593
 594   case SILC_PROTOCOL_STATE_END:
 595     {
 596       /*
 597        * End protocol
 598        */
 599       SilcSKEKeyMaterial *keymat;
 600       int key_len = silc_cipher_get_key_len(ctx->ske->prop->cipher);
 601       int hash_len = silc_hash_len(ctx->ske->prop->hash);
 602
 603       SILC_LOG_DEBUG(("Process computed key material"));
 604
 605       /* Process the key material */
 606       keymat = silc_calloc(1, sizeof(*keymat));
 607       status = silc_ske_process_key_material(ctx->ske, 16, key_len, hash_len,
 608                                              keymat);
 609       if (status != SILC_SKE_STATUS_OK) {
 610         SILC_LOG_ERROR(("Error during Key Exchange protocol: "
 611                         "could not process key material"));
 612
 613         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 614         silc_protocol_execute(protocol, server->schedule, 0, 300000);
 615         silc_ske_free_key_material(keymat);
 616         return;
 617       }
 618       ctx->keymat = keymat;
 619
 620       /* Send Ok to the other end if we are responder. If we are initiator
 621          we have sent this already. */
 622       if (ctx->responder == TRUE) {
 623         SILC_LOG_DEBUG(("Ending key exchange protocol"));
 624         silc_ske_end(ctx->ske);
 625       }
 626
 627       /* Unregister the timeout task since the protocol has ended.
 628          This was the timeout task to be executed if the protocol is
 629          not completed fast enough. */
 630       if (ctx->timeout_task)
 631         silc_schedule_task_del(server->schedule, ctx->timeout_task);
 632
 633       /* Assure that after calling final callback there cannot be pending
 634          executions for this protocol anymore. This just unregisters any
 635          timeout callbacks for this protocol. */
 636       silc_protocol_cancel(protocol, server->schedule);
 637
 638       /* Call the final callback */
 639       if (protocol->final_callback)
 640         silc_protocol_execute_final(protocol, server->schedule);
 641       else
 642         silc_protocol_free(protocol);
 643     }
 644     break;
 645
 646   case SILC_PROTOCOL_STATE_ERROR:
 647     /*
 648      * Error occured
 649      */
 650
 651     /* Send abort notification */
 652     silc_ske_abort(ctx->ske, ctx->ske->status);
 653
 654     /* Unregister the timeout task since the protocol has ended.
 655        This was the timeout task to be executed if the protocol is
 656        not completed fast enough. */
 657     if (ctx->timeout_task)
 658       silc_schedule_task_del(server->schedule, ctx->timeout_task);
 659
 660     /* Assure that after calling final callback there cannot be pending
 661        executions for this protocol anymore. This just unregisters any
 662        timeout callbacks for this protocol. */
 663     silc_protocol_cancel(protocol, server->schedule);
 664
 665     /* On error the final callback is always called. */
 666     if (protocol->final_callback)
 667       silc_protocol_execute_final(protocol, server->schedule);
 668     else
 669       silc_protocol_free(protocol);
 670     break;
 671
 672   case SILC_PROTOCOL_STATE_FAILURE:
 673     /*
 674      * We have received failure from remote
 675      */
 676
 677     /* Unregister the timeout task since the protocol has ended.
 678        This was the timeout task to be executed if the protocol is
 679        not completed fast enough. */
 680     if (ctx->timeout_task)
 681       silc_schedule_task_del(server->schedule, ctx->timeout_task);
 682
 683     /* Assure that after calling final callback there cannot be pending
 684        executions for this protocol anymore. This just unregisters any
 685        timeout callbacks for this protocol. */
 686     silc_protocol_cancel(protocol, server->schedule);
 687
 688     /* On error the final callback is always called. */
 689     if (protocol->final_callback)
 690       silc_protocol_execute_final(protocol, server->schedule);
 691     else
 692       silc_protocol_free(protocol);
 693     break;
 694
 695   case SILC_PROTOCOL_STATE_UNKNOWN:
 696     break;
 697   }
 698 }
 699
 700 /*
 701  * Connection Authentication protocol functions
 702  */
 703
 704 static int
 705 silc_server_password_authentication(SilcServer server, char *local_auth,
 706                                     char *remote_auth)
 707 {
 708   if (!remote_auth || !local_auth || strlen(local_auth) != strlen(remote_auth))
 709     return FALSE;
 710
 711   if (!memcmp(remote_auth, local_auth, strlen(local_auth)))
 712     return TRUE;
 713
 714   return FALSE;
 715 }
 716
 717 static int
 718 silc_server_public_key_authentication(SilcServer server,
 719                                       SilcPublicKey pub_key,
 720                                       unsigned char *sign,
 721                                       SilcUInt32 sign_len,
 722                                       SilcSKE ske)
 723 {
 724   SilcPKCS pkcs;
 725   int len;
 726   SilcBuffer auth;
 727
 728   if (!pub_key || !sign)
 729     return FALSE;
 730
 731   silc_pkcs_alloc(pub_key->name, &pkcs);
 732   if (!silc_pkcs_public_key_set(pkcs, pub_key)) {
 733     silc_pkcs_free(pkcs);
 734     return FALSE;
 735   }
 736
 737   /* Make the authentication data. Protocol says it is HASH plus
 738      KE Start Payload. */
 739   len = ske->hash_len + ske->start_payload_copy->len;
 740   auth = silc_buffer_alloc(len);
 741   silc_buffer_pull_tail(auth, len);
 742   silc_buffer_format(auth,
 743                      SILC_STR_UI_XNSTRING(ske->hash, ske->hash_len),
 744                      SILC_STR_UI_XNSTRING(ske->start_payload_copy->data,
 745                                           ske->start_payload_copy->len),
 746                      SILC_STR_END);
 747
 748   /* Verify signature */
 749   if (silc_pkcs_verify_with_hash(pkcs, ske->prop->hash, sign, sign_len,
 750                                  auth->data, auth->len)) {
 751     silc_pkcs_free(pkcs);
 752     silc_buffer_free(auth);
 753     return TRUE;
 754   }
 755
 756   silc_pkcs_free(pkcs);
 757   silc_buffer_free(auth);
 758   return FALSE;
 759 }
 760
 761 static int
 762 silc_server_get_public_key_auth(SilcServer server,
 763                                 unsigned char **auth_data,
 764                                 SilcUInt32 *auth_data_len,
 765                                 SilcSKE ske)
 766 {
 767   int len;
 768   SilcPKCS pkcs;
 769   SilcBuffer auth;
 770
 771   pkcs = server->pkcs;
 772
 773   /* Make the authentication data. Protocol says it is HASH plus
 774      KE Start Payload. */
 775   len = ske->hash_len + ske->start_payload_copy->len;
 776   auth = silc_buffer_alloc(len);
 777   silc_buffer_pull_tail(auth, len);
 778   silc_buffer_format(auth,
 779                      SILC_STR_UI_XNSTRING(ske->hash, ske->hash_len),
 780                      SILC_STR_UI_XNSTRING(ske->start_payload_copy->data,
 781                                           ske->start_payload_copy->len),
 782                      SILC_STR_END);
 783
 784   *auth_data = silc_calloc(silc_pkcs_get_key_len(pkcs), sizeof(**auth_data));
 785   if (silc_pkcs_sign_with_hash(pkcs, ske->prop->hash, auth->data,
 786                                auth->len, *auth_data, auth_data_len)) {
 787     silc_buffer_free(auth);
 788     return TRUE;
 789   }
 790
 791   SILC_LOG_ERROR(("Error computing signature"));
 792
 793   silc_free(*auth_data);
 794   silc_buffer_free(auth);
 795   return FALSE;
 796 }
 797
 798 /* Function that actually performs the authentication to the remote. This
 799    supports both passphrase and public key authentication. */
 800
 801 static bool
 802 silc_server_get_authentication(SilcServerConnAuthInternalContext *ctx,
 803                                char *local_passphrase,
 804                                SilcHashTable local_publickeys,
 805                                unsigned char *remote_auth,
 806                                SilcUInt32 remote_auth_len)
 807 {
 808   SilcServer server = (SilcServer)ctx->server;
 809   SilcSKE ske = ctx->ske;
 810   bool result = FALSE;
 811
 812   /* If we don't have authentication data set at all we do not require
 813      authentication at all */
 814   if (!local_passphrase && (!local_publickeys ||
 815                             !silc_hash_table_count(local_publickeys))) {
 816     SILC_LOG_DEBUG(("No authentication required"));
 817     return TRUE;
 818   }
 819
 820   /* If both passphrase and public key is provided then we'll try both of
 821      them and see which one of them authenticates.  If only one of them is
 822      set, then try only that. */
 823
 824   /* Try first passphrase (as it is faster to check) */
 825   if (local_passphrase) {
 826     SILC_LOG_DEBUG(("Password authentication"));
 827     result = silc_server_password_authentication(server, local_passphrase,
 828                                                  remote_auth);
 829   }
 830
 831   /* Try public key authenetication */
 832   if (!result && local_publickeys) {
 833     SilcPublicKey cached_key;
 834     SilcPublicKey remote_key =
 835       ((SilcIDListData)ctx->sock->user_data)->public_key;
 836
 837     SILC_LOG_DEBUG(("Public key authentication"));
 838
 839     /* Find the public key to be used in authentication */
 840     cached_key = silc_server_find_public_key(server, local_publickeys,
 841                                              remote_key);
 842     if (!cached_key)
 843       return FALSE;
 844
 845     result = silc_server_public_key_authentication(server, cached_key,
 846                                                    remote_auth,
 847                                                    remote_auth_len, ske);
 848   }
 849
 850   SILC_LOG_DEBUG(("Authentication %s", result ? "successful" : "failed"));
 851
 852   return result;
 853 }
 854
 855 /* Performs connection authentication protocol. If responder, we
 856    authenticate the remote data received. If initiator, we will send
 857    authentication data to the remote end. */
 858
 859 SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
 860 {
 861   SilcProtocol protocol = (SilcProtocol)context;
 862   SilcServerConnAuthInternalContext *ctx =
 863     (SilcServerConnAuthInternalContext *)protocol->context;
 864   SilcServer server = (SilcServer)ctx->server;
 865
 866   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 867     protocol->state = SILC_PROTOCOL_STATE_START;
 868
 869   SILC_LOG_DEBUG(("Current protocol state %d", protocol->state));
 870
 871   switch(protocol->state) {
 872   case SILC_PROTOCOL_STATE_START:
 873     {
 874       /*
 875        * Start protocol.
 876        */
 877
 878       if (ctx->responder == TRUE) {
 879         /*
 880          * We are receiving party
 881          */
 882         int ret;
 883         SilcUInt16 payload_len;
 884         SilcUInt16 conn_type;
 885         unsigned char *auth_data = NULL;
 886
 887         SILC_LOG_INFO(("Performing authentication protocol for %s (%s)",
 888                        ctx->sock->hostname, ctx->sock->ip));
 889
 890         /* Parse the received authentication data packet. The received
 891            payload is Connection Auth Payload. */
 892         ret = silc_buffer_unformat(ctx->packet->buffer,
 893                                    SILC_STR_UI_SHORT(&payload_len),
 894                                    SILC_STR_UI_SHORT(&conn_type),
 895                                    SILC_STR_END);
 896         if (ret == -1) {
 897           SILC_LOG_ERROR(("Bad payload in authentication packet"));
 898           protocol->state = SILC_PROTOCOL_STATE_ERROR;
 899           silc_protocol_execute(protocol, server->schedule, 0, 300000);
 900           return;
 901         }
 902
 903         if (payload_len != ctx->packet->buffer->len) {
 904           SILC_LOG_ERROR(("Bad payload length in authentication packet"));
 905           protocol->state = SILC_PROTOCOL_STATE_ERROR;
 906           silc_protocol_execute(protocol, server->schedule, 0, 300000);
 907           return;
 908         }
 909
 910         payload_len -= 4;
 911
 912         if (conn_type < SILC_SOCKET_TYPE_CLIENT ||
 913             conn_type > SILC_SOCKET_TYPE_ROUTER) {
 914           SILC_LOG_ERROR(("Bad connection type (%d) in authentication packet",
 915                           conn_type));
 916           protocol->state = SILC_PROTOCOL_STATE_ERROR;
 917           silc_protocol_execute(protocol, server->schedule, 0, 300000);
 918           return;
 919         }
 920
 921         if (payload_len > 0) {
 922           /* Get authentication data */
 923           silc_buffer_pull(ctx->packet->buffer, 4);
 924           ret = silc_buffer_unformat(ctx->packet->buffer,
 925                                      SILC_STR_UI_XNSTRING_ALLOC(&auth_data,
 926                                                                 payload_len),
 927                                      SILC_STR_END);
 928           if (ret == -1) {
 929             SILC_LOG_DEBUG(("Bad payload in authentication payload"));
 930             protocol->state = SILC_PROTOCOL_STATE_ERROR;
 931             silc_protocol_execute(protocol, server->schedule, 0, 300000);
 932             return;
 933           }
 934         }
 935
 936         /*
 937          * Check the remote connection type and make sure that we have
 938          * configured this connection. If we haven't allowed this connection
 939          * the authentication must be failed.
 940          */
 941
 942         SILC_LOG_DEBUG(("Remote connection type %d", conn_type));
 943
 944         /* Remote end is client */
 945         if (conn_type == SILC_SOCKET_TYPE_CLIENT) {
 946           SilcServerConfigClient *client = ctx->cconfig.ref_ptr;
 947
 948           if (client) {
 949             ret = silc_server_get_authentication(ctx, client->passphrase,
 950                                                  client->publickeys,
 951                                                  auth_data, payload_len);
 952             if (!ret) {
 953               /* Authentication failed */
 954               SILC_LOG_ERROR(("Authentication failed"));
 955               silc_free(auth_data);
 956               protocol->state = SILC_PROTOCOL_STATE_ERROR;
 957               silc_protocol_execute(protocol, server->schedule, 0, 300000);
 958               return;
 959             }
 960           } else {
 961             SILC_LOG_ERROR(("Remote client connection not configured"));
 962             SILC_LOG_ERROR(("Authentication failed"));
 963             silc_free(auth_data);
 964             protocol->state = SILC_PROTOCOL_STATE_ERROR;
 965             silc_protocol_execute(protocol, server->schedule,
 966                                   0, 300000);
 967             return;
 968           }
 969         }
 970
 971         /* Remote end is server */
 972         if (conn_type == SILC_SOCKET_TYPE_SERVER) {
 973           SilcServerConfigServer *serv = ctx->sconfig.ref_ptr;
 974
 975           if (serv) {
 976             ret = silc_server_get_authentication(ctx, serv->passphrase,
 977                                                  serv->publickeys,
 978                                                  auth_data, payload_len);
 979             if (!ret) {
 980               /* Authentication failed */
 981               SILC_LOG_ERROR(("Authentication failed"));
 982               silc_free(auth_data);
 983               protocol->state = SILC_PROTOCOL_STATE_ERROR;
 984               silc_protocol_execute(protocol, server->schedule, 0, 300000);
 985               return;
 986             }
 987           } else {
 988             SILC_LOG_ERROR(("Remote server connection not configured"));
 989             SILC_LOG_ERROR(("Authentication failed"));
 990             protocol->state = SILC_PROTOCOL_STATE_ERROR;
 991             silc_protocol_execute(protocol, server->schedule,
 992                                   0, 300000);
 993             silc_free(auth_data);
 994             return;
 995           }
 996         }
 997
 998         /* Remote end is router */
 999         if (conn_type == SILC_SOCKET_TYPE_ROUTER) {
1000           SilcServerConfigRouter *serv = ctx->rconfig.ref_ptr;
1001
1002           if (serv) {
1003             ret = silc_server_get_authentication(ctx, serv->passphrase,
1004                                                  serv->publickeys,
1005                                                  auth_data, payload_len);
1006             if (!ret) {
1007               /* Authentication failed */
1008               SILC_LOG_ERROR(("Authentication failed"));
1009               silc_free(auth_data);
1010               protocol->state = SILC_PROTOCOL_STATE_ERROR;
1011               silc_protocol_execute(protocol, server->schedule, 0, 300000);
1012               return;
1013             }
1014           } else {
1015             SILC_LOG_ERROR(("Remote router connection not configured"));
1016             SILC_LOG_ERROR(("Authentication failed"));
1017             silc_free(auth_data);
1018             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1019             silc_protocol_execute(protocol, server->schedule,
1020                                   0, 300000);
1021             return;
1022           }
1023         }
1024
1025         silc_free(auth_data);
1026
1027         /* Save connection type. This is later used to create the
1028            ID for the connection. */
1029         ctx->conn_type = conn_type;
1030
1031         /* Advance protocol state. */
1032         protocol->state = SILC_PROTOCOL_STATE_END;
1033         silc_protocol_execute(protocol, server->schedule, 0, 0);
1034
1035       } else {
1036         /*
1037          * We are initiator. We are authenticating ourselves to a
1038          * remote server. We will send the authentication data to the
1039          * other end for verify.
1040          */
1041         SilcBuffer packet;
1042         int payload_len = 0;
1043         unsigned char *auth_data = NULL;
1044         SilcUInt32 auth_data_len = 0;
1045
1046         switch(ctx->auth_meth) {
1047         case SILC_AUTH_NONE:
1048           /* No authentication required */
1049           break;
1050
1051         case SILC_AUTH_PASSWORD:
1052           /* Password authentication */
1053           if (ctx->auth_data && ctx->auth_data_len) {
1054             auth_data = strdup(ctx->auth_data);
1055             auth_data_len = ctx->auth_data_len;
1056             break;
1057           }
1058           break;
1059
1060         case SILC_AUTH_PUBLIC_KEY:
1061           {
1062             /* Public key authentication */
1063             silc_server_get_public_key_auth(server, &auth_data, &auth_data_len,
1064                                             ctx->ske);
1065             break;
1066           }
1067         }
1068
1069         payload_len = 4 + auth_data_len;
1070         packet = silc_buffer_alloc(payload_len);
1071         silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1072         silc_buffer_format(packet,
1073                            SILC_STR_UI_SHORT(payload_len),
1074                            SILC_STR_UI_SHORT(server->server_type
1075                                               == SILC_SERVER ?
1076                                               SILC_SOCKET_TYPE_SERVER :
1077                                               SILC_SOCKET_TYPE_ROUTER),
1078                            SILC_STR_UI_XNSTRING(auth_data, auth_data_len),
1079                            SILC_STR_END);
1080
1081         /* Send the packet to server */
1082         silc_server_packet_send(server, ctx->sock,
1083                                 SILC_PACKET_CONNECTION_AUTH, 0,
1084                                 packet->data, packet->len, TRUE);
1085
1086         if (auth_data) {
1087           memset(auth_data, 0, auth_data_len);
1088           silc_free(auth_data);
1089         }
1090         silc_buffer_free(packet);
1091
1092         /* Next state is end of protocol */
1093         protocol->state = SILC_PROTOCOL_STATE_END;
1094       }
1095     }
1096     break;
1097
1098   case SILC_PROTOCOL_STATE_END:
1099     {
1100       /*
1101        * End protocol
1102        */
1103       unsigned char ok[4];
1104
1105       SILC_PUT32_MSB(SILC_AUTH_OK, ok);
1106
1107       /* Authentication successful */
1108       silc_server_packet_send(server, ctx->sock, SILC_PACKET_SUCCESS,
1109                               0, ok, 4, TRUE);
1110
1111       /* Unregister the timeout task since the protocol has ended.
1112          This was the timeout task to be executed if the protocol is
1113          not completed fast enough. */
1114       if (ctx->timeout_task)
1115         silc_schedule_task_del(server->schedule, ctx->timeout_task);
1116
1117       /* Assure that after calling final callback there cannot be pending
1118          executions for this protocol anymore. This just unregisters any
1119          timeout callbacks for this protocol. */
1120       silc_protocol_cancel(protocol, server->schedule);
1121
1122       /* Protocol has ended, call the final callback */
1123       if (protocol->final_callback)
1124         silc_protocol_execute_final(protocol, server->schedule);
1125       else
1126         silc_protocol_free(protocol);
1127     }
1128     break;
1129   case SILC_PROTOCOL_STATE_ERROR:
1130     {
1131       /*
1132        * Error. Send notify to remote.
1133        */
1134       unsigned char error[4];
1135
1136       /* Authentication failed */
1137       SILC_PUT32_MSB(SILC_AUTH_FAILED, error);
1138       silc_server_packet_send(server, ctx->sock, SILC_PACKET_FAILURE,
1139                               0, error, 4, TRUE);
1140
1141       /* Unregister the timeout task since the protocol has ended.
1142          This was the timeout task to be executed if the protocol is
1143          not completed fast enough. */
1144       if (ctx->timeout_task)
1145         silc_schedule_task_del(server->schedule, ctx->timeout_task);
1146
1147       /* Assure that after calling final callback there cannot be pending
1148          executions for this protocol anymore. This just unregisters any
1149          timeout callbacks for this protocol. */
1150       silc_protocol_cancel(protocol, server->schedule);
1151
1152       /* On error the final callback is always called. */
1153       if (protocol->final_callback)
1154         silc_protocol_execute_final(protocol, server->schedule);
1155       else
1156         silc_protocol_free(protocol);
1157     }
1158     break;
1159
1160   case SILC_PROTOCOL_STATE_FAILURE:
1161     /*
1162      * We have received failure from remote
1163      */
1164
1165     SILC_LOG_ERROR(("Received Authentication Failure"));
1166
1167     /* Unregister the timeout task since the protocol has ended.
1168        This was the timeout task to be executed if the protocol is
1169        not completed fast enough. */
1170     if (ctx->timeout_task)
1171       silc_schedule_task_del(server->schedule, ctx->timeout_task);
1172
1173     /* Assure that after calling final callback there cannot be pending
1174        executions for this protocol anymore. This just unregisters any
1175        timeout callbacks for this protocol. */
1176     silc_protocol_cancel(protocol, server->schedule);
1177
1178     /* On error the final callback is always called. */
1179     if (protocol->final_callback)
1180       silc_protocol_execute_final(protocol, server->schedule);
1181     else
1182       silc_protocol_free(protocol);
1183     break;
1184
1185   case SILC_PROTOCOL_STATE_UNKNOWN:
1186     break;
1187   }
1188 }
1189
1190 /*
1191  * Re-key protocol routines
1192  */
1193
1194 /* Actually takes the new keys into use. */
1195
1196 static void
1197 silc_server_protocol_rekey_validate(SilcServer server,
1198                                     SilcServerRekeyInternalContext *ctx,
1199                                     SilcIDListData idata,
1200                                     SilcSKEKeyMaterial *keymat,
1201                                     bool send)
1202 {
1203   if (ctx->responder == TRUE) {
1204     if (send) {
1205       silc_cipher_set_key(idata->send_key, keymat->receive_enc_key,
1206                           keymat->enc_key_len);
1207       silc_cipher_set_iv(idata->send_key, keymat->receive_iv);
1208       silc_hmac_set_key(idata->hmac_send, keymat->receive_hmac_key,
1209                         keymat->hmac_key_len);
1210     } else {
1211       silc_cipher_set_key(idata->receive_key, keymat->send_enc_key,
1212                           keymat->enc_key_len);
1213       silc_cipher_set_iv(idata->receive_key, keymat->send_iv);
1214       silc_hmac_set_key(idata->hmac_receive, keymat->send_hmac_key,
1215                         keymat->hmac_key_len);
1216     }
1217   } else {
1218     if (send) {
1219       silc_cipher_set_key(idata->send_key, keymat->send_enc_key,
1220                           keymat->enc_key_len);
1221       silc_cipher_set_iv(idata->send_key, keymat->send_iv);
1222       silc_hmac_set_key(idata->hmac_send, keymat->send_hmac_key,
1223                         keymat->hmac_key_len);
1224     } else {
1225       silc_cipher_set_key(idata->receive_key, keymat->receive_enc_key,
1226                           keymat->enc_key_len);
1227       silc_cipher_set_iv(idata->receive_key, keymat->receive_iv);
1228       silc_hmac_set_key(idata->hmac_receive, keymat->receive_hmac_key,
1229                         keymat->hmac_key_len);
1230     }
1231   }
1232
1233   /* Save the current sending encryption key */
1234   if (!send) {
1235     memset(idata->rekey->send_enc_key, 0, idata->rekey->enc_key_len);
1236     silc_free(idata->rekey->send_enc_key);
1237     idata->rekey->send_enc_key = silc_memdup(keymat->send_enc_key,
1238                                              keymat->enc_key_len / 8);
1239     idata->rekey->enc_key_len = keymat->enc_key_len / 8;
1240   }
1241 }
1242
1243 /* This function actually re-generates (when not using PFS) the keys and
1244    takes them into use. */
1245
1246 void silc_server_protocol_rekey_generate(SilcServer server,
1247                                          SilcServerRekeyInternalContext *ctx,
1248                                          bool send)
1249 {
1250   SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1251   SilcSKEKeyMaterial *keymat;
1252   SilcUInt32 key_len = silc_cipher_get_key_len(idata->send_key);
1253   SilcUInt32 hash_len = silc_hash_len(idata->hash);
1254
1255   SILC_LOG_DEBUG(("Generating new %s session keys (no PFS)",
1256                   send ? "sending" : "receiving"));
1257
1258   /* Generate the new key */
1259   keymat = silc_calloc(1, sizeof(*keymat));
1260   silc_ske_process_key_material_data(idata->rekey->send_enc_key,
1261                                      idata->rekey->enc_key_len,
1262                                      16, key_len, hash_len,
1263                                      idata->hash, keymat);
1264
1265   /* Set the keys into use */
1266   silc_server_protocol_rekey_validate(server, ctx, idata, keymat, send);
1267
1268   silc_ske_free_key_material(keymat);
1269 }
1270
1271 /* This function actually re-generates (with PFS) the keys and
1272    takes them into use. */
1273
1274 void
1275 silc_server_protocol_rekey_generate_pfs(SilcServer server,
1276                                         SilcServerRekeyInternalContext *ctx,
1277                                         bool send)
1278 {
1279   SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1280   SilcSKEKeyMaterial *keymat;
1281   SilcUInt32 key_len = silc_cipher_get_key_len(idata->send_key);
1282   SilcUInt32 hash_len = silc_hash_len(idata->hash);
1283   unsigned char *tmpbuf;
1284   SilcUInt32 klen;
1285
1286   SILC_LOG_DEBUG(("Generating new %s session keys (with PFS)",
1287                   send ? "sending" : "receiving"));
1288
1289   /* Encode KEY to binary data */
1290   tmpbuf = silc_mp_mp2bin(ctx->ske->KEY, 0, &klen);
1291
1292   /* Generate the new key */
1293   keymat = silc_calloc(1, sizeof(*keymat));
1294   silc_ske_process_key_material_data(tmpbuf, klen, 16, key_len, hash_len,
1295                                      idata->hash, keymat);
1296
1297   /* Set the keys into use */
1298   silc_server_protocol_rekey_validate(server, ctx, idata, keymat, send);
1299
1300   memset(tmpbuf, 0, klen);
1301   silc_free(tmpbuf);
1302   silc_ske_free_key_material(keymat);
1303 }
1304
1305 /* Packet sending callback. This function is provided as packet sending
1306    routine to the Key Exchange functions. */
1307
1308 static void
1309 silc_server_protocol_rekey_send_packet(SilcSKE ske,
1310                                        SilcBuffer packet,
1311                                        SilcPacketType type,
1312                                        void *context)
1313 {
1314   SilcProtocol protocol = (SilcProtocol)context;
1315   SilcServerRekeyInternalContext *ctx =
1316     (SilcServerRekeyInternalContext *)protocol->context;
1317   SilcServer server = (SilcServer)ctx->server;
1318
1319   /* Send the packet immediately */
1320   silc_server_packet_send(server, ctx->sock,
1321                           type, 0, packet->data, packet->len, FALSE);
1322 }
1323
1324 /* Performs re-key as defined in the SILC protocol specification. */
1325
1326 SILC_TASK_CALLBACK(silc_server_protocol_rekey)
1327 {
1328   SilcProtocol protocol = (SilcProtocol)context;
1329   SilcServerRekeyInternalContext *ctx =
1330     (SilcServerRekeyInternalContext *)protocol->context;
1331   SilcServer server = (SilcServer)ctx->server;
1332   SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1333   SilcSKEStatus status;
1334
1335   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
1336     protocol->state = SILC_PROTOCOL_STATE_START;
1337
1338   SILC_LOG_DEBUG(("Current protocol state %d", protocol->state));
1339
1340   switch(protocol->state) {
1341   case SILC_PROTOCOL_STATE_START:
1342     {
1343       /*
1344        * Start protocol.
1345        */
1346
1347       if (ctx->responder == TRUE) {
1348         /*
1349          * We are receiving party
1350          */
1351
1352         if (ctx->pfs == TRUE) {
1353           /*
1354            * Use Perfect Forward Secrecy, ie. negotiate the key material
1355            * using the SKE protocol.
1356            */
1357
1358           if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_1) {
1359             SILC_LOG_ERROR(("Error during Re-key (R PFS): re-key state is "
1360                             "incorrect (received %d, expected %d packet), "
1361                             "with %s (%s)", ctx->packet->type,
1362                             SILC_PACKET_KEY_EXCHANGE_1, ctx->sock->hostname,
1363                             ctx->sock->ip));
1364             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1365             silc_protocol_execute(protocol, server->schedule, 0, 300000);
1366             return;
1367           }
1368
1369           ctx->ske = silc_ske_alloc(server->rng, server);
1370           ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
1371           silc_ske_group_get_by_number(idata->rekey->ske_group,
1372                                        &ctx->ske->prop->group);
1373
1374           silc_ske_set_callbacks(ctx->ske,
1375                                  silc_server_protocol_rekey_send_packet,
1376                                  NULL, NULL, NULL, silc_ske_check_version,
1377                                  context);
1378
1379           status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer);
1380           if (status != SILC_SKE_STATUS_OK) {
1381             SILC_LOG_ERROR(("Error (%s) during Re-key (R PFS), with %s (%s)",
1382                             silc_ske_map_status(status), ctx->sock->hostname,
1383                             ctx->sock->ip));
1384             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1385             silc_protocol_execute(protocol, server->schedule, 0, 300000);
1386             return;
1387           }
1388
1389           /* Advance the protocol state */
1390           protocol->state++;
1391           silc_protocol_execute(protocol, server->schedule, 0, 0);
1392         } else {
1393           /*
1394            * Do normal and simple re-key.
1395            */
1396
1397           /* Send the REKEY_DONE to indicate we will take new keys into use */
1398           silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1399                                   0, NULL, 0, FALSE);
1400
1401           /* After we send REKEY_DONE we must set the sending encryption
1402              key to the new key since all packets after this packet must
1403              encrypted with the new key. */
1404           silc_server_protocol_rekey_generate(server, ctx, TRUE);
1405
1406           /* The protocol ends in next stage. */
1407           protocol->state = SILC_PROTOCOL_STATE_END;
1408         }
1409
1410       } else {
1411         /*
1412          * We are the initiator of this protocol
1413          */
1414
1415         /* Start the re-key by sending the REKEY packet */
1416         silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY,
1417                                 0, NULL, 0, FALSE);
1418
1419         if (ctx->pfs == TRUE) {
1420           /*
1421            * Use Perfect Forward Secrecy, ie. negotiate the key material
1422            * using the SKE protocol.
1423            */
1424           ctx->ske = silc_ske_alloc(server->rng, server);
1425           ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
1426           silc_ske_group_get_by_number(idata->rekey->ske_group,
1427                                        &ctx->ske->prop->group);
1428
1429           silc_ske_set_callbacks(ctx->ske,
1430                                  silc_server_protocol_rekey_send_packet,
1431                                  NULL, NULL, NULL, silc_ske_check_version,
1432                                  context);
1433
1434           status = silc_ske_initiator_phase_2(ctx->ske, NULL, NULL, 0);
1435           if (status != SILC_SKE_STATUS_OK) {
1436             SILC_LOG_ERROR(("Error (%s) during Re-key (I PFS), with %s (%s)",
1437                             silc_ske_map_status(status), ctx->sock->hostname,
1438                             ctx->sock->ip));
1439             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1440             silc_protocol_execute(protocol, server->schedule, 0, 300000);
1441             return;
1442           }
1443
1444           /* Advance the protocol state */
1445           protocol->state++;
1446         } else {
1447           /*
1448            * Do normal and simple re-key.
1449            */
1450
1451           /* Send the REKEY_DONE to indicate we will take new keys into use
1452              now. */
1453           silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1454                                   0, NULL, 0, FALSE);
1455
1456           /* After we send REKEY_DONE we must set the sending encryption
1457              key to the new key since all packets after this packet must
1458              encrypted with the new key. */
1459           silc_server_protocol_rekey_generate(server, ctx, TRUE);
1460
1461           /* The protocol ends in next stage. */
1462           protocol->state = SILC_PROTOCOL_STATE_END;
1463         }
1464       }
1465     }
1466     break;
1467
1468   case 2:
1469     /*
1470      * Second state, used only when oding re-key with PFS.
1471      */
1472     if (ctx->responder == TRUE) {
1473       if (ctx->pfs == TRUE) {
1474         /*
1475          * Send our KE packe to the initiator now that we've processed
1476          * the initiator's KE packet.
1477          */
1478         status = silc_ske_responder_finish(ctx->ske, NULL, NULL,
1479                                            SILC_SKE_PK_TYPE_SILC);
1480         if (status != SILC_SKE_STATUS_OK) {
1481           SILC_LOG_ERROR(("Error (%s) during Re-key (R PFS), with %s (%s)",
1482                           silc_ske_map_status(status), ctx->sock->hostname,
1483                           ctx->sock->ip));
1484           protocol->state = SILC_PROTOCOL_STATE_ERROR;
1485           silc_protocol_execute(protocol, server->schedule, 0, 300000);
1486           return;
1487         }
1488       }
1489
1490     } else {
1491       if (ctx->pfs == TRUE) {
1492         /*
1493          * The packet type must be KE packet
1494          */
1495         if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_2) {
1496           SILC_LOG_ERROR(("Error during Re-key (I PFS): re-key state is "
1497                           "incorrect (received %d, expected %d packet), "
1498                           "with %s (%s)", ctx->packet->type,
1499                           SILC_PACKET_KEY_EXCHANGE_2, ctx->sock->hostname,
1500                           ctx->sock->ip));
1501           protocol->state = SILC_PROTOCOL_STATE_ERROR;
1502           silc_protocol_execute(protocol, server->schedule, 0, 300000);
1503           return;
1504         }
1505
1506         status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer);
1507         if (status != SILC_SKE_STATUS_OK) {
1508           SILC_LOG_ERROR(("Error (%s) during Re-key (I PFS), with %s (%s)",
1509                           silc_ske_map_status(status), ctx->sock->hostname,
1510                           ctx->sock->ip));
1511           protocol->state = SILC_PROTOCOL_STATE_ERROR;
1512           silc_protocol_execute(protocol, server->schedule, 0, 300000);
1513           return;
1514         }
1515       }
1516     }
1517
1518     /* Send the REKEY_DONE to indicate we will take new keys into use
1519        now. */
1520     silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1521                             0, NULL, 0, FALSE);
1522
1523     /* After we send REKEY_DONE we must set the sending encryption
1524        key to the new key since all packets after this packet must
1525        encrypted with the new key. */
1526     silc_server_protocol_rekey_generate_pfs(server, ctx, TRUE);
1527
1528     /* The protocol ends in next stage. */
1529     protocol->state = SILC_PROTOCOL_STATE_END;
1530     break;
1531
1532   case SILC_PROTOCOL_STATE_END:
1533     /*
1534      * End protocol
1535      */
1536
1537     if (ctx->packet->type != SILC_PACKET_REKEY_DONE) {
1538       SILC_LOG_ERROR(("Error during Re-key (%s PFS): re-key state is "
1539                       "incorrect (received %d, expected %d packet), "
1540                       "with %s (%s)", ctx->responder ? "R" : "I",
1541                       ctx->packet->type, SILC_PACKET_REKEY_DONE,
1542                       ctx->sock->hostname, ctx->sock->ip));
1543       protocol->state = SILC_PROTOCOL_STATE_ERROR;
1544       silc_protocol_execute(protocol, server->schedule, 0, 300000);
1545       return;
1546     }
1547
1548     /* We received the REKEY_DONE packet and all packets after this is
1549        encrypted with the new key so set the decryption key to the new key */
1550     if (ctx->pfs == TRUE)
1551       silc_server_protocol_rekey_generate_pfs(server, ctx, FALSE);
1552     else
1553       silc_server_protocol_rekey_generate(server, ctx, FALSE);
1554
1555     /* Assure that after calling final callback there cannot be pending
1556        executions for this protocol anymore. This just unregisters any
1557        timeout callbacks for this protocol. */
1558     silc_protocol_cancel(protocol, server->schedule);
1559
1560     /* Protocol has ended, call the final callback */
1561     if (protocol->final_callback)
1562       silc_protocol_execute_final(protocol, server->schedule);
1563     else
1564       silc_protocol_free(protocol);
1565     break;
1566
1567   case SILC_PROTOCOL_STATE_ERROR:
1568     /*
1569      * Error occured
1570      */
1571
1572     if (ctx->pfs == TRUE)
1573       /* Send abort notification */
1574       silc_ske_abort(ctx->ske, ctx->ske->status);
1575
1576     /* Assure that after calling final callback there cannot be pending
1577        executions for this protocol anymore. This just unregisters any
1578        timeout callbacks for this protocol. */
1579     silc_protocol_cancel(protocol, server->schedule);
1580
1581     /* On error the final callback is always called. */
1582     if (protocol->final_callback)
1583       silc_protocol_execute_final(protocol, server->schedule);
1584     else
1585       silc_protocol_free(protocol);
1586     break;
1587
1588   case SILC_PROTOCOL_STATE_FAILURE:
1589     /*
1590      * We have received failure from remote
1591      */
1592
1593     SILC_LOG_ERROR(("Error during Re-Key: received Failure"));
1594
1595     /* Assure that after calling final callback there cannot be pending
1596        executions for this protocol anymore. This just unregisters any
1597        timeout callbacks for this protocol. */
1598     silc_protocol_cancel(protocol, server->schedule);
1599
1600     /* On error the final callback is always called. */
1601     if (protocol->final_callback)
1602       silc_protocol_execute_final(protocol, server->schedule);
1603     else
1604       silc_protocol_free(protocol);
1605     break;
1606
1607   case SILC_PROTOCOL_STATE_UNKNOWN:
1608     break;
1609   }
1610
1611 }
1612
1613 /* Registers protocols used in server. */
1614
1615 void silc_server_protocols_register(void)
1616 {
1617   silc_protocol_register(SILC_PROTOCOL_SERVER_CONNECTION_AUTH,
1618                          silc_server_protocol_connection_auth);
1619   silc_protocol_register(SILC_PROTOCOL_SERVER_KEY_EXCHANGE,
1620                          silc_server_protocol_key_exchange);
1621   silc_protocol_register(SILC_PROTOCOL_SERVER_REKEY,
1622                          silc_server_protocol_rekey);
1623   silc_protocol_register(SILC_PROTOCOL_SERVER_BACKUP,
1624                          silc_server_protocol_backup);
1625 }
1626
1627 /* Unregisters protocols */
1628
1629 void silc_server_protocols_unregister(void)
1630 {
1631   silc_protocol_unregister(SILC_PROTOCOL_SERVER_CONNECTION_AUTH,
1632                            silc_server_protocol_connection_auth);
1633   silc_protocol_unregister(SILC_PROTOCOL_SERVER_KEY_EXCHANGE,
1634                            silc_server_protocol_key_exchange);
1635   silc_protocol_unregister(SILC_PROTOCOL_SERVER_REKEY,
1636                            silc_server_protocol_rekey);
1637   silc_protocol_unregister(SILC_PROTOCOL_SERVER_BACKUP,
1638                            silc_server_protocol_backup);
1639 }