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   *auth_data = silc_calloc(silc_pkcs_get_key_len(pkcs), sizeof(**auth_data));
 808   if (silc_pkcs_sign_with_hash(pkcs, ske->prop->hash, auth->data,
 809                                auth->len, *auth_data, auth_data_len)) {
 810     silc_buffer_free(auth);
 811     return TRUE;
 812   }
 813
 814   silc_free(*auth_data);
 815   silc_buffer_free(auth);
 816   return FALSE;
 817 }
 818
 819 /* Function that actually performs the authentication to the remote. This
 820    supports both passphrase and public key authentication. */
 821
 822 static bool
 823 silc_server_get_authentication(SilcServerConnAuthInternalContext *ctx,
 824                                char *local_passphrase,
 825                                void *local_publickey,
 826                                unsigned char *remote_auth,
 827                                uint32 remote_auth_len)
 828 {
 829   SilcServer server = (SilcServer)ctx->server;
 830   SilcSKE ske = ctx->ske;
 831   bool result = FALSE;
 832
 833   /* If we don't have authentication data set at all we do not require
 834      authentication at all */
 835   if (!local_passphrase && !local_publickey) {
 836     SILC_LOG_DEBUG(("No authentication required"));
 837     return TRUE;
 838   }
 839
 840   /* If both passphrase and public key is provided then we'll try both of
 841      them and see which one of them authenticates.  If only one of them is
 842      set, then try only that. */
 843
 844   /* Try first passphrase (as it is faster to check) */
 845   if (local_passphrase) {
 846     SILC_LOG_DEBUG(("Password authentication"));
 847     result = silc_server_password_authentication(server, local_passphrase,
 848                                                  remote_auth);
 849   }
 850
 851   /* Try public key authenetication */
 852   if (!result && local_publickey) {
 853     SILC_LOG_DEBUG(("Public key authentication"));
 854     result = silc_server_public_key_authentication(server,
 855                                                    local_publickey,
 856                                                    remote_auth,
 857                                                    remote_auth_len,
 858                                                    ske);
 859   }
 860
 861   return result;
 862 }
 863
 864 /* Performs connection authentication protocol. If responder, we
 865    authenticate the remote data received. If initiator, we will send
 866    authentication data to the remote end. */
 867
 868 SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
 869 {
 870   SilcProtocol protocol = (SilcProtocol)context;
 871   SilcServerConnAuthInternalContext *ctx =
 872     (SilcServerConnAuthInternalContext *)protocol->context;
 873   SilcServer server = (SilcServer)ctx->server;
 874
 875   SILC_LOG_DEBUG(("Start"));
 876
 877   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 878     protocol->state = SILC_PROTOCOL_STATE_START;
 879
 880   SILC_LOG_DEBUG(("State=%d", protocol->state));
 881
 882   switch(protocol->state) {
 883   case SILC_PROTOCOL_STATE_START:
 884     {
 885       /*
 886        * Start protocol.
 887        */
 888
 889       if (ctx->responder == TRUE) {
 890         /*
 891          * We are receiving party
 892          */
 893         int ret;
 894         uint16 payload_len;
 895         uint16 conn_type;
 896         unsigned char *auth_data = NULL;
 897
 898         SILC_LOG_INFO(("Performing authentication protocol for %s (%s)",
 899                        ctx->sock->hostname, ctx->sock->ip));
 900
 901         /* Parse the received authentication data packet. The received
 902            payload is Connection Auth Payload. */
 903         ret = silc_buffer_unformat(ctx->packet->buffer,
 904                                    SILC_STR_UI_SHORT(&payload_len),
 905                                    SILC_STR_UI_SHORT(&conn_type),
 906                                    SILC_STR_END);
 907         if (ret == -1) {
 908           SILC_LOG_DEBUG(("Bad payload in authentication packet"));
 909           protocol->state = SILC_PROTOCOL_STATE_ERROR;
 910           silc_protocol_execute(protocol, server->schedule, 0, 300000);
 911           return;
 912         }
 913
 914         if (payload_len != ctx->packet->buffer->len) {
 915           SILC_LOG_DEBUG(("Bad payload in authentication packet"));
 916           protocol->state = SILC_PROTOCOL_STATE_ERROR;
 917           silc_protocol_execute(protocol, server->schedule, 0, 300000);
 918           return;
 919         }
 920
 921         payload_len -= 4;
 922
 923         if (conn_type < SILC_SOCKET_TYPE_CLIENT ||
 924             conn_type > SILC_SOCKET_TYPE_ROUTER) {
 925           SILC_LOG_ERROR(("Bad connection type %d", conn_type));
 926           protocol->state = SILC_PROTOCOL_STATE_ERROR;
 927           silc_protocol_execute(protocol, server->schedule, 0, 300000);
 928           return;
 929         }
 930
 931         if (payload_len > 0) {
 932           /* Get authentication data */
 933           silc_buffer_pull(ctx->packet->buffer, 4);
 934           ret = silc_buffer_unformat(ctx->packet->buffer,
 935                                      SILC_STR_UI_XNSTRING_ALLOC(&auth_data,
 936                                                                 payload_len),
 937                                      SILC_STR_END);
 938           if (ret == -1) {
 939             SILC_LOG_DEBUG(("Bad payload in authentication packet"));
 940             protocol->state = SILC_PROTOCOL_STATE_ERROR;
 941             silc_protocol_execute(protocol, server->schedule, 0, 300000);
 942             return;
 943           }
 944         }
 945
 946         /*
 947          * Check the remote connection type and make sure that we have
 948          * configured this connection. If we haven't allowed this connection
 949          * the authentication must be failed.
 950          */
 951
 952         SILC_LOG_DEBUG(("Remote connection type %d", conn_type));
 953
 954         /* Remote end is client */
 955         if (conn_type == SILC_SOCKET_TYPE_CLIENT) {
 956           SilcServerConfigSectionClient *client = ctx->cconfig;
 957
 958           if (client) {
 959             ret = silc_server_get_authentication(ctx, client->passphrase,
 960                                                  client->publickey,
 961                                                  auth_data, payload_len);
 962             if (!ret) {
 963               /* Authentication failed */
 964               SILC_LOG_ERROR(("Authentication failed"));
 965               SILC_LOG_DEBUG(("Authentication failed"));
 966               silc_free(auth_data);
 967               protocol->state = SILC_PROTOCOL_STATE_ERROR;
 968               silc_protocol_execute(protocol, server->schedule, 0, 300000);
 969               return;
 970             }
 971           } else {
 972             SILC_LOG_DEBUG(("No configuration for remote client connection"));
 973             SILC_LOG_ERROR(("Remote client connection not configured"));
 974             SILC_LOG_ERROR(("Authentication failed"));
 975             silc_free(auth_data);
 976             protocol->state = SILC_PROTOCOL_STATE_ERROR;
 977             silc_protocol_execute(protocol, server->schedule,
 978                                   0, 300000);
 979             return;
 980           }
 981         }
 982
 983         /* Remote end is server */
 984         if (conn_type == SILC_SOCKET_TYPE_SERVER) {
 985           SilcServerConfigSectionServer *serv = ctx->sconfig;
 986
 987           if (serv) {
 988             ret = silc_server_get_authentication(ctx, serv->passphrase,
 989                                                  serv->publickey,
 990                                                  auth_data, payload_len);
 991             if (!ret) {
 992               /* Authentication failed */
 993               SILC_LOG_ERROR(("Authentication failed"));
 994               SILC_LOG_DEBUG(("Authentication failed"));
 995               silc_free(auth_data);
 996               protocol->state = SILC_PROTOCOL_STATE_ERROR;
 997               silc_protocol_execute(protocol, server->schedule, 0, 300000);
 998               return;
 999             }
1000           } else {
1001             SILC_LOG_DEBUG(("No configuration for remote server connection"));
1002             SILC_LOG_ERROR(("Remote server connection not configured"));
1003             SILC_LOG_ERROR(("Authentication failed"));
1004             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1005             silc_protocol_execute(protocol, server->schedule,
1006                                   0, 300000);
1007             silc_free(auth_data);
1008             return;
1009           }
1010         }
1011
1012         /* Remote end is router */
1013         if (conn_type == SILC_SOCKET_TYPE_ROUTER) {
1014           SilcServerConfigSectionRouter *serv = ctx->rconfig;
1015
1016           if (serv) {
1017             ret = silc_server_get_authentication(ctx, serv->passphrase,
1018                                                  serv->publickey,
1019                                                  auth_data, payload_len);
1020             if (!ret) {
1021               /* Authentication failed */
1022               SILC_LOG_ERROR(("Authentication failed"));
1023               SILC_LOG_DEBUG(("Authentication failed"));
1024               silc_free(auth_data);
1025               protocol->state = SILC_PROTOCOL_STATE_ERROR;
1026               silc_protocol_execute(protocol, server->schedule, 0, 300000);
1027               return;
1028             }
1029           } else {
1030             SILC_LOG_DEBUG(("No configuration for remote router connection"));
1031             SILC_LOG_ERROR(("Remote router connection not configured"));
1032             SILC_LOG_ERROR(("Authentication failed"));
1033             silc_free(auth_data);
1034             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1035             silc_protocol_execute(protocol, server->schedule,
1036                                   0, 300000);
1037             return;
1038           }
1039         }
1040
1041         silc_free(auth_data);
1042
1043         /* Save connection type. This is later used to create the
1044            ID for the connection. */
1045         ctx->conn_type = conn_type;
1046
1047         /* Advance protocol state. */
1048         protocol->state = SILC_PROTOCOL_STATE_END;
1049         silc_protocol_execute(protocol, server->schedule, 0, 0);
1050
1051       } else {
1052         /*
1053          * We are initiator. We are authenticating ourselves to a
1054          * remote server. We will send the authentication data to the
1055          * other end for verify.
1056          */
1057         SilcBuffer packet;
1058         int payload_len = 0;
1059         unsigned char *auth_data = NULL;
1060         uint32 auth_data_len = 0;
1061
1062         switch(ctx->auth_meth) {
1063         case SILC_AUTH_NONE:
1064           /* No authentication required */
1065           break;
1066
1067         case SILC_AUTH_PASSWORD:
1068           /* Password authentication */
1069           if (ctx->auth_data && ctx->auth_data_len) {
1070             auth_data = strdup(ctx->auth_data);
1071             auth_data_len = ctx->auth_data_len;
1072             break;
1073           }
1074           break;
1075
1076         case SILC_AUTH_PUBLIC_KEY:
1077           {
1078             /* Public key authentication */
1079             silc_server_get_public_key_auth(server, &auth_data, &auth_data_len,
1080                                             ctx->ske);
1081             break;
1082           }
1083         }
1084
1085         payload_len = 4 + auth_data_len;
1086         packet = silc_buffer_alloc(payload_len);
1087         silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1088         silc_buffer_format(packet,
1089                            SILC_STR_UI_SHORT(payload_len),
1090                            SILC_STR_UI_SHORT(server->server_type
1091                                               == SILC_SERVER ?
1092                                               SILC_SOCKET_TYPE_SERVER :
1093                                               SILC_SOCKET_TYPE_ROUTER),
1094                            SILC_STR_UI_XNSTRING(auth_data, auth_data_len),
1095                            SILC_STR_END);
1096
1097         /* Send the packet to server */
1098         silc_server_packet_send(server, ctx->sock,
1099                                 SILC_PACKET_CONNECTION_AUTH, 0,
1100                                 packet->data, packet->len, TRUE);
1101
1102         if (auth_data) {
1103           memset(auth_data, 0, auth_data_len);
1104           silc_free(auth_data);
1105         }
1106         silc_buffer_free(packet);
1107
1108         /* Next state is end of protocol */
1109         protocol->state = SILC_PROTOCOL_STATE_END;
1110       }
1111     }
1112     break;
1113
1114   case SILC_PROTOCOL_STATE_END:
1115     {
1116       /*
1117        * End protocol
1118        */
1119       unsigned char ok[4];
1120
1121       SILC_PUT32_MSB(SILC_AUTH_OK, ok);
1122
1123       /* Authentication successful */
1124       silc_server_packet_send(server, ctx->sock, SILC_PACKET_SUCCESS,
1125                               0, ok, 4, TRUE);
1126
1127       /* Unregister the timeout task since the protocol has ended.
1128          This was the timeout task to be executed if the protocol is
1129          not completed fast enough. */
1130       if (ctx->timeout_task)
1131         silc_schedule_task_del(server->schedule, ctx->timeout_task);
1132
1133       /* Assure that after calling final callback there cannot be pending
1134          executions for this protocol anymore. This just unregisters any
1135          timeout callbacks for this protocol. */
1136       silc_protocol_cancel(protocol, server->schedule);
1137
1138       /* Protocol has ended, call the final callback */
1139       if (protocol->final_callback)
1140         silc_protocol_execute_final(protocol, server->schedule);
1141       else
1142         silc_protocol_free(protocol);
1143     }
1144     break;
1145   case SILC_PROTOCOL_STATE_ERROR:
1146     {
1147       /*
1148        * Error. Send notify to remote.
1149        */
1150       unsigned char error[4];
1151
1152       SILC_PUT32_MSB(SILC_AUTH_FAILED, error);
1153
1154       /* Authentication failed */
1155       silc_server_packet_send(server, ctx->sock, SILC_PACKET_FAILURE,
1156                               0, error, 4, TRUE);
1157
1158       /* Unregister the timeout task since the protocol has ended.
1159          This was the timeout task to be executed if the protocol is
1160          not completed fast enough. */
1161       if (ctx->timeout_task)
1162         silc_schedule_task_del(server->schedule, ctx->timeout_task);
1163
1164       /* Assure that after calling final callback there cannot be pending
1165          executions for this protocol anymore. This just unregisters any
1166          timeout callbacks for this protocol. */
1167       silc_protocol_cancel(protocol, server->schedule);
1168
1169       /* On error the final callback is always called. */
1170       if (protocol->final_callback)
1171         silc_protocol_execute_final(protocol, server->schedule);
1172       else
1173         silc_protocol_free(protocol);
1174     }
1175     break;
1176
1177   case SILC_PROTOCOL_STATE_FAILURE:
1178     /*
1179      * We have received failure from remote
1180      */
1181
1182     /* Unregister the timeout task since the protocol has ended.
1183        This was the timeout task to be executed if the protocol is
1184        not completed fast enough. */
1185     if (ctx->timeout_task)
1186       silc_schedule_task_del(server->schedule, ctx->timeout_task);
1187
1188     /* Assure that after calling final callback there cannot be pending
1189        executions for this protocol anymore. This just unregisters any
1190        timeout callbacks for this protocol. */
1191     silc_protocol_cancel(protocol, server->schedule);
1192
1193     /* On error the final callback is always called. */
1194     if (protocol->final_callback)
1195       silc_protocol_execute_final(protocol, server->schedule);
1196     else
1197       silc_protocol_free(protocol);
1198     break;
1199
1200   case SILC_PROTOCOL_STATE_UNKNOWN:
1201     break;
1202   }
1203 }
1204
1205 /*
1206  * Re-key protocol routines
1207  */
1208
1209 /* Actually takes the new keys into use. */
1210
1211 static void
1212 silc_server_protocol_rekey_validate(SilcServer server,
1213                                     SilcServerRekeyInternalContext *ctx,
1214                                     SilcIDListData idata,
1215                                     SilcSKEKeyMaterial *keymat,
1216                                     bool send)
1217 {
1218   if (ctx->responder == TRUE) {
1219     if (send) {
1220       silc_cipher_set_key(idata->send_key, keymat->receive_enc_key,
1221                           keymat->enc_key_len);
1222       silc_cipher_set_iv(idata->send_key, keymat->receive_iv);
1223       silc_hmac_set_key(idata->hmac_send, keymat->receive_hmac_key,
1224                         keymat->hmac_key_len);
1225     } else {
1226       silc_cipher_set_key(idata->receive_key, keymat->send_enc_key,
1227                           keymat->enc_key_len);
1228       silc_cipher_set_iv(idata->receive_key, keymat->send_iv);
1229       silc_hmac_set_key(idata->hmac_receive, keymat->send_hmac_key,
1230                         keymat->hmac_key_len);
1231     }
1232   } else {
1233     if (send) {
1234       silc_cipher_set_key(idata->send_key, keymat->send_enc_key,
1235                           keymat->enc_key_len);
1236       silc_cipher_set_iv(idata->send_key, keymat->send_iv);
1237       silc_hmac_set_key(idata->hmac_send, keymat->send_hmac_key,
1238                         keymat->hmac_key_len);
1239     } else {
1240       silc_cipher_set_key(idata->receive_key, keymat->receive_enc_key,
1241                           keymat->enc_key_len);
1242       silc_cipher_set_iv(idata->receive_key, keymat->receive_iv);
1243       silc_hmac_set_key(idata->hmac_receive, keymat->receive_hmac_key,
1244                         keymat->hmac_key_len);
1245     }
1246   }
1247
1248   /* Save the current sending encryption key */
1249   if (!send) {
1250     memset(idata->rekey->send_enc_key, 0, idata->rekey->enc_key_len);
1251     silc_free(idata->rekey->send_enc_key);
1252     idata->rekey->send_enc_key =
1253       silc_calloc(keymat->enc_key_len / 8,
1254                   sizeof(*idata->rekey->send_enc_key));
1255     memcpy(idata->rekey->send_enc_key, keymat->send_enc_key,
1256            keymat->enc_key_len / 8);
1257     idata->rekey->enc_key_len = keymat->enc_key_len / 8;
1258   }
1259 }
1260
1261 /* This function actually re-generates (when not using PFS) the keys and
1262    takes them into use. */
1263
1264 void silc_server_protocol_rekey_generate(SilcServer server,
1265                                          SilcServerRekeyInternalContext *ctx,
1266                                          bool send)
1267 {
1268   SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1269   SilcSKEKeyMaterial *keymat;
1270   uint32 key_len = silc_cipher_get_key_len(idata->send_key);
1271   uint32 hash_len = idata->hash->hash->hash_len;
1272
1273   SILC_LOG_DEBUG(("Generating new %s session keys (no PFS)",
1274                   send ? "sending" : "receiving"));
1275
1276   /* Generate the new key */
1277   keymat = silc_calloc(1, sizeof(*keymat));
1278   silc_ske_process_key_material_data(idata->rekey->send_enc_key,
1279                                      idata->rekey->enc_key_len,
1280                                      16, key_len, hash_len,
1281                                      idata->hash, keymat);
1282
1283   /* Set the keys into use */
1284   silc_server_protocol_rekey_validate(server, ctx, idata, keymat, send);
1285
1286   silc_ske_free_key_material(keymat);
1287 }
1288
1289 /* This function actually re-generates (with PFS) the keys and
1290    takes them into use. */
1291
1292 void
1293 silc_server_protocol_rekey_generate_pfs(SilcServer server,
1294                                         SilcServerRekeyInternalContext *ctx,
1295                                         bool send)
1296 {
1297   SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1298   SilcSKEKeyMaterial *keymat;
1299   uint32 key_len = silc_cipher_get_key_len(idata->send_key);
1300   uint32 hash_len = idata->hash->hash->hash_len;
1301   unsigned char *tmpbuf;
1302   uint32 klen;
1303
1304   SILC_LOG_DEBUG(("Generating new %s session keys (with PFS)",
1305                   send ? "sending" : "receiving"));
1306
1307   /* Encode KEY to binary data */
1308   tmpbuf = silc_mp_mp2bin(ctx->ske->KEY, 0, &klen);
1309
1310   /* Generate the new key */
1311   keymat = silc_calloc(1, sizeof(*keymat));
1312   silc_ske_process_key_material_data(tmpbuf, klen, 16, key_len, hash_len,
1313                                      idata->hash, keymat);
1314
1315   /* Set the keys into use */
1316   silc_server_protocol_rekey_validate(server, ctx, idata, keymat, send);
1317
1318   memset(tmpbuf, 0, klen);
1319   silc_free(tmpbuf);
1320   silc_ske_free_key_material(keymat);
1321 }
1322
1323 /* Packet sending callback. This function is provided as packet sending
1324    routine to the Key Exchange functions. */
1325
1326 static void
1327 silc_server_protocol_rekey_send_packet(SilcSKE ske,
1328                                        SilcBuffer packet,
1329                                        SilcPacketType type,
1330                                        void *context)
1331 {
1332   SilcProtocol protocol = (SilcProtocol)context;
1333   SilcServerRekeyInternalContext *ctx =
1334     (SilcServerRekeyInternalContext *)protocol->context;
1335   SilcServer server = (SilcServer)ctx->server;
1336
1337   /* Send the packet immediately */
1338   silc_server_packet_send(server, ctx->sock,
1339                           type, 0, packet->data, packet->len, FALSE);
1340 }
1341
1342 /* Performs re-key as defined in the SILC protocol specification. */
1343
1344 SILC_TASK_CALLBACK(silc_server_protocol_rekey)
1345 {
1346   SilcProtocol protocol = (SilcProtocol)context;
1347   SilcServerRekeyInternalContext *ctx =
1348     (SilcServerRekeyInternalContext *)protocol->context;
1349   SilcServer server = (SilcServer)ctx->server;
1350   SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1351   SilcSKEStatus status;
1352
1353   SILC_LOG_DEBUG(("Start"));
1354
1355   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
1356     protocol->state = SILC_PROTOCOL_STATE_START;
1357
1358   SILC_LOG_DEBUG(("State=%d", protocol->state));
1359
1360   switch(protocol->state) {
1361   case SILC_PROTOCOL_STATE_START:
1362     {
1363       /*
1364        * Start protocol.
1365        */
1366
1367       if (ctx->responder == TRUE) {
1368         /*
1369          * We are receiving party
1370          */
1371
1372         if (ctx->pfs == TRUE) {
1373           /*
1374            * Use Perfect Forward Secrecy, ie. negotiate the key material
1375            * using the SKE protocol.
1376            */
1377
1378           if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_1) {
1379             /* Error in protocol */
1380             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1381             silc_protocol_execute(protocol, server->schedule, 0, 300000);
1382             return;
1383           }
1384
1385           ctx->ske = silc_ske_alloc();
1386           ctx->ske->rng = server->rng;
1387           ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
1388           silc_ske_group_get_by_number(idata->rekey->ske_group,
1389                                        &ctx->ske->prop->group);
1390
1391           silc_ske_set_callbacks(ctx->ske,
1392                                  silc_server_protocol_rekey_send_packet,
1393                                  NULL, NULL, NULL, silc_ske_check_version,
1394                                  context);
1395
1396           status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer);
1397           if (status != SILC_SKE_STATUS_OK) {
1398             SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
1399                               silc_ske_map_status(status)));
1400
1401             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1402             silc_protocol_execute(protocol, server->schedule, 0, 300000);
1403             return;
1404           }
1405
1406           /* Advance the protocol state */
1407           protocol->state++;
1408           silc_protocol_execute(protocol, server->schedule, 0, 0);
1409         } else {
1410           /*
1411            * Do normal and simple re-key.
1412            */
1413
1414           /* Send the REKEY_DONE to indicate we will take new keys into use */
1415           silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1416                                   0, NULL, 0, FALSE);
1417
1418           /* After we send REKEY_DONE we must set the sending encryption
1419              key to the new key since all packets after this packet must
1420              encrypted with the new key. */
1421           silc_server_protocol_rekey_generate(server, ctx, TRUE);
1422
1423           /* The protocol ends in next stage. */
1424           protocol->state = SILC_PROTOCOL_STATE_END;
1425         }
1426
1427       } else {
1428         /*
1429          * We are the initiator of this protocol
1430          */
1431
1432         /* Start the re-key by sending the REKEY packet */
1433         silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY,
1434                                 0, NULL, 0, FALSE);
1435
1436         if (ctx->pfs == TRUE) {
1437           /*
1438            * Use Perfect Forward Secrecy, ie. negotiate the key material
1439            * using the SKE protocol.
1440            */
1441           ctx->ske = silc_ske_alloc();
1442           ctx->ske->rng = server->rng;
1443           ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
1444           silc_ske_group_get_by_number(idata->rekey->ske_group,
1445                                        &ctx->ske->prop->group);
1446
1447           silc_ske_set_callbacks(ctx->ske,
1448                                  silc_server_protocol_rekey_send_packet,
1449                                  NULL, NULL, NULL, silc_ske_check_version,
1450                                  context);
1451
1452           status = silc_ske_initiator_phase_2(ctx->ske, NULL, NULL);
1453           if (status != SILC_SKE_STATUS_OK) {
1454             SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
1455                               silc_ske_map_status(status)));
1456
1457             protocol->state = SILC_PROTOCOL_STATE_ERROR;
1458             silc_protocol_execute(protocol, server->schedule, 0, 300000);
1459             return;
1460           }
1461
1462           /* Advance the protocol state */
1463           protocol->state++;
1464         } else {
1465           /*
1466            * Do normal and simple re-key.
1467            */
1468
1469           /* Send the REKEY_DONE to indicate we will take new keys into use
1470              now. */
1471           silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1472                                   0, NULL, 0, FALSE);
1473
1474           /* After we send REKEY_DONE we must set the sending encryption
1475              key to the new key since all packets after this packet must
1476              encrypted with the new key. */
1477           silc_server_protocol_rekey_generate(server, ctx, TRUE);
1478
1479           /* The protocol ends in next stage. */
1480           protocol->state = SILC_PROTOCOL_STATE_END;
1481         }
1482       }
1483     }
1484     break;
1485
1486   case 2:
1487     /*
1488      * Second state, used only when oding re-key with PFS.
1489      */
1490     if (ctx->responder == TRUE) {
1491       if (ctx->pfs == TRUE) {
1492         /*
1493          * Send our KE packe to the initiator now that we've processed
1494          * the initiator's KE packet.
1495          */
1496         status = silc_ske_responder_finish(ctx->ske, NULL, NULL,
1497                                            SILC_SKE_PK_TYPE_SILC);
1498         if (status != SILC_SKE_STATUS_OK) {
1499           SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
1500                             silc_ske_map_status(status)));
1501
1502           protocol->state = SILC_PROTOCOL_STATE_ERROR;
1503           silc_protocol_execute(protocol, server->schedule, 0, 300000);
1504           return;
1505         }
1506       }
1507
1508     } else {
1509       if (ctx->pfs == TRUE) {
1510         /*
1511          * The packet type must be KE packet
1512          */
1513         if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_2) {
1514           /* Error in protocol */
1515           protocol->state = SILC_PROTOCOL_STATE_ERROR;
1516           silc_protocol_execute(protocol, server->schedule, 0, 300000);
1517           return;
1518         }
1519
1520         status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer);
1521         if (status != SILC_SKE_STATUS_OK) {
1522           SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
1523                             silc_ske_map_status(status)));
1524
1525           protocol->state = SILC_PROTOCOL_STATE_ERROR;
1526           silc_protocol_execute(protocol, server->schedule, 0, 300000);
1527           return;
1528         }
1529       }
1530     }
1531
1532     /* Send the REKEY_DONE to indicate we will take new keys into use
1533        now. */
1534     silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1535                             0, NULL, 0, FALSE);
1536
1537     /* After we send REKEY_DONE we must set the sending encryption
1538        key to the new key since all packets after this packet must
1539        encrypted with the new key. */
1540     silc_server_protocol_rekey_generate_pfs(server, ctx, TRUE);
1541
1542     /* The protocol ends in next stage. */
1543     protocol->state = SILC_PROTOCOL_STATE_END;
1544     break;
1545
1546   case SILC_PROTOCOL_STATE_END:
1547     /*
1548      * End protocol
1549      */
1550
1551     if (ctx->packet->type != SILC_PACKET_REKEY_DONE) {
1552       /* Error in protocol */
1553       protocol->state = SILC_PROTOCOL_STATE_ERROR;
1554       silc_protocol_execute(protocol, server->schedule, 0, 300000);
1555       return;
1556     }
1557
1558     /* We received the REKEY_DONE packet and all packets after this is
1559        encrypted with the new key so set the decryption key to the new key */
1560     silc_server_protocol_rekey_generate(server, ctx, FALSE);
1561
1562     /* Assure that after calling final callback there cannot be pending
1563        executions for this protocol anymore. This just unregisters any
1564        timeout callbacks for this protocol. */
1565     silc_protocol_cancel(protocol, server->schedule);
1566
1567     /* Protocol has ended, call the final callback */
1568     if (protocol->final_callback)
1569       silc_protocol_execute_final(protocol, server->schedule);
1570     else
1571       silc_protocol_free(protocol);
1572     break;
1573
1574   case SILC_PROTOCOL_STATE_ERROR:
1575     /*
1576      * Error occured
1577      */
1578
1579     if (ctx->pfs == TRUE) {
1580       /* Send abort notification */
1581       silc_ske_abort(ctx->ske, ctx->ske->status);
1582     }
1583
1584     /* Assure that after calling final callback there cannot be pending
1585        executions for this protocol anymore. This just unregisters any
1586        timeout callbacks for this protocol. */
1587     silc_protocol_cancel(protocol, server->schedule);
1588
1589     /* On error the final callback is always called. */
1590     if (protocol->final_callback)
1591       silc_protocol_execute_final(protocol, server->schedule);
1592     else
1593       silc_protocol_free(protocol);
1594     break;
1595
1596   case SILC_PROTOCOL_STATE_FAILURE:
1597     /*
1598      * We have received failure from remote
1599      */
1600
1601     /* Assure that after calling final callback there cannot be pending
1602        executions for this protocol anymore. This just unregisters any
1603        timeout callbacks for this protocol. */
1604     silc_protocol_cancel(protocol, server->schedule);
1605
1606     /* On error the final callback is always called. */
1607     if (protocol->final_callback)
1608       silc_protocol_execute_final(protocol, server->schedule);
1609     else
1610       silc_protocol_free(protocol);
1611     break;
1612
1613   case SILC_PROTOCOL_STATE_UNKNOWN:
1614     break;
1615   }
1616
1617 }
1618
1619 /* Registers protocols used in server. */
1620
1621 void silc_server_protocols_register(void)
1622 {
1623   silc_protocol_register(SILC_PROTOCOL_SERVER_CONNECTION_AUTH,
1624                          silc_server_protocol_connection_auth);
1625   silc_protocol_register(SILC_PROTOCOL_SERVER_KEY_EXCHANGE,
1626                          silc_server_protocol_key_exchange);
1627   silc_protocol_register(SILC_PROTOCOL_SERVER_REKEY,
1628                          silc_server_protocol_rekey);
1629   silc_protocol_register(SILC_PROTOCOL_SERVER_BACKUP,
1630                          silc_server_protocol_backup);
1631 }
1632
1633 /* Unregisters protocols */
1634
1635 void silc_server_protocols_unregister(void)
1636 {
1637   silc_protocol_unregister(SILC_PROTOCOL_SERVER_CONNECTION_AUTH,
1638                            silc_server_protocol_connection_auth);
1639   silc_protocol_unregister(SILC_PROTOCOL_SERVER_KEY_EXCHANGE,
1640                            silc_server_protocol_key_exchange);
1641   silc_protocol_unregister(SILC_PROTOCOL_SERVER_REKEY,
1642                            silc_server_protocol_rekey);
1643   silc_protocol_unregister(SILC_PROTOCOL_SERVER_BACKUP,
1644                            silc_server_protocol_backup);
1645 }