apps/silcd/protocol.c

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