lib/silcclient/protocol.c

   1 /*
   2
   3   protocol.c
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 1997 - 2000 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /*
  21  * Client side of the protocols.
  22  */
  23 /* $Id$ */
  24
  25 #include "clientlibincludes.h"
  26
  27 SILC_TASK_CALLBACK(silc_client_protocol_connection_auth);
  28 SILC_TASK_CALLBACK(silc_client_protocol_key_exchange);
  29
  30 extern char *silc_version_string;
  31
  32 /*
  33  * Key Exhange protocol functions
  34  */
  35
  36 /* Function that is called when SKE protocol sends packets to network. */
  37
  38 static void silc_client_protocol_ke_send_packet(SilcSKE ske,
  39                                                 SilcBuffer packet,
  40                                                 SilcPacketType type,
  41                                                 void *context)
  42 {
  43   SilcProtocol protocol = (SilcProtocol)context;
  44   SilcClientKEInternalContext *ctx =
  45     (SilcClientKEInternalContext *)protocol->context;
  46   SilcClient client = (SilcClient)ctx->client;
  47
  48   /* Send the packet immediately */
  49   silc_client_packet_send(client, ske->sock, type, NULL, 0, NULL, NULL,
  50                           packet->data, packet->len, TRUE);
  51
  52 }
  53
  54 /* Callback that is called when we have received KE2 payload from
  55    responder. We try to verify the public key now. */
  56
  57 static SilcSKEStatus
  58 silc_client_protocol_ke_verify_key(SilcSKE ske,
  59                                    unsigned char *pk_data,
  60                                    unsigned int pk_len,
  61                                    SilcSKEPKType pk_type,
  62                                    void *context)
  63 {
  64   SilcProtocol protocol = (SilcProtocol)context;
  65   SilcClientKEInternalContext *ctx =
  66     (SilcClientKEInternalContext *)protocol->context;
  67   SilcClient client = (SilcClient)ctx->client;
  68
  69   SILC_LOG_DEBUG(("Start"));
  70
  71   /* Verify server key from user. */
  72   if (!client->ops->verify_server_key(client, ctx->sock->user_data,
  73                                       pk_data, pk_len, pk_type))
  74     return SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY;
  75
  76   return SILC_SKE_STATUS_OK;
  77 }
  78
  79 /* Sets the negotiated key material into use for particular connection. */
  80
  81 static void silc_client_protocol_ke_set_keys(SilcSKE ske,
  82                                              SilcSocketConnection sock,
  83                                              SilcSKEKeyMaterial *keymat,
  84                                              SilcCipher cipher,
  85                                              SilcPKCS pkcs,
  86                                              SilcHash hash)
  87 {
  88   SilcClientConnection conn = (SilcClientConnection)sock->user_data;
  89   SilcHash nhash;
  90
  91   SILC_LOG_DEBUG(("Setting new keys into use"));
  92
  93   /* Allocate cipher to be used in the communication */
  94   silc_cipher_alloc(cipher->cipher->name, &conn->send_key);
  95   silc_cipher_alloc(cipher->cipher->name, &conn->receive_key);
  96
  97   conn->send_key->cipher->set_key(conn->send_key->context,
  98                                  keymat->send_enc_key,
  99                                  keymat->enc_key_len);
 100   conn->send_key->set_iv(conn->send_key, keymat->send_iv);
 101   conn->receive_key->cipher->set_key(conn->receive_key->context,
 102                                     keymat->receive_enc_key,
 103                                     keymat->enc_key_len);
 104   conn->receive_key->set_iv(conn->receive_key, keymat->receive_iv);
 105
 106   /* Allocate PKCS to be used */
 107 #if 0
 108   /* XXX Do we ever need to allocate PKCS for the connection??
 109      If yes, we need to change KE protocol to get the initiators
 110      public key. */
 111   silc_pkcs_alloc(pkcs->pkcs->name, &conn->public_Key);
 112   silc_pkcs_set_public_key(conn->public_key, ske->ke2_payload->pk_data,
 113                            ske->ke2_payload->pk_len);
 114 #endif
 115
 116   /* Save HMAC key to be used in the communication. */
 117   silc_hash_alloc(hash->hash->name, &nhash);
 118   silc_hmac_alloc(nhash, &conn->hmac);
 119   silc_hmac_set_key(conn->hmac, keymat->hmac_key, keymat->hmac_key_len);
 120 }
 121
 122 /* Checks the version string of the server. */
 123
 124 SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
 125                                      unsigned int len)
 126 {
 127   SilcSocketConnection conn = (SilcSocketConnection)ske->sock->user_data;
 128   SilcClient client = (SilcClient)ske->user_data;
 129   SilcSKEStatus status = SILC_SKE_STATUS_OK;
 130
 131   /* Check for initial version string */
 132   if (!strstr(version, "SILC-1.0-"))
 133     status = SILC_SKE_STATUS_BAD_VERSION;
 134
 135   /* Check software version */
 136
 137   if (len < strlen(silc_version_string))
 138     status = SILC_SKE_STATUS_BAD_VERSION;
 139
 140   /* XXX for now there is no other tests due to the abnormal version
 141      string that is used */
 142
 143   if (status != SILC_SKE_STATUS_OK)
 144     client->ops->say(client, conn,
 145                      "We don't support server version `%s'", version);
 146
 147   return status;
 148 }
 149
 150 /* Performs key exchange protocol. This is used for both initiator
 151    and responder key exchange. This may be called recursively. */
 152
 153 SILC_TASK_CALLBACK(silc_client_protocol_key_exchange)
 154 {
 155   SilcProtocol protocol = (SilcProtocol)context;
 156   SilcClientKEInternalContext *ctx =
 157     (SilcClientKEInternalContext *)protocol->context;
 158   SilcClient client = (SilcClient)ctx->client;
 159   SilcClientConnection conn = ctx->sock->user_data;
 160   SilcSKEStatus status = 0;
 161
 162   SILC_LOG_DEBUG(("Start"));
 163
 164   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 165     protocol->state = SILC_PROTOCOL_STATE_START;
 166
 167   switch(protocol->state) {
 168   case SILC_PROTOCOL_STATE_START:
 169     {
 170       /*
 171        * Start Protocol
 172        */
 173       SilcSKE ske;
 174
 175       /* Allocate Key Exchange object */
 176       ske = silc_ske_alloc();
 177       ctx->ske = ske;
 178       ske->rng = client->rng;
 179       ske->user_data = (void *)client;
 180
 181       if (ctx->responder == TRUE) {
 182 #if 0
 183         SilcBuffer start_payload;
 184
 185
 186         /* Start the key exchange by processing the received security
 187            properties packet from initiator. */
 188         status = silc_ske_responder_start(ske, ctx->rng, ctx->sock,
 189                                           start_payload,
 190                                           silc_client_protocol_ke_send_packet,
 191                                           context);
 192 #endif
 193       } else {
 194         SilcSKEStartPayload *start_payload;
 195
 196         /* Assemble security properties. */
 197         silc_ske_assemble_security_properties(ske, SILC_SKE_SP_FLAG_NONE,
 198                                               silc_version_string,
 199                                               &start_payload);
 200
 201         /* Start the key exchange by sending our security properties
 202            to the remote end. */
 203         status = silc_ske_initiator_start(ske, ctx->rng, ctx->sock,
 204                                           start_payload,
 205                                           silc_client_protocol_ke_send_packet,
 206                                           context);
 207       }
 208
 209       if (status != SILC_SKE_STATUS_OK) {
 210         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 211                           status));
 212         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 213                         status));
 214
 215         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 216         protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 217         return;
 218       }
 219
 220       /* Advance the state of the protocol. */
 221       protocol->state++;
 222     }
 223     break;
 224   case 2:
 225     {
 226       /*
 227        * Phase 1
 228        */
 229       if (ctx->responder == TRUE) {
 230 #if 0
 231         status =
 232           silc_ske_responder_phase_1(ctx->ske,
 233                                      ctx->ske->start_payload,
 234                                      silc_server_protocol_ke_send_packet,
 235                                      context);
 236 #endif
 237       } else {
 238         /* Call Phase-1 function. This processes the Key Exchange Start
 239            paylaod reply we just got from the responder. The callback
 240            function will receive the processed payload where we will
 241            save it. */
 242         status = silc_ske_initiator_phase_1(ctx->ske, ctx->packet->buffer,
 243                                             NULL, NULL);
 244       }
 245
 246       if (status != SILC_SKE_STATUS_OK) {
 247         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 248                           status));
 249         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 250                         status));
 251
 252         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 253         protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 254         return;
 255       }
 256
 257       /* Advance the state of the protocol and call the next state. */
 258       protocol->state++;
 259       protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 260     }
 261     break;
 262   case 3:
 263     {
 264       /*
 265        * Phase 2
 266        */
 267       if (ctx->responder == TRUE) {
 268 #if 0
 269         status =
 270           silc_ske_responder_phase_2(ctx->ske,
 271                                      ctx->ske->start_payload,
 272                                      silc_server_protocol_ke_send_packet,
 273                                      context);
 274 #endif
 275       } else {
 276         /* Call the Phase-2 function. This creates Diffie Hellman
 277            key exchange parameters and sends our public part inside
 278            Key Exhange 1 Payload to the responder. */
 279         status =
 280           silc_ske_initiator_phase_2(ctx->ske,
 281                                      client->public_key,
 282                                      silc_client_protocol_ke_send_packet,
 283                                      context);
 284       }
 285
 286       if (status != SILC_SKE_STATUS_OK) {
 287         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 288                           status));
 289         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 290                         status));
 291
 292         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 293         protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 294         return;
 295       }
 296
 297       /* Advance the state of the protocol. */
 298       protocol->state++;
 299     }
 300     break;
 301   case 4:
 302     {
 303       /*
 304        * Finish protocol
 305        */
 306       if (ctx->responder == TRUE) {
 307         status = 0;
 308 #if 0
 309         status =
 310           silc_ske_responder_phase_2(ctx->ske,
 311                                      ctx->ske->start_payload,
 312                                      silc_server_protocol_ke_send_packet,
 313                                      context);
 314 #endif
 315       } else {
 316         /* Finish the protocol. This verifies the Key Exchange 2 payload
 317            sent by responder. */
 318         status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer,
 319                                            silc_client_protocol_ke_verify_key,
 320                                            context, NULL, NULL);
 321       }
 322
 323       if (status != SILC_SKE_STATUS_OK) {
 324
 325         if (status == SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY) {
 326           client->ops->say(client, conn,
 327                            "Received unsupported server %s public key",
 328                            ctx->sock->hostname);
 329         } else {
 330           client->ops->say(client, conn,
 331                            "Error during key exchange protocol with server %s",
 332                            ctx->sock->hostname);
 333         }
 334         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 335         protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 336         return;
 337       }
 338
 339       /* Send Ok to the other end. We will end the protocol as server
 340          sends Ok to us when we will take the new keys into use. */
 341       silc_ske_end(ctx->ske, silc_client_protocol_ke_send_packet, context);
 342
 343       /* End the protocol on the next round */
 344       protocol->state = SILC_PROTOCOL_STATE_END;
 345     }
 346     break;
 347
 348   case SILC_PROTOCOL_STATE_END:
 349     {
 350       /*
 351        * End protocol
 352        */
 353       SilcSKEKeyMaterial *keymat;
 354
 355       /* Process the key material */
 356       keymat = silc_calloc(1, sizeof(*keymat));
 357       silc_ske_process_key_material(ctx->ske, 16, (16 * 8), 16, keymat);
 358
 359       /* Take the negotiated keys into use. */
 360       silc_client_protocol_ke_set_keys(ctx->ske, ctx->sock, keymat,
 361                                        ctx->ske->prop->cipher,
 362                                        ctx->ske->prop->pkcs,
 363                                        ctx->ske->prop->hash);
 364
 365       /* Protocol has ended, call the final callback */
 366       if (protocol->final_callback)
 367         protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 368       else
 369         silc_protocol_free(protocol);
 370     }
 371     break;
 372
 373   case SILC_PROTOCOL_STATE_ERROR:
 374     /*
 375      * Error during protocol
 376      */
 377
 378     /* Send abort notification */
 379     silc_ske_abort(ctx->ske, ctx->ske->status,
 380                    silc_client_protocol_ke_send_packet,
 381                    context);
 382
 383     /* On error the final callback is always called. */
 384     if (protocol->final_callback)
 385       protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 386     else
 387       silc_protocol_free(protocol);
 388     break;
 389
 390   case SILC_PROTOCOL_STATE_FAILURE:
 391     /*
 392      * Received failure from remote.
 393      */
 394
 395     /* On error the final callback is always called. */
 396     if (protocol->final_callback)
 397       protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 398     else
 399       silc_protocol_free(protocol);
 400     break;
 401   case SILC_PROTOCOL_STATE_UNKNOWN:
 402     break;
 403   }
 404 }
 405
 406 /*
 407  * Connection Authentication protocol functions
 408  */
 409
 410 SILC_TASK_CALLBACK(silc_client_protocol_connection_auth)
 411 {
 412   SilcProtocol protocol = (SilcProtocol)context;
 413   SilcClientConnAuthInternalContext *ctx =
 414     (SilcClientConnAuthInternalContext *)protocol->context;
 415   SilcClient client = (SilcClient)ctx->client;
 416   SilcClientConnection conn = ctx->sock->user_data;
 417
 418   SILC_LOG_DEBUG(("Start"));
 419
 420   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 421     protocol->state = SILC_PROTOCOL_STATE_START;
 422
 423   switch(protocol->state) {
 424   case SILC_PROTOCOL_STATE_START:
 425     {
 426       /*
 427        * Start protocol. We send authentication data to the server
 428        * to be authenticated.
 429        */
 430       SilcBuffer packet;
 431       int payload_len = 0;
 432       unsigned char *auth_data = NULL;
 433       unsigned int auth_data_len = 0;
 434
 435       switch(ctx->auth_meth) {
 436       case SILC_AUTH_NONE:
 437         /* No authentication required */
 438         break;
 439
 440       case SILC_AUTH_PASSWORD:
 441         /* Password authentication */
 442         if (ctx->auth_data && ctx->auth_data_len) {
 443           auth_data = ctx->auth_data;
 444           auth_data_len = ctx->auth_data_len;
 445           break;
 446         }
 447
 448         client->ops->say(client, conn,
 449                          "Password authentication required by server %s",
 450                          ctx->sock->hostname);
 451         auth_data = client->ops->ask_passphrase(client, conn);
 452         auth_data_len = strlen(auth_data);
 453         break;
 454
 455       case SILC_AUTH_PUBLIC_KEY:
 456         /* XXX */
 457         break;
 458       }
 459
 460       payload_len = 4 + auth_data_len;
 461       packet = silc_buffer_alloc(payload_len);
 462       silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
 463       silc_buffer_format(packet,
 464                          SILC_STR_UI_SHORT(payload_len),
 465                          SILC_STR_UI_SHORT(SILC_SOCKET_TYPE_CLIENT),
 466                          SILC_STR_UI_XNSTRING(auth_data, auth_data_len),
 467                          SILC_STR_END);
 468
 469       /* Send the packet to server */
 470       silc_client_packet_send(client, ctx->sock,
 471                               SILC_PACKET_CONNECTION_AUTH,
 472                               NULL, 0, NULL, NULL,
 473                               packet->data, packet->len, TRUE);
 474
 475       if (auth_data) {
 476         memset(auth_data, 0, auth_data_len);
 477         silc_free(auth_data);
 478       }
 479       silc_buffer_free(packet);
 480
 481       /* Next state is end of protocol */
 482       protocol->state = SILC_PROTOCOL_STATE_END;
 483     }
 484     break;
 485
 486   case SILC_PROTOCOL_STATE_END:
 487     {
 488       /*
 489        * End protocol. Nothing special to be done here.
 490        */
 491
 492       /* Protocol has ended, call the final callback */
 493       if (protocol->final_callback)
 494         protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 495       else
 496         silc_protocol_free(protocol);
 497     }
 498     break;
 499
 500   case SILC_PROTOCOL_STATE_ERROR:
 501     {
 502       /*
 503        * Error. Send notify to remote.
 504        */
 505       unsigned char error[4];
 506
 507       SILC_PUT32_MSB(SILC_AUTH_FAILED, error);
 508
 509       /* Error in protocol. Send FAILURE packet. Although I don't think
 510          this could ever happen on client side. */
 511       silc_client_packet_send(client, ctx->sock, SILC_PACKET_FAILURE,
 512                               NULL, 0, NULL, NULL, error, 4, TRUE);
 513
 514       /* On error the final callback is always called. */
 515       if (protocol->final_callback)
 516         protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 517       else
 518         silc_protocol_free(protocol);
 519     }
 520
 521   case SILC_PROTOCOL_STATE_FAILURE:
 522     /*
 523      * Received failure from remote.
 524      */
 525
 526     /* On error the final callback is always called. */
 527     if (protocol->final_callback)
 528       protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 529     else
 530       silc_protocol_free(protocol);
 531     break;
 532
 533   case SILC_PROTOCOL_STATE_UNKNOWN:
 534     break;
 535   }
 536 }
 537
 538 /* Registers protocols used in client */
 539
 540 void silc_client_protocols_register(void)
 541 {
 542   silc_protocol_register(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
 543                          silc_client_protocol_connection_auth);
 544   silc_protocol_register(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
 545                          silc_client_protocol_key_exchange);
 546 }
 547
 548 /* Unregisters protocols */
 549
 550 void silc_client_protocols_unregister(void)
 551 {
 552   silc_protocol_unregister(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
 553                            silc_client_protocol_connection_auth);
 554   silc_protocol_unregister(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
 555                            silc_client_protocol_key_exchange);
 556 }