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 /* XXX TODO */
 123
 124 SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
 125                                      unsigned int len)
 126 {
 127   return SILC_SKE_STATUS_OK;
 128 }
 129
 130 /* Performs key exchange protocol. This is used for both initiator
 131    and responder key exchange. This may be called recursively. */
 132
 133 SILC_TASK_CALLBACK(silc_client_protocol_key_exchange)
 134 {
 135   SilcProtocol protocol = (SilcProtocol)context;
 136   SilcClientKEInternalContext *ctx =
 137     (SilcClientKEInternalContext *)protocol->context;
 138   SilcClient client = (SilcClient)ctx->client;
 139   SilcClientConnection conn = ctx->sock->user_data;
 140   SilcSKEStatus status = 0;
 141
 142   SILC_LOG_DEBUG(("Start"));
 143
 144   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 145     protocol->state = SILC_PROTOCOL_STATE_START;
 146
 147   switch(protocol->state) {
 148   case SILC_PROTOCOL_STATE_START:
 149     {
 150       /*
 151        * Start Protocol
 152        */
 153       SilcSKE ske;
 154
 155       /* Allocate Key Exchange object */
 156       ske = silc_ske_alloc();
 157       ctx->ske = ske;
 158       ske->rng = client->rng;
 159
 160       if (ctx->responder == TRUE) {
 161 #if 0
 162         SilcBuffer start_payload;
 163
 164
 165         /* Start the key exchange by processing the received security
 166            properties packet from initiator. */
 167         status = silc_ske_responder_start(ske, ctx->rng, ctx->sock,
 168                                           start_payload,
 169                                           silc_client_protocol_ke_send_packet,
 170                                           context);
 171 #endif
 172       } else {
 173         SilcSKEStartPayload *start_payload;
 174
 175         /* Assemble security properties. */
 176         silc_ske_assemble_security_properties(ske, SILC_SKE_SP_FLAG_NONE,
 177                                               silc_version_string,
 178                                               &start_payload);
 179
 180         /* Start the key exchange by sending our security properties
 181            to the remote end. */
 182         status = silc_ske_initiator_start(ske, ctx->rng, ctx->sock,
 183                                           start_payload,
 184                                           silc_client_protocol_ke_send_packet,
 185                                           context);
 186       }
 187
 188       if (status != SILC_SKE_STATUS_OK) {
 189         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 190                           status));
 191         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 192                         status));
 193
 194         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 195         protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 196         return;
 197       }
 198
 199       /* Advance the state of the protocol. */
 200       protocol->state++;
 201     }
 202     break;
 203   case 2:
 204     {
 205       /*
 206        * Phase 1
 207        */
 208       if (ctx->responder == TRUE) {
 209 #if 0
 210         status =
 211           silc_ske_responder_phase_1(ctx->ske,
 212                                      ctx->ske->start_payload,
 213                                      silc_server_protocol_ke_send_packet,
 214                                      context);
 215 #endif
 216       } else {
 217         /* Call Phase-1 function. This processes the Key Exchange Start
 218            paylaod reply we just got from the responder. The callback
 219            function will receive the processed payload where we will
 220            save it. */
 221         status = silc_ske_initiator_phase_1(ctx->ske, ctx->packet, NULL, NULL);
 222       }
 223
 224       if (status != SILC_SKE_STATUS_OK) {
 225         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 226                           status));
 227         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 228                         status));
 229
 230         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 231         protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 232         return;
 233       }
 234
 235       /* Advance the state of the protocol and call the next state. */
 236       protocol->state++;
 237       protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 238     }
 239     break;
 240   case 3:
 241     {
 242       /*
 243        * Phase 2
 244        */
 245       if (ctx->responder == TRUE) {
 246 #if 0
 247         status =
 248           silc_ske_responder_phase_2(ctx->ske,
 249                                      ctx->ske->start_payload,
 250                                      silc_server_protocol_ke_send_packet,
 251                                      context);
 252 #endif
 253       } else {
 254         /* Call the Phase-2 function. This creates Diffie Hellman
 255            key exchange parameters and sends our public part inside
 256            Key Exhange 1 Payload to the responder. */
 257         status =
 258           silc_ske_initiator_phase_2(ctx->ske,
 259                                      client->public_key,
 260                                      silc_client_protocol_ke_send_packet,
 261                                      context);
 262       }
 263
 264       if (status != SILC_SKE_STATUS_OK) {
 265         SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol",
 266                           status));
 267         SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol",
 268                         status));
 269
 270         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 271         protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 272         return;
 273       }
 274
 275       /* Advance the state of the protocol. */
 276       protocol->state++;
 277     }
 278     break;
 279   case 4:
 280     {
 281       /*
 282        * Finish protocol
 283        */
 284       if (ctx->responder == TRUE) {
 285         status = 0;
 286 #if 0
 287         status =
 288           silc_ske_responder_phase_2(ctx->ske,
 289                                      ctx->ske->start_payload,
 290                                      silc_server_protocol_ke_send_packet,
 291                                      context);
 292 #endif
 293       } else {
 294         /* Finish the protocol. This verifies the Key Exchange 2 payload
 295            sent by responder. */
 296         status = silc_ske_initiator_finish(ctx->ske, ctx->packet,
 297                                            silc_client_protocol_ke_verify_key,
 298                                            context, NULL, NULL);
 299       }
 300
 301       if (status != SILC_SKE_STATUS_OK) {
 302
 303         if (status == SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY) {
 304           client->ops->say(client, conn,
 305                            "Received unsupported server %s public key",
 306                            ctx->sock->hostname);
 307         } else {
 308           client->ops->say(client, conn,
 309                            "Error during key exchange protocol with server %s",
 310                            ctx->sock->hostname);
 311         }
 312         protocol->state = SILC_PROTOCOL_STATE_ERROR;
 313         protocol->execute(client->timeout_queue, 0, protocol, fd, 0, 0);
 314         return;
 315       }
 316
 317       /* Send Ok to the other end. We will end the protocol as server
 318          sends Ok to us when we will take the new keys into use. */
 319       silc_ske_end(ctx->ske, silc_client_protocol_ke_send_packet, context);
 320
 321       /* End the protocol on the next round */
 322       protocol->state = SILC_PROTOCOL_STATE_END;
 323     }
 324     break;
 325
 326   case SILC_PROTOCOL_STATE_END:
 327     {
 328       /*
 329        * End protocol
 330        */
 331       SilcSKEKeyMaterial *keymat;
 332
 333       /* Process the key material */
 334       keymat = silc_calloc(1, sizeof(*keymat));
 335       silc_ske_process_key_material(ctx->ske, 16, (16 * 8), 16, keymat);
 336
 337       /* Take the negotiated keys into use. */
 338       silc_client_protocol_ke_set_keys(ctx->ske, ctx->sock, keymat,
 339                                        ctx->ske->prop->cipher,
 340                                        ctx->ske->prop->pkcs,
 341                                        ctx->ske->prop->hash);
 342
 343       /* Protocol has ended, call the final callback */
 344       if (protocol->final_callback)
 345         protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 346       else
 347         silc_protocol_free(protocol);
 348     }
 349     break;
 350
 351   case SILC_PROTOCOL_STATE_ERROR:
 352     /*
 353      * Error during protocol
 354      */
 355
 356     /* Send abort notification */
 357     silc_ske_abort(ctx->ske, ctx->ske->status,
 358                    silc_client_protocol_ke_send_packet,
 359                    context);
 360
 361     /* On error the final callback is always called. */
 362     if (protocol->final_callback)
 363       protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 364     else
 365       silc_protocol_free(protocol);
 366     break;
 367
 368   case SILC_PROTOCOL_STATE_FAILURE:
 369     /*
 370      * Received failure from remote.
 371      */
 372
 373     /* On error the final callback is always called. */
 374     if (protocol->final_callback)
 375       protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 376     else
 377       silc_protocol_free(protocol);
 378     break;
 379   case SILC_PROTOCOL_STATE_UNKNOWN:
 380     break;
 381   }
 382 }
 383
 384 /*
 385  * Connection Authentication protocol functions
 386  */
 387
 388 SILC_TASK_CALLBACK(silc_client_protocol_connection_auth)
 389 {
 390   SilcProtocol protocol = (SilcProtocol)context;
 391   SilcClientConnAuthInternalContext *ctx =
 392     (SilcClientConnAuthInternalContext *)protocol->context;
 393   SilcClient client = (SilcClient)ctx->client;
 394   SilcClientConnection conn = ctx->sock->user_data;
 395
 396   SILC_LOG_DEBUG(("Start"));
 397
 398   if (protocol->state == SILC_PROTOCOL_STATE_UNKNOWN)
 399     protocol->state = SILC_PROTOCOL_STATE_START;
 400
 401   switch(protocol->state) {
 402   case SILC_PROTOCOL_STATE_START:
 403     {
 404       /*
 405        * Start protocol. We send authentication data to the server
 406        * to be authenticated.
 407        */
 408       SilcBuffer packet;
 409       int payload_len = 0;
 410       unsigned char *auth_data = NULL;
 411       unsigned int auth_data_len = 0;
 412
 413       switch(ctx->auth_meth) {
 414       case SILC_PROTOCOL_CONN_AUTH_NONE:
 415         /* No authentication required */
 416         break;
 417
 418       case SILC_PROTOCOL_CONN_AUTH_PASSWORD:
 419         /* Password authentication */
 420         if (ctx->auth_data && ctx->auth_data_len) {
 421           auth_data = ctx->auth_data;
 422           auth_data_len = ctx->auth_data_len;
 423           break;
 424         }
 425
 426         client->ops->say(client, conn,
 427                          "Password authentication required by server %s",
 428                          ctx->sock->hostname);
 429         auth_data = client->ops->ask_passphrase(client, conn);
 430         auth_data_len = strlen(auth_data);
 431         break;
 432
 433       case SILC_PROTOCOL_CONN_AUTH_PUBLIC_KEY:
 434         /* XXX */
 435         break;
 436       }
 437
 438       payload_len = 4 + auth_data_len;
 439       packet = silc_buffer_alloc(payload_len);
 440       silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
 441       silc_buffer_format(packet,
 442                          SILC_STR_UI_SHORT(payload_len),
 443                          SILC_STR_UI_SHORT(SILC_SOCKET_TYPE_CLIENT),
 444                          SILC_STR_UI_XNSTRING(auth_data, auth_data_len),
 445                          SILC_STR_END);
 446
 447       /* Send the packet to server */
 448       silc_client_packet_send(client, ctx->sock,
 449                               SILC_PACKET_CONNECTION_AUTH,
 450                               NULL, 0, NULL, NULL,
 451                               packet->data, packet->len, TRUE);
 452
 453       if (auth_data) {
 454         memset(auth_data, 0, auth_data_len);
 455         silc_free(auth_data);
 456       }
 457       silc_buffer_free(packet);
 458
 459       /* Next state is end of protocol */
 460       protocol->state = SILC_PROTOCOL_STATE_END;
 461     }
 462     break;
 463
 464   case SILC_PROTOCOL_STATE_END:
 465     {
 466       /*
 467        * End protocol. Nothing special to be done here.
 468        */
 469
 470       /* Protocol has ended, call the final callback */
 471       if (protocol->final_callback)
 472         protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 473       else
 474         silc_protocol_free(protocol);
 475     }
 476     break;
 477
 478   case SILC_PROTOCOL_STATE_ERROR:
 479     {
 480       /*
 481        * Error. Send notify to remote.
 482        */
 483       unsigned char error[4];
 484
 485       SILC_PUT32_MSB(SILC_CONN_AUTH_FAILED, error);
 486
 487       /* Error in protocol. Send FAILURE packet. Although I don't think
 488          this could ever happen on client side. */
 489       silc_client_packet_send(client, ctx->sock, SILC_PACKET_FAILURE,
 490                               NULL, 0, NULL, NULL, error, 4, TRUE);
 491
 492       /* On error the final callback is always called. */
 493       if (protocol->final_callback)
 494         protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 495       else
 496         silc_protocol_free(protocol);
 497     }
 498
 499   case SILC_PROTOCOL_STATE_FAILURE:
 500     /*
 501      * Received failure from remote.
 502      */
 503
 504     /* On error the final callback is always called. */
 505     if (protocol->final_callback)
 506       protocol->execute_final(client->timeout_queue, 0, protocol, fd);
 507     else
 508       silc_protocol_free(protocol);
 509     break;
 510
 511   case SILC_PROTOCOL_STATE_UNKNOWN:
 512     break;
 513   }
 514 }
 515
 516 /* Registers protocols used in client */
 517
 518 void silc_client_protocols_register(void)
 519 {
 520   silc_protocol_register(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
 521                          silc_client_protocol_connection_auth);
 522   silc_protocol_register(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
 523                          silc_client_protocol_key_exchange);
 524 }
 525
 526 /* Unregisters protocols */
 527
 528 void silc_client_protocols_unregister(void)
 529 {
 530   silc_protocol_unregister(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
 531                            silc_client_protocol_connection_auth);
 532   silc_protocol_unregister(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
 533                            silc_client_protocol_key_exchange);
 534 }