5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2001 Pekka Riikonen
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.
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.
21 * Server side of the protocols.
25 #include "serverincludes.h"
26 #include "server_internal.h"
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);
32 extern char *silc_version_string;
35 * Key Exhange protocol functions
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)
44 char file[256], filename[256], *fingerprint;
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));
53 /* Accept client keys without verification */
54 if (conn_type == SILC_SOCKET_TYPE_CLIENT) {
55 SILC_LOG_DEBUG(("Accepting client public key without verification"));
59 memset(filename, 0, sizeof(filename));
60 memset(file, 0, sizeof(file));
61 snprintf(file, sizeof(file) - 1, "serverkey_%s_%d.pub", sock->hostname,
63 snprintf(filename, sizeof(filename) - 1, SILC_ETCDIR "/serverkeys/%s",
66 /* Create serverkeys directory if it doesn't exist. */
67 if (stat(SILC_ETCDIR "/serverkeys", &st) < 0) {
68 /* If dir doesn't exist */
69 if (errno == ENOENT) {
70 if (mkdir(SILC_ETCDIR "/serverkeys", 0755) < 0) {
71 SILC_LOG_ERROR(("Couldn't create `%s' directory\n",
72 SILC_ETCDIR "/serverkeys"));
76 SILC_LOG_ERROR(("%s\n", strerror(errno)));
81 /* Take fingerprint of the public key */
82 fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
83 SILC_LOG_DEBUG(("Received server %s (%s) port %d public key (%s)",
84 sock->hostname, sock->ip, sock->port, fingerprint));
85 silc_free(fingerprint);
87 /* Check whether this key already exists */
88 if (stat(filename, &st) < 0) {
89 /* We don't have it, then cache it. */
90 SILC_LOG_DEBUG(("New public key from server"));
92 silc_pkcs_save_public_key_data(filename, pk, pk_len,
96 /* The key already exists, verify it. */
97 SilcPublicKey public_key;
101 SILC_LOG_DEBUG(("We have the public key saved locally"));
103 /* Load the key file */
104 if (!silc_pkcs_load_public_key(filename, &public_key,
106 if (!silc_pkcs_load_public_key(filename, &public_key,
107 SILC_PKCS_FILE_BIN)) {
108 SILC_LOG_WARNING(("Could not load local copy of the %s (%s) port %d "
109 "server public key", sock->hostname, sock->ip,
112 /* Save the key for future checking */
114 silc_pkcs_save_public_key_data(filename, pk, pk_len,
119 /* Encode the key data */
120 encpk = silc_pkcs_public_key_encode(public_key, &encpk_len);
122 SILC_LOG_WARNING(("Local copy of the server %s (%s) port %d public key "
123 "is malformed", sock->hostname, sock->ip, sock->port));
125 /* Save the key for future checking */
127 silc_pkcs_save_public_key_data(filename, pk, pk_len,
132 if (memcmp(encpk, pk, encpk_len)) {
133 SILC_LOG_WARNING(("%s (%s) port %d server public key does not match "
134 "with local copy", sock->hostname, sock->ip,
136 SILC_LOG_WARNING(("It is possible that the key has expired or changed"));
137 SILC_LOG_WARNING(("It is also possible that some one is performing "
138 "man-in-the-middle attack"));
139 SILC_LOG_WARNING(("Will not accept the server %s (%s) port %d public "
141 sock->hostname, sock->ip, sock->port));
145 /* Local copy matched */
150 /* Callback that is called when we have received KE2 payload from
151 responder. We try to verify the public key now. */
154 silc_server_protocol_ke_verify_key(SilcSKE ske,
155 unsigned char *pk_data,
157 SilcSKEPKType pk_type,
159 SilcSKEVerifyCbCompletion completion,
160 void *completion_context)
162 SilcProtocol protocol = (SilcProtocol)context;
163 SilcServerKEInternalContext *ctx =
164 (SilcServerKEInternalContext *)protocol->context;
165 SilcServer server = (SilcServer)ctx->server;
167 SILC_LOG_DEBUG(("Start"));
169 if (silc_verify_public_key_internal(server, ctx->sock,
170 (ctx->responder == FALSE ?
171 SILC_SOCKET_TYPE_ROUTER:
172 ctx->sconfig ? SILC_SOCKET_TYPE_SERVER :
173 ctx->rconfig ? SILC_SOCKET_TYPE_ROUTER :
174 SILC_SOCKET_TYPE_CLIENT),
175 pk_data, pk_len, pk_type))
176 completion(ske, SILC_SKE_STATUS_OK, completion_context);
178 completion(ske, SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY,
182 /* Packet sending callback. This function is provided as packet sending
183 routine to the Key Exchange functions. */
185 static void silc_server_protocol_ke_send_packet(SilcSKE ske,
190 SilcProtocol protocol = (SilcProtocol)context;
191 SilcServerKEInternalContext *ctx =
192 (SilcServerKEInternalContext *)protocol->context;
193 SilcServer server = (SilcServer)ctx->server;
195 /* Send the packet immediately */
196 silc_server_packet_send(server, ske->sock,
197 type, 0, packet->data, packet->len, TRUE);
200 /* Sets the negotiated key material into use for particular connection. */
202 int silc_server_protocol_ke_set_keys(SilcSKE ske,
203 SilcSocketConnection sock,
204 SilcSKEKeyMaterial *keymat,
209 SilcSKEDiffieHellmanGroup group,
212 SilcUnknownEntry conn_data;
213 SilcIDListData idata;
215 SILC_LOG_DEBUG(("Setting new key into use"));
217 conn_data = silc_calloc(1, sizeof(*conn_data));
218 idata = (SilcIDListData)conn_data;
220 /* Allocate cipher to be used in the communication */
221 if (!silc_cipher_alloc(cipher->cipher->name, &idata->send_key)) {
222 silc_free(conn_data);
225 if (!silc_cipher_alloc(cipher->cipher->name, &idata->receive_key)) {
226 silc_free(conn_data);
230 if (is_responder == TRUE) {
231 silc_cipher_set_key(idata->send_key, keymat->receive_enc_key,
232 keymat->enc_key_len);
233 silc_cipher_set_iv(idata->send_key, keymat->receive_iv);
234 silc_cipher_set_key(idata->receive_key, keymat->send_enc_key,
235 keymat->enc_key_len);
236 silc_cipher_set_iv(idata->receive_key, keymat->send_iv);
238 silc_cipher_set_key(idata->send_key, keymat->send_enc_key,
239 keymat->enc_key_len);
240 silc_cipher_set_iv(idata->send_key, keymat->send_iv);
241 silc_cipher_set_key(idata->receive_key, keymat->receive_enc_key,
242 keymat->enc_key_len);
243 silc_cipher_set_iv(idata->receive_key, keymat->receive_iv);
246 idata->rekey = silc_calloc(1, sizeof(*idata->rekey));
247 idata->rekey->send_enc_key =
248 silc_calloc(keymat->enc_key_len / 8,
249 sizeof(*idata->rekey->send_enc_key));
250 memcpy(idata->rekey->send_enc_key,
251 keymat->send_enc_key, keymat->enc_key_len / 8);
252 idata->rekey->enc_key_len = keymat->enc_key_len / 8;
254 if (ske->start_payload->flags & SILC_SKE_SP_FLAG_PFS)
255 idata->rekey->pfs = TRUE;
256 idata->rekey->ske_group = silc_ske_group_get_number(group);
258 /* Save the remote host's public key */
259 silc_pkcs_public_key_decode(ske->ke1_payload->pk_data,
260 ske->ke1_payload->pk_len, &idata->public_key);
263 if (!silc_hash_alloc(hash->hash->name, &idata->hash)) {
264 silc_cipher_free(idata->send_key);
265 silc_cipher_free(idata->receive_key);
266 silc_free(conn_data);
270 /* Save HMAC key to be used in the communication. */
271 if (!silc_hmac_alloc((char *)silc_hmac_get_name(hmac), NULL,
272 &idata->hmac_send)) {
273 silc_cipher_free(idata->send_key);
274 silc_cipher_free(idata->receive_key);
275 silc_hash_free(idata->hash);
276 silc_free(conn_data);
279 silc_hmac_set_key(idata->hmac_send, keymat->hmac_key, keymat->hmac_key_len);
280 idata->hmac_receive = idata->hmac_send;
282 sock->user_data = (void *)conn_data;
284 SILC_LOG_INFO(("%s (%s) security properties: %s %s %s",
285 sock->hostname, sock->ip,
286 idata->send_key->cipher->name,
287 (char *)silc_hmac_get_name(idata->hmac_send),
288 idata->hash->hash->name));
293 /* Check remote host version string */
295 SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
296 uint32 len, void *context)
298 SilcSKEStatus status = SILC_SKE_STATUS_OK;
300 int maj = 0, min = 0, build = 0, maj2 = 0, min2 = 0, build2 = 0;
302 SILC_LOG_INFO(("%s (%s) is version %s", ske->sock->hostname,
303 ske->sock->ip, version));
305 /* Check for initial version string */
306 if (!strstr(version, "SILC-1.0-"))
307 status = SILC_SKE_STATUS_BAD_VERSION;
309 /* Check software version */
313 status = SILC_SKE_STATUS_BAD_VERSION;
316 cp = strchr(cp, '.');
322 cp = strchr(cp, '.');
324 build = atoi(cp + 1);
327 cp = silc_version_string + 9;
329 status = SILC_SKE_STATUS_BAD_VERSION;
332 cp = strchr(cp, '.');
338 cp = strchr(cp, '.');
340 build2 = atoi(cp + 1);
344 status = SILC_SKE_STATUS_BAD_VERSION;
346 status = SILC_SKE_STATUS_BAD_VERSION;
351 /* Callback that is called by the SKE to indicate that it is safe to
352 continue the execution of the protocol. This is used only if we are
353 initiator. Is given as argument to the silc_ske_initiator_finish or
354 silc_ske_responder_phase_2 functions. This is called due to the fact
355 that the public key verification process is asynchronous and we must
356 not continue the protocl until the public key has been verified and
357 this callback is called. */
359 static void silc_server_protocol_ke_continue(SilcSKE ske, void *context)
361 SilcProtocol protocol = (SilcProtocol)context;
362 SilcServerKEInternalContext *ctx =
363 (SilcServerKEInternalContext *)protocol->context;
364 SilcServer server = (SilcServer)ctx->server;
366 SILC_LOG_DEBUG(("Start"));
368 if (ske->status != SILC_SKE_STATUS_OK) {
369 SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
370 silc_ske_map_status(ske->status)));
371 SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
372 silc_ske_map_status(ske->status)));
374 protocol->state = SILC_PROTOCOL_STATE_ERROR;
375 silc_protocol_execute(protocol, server->schedule, 0, 300000);
379 /* Send Ok to the other end. We will end the protocol as responder
380 sends Ok to us when we will take the new keys into use. */
381 if (ctx->responder == FALSE) {
382 silc_ske_end(ctx->ske);
384 /* End the protocol on the next round */
385 protocol->state = SILC_PROTOCOL_STATE_END;
388 /* Advance protocol state and call the next state if we are responder.
389 This happens when this callback was sent to silc_ske_responder_phase_2
391 if (ctx->responder == TRUE) {
393 silc_protocol_execute(protocol, server->schedule, 0, 100000);
397 /* Performs key exchange protocol. This is used for both initiator
398 and responder key exchange. This is performed always when accepting
399 new connection to the server. This may be called recursively. */
401 SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
403 SilcProtocol protocol = (SilcProtocol)context;
404 SilcServerKEInternalContext *ctx =
405 (SilcServerKEInternalContext *)protocol->context;
406 SilcServer server = (SilcServer)ctx->server;
407 SilcSKEStatus status = SILC_SKE_STATUS_OK;
409 SILC_LOG_DEBUG(("Start"));
411 if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
412 protocol->state = SILC_PROTOCOL_STATE_START;
414 SILC_LOG_DEBUG(("State=%d", protocol->state));
416 switch(protocol->state) {
417 case SILC_PROTOCOL_STATE_START:
424 /* Allocate Key Exchange object */
425 ske = silc_ske_alloc();
427 ske->rng = server->rng;
429 silc_ske_set_callbacks(ske, silc_server_protocol_ke_send_packet, NULL,
430 silc_server_protocol_ke_verify_key,
431 silc_server_protocol_ke_continue,
432 silc_ske_check_version, context);
434 if (ctx->responder == TRUE) {
435 /* Start the key exchange by processing the received security
436 properties packet from initiator. */
437 status = silc_ske_responder_start(ske, ctx->rng, ctx->sock,
439 ctx->packet->buffer, FALSE);
441 SilcSKEStartPayload *start_payload;
443 /* Assemble security properties. */
444 silc_ske_assemble_security_properties(ske, SILC_SKE_SP_FLAG_NONE,
448 /* Start the key exchange by sending our security properties
449 to the remote end. */
450 status = silc_ske_initiator_start(ske, ctx->rng, ctx->sock,
454 /* Return now if the procedure is pending. */
455 if (status == SILC_SKE_STATUS_PENDING)
458 if (status != SILC_SKE_STATUS_OK) {
459 SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
460 silc_ske_map_status(status)));
461 SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
462 silc_ske_map_status(status)));
464 protocol->state = SILC_PROTOCOL_STATE_ERROR;
465 silc_protocol_execute(protocol, server->schedule, 0, 300000);
469 /* Advance protocol state and call the next state if we are responder */
471 if (ctx->responder == TRUE)
472 silc_protocol_execute(protocol, server->schedule, 0, 100000);
480 if (ctx->responder == TRUE) {
481 /* Sends the selected security properties to the initiator. */
482 status = silc_ske_responder_phase_1(ctx->ske,
483 ctx->ske->start_payload);
485 /* Call Phase-1 function. This processes the Key Exchange Start
486 paylaod reply we just got from the responder. The callback
487 function will receive the processed payload where we will
489 status = silc_ske_initiator_phase_1(ctx->ske, ctx->packet->buffer);
492 /* Return now if the procedure is pending. */
493 if (status == SILC_SKE_STATUS_PENDING)
496 if (status != SILC_SKE_STATUS_OK) {
497 SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
498 silc_ske_map_status(status)));
499 SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
500 silc_ske_map_status(status)));
502 protocol->state = SILC_PROTOCOL_STATE_ERROR;
503 silc_protocol_execute(protocol, server->schedule, 0, 300000);
507 /* Advance protocol state and call next state if we are initiator */
509 if (ctx->responder == FALSE)
510 silc_protocol_execute(protocol, server->schedule, 0, 100000);
518 if (ctx->responder == TRUE) {
519 /* Process the received Key Exchange 1 Payload packet from
520 the initiator. This also creates our parts of the Diffie
521 Hellman algorithm. The silc_server_protocol_ke_continue
522 will be called after the public key has been verified. */
523 status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer);
525 /* Call the Phase-2 function. This creates Diffie Hellman
526 key exchange parameters and sends our public part inside
527 Key Exhange 1 Payload to the responder. */
528 status = silc_ske_initiator_phase_2(ctx->ske,
530 server->private_key);
534 /* Return now if the procedure is pending. */
535 if (status == SILC_SKE_STATUS_PENDING)
538 if (status != SILC_SKE_STATUS_OK) {
539 SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
540 silc_ske_map_status(status)));
541 SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
542 silc_ske_map_status(status)));
544 protocol->state = SILC_PROTOCOL_STATE_ERROR;
545 silc_protocol_execute(protocol, server->schedule, 0, 300000);
555 if (ctx->responder == TRUE) {
556 /* This creates the key exchange material and sends our
557 public parts to the initiator inside Key Exchange 2 Payload. */
558 status = silc_ske_responder_finish(ctx->ske,
561 SILC_SKE_PK_TYPE_SILC);
563 /* End the protocol on the next round */
564 protocol->state = SILC_PROTOCOL_STATE_END;
566 /* Finish the protocol. This verifies the Key Exchange 2 payload
567 sent by responder. The silc_server_protocol_ke_continue will
568 be called after the public key has been verified. */
569 status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer);
572 /* Return now if the procedure is pending. */
573 if (status == SILC_SKE_STATUS_PENDING)
576 if (status != SILC_SKE_STATUS_OK) {
577 SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
578 silc_ske_map_status(status)));
579 SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
580 silc_ske_map_status(status)));
582 protocol->state = SILC_PROTOCOL_STATE_ERROR;
583 silc_protocol_execute(protocol, server->schedule, 0, 300000);
589 case SILC_PROTOCOL_STATE_END:
594 SilcSKEKeyMaterial *keymat;
595 int key_len = silc_cipher_get_key_len(ctx->ske->prop->cipher);
596 int hash_len = ctx->ske->prop->hash->hash->hash_len;
598 /* Process the key material */
599 keymat = silc_calloc(1, sizeof(*keymat));
600 status = silc_ske_process_key_material(ctx->ske, 16, key_len, hash_len,
602 if (status != SILC_SKE_STATUS_OK) {
603 protocol->state = SILC_PROTOCOL_STATE_ERROR;
604 silc_protocol_execute(protocol, server->schedule, 0, 300000);
605 silc_ske_free_key_material(keymat);
608 ctx->keymat = keymat;
610 /* Send Ok to the other end if we are responder. If we are initiator
611 we have sent this already. */
612 if (ctx->responder == TRUE)
613 silc_ske_end(ctx->ske);
615 /* Unregister the timeout task since the protocol has ended.
616 This was the timeout task to be executed if the protocol is
617 not completed fast enough. */
618 if (ctx->timeout_task)
619 silc_schedule_task_del(server->schedule, ctx->timeout_task);
621 /* Call the final callback */
622 if (protocol->final_callback)
623 silc_protocol_execute_final(protocol, server->schedule);
625 silc_protocol_free(protocol);
629 case SILC_PROTOCOL_STATE_ERROR:
634 /* Send abort notification */
635 silc_ske_abort(ctx->ske, ctx->ske->status);
637 /* Unregister the timeout task since the protocol has ended.
638 This was the timeout task to be executed if the protocol is
639 not completed fast enough. */
640 if (ctx->timeout_task)
641 silc_schedule_task_del(server->schedule, ctx->timeout_task);
643 /* On error the final callback is always called. */
644 if (protocol->final_callback)
645 silc_protocol_execute_final(protocol, server->schedule);
647 silc_protocol_free(protocol);
650 case SILC_PROTOCOL_STATE_FAILURE:
652 * We have received failure from remote
655 /* Unregister the timeout task since the protocol has ended.
656 This was the timeout task to be executed if the protocol is
657 not completed fast enough. */
658 if (ctx->timeout_task)
659 silc_schedule_task_del(server->schedule, ctx->timeout_task);
661 /* On error the final callback is always called. */
662 if (protocol->final_callback)
663 silc_protocol_execute_final(protocol, server->schedule);
665 silc_protocol_free(protocol);
668 case SILC_PROTOCOL_STATE_UNKNOWN:
674 * Connection Authentication protocol functions
678 silc_server_password_authentication(SilcServer server, char *auth1,
681 if (!auth1 || !auth2)
684 if (!memcmp(auth1, auth2, strlen(auth1)))
691 silc_server_public_key_authentication(SilcServer server,
692 SilcPublicKey pub_key,
701 if (!pub_key || !sign)
704 silc_pkcs_alloc(pub_key->name, &pkcs);
705 if (!silc_pkcs_public_key_set(pkcs, pub_key)) {
706 silc_pkcs_free(pkcs);
710 /* Make the authentication data. Protocol says it is HASH plus
712 len = ske->hash_len + ske->start_payload_copy->len;
713 auth = silc_buffer_alloc(len);
714 silc_buffer_pull_tail(auth, len);
715 silc_buffer_format(auth,
716 SILC_STR_UI_XNSTRING(ske->hash, ske->hash_len),
717 SILC_STR_UI_XNSTRING(ske->start_payload_copy->data,
718 ske->start_payload_copy->len),
721 /* Verify signature */
722 if (silc_pkcs_verify_with_hash(pkcs, ske->prop->hash, sign, sign_len,
723 auth->data, auth->len)) {
724 silc_pkcs_free(pkcs);
725 silc_buffer_free(auth);
729 silc_pkcs_free(pkcs);
730 silc_buffer_free(auth);
735 silc_server_get_public_key_auth(SilcServer server,
736 unsigned char *auth_data,
737 uint32 *auth_data_len,
746 /* Make the authentication data. Protocol says it is HASH plus
748 len = ske->hash_len + ske->start_payload_copy->len;
749 auth = silc_buffer_alloc(len);
750 silc_buffer_pull_tail(auth, len);
751 silc_buffer_format(auth,
752 SILC_STR_UI_XNSTRING(ske->hash, ske->hash_len),
753 SILC_STR_UI_XNSTRING(ske->start_payload_copy->data,
754 ske->start_payload_copy->len),
757 if (silc_pkcs_sign_with_hash(pkcs, ske->prop->hash, auth->data,
758 auth->len, auth_data, auth_data_len)) {
759 silc_buffer_free(auth);
763 silc_buffer_free(auth);
767 /* Performs connection authentication protocol. If responder, we
768 authenticate the remote data received. If initiator, we will send
769 authentication data to the remote end. */
771 SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
773 SilcProtocol protocol = (SilcProtocol)context;
774 SilcServerConnAuthInternalContext *ctx =
775 (SilcServerConnAuthInternalContext *)protocol->context;
776 SilcServer server = (SilcServer)ctx->server;
778 SILC_LOG_DEBUG(("Start"));
780 if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
781 protocol->state = SILC_PROTOCOL_STATE_START;
783 SILC_LOG_DEBUG(("State=%d", protocol->state));
785 switch(protocol->state) {
786 case SILC_PROTOCOL_STATE_START:
792 if (ctx->responder == TRUE) {
794 * We are receiving party
799 unsigned char *auth_data = NULL;
801 SILC_LOG_INFO(("Performing authentication protocol for %s (%s)",
802 ctx->sock->hostname, ctx->sock->ip));
804 /* Parse the received authentication data packet. The received
805 payload is Connection Auth Payload. */
806 ret = silc_buffer_unformat(ctx->packet->buffer,
807 SILC_STR_UI_SHORT(&payload_len),
808 SILC_STR_UI_SHORT(&conn_type),
811 SILC_LOG_DEBUG(("Bad payload in authentication packet"));
812 protocol->state = SILC_PROTOCOL_STATE_ERROR;
813 silc_protocol_execute(protocol, server->schedule, 0, 300000);
817 if (payload_len != ctx->packet->buffer->len) {
818 SILC_LOG_DEBUG(("Bad payload in authentication packet"));
819 protocol->state = SILC_PROTOCOL_STATE_ERROR;
820 silc_protocol_execute(protocol, server->schedule, 0, 300000);
826 if (conn_type < SILC_SOCKET_TYPE_CLIENT ||
827 conn_type > SILC_SOCKET_TYPE_ROUTER) {
828 SILC_LOG_ERROR(("Bad connection type %d", conn_type));
829 protocol->state = SILC_PROTOCOL_STATE_ERROR;
830 silc_protocol_execute(protocol, server->schedule, 0, 300000);
834 if (payload_len > 0) {
835 /* Get authentication data */
836 silc_buffer_pull(ctx->packet->buffer, 4);
837 ret = silc_buffer_unformat(ctx->packet->buffer,
838 SILC_STR_UI_XNSTRING_ALLOC(&auth_data,
842 SILC_LOG_DEBUG(("Bad payload in authentication packet"));
843 protocol->state = SILC_PROTOCOL_STATE_ERROR;
844 silc_protocol_execute(protocol, server->schedule, 0, 300000);
850 * Check the remote connection type and make sure that we have
851 * configured this connection. If we haven't allowed this connection
852 * the authentication must be failed.
855 SILC_LOG_DEBUG(("Remote connection type %d", conn_type));
857 /* Remote end is client */
858 if (conn_type == SILC_SOCKET_TYPE_CLIENT) {
859 SilcServerConfigSectionClientConnection *client = ctx->cconfig;
862 switch(client->auth_meth) {
864 /* No authentication required */
865 SILC_LOG_DEBUG(("No authentication required"));
868 case SILC_AUTH_PASSWORD:
869 /* Password authentication */
870 SILC_LOG_DEBUG(("Password authentication"));
871 ret = silc_server_password_authentication(server, auth_data,
877 /* Authentication failed */
878 SILC_LOG_ERROR(("Authentication failed"));
879 SILC_LOG_DEBUG(("Authentication failed"));
880 silc_free(auth_data);
881 protocol->state = SILC_PROTOCOL_STATE_ERROR;
882 silc_protocol_execute(protocol, server->schedule,
887 case SILC_AUTH_PUBLIC_KEY:
888 /* Public key authentication */
889 SILC_LOG_DEBUG(("Public key authentication"));
890 ret = silc_server_public_key_authentication(server,
899 SILC_LOG_ERROR(("Authentication failed"));
900 SILC_LOG_DEBUG(("Authentication failed"));
901 silc_free(auth_data);
902 protocol->state = SILC_PROTOCOL_STATE_ERROR;
903 silc_protocol_execute(protocol, server->schedule,
908 SILC_LOG_DEBUG(("No configuration for remote connection"));
909 SILC_LOG_ERROR(("Remote connection not configured"));
910 SILC_LOG_ERROR(("Authentication failed"));
911 silc_free(auth_data);
912 protocol->state = SILC_PROTOCOL_STATE_ERROR;
913 silc_protocol_execute(protocol, server->schedule,
919 /* Remote end is server */
920 if (conn_type == SILC_SOCKET_TYPE_SERVER) {
921 SilcServerConfigSectionServerConnection *serv = ctx->sconfig;
924 switch(serv->auth_meth) {
926 /* No authentication required */
927 SILC_LOG_DEBUG(("No authentication required"));
930 case SILC_AUTH_PASSWORD:
931 /* Password authentication */
932 SILC_LOG_DEBUG(("Password authentication"));
933 ret = silc_server_password_authentication(server, auth_data,
939 /* Authentication failed */
940 SILC_LOG_ERROR(("Authentication failed"));
941 SILC_LOG_DEBUG(("Authentication failed"));
942 silc_free(auth_data);
943 protocol->state = SILC_PROTOCOL_STATE_ERROR;
944 silc_protocol_execute(protocol, server->schedule,
949 case SILC_AUTH_PUBLIC_KEY:
950 /* Public key authentication */
951 SILC_LOG_DEBUG(("Public key authentication"));
952 ret = silc_server_public_key_authentication(server,
961 SILC_LOG_ERROR(("Authentication failed"));
962 SILC_LOG_DEBUG(("Authentication failed"));
963 silc_free(auth_data);
964 protocol->state = SILC_PROTOCOL_STATE_ERROR;
965 silc_protocol_execute(protocol, server->schedule,
970 SILC_LOG_DEBUG(("No configuration for remote connection"));
971 SILC_LOG_ERROR(("Remote connection not configured"));
972 SILC_LOG_ERROR(("Authentication failed"));
973 protocol->state = SILC_PROTOCOL_STATE_ERROR;
974 silc_protocol_execute(protocol, server->schedule,
976 silc_free(auth_data);
981 /* Remote end is router */
982 if (conn_type == SILC_SOCKET_TYPE_ROUTER) {
983 SilcServerConfigSectionServerConnection *serv = ctx->rconfig;
986 switch(serv->auth_meth) {
988 /* No authentication required */
989 SILC_LOG_DEBUG(("No authentication required"));
992 case SILC_AUTH_PASSWORD:
993 /* Password authentication */
994 SILC_LOG_DEBUG(("Password authentication"));
995 ret = silc_server_password_authentication(server, auth_data,
1001 /* Authentication failed */
1002 SILC_LOG_ERROR(("Authentication failed"));
1003 SILC_LOG_DEBUG(("Authentication failed"));
1004 silc_free(auth_data);
1005 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1006 silc_protocol_execute(protocol, server->schedule,
1011 case SILC_AUTH_PUBLIC_KEY:
1012 /* Public key authentication */
1013 SILC_LOG_DEBUG(("Public key authentication"));
1014 ret = silc_server_public_key_authentication(server,
1023 SILC_LOG_ERROR(("Authentication failed"));
1024 SILC_LOG_DEBUG(("Authentication failed"));
1025 silc_free(auth_data);
1026 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1027 silc_protocol_execute(protocol, server->schedule,
1032 SILC_LOG_DEBUG(("No configuration for remote connection"));
1033 SILC_LOG_ERROR(("Remote connection not configured"));
1034 SILC_LOG_ERROR(("Authentication failed"));
1035 silc_free(auth_data);
1036 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1037 silc_protocol_execute(protocol, server->schedule,
1043 silc_free(auth_data);
1045 /* Save connection type. This is later used to create the
1046 ID for the connection. */
1047 ctx->conn_type = conn_type;
1049 /* Advance protocol state. */
1050 protocol->state = SILC_PROTOCOL_STATE_END;
1051 silc_protocol_execute(protocol, server->schedule, 0, 0);
1055 * We are initiator. We are authenticating ourselves to a
1056 * remote server. We will send the authentication data to the
1057 * other end for verify.
1060 int payload_len = 0;
1061 unsigned char *auth_data = NULL;
1062 uint32 auth_data_len = 0;
1064 switch(ctx->auth_meth) {
1065 case SILC_AUTH_NONE:
1066 /* No authentication required */
1069 case SILC_AUTH_PASSWORD:
1070 /* Password authentication */
1071 if (ctx->auth_data && ctx->auth_data_len) {
1072 auth_data = strdup(ctx->auth_data);
1073 auth_data_len = ctx->auth_data_len;
1078 case SILC_AUTH_PUBLIC_KEY:
1080 unsigned char sign[1024];
1082 /* Public key authentication */
1083 silc_server_get_public_key_auth(server, sign, &auth_data_len,
1085 auth_data = silc_calloc(auth_data_len, sizeof(*auth_data));
1086 memcpy(auth_data, sign, auth_data_len);
1091 payload_len = 4 + auth_data_len;
1092 packet = silc_buffer_alloc(payload_len);
1093 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1094 silc_buffer_format(packet,
1095 SILC_STR_UI_SHORT(payload_len),
1096 SILC_STR_UI_SHORT(server->server_type
1098 SILC_SOCKET_TYPE_SERVER :
1099 SILC_SOCKET_TYPE_ROUTER),
1100 SILC_STR_UI_XNSTRING(auth_data, auth_data_len),
1103 /* Send the packet to server */
1104 silc_server_packet_send(server, ctx->sock,
1105 SILC_PACKET_CONNECTION_AUTH, 0,
1106 packet->data, packet->len, TRUE);
1109 memset(auth_data, 0, auth_data_len);
1110 silc_free(auth_data);
1112 silc_buffer_free(packet);
1114 /* Next state is end of protocol */
1115 protocol->state = SILC_PROTOCOL_STATE_END;
1120 case SILC_PROTOCOL_STATE_END:
1125 unsigned char ok[4];
1127 SILC_PUT32_MSB(SILC_AUTH_OK, ok);
1129 /* Authentication successful */
1130 silc_server_packet_send(server, ctx->sock, SILC_PACKET_SUCCESS,
1133 /* Unregister the timeout task since the protocol has ended.
1134 This was the timeout task to be executed if the protocol is
1135 not completed fast enough. */
1136 if (ctx->timeout_task)
1137 silc_schedule_task_del(server->schedule, ctx->timeout_task);
1139 /* Protocol has ended, call the final callback */
1140 if (protocol->final_callback)
1141 silc_protocol_execute_final(protocol, server->schedule);
1143 silc_protocol_free(protocol);
1146 case SILC_PROTOCOL_STATE_ERROR:
1149 * Error. Send notify to remote.
1151 unsigned char error[4];
1153 SILC_PUT32_MSB(SILC_AUTH_FAILED, error);
1155 /* Authentication failed */
1156 silc_server_packet_send(server, ctx->sock, SILC_PACKET_FAILURE,
1159 /* Unregister the timeout task since the protocol has ended.
1160 This was the timeout task to be executed if the protocol is
1161 not completed fast enough. */
1162 if (ctx->timeout_task)
1163 silc_schedule_task_del(server->schedule, ctx->timeout_task);
1165 /* On error the final callback is always called. */
1166 if (protocol->final_callback)
1167 silc_protocol_execute_final(protocol, server->schedule);
1169 silc_protocol_free(protocol);
1173 case SILC_PROTOCOL_STATE_FAILURE:
1175 * We have received failure from remote
1178 /* Unregister the timeout task since the protocol has ended.
1179 This was the timeout task to be executed if the protocol is
1180 not completed fast enough. */
1181 if (ctx->timeout_task)
1182 silc_schedule_task_del(server->schedule, ctx->timeout_task);
1184 /* On error the final callback is always called. */
1185 if (protocol->final_callback)
1186 silc_protocol_execute_final(protocol, server->schedule);
1188 silc_protocol_free(protocol);
1191 case SILC_PROTOCOL_STATE_UNKNOWN:
1197 * Re-key protocol routines
1200 /* Actually takes the new keys into use. */
1203 silc_server_protocol_rekey_validate(SilcServer server,
1204 SilcServerRekeyInternalContext *ctx,
1205 SilcIDListData idata,
1206 SilcSKEKeyMaterial *keymat,
1209 if (ctx->responder == TRUE) {
1211 silc_cipher_set_key(idata->send_key, keymat->receive_enc_key,
1212 keymat->enc_key_len);
1213 silc_cipher_set_iv(idata->send_key, keymat->receive_iv);
1215 silc_cipher_set_key(idata->receive_key, keymat->send_enc_key,
1216 keymat->enc_key_len);
1217 silc_cipher_set_iv(idata->receive_key, keymat->send_iv);
1221 silc_cipher_set_key(idata->send_key, keymat->send_enc_key,
1222 keymat->enc_key_len);
1223 silc_cipher_set_iv(idata->send_key, keymat->send_iv);
1225 silc_cipher_set_key(idata->receive_key, keymat->receive_enc_key,
1226 keymat->enc_key_len);
1227 silc_cipher_set_iv(idata->receive_key, keymat->receive_iv);
1232 silc_hmac_alloc((char *)silc_hmac_get_name(idata->hmac_send), NULL,
1234 silc_hmac_set_key(idata->hmac_send, keymat->hmac_key,
1235 keymat->hmac_key_len);
1237 silc_hmac_free(idata->hmac_receive);
1238 idata->hmac_receive = idata->hmac_send;
1241 /* Save the current sending encryption key */
1243 memset(idata->rekey->send_enc_key, 0, idata->rekey->enc_key_len);
1244 silc_free(idata->rekey->send_enc_key);
1245 idata->rekey->send_enc_key =
1246 silc_calloc(keymat->enc_key_len / 8,
1247 sizeof(*idata->rekey->send_enc_key));
1248 memcpy(idata->rekey->send_enc_key, keymat->send_enc_key,
1249 keymat->enc_key_len / 8);
1250 idata->rekey->enc_key_len = keymat->enc_key_len / 8;
1254 /* This function actually re-generates (when not using PFS) the keys and
1255 takes them into use. */
1257 void silc_server_protocol_rekey_generate(SilcServer server,
1258 SilcServerRekeyInternalContext *ctx,
1261 SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1262 SilcSKEKeyMaterial *keymat;
1263 uint32 key_len = silc_cipher_get_key_len(idata->send_key);
1264 uint32 hash_len = idata->hash->hash->hash_len;
1266 SILC_LOG_DEBUG(("Generating new %s session keys (no PFS)",
1267 send ? "sending" : "receiving"));
1269 /* Generate the new key */
1270 keymat = silc_calloc(1, sizeof(*keymat));
1271 silc_ske_process_key_material_data(idata->rekey->send_enc_key,
1272 idata->rekey->enc_key_len,
1273 16, key_len, hash_len,
1274 idata->hash, keymat);
1276 /* Set the keys into use */
1277 silc_server_protocol_rekey_validate(server, ctx, idata, keymat, send);
1279 silc_ske_free_key_material(keymat);
1282 /* This function actually re-generates (with PFS) the keys and
1283 takes them into use. */
1286 silc_server_protocol_rekey_generate_pfs(SilcServer server,
1287 SilcServerRekeyInternalContext *ctx,
1290 SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1291 SilcSKEKeyMaterial *keymat;
1292 uint32 key_len = silc_cipher_get_key_len(idata->send_key);
1293 uint32 hash_len = idata->hash->hash->hash_len;
1294 unsigned char *tmpbuf;
1297 SILC_LOG_DEBUG(("Generating new %s session keys (with PFS)",
1298 send ? "sending" : "receiving"));
1300 /* Encode KEY to binary data */
1301 tmpbuf = silc_mp_mp2bin(ctx->ske->KEY, 0, &klen);
1303 /* Generate the new key */
1304 keymat = silc_calloc(1, sizeof(*keymat));
1305 silc_ske_process_key_material_data(tmpbuf, klen, 16, key_len, hash_len,
1306 idata->hash, keymat);
1308 /* Set the keys into use */
1309 silc_server_protocol_rekey_validate(server, ctx, idata, keymat, send);
1311 memset(tmpbuf, 0, klen);
1313 silc_ske_free_key_material(keymat);
1316 /* Packet sending callback. This function is provided as packet sending
1317 routine to the Key Exchange functions. */
1320 silc_server_protocol_rekey_send_packet(SilcSKE ske,
1322 SilcPacketType type,
1325 SilcProtocol protocol = (SilcProtocol)context;
1326 SilcServerRekeyInternalContext *ctx =
1327 (SilcServerRekeyInternalContext *)protocol->context;
1328 SilcServer server = (SilcServer)ctx->server;
1330 /* Send the packet immediately */
1331 silc_server_packet_send(server, ctx->sock,
1332 type, 0, packet->data, packet->len, FALSE);
1335 /* Performs re-key as defined in the SILC protocol specification. */
1337 SILC_TASK_CALLBACK(silc_server_protocol_rekey)
1339 SilcProtocol protocol = (SilcProtocol)context;
1340 SilcServerRekeyInternalContext *ctx =
1341 (SilcServerRekeyInternalContext *)protocol->context;
1342 SilcServer server = (SilcServer)ctx->server;
1343 SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
1344 SilcSKEStatus status;
1346 SILC_LOG_DEBUG(("Start"));
1348 if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
1349 protocol->state = SILC_PROTOCOL_STATE_START;
1351 SILC_LOG_DEBUG(("State=%d", protocol->state));
1353 switch(protocol->state) {
1354 case SILC_PROTOCOL_STATE_START:
1360 if (ctx->responder == TRUE) {
1362 * We are receiving party
1365 if (ctx->pfs == TRUE) {
1367 * Use Perfect Forward Secrecy, ie. negotiate the key material
1368 * using the SKE protocol.
1371 if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_1) {
1372 /* Error in protocol */
1373 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1374 silc_protocol_execute(protocol, server->schedule, 0, 300000);
1378 ctx->ske = silc_ske_alloc();
1379 ctx->ske->rng = server->rng;
1380 ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
1381 silc_ske_get_group_by_number(idata->rekey->ske_group,
1382 &ctx->ske->prop->group);
1384 silc_ske_set_callbacks(ctx->ske,
1385 silc_server_protocol_rekey_send_packet,
1386 NULL, NULL, NULL, silc_ske_check_version,
1389 status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer);
1390 if (status != SILC_SKE_STATUS_OK) {
1391 SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
1392 silc_ske_map_status(status)));
1394 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1395 silc_protocol_execute(protocol, server->schedule, 0, 300000);
1399 /* Advance the protocol state */
1401 silc_protocol_execute(protocol, server->schedule, 0, 0);
1404 * Do normal and simple re-key.
1407 /* Send the REKEY_DONE to indicate we will take new keys into use */
1408 silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1411 /* After we send REKEY_DONE we must set the sending encryption
1412 key to the new key since all packets after this packet must
1413 encrypted with the new key. */
1414 silc_server_protocol_rekey_generate(server, ctx, TRUE);
1416 /* The protocol ends in next stage. */
1417 protocol->state = SILC_PROTOCOL_STATE_END;
1422 * We are the initiator of this protocol
1425 /* Start the re-key by sending the REKEY packet */
1426 silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY,
1429 if (ctx->pfs == TRUE) {
1431 * Use Perfect Forward Secrecy, ie. negotiate the key material
1432 * using the SKE protocol.
1434 ctx->ske = silc_ske_alloc();
1435 ctx->ske->rng = server->rng;
1436 ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
1437 silc_ske_get_group_by_number(idata->rekey->ske_group,
1438 &ctx->ske->prop->group);
1440 silc_ske_set_callbacks(ctx->ske,
1441 silc_server_protocol_rekey_send_packet,
1442 NULL, NULL, NULL, silc_ske_check_version,
1445 status = silc_ske_initiator_phase_2(ctx->ske, NULL, NULL);
1446 if (status != SILC_SKE_STATUS_OK) {
1447 SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
1448 silc_ske_map_status(status)));
1450 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1451 silc_protocol_execute(protocol, server->schedule, 0, 300000);
1455 /* Advance the protocol state */
1459 * Do normal and simple re-key.
1462 /* Send the REKEY_DONE to indicate we will take new keys into use
1464 silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1467 /* After we send REKEY_DONE we must set the sending encryption
1468 key to the new key since all packets after this packet must
1469 encrypted with the new key. */
1470 silc_server_protocol_rekey_generate(server, ctx, TRUE);
1472 /* The protocol ends in next stage. */
1473 protocol->state = SILC_PROTOCOL_STATE_END;
1481 * Second state, used only when oding re-key with PFS.
1483 if (ctx->responder == TRUE) {
1484 if (ctx->pfs == TRUE) {
1486 * Send our KE packe to the initiator now that we've processed
1487 * the initiator's KE packet.
1489 status = silc_ske_responder_finish(ctx->ske, NULL, NULL,
1490 SILC_SKE_PK_TYPE_SILC);
1491 if (status != SILC_SKE_STATUS_OK) {
1492 SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
1493 silc_ske_map_status(status)));
1495 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1496 silc_protocol_execute(protocol, server->schedule, 0, 300000);
1502 if (ctx->pfs == TRUE) {
1504 * The packet type must be KE packet
1506 if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_2) {
1507 /* Error in protocol */
1508 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1509 silc_protocol_execute(protocol, server->schedule, 0, 300000);
1513 status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer);
1514 if (status != SILC_SKE_STATUS_OK) {
1515 SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
1516 silc_ske_map_status(status)));
1518 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1519 silc_protocol_execute(protocol, server->schedule, 0, 300000);
1525 /* Send the REKEY_DONE to indicate we will take new keys into use
1527 silc_server_packet_send(server, ctx->sock, SILC_PACKET_REKEY_DONE,
1530 /* After we send REKEY_DONE we must set the sending encryption
1531 key to the new key since all packets after this packet must
1532 encrypted with the new key. */
1533 silc_server_protocol_rekey_generate_pfs(server, ctx, TRUE);
1535 /* The protocol ends in next stage. */
1536 protocol->state = SILC_PROTOCOL_STATE_END;
1539 case SILC_PROTOCOL_STATE_END:
1544 if (ctx->packet->type != SILC_PACKET_REKEY_DONE) {
1545 /* Error in protocol */
1546 protocol->state = SILC_PROTOCOL_STATE_ERROR;
1547 silc_protocol_execute(protocol, server->schedule, 0, 300000);
1551 /* We received the REKEY_DONE packet and all packets after this is
1552 encrypted with the new key so set the decryption key to the new key */
1553 silc_server_protocol_rekey_generate(server, ctx, FALSE);
1555 /* Protocol has ended, call the final callback */
1556 if (protocol->final_callback)
1557 silc_protocol_execute_final(protocol, server->schedule);
1559 silc_protocol_free(protocol);
1562 case SILC_PROTOCOL_STATE_ERROR:
1567 if (ctx->pfs == TRUE) {
1568 /* Send abort notification */
1569 silc_ske_abort(ctx->ske, ctx->ske->status);
1572 /* On error the final callback is always called. */
1573 if (protocol->final_callback)
1574 silc_protocol_execute_final(protocol, server->schedule);
1576 silc_protocol_free(protocol);
1579 case SILC_PROTOCOL_STATE_FAILURE:
1581 * We have received failure from remote
1584 /* On error the final callback is always called. */
1585 if (protocol->final_callback)
1586 silc_protocol_execute_final(protocol, server->schedule);
1588 silc_protocol_free(protocol);
1591 case SILC_PROTOCOL_STATE_UNKNOWN:
1597 /* Registers protocols used in server. */
1599 void silc_server_protocols_register(void)
1601 silc_protocol_register(SILC_PROTOCOL_SERVER_CONNECTION_AUTH,
1602 silc_server_protocol_connection_auth);
1603 silc_protocol_register(SILC_PROTOCOL_SERVER_KEY_EXCHANGE,
1604 silc_server_protocol_key_exchange);
1605 silc_protocol_register(SILC_PROTOCOL_SERVER_REKEY,
1606 silc_server_protocol_rekey);
1607 silc_protocol_register(SILC_PROTOCOL_SERVER_BACKUP,
1608 silc_server_protocol_backup);
1611 /* Unregisters protocols */
1613 void silc_server_protocols_unregister(void)
1615 silc_protocol_unregister(SILC_PROTOCOL_SERVER_CONNECTION_AUTH,
1616 silc_server_protocol_connection_auth);
1617 silc_protocol_unregister(SILC_PROTOCOL_SERVER_KEY_EXCHANGE,
1618 silc_server_protocol_key_exchange);
1619 silc_protocol_unregister(SILC_PROTOCOL_SERVER_REKEY,
1620 silc_server_protocol_rekey);
1621 silc_protocol_unregister(SILC_PROTOCOL_SERVER_BACKUP,
1622 silc_server_protocol_backup);