git.tinc-vpn.org Git - tinc/blob - src/protocol.c

   1 /*
   2     protocol.c -- handle the meta-protocol
   3     Copyright (C) 1999-2001 Ivo Timmermans <itimmermans@bigfoot.com>,
   4                   2000,2001 Guus Sliepen <guus@sliepen.warande.net>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20     $Id: protocol.c,v 1.28.4.94 2001/06/09 10:00:34 guus Exp $
  21 */
  22
  23 #include "config.h"
  24
  25 #include <sys/types.h>
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <syslog.h>
  30 #include <sys/socket.h>
  31 #include <unistd.h>
  32 #include <stdio.h>
  33 #include <stdarg.h>
  34 #include <errno.h>
  35
  36 #include <utils.h>
  37 #include <xalloc.h>
  38 #include <avl_tree.h>
  39 #include <list.h>
  40
  41 #include <netinet/in.h>
  42
  43 #ifdef HAVE_OPENSSL_SHA_H
  44 # include <openssl/sha.h>
  45 #else
  46 # include <sha.h>
  47 #endif
  48
  49 #ifdef HAVE_OPENSSL_RAND_H
  50 # include <openssl/rand.h>
  51 #else
  52 # include <rand.h>
  53 #endif
  54
  55 #ifdef HAVE_OPENSSL_EVP_H
  56 # include <openssl/evp.h>
  57 #else
  58 # include <evp.h>
  59 #endif
  60
  61
  62 #include "conf.h"
  63 #include "net.h"
  64 #include "netutl.h"
  65 #include "protocol.h"
  66 #include "meta.h"
  67 #include "connection.h"
  68
  69 #include "system.h"
  70
  71 int mykeyused = 0;
  72
  73 int check_id(char *id)
  74 {
  75   int i;
  76
  77   for (i = 0; i < strlen(id); i++)
  78     if(!isalnum(id[i]) && id[i] != '_')
  79       return -1;
  80
  81   return 0;
  82 }
  83
  84 /* Generic request routines - takes care of logging and error
  85    detection as well */
  86
  87 int send_request(connection_t *cl, const char *format, ...)
  88 {
  89   va_list args;
  90   char buffer[MAXBUFSIZE];
  91   int len, request;
  92
  93 cp
  94   /* Use vsnprintf instead of vasprintf: faster, no memory
  95      fragmentation, cleanup is automatic, and there is a limit on the
  96      input buffer anyway */
  97
  98   va_start(args, format);
  99   len = vsnprintf(buffer, MAXBUFSIZE, format, args);
 100   request = va_arg(args, int);
 101   va_end(args);
 102
 103   if(len < 0 || len > MAXBUFSIZE-1)
 104     {
 105       syslog(LOG_ERR, _("Output buffer overflow while sending %s to %s (%s)"), request_name[request], cl->name, cl->hostname);
 106       return -1;
 107     }
 108
 109   if(debug_lvl >= DEBUG_PROTOCOL)
 110     {
 111       if(debug_lvl >= DEBUG_META)
 112         syslog(LOG_DEBUG, _("Sending %s to %s (%s): %s"), request_name[request], cl->name, cl->hostname, buffer);
 113       else
 114         syslog(LOG_DEBUG, _("Sending %s to %s (%s)"), request_name[request], cl->name, cl->hostname);
 115     }
 116
 117   buffer[len++] = '\n';
 118 cp
 119   return send_meta(cl, buffer, len);
 120 }
 121
 122 int receive_request(connection_t *cl)
 123 {
 124   int request;
 125 cp
 126   if(sscanf(cl->buffer, "%d", &request) == 1)
 127     {
 128       if((request < 0) || (request >= LAST) || (request_handlers[request] == NULL))
 129         {
 130           if(debug_lvl >= DEBUG_META)
 131             syslog(LOG_DEBUG, _("Unknown request from %s (%s): %s"),
 132                    cl->name, cl->hostname, cl->buffer);
 133           else
 134             syslog(LOG_ERR, _("Unknown request from %s (%s)"),
 135                    cl->name, cl->hostname);
 136
 137           return -1;
 138         }
 139       else
 140         {
 141           if(debug_lvl >= DEBUG_PROTOCOL)
 142             {
 143               if(debug_lvl >= DEBUG_META)
 144                 syslog(LOG_DEBUG, _("Got %s from %s (%s): %s"),
 145                        request_name[request], cl->name, cl->hostname, cl->buffer);
 146               else
 147                 syslog(LOG_DEBUG, _("Got %s from %s (%s)"),
 148                        request_name[request], cl->name, cl->hostname);
 149             }
 150         }
 151
 152       if((cl->allow_request != ALL) && (cl->allow_request != request))
 153         {
 154           syslog(LOG_ERR, _("Unauthorized request from %s (%s)"), cl->name, cl->hostname);
 155           return -1;
 156         }
 157
 158       if(request_handlers[request](cl))
 159         /* Something went wrong. Probably scriptkiddies. Terminate. */
 160         {
 161           syslog(LOG_ERR, _("Error while processing %s from %s (%s)"),
 162                  request_name[request], cl->name, cl->hostname);
 163           return -1;
 164         }
 165     }
 166   else
 167     {
 168       syslog(LOG_ERR, _("Bogus data received from %s (%s)"),
 169              cl->name, cl->hostname);
 170       return -1;
 171     }
 172 cp
 173   return 0;
 174 }
 175
 176 /* The authentication protocol is described in detail in doc/SECURITY2,
 177    the rest will be described in doc/PROTOCOL. */
 178
 179 int send_id(connection_t *cl)
 180 {
 181 cp
 182   return send_request(cl, "%d %s %d %lx %hd", ID, myself->name, myself->protocol_version, myself->options, myself->port);
 183 }
 184
 185 int id_h(connection_t *cl)
 186 {
 187   connection_t *old;
 188   unsigned short int port;
 189   char name[MAX_STRING_SIZE];
 190   avl_node_t *node;
 191 cp
 192   if(sscanf(cl->buffer, "%*d "MAX_STRING" %d %lx %hd", name, &cl->protocol_version, &cl->options, &port) != 4)
 193     {
 194        syslog(LOG_ERR, _("Got bad ID from %s"), cl->hostname);
 195        return -1;
 196     }
 197
 198   /* Check if version matches */
 199
 200   if(cl->protocol_version != myself->protocol_version)
 201     {
 202       syslog(LOG_ERR, _("Peer %s (%s) uses incompatible version %d"),
 203              cl->name, cl->hostname, cl->protocol_version);
 204       return -1;
 205     }
 206
 207   /* Check if identity is a valid name */
 208
 209   if(check_id(name))
 210     {
 211       syslog(LOG_ERR, _("Peer %s uses invalid identity name"), cl->hostname);
 212       return -1;
 213     }
 214
 215   /* Copy string to cl */
 216
 217   if(cl->name)
 218     free(cl->name);
 219
 220   cl->name = xstrdup(name);
 221
 222   /* Load information about peer */
 223
 224   if(read_host_config(cl))
 225     {
 226       syslog(LOG_ERR, _("Peer %s had unknown identity (%s)"), cl->hostname, cl->name);
 227       return -1;
 228     }
 229
 230   /* First check if the host we connected to is already in our
 231      connection list. If so, we are probably making a loop, which
 232      is not desirable.
 233    */
 234
 235   if(cl->status.outgoing)
 236     {
 237       if((old = lookup_id(cl->name)))
 238         {
 239           if(debug_lvl >= DEBUG_CONNECTIONS)
 240             syslog(LOG_NOTICE, _("Uplink %s (%s) is already in our connection list"), cl->name, cl->hostname);
 241           cl->status.outgoing = 0;
 242           old->status.outgoing = 1;
 243           terminate_connection(cl);
 244           return 0;
 245         }
 246     }
 247
 248   /* Now we can add the name to the id tree */
 249
 250   id_add(cl);
 251
 252   /* And uhr... cl->port just changed so we have to unlink it from the connection tree and re-insert... */
 253
 254   node = avl_unlink(connection_tree, cl);
 255   cl->port = port;
 256   avl_insert_node(connection_tree, node);
 257
 258   /* Read in the public key, so that we can send a metakey */
 259
 260   if(read_rsa_public_key(cl))
 261     return -1;
 262
 263   cl->allow_request = METAKEY;
 264 cp
 265   return send_metakey(cl);
 266 }
 267
 268 int ack_h(connection_t *cl)
 269 {
 270   config_t const *cfg;
 271   connection_t *old, *p;
 272   subnet_t *subnet;
 273   avl_node_t *node, *node2;
 274 cp
 275   /* Okay, before we active the connection, we check if there is another entry
 276      in the connection list with the same name. If so, it presumably is an
 277      old connection that has timed out but we don't know it yet.
 278    */
 279
 280   while((old = lookup_id(cl->name)))
 281     {
 282       if(debug_lvl >= DEBUG_CONNECTIONS)
 283         syslog(LOG_NOTICE, _("Removing old entry for %s at %s in favour of new connection from %s"),
 284         cl->name, old->hostname, cl->hostname);
 285
 286       terminate_connection(old);
 287     }
 288
 289   /* Activate this connection */
 290
 291   cl->allow_request = ALL;
 292   cl->status.active = 1;
 293   cl->nexthop = cl;
 294   cl->cipher_pkttype = EVP_bf_cbc();
 295   cl->cipher_pktkeylength = cl->cipher_pkttype->key_len + cl->cipher_pkttype->iv_len;
 296
 297   if(debug_lvl >= DEBUG_CONNECTIONS)
 298     syslog(LOG_NOTICE, _("Connection with %s (%s) activated"), cl->name, cl->hostname);
 299
 300   if(cl->status.outgoing)
 301     seconds_till_retry = 5;     /* Reset retry timeout */
 302 cp
 303   /* Check some options */
 304
 305   if((cfg = get_config_val(cl->config, config_indirectdata)))
 306     {
 307       if(cfg->data.val == stupid_true)
 308         cl->options |= OPTION_INDIRECT;
 309     }
 310
 311   if((cfg = get_config_val(cl->config, config_tcponly)))
 312     {
 313       if(cfg->data.val == stupid_true)
 314         cl->options |= OPTION_TCPONLY;
 315     }
 316
 317   /* Send him our subnets */
 318
 319   for(node = myself->subnet_tree->head; node; node = node->next)
 320     {
 321       subnet = (subnet_t *)node->data;
 322       send_add_subnet(cl, subnet);
 323     }
 324
 325   /* And send him all the hosts and their subnets we know... */
 326
 327   for(node = connection_tree->head; node; node = node->next)
 328     {
 329       p = (connection_t *)node->data;
 330
 331       if(p != cl && p->status.active)
 332         {
 333           /* Notify others of this connection */
 334
 335           if(p->status.meta)
 336             send_add_host(p, cl);
 337
 338           /* Notify new connection of everything we know */
 339
 340           send_add_host(cl, p);
 341
 342           for(node2 = p->subnet_tree->head; node2; node2 = node2->next)
 343             {
 344               subnet = (subnet_t *)node2->data;
 345               send_add_subnet(cl, subnet);
 346             }
 347         }
 348     }
 349 cp
 350   return 0;
 351 }
 352
 353 int send_challenge(connection_t *cl)
 354 {
 355   char *buffer;
 356   int len, x;
 357 cp
 358   /* CHECKME: what is most reasonable value for len? */
 359
 360   len = RSA_size(cl->rsa_key);
 361
 362   /* Allocate buffers for the challenge */
 363
 364   buffer = xmalloc(len*2+1);
 365
 366   if(cl->hischallenge)
 367     free(cl->hischallenge);
 368
 369   cl->hischallenge = xmalloc(len);
 370 cp
 371   /* Copy random data to the buffer */
 372
 373   RAND_bytes(cl->hischallenge, len);
 374
 375 cp
 376   /* Convert to hex */
 377
 378   bin2hex(cl->hischallenge, buffer, len);
 379   buffer[len*2] = '\0';
 380
 381 cp
 382   /* Send the challenge */
 383
 384   x = send_request(cl, "%d %s", CHALLENGE, buffer);
 385   free(buffer);
 386 cp
 387   return x;
 388 }
 389
 390 int challenge_h(connection_t *cl)
 391 {
 392   char buffer[MAX_STRING_SIZE];
 393   int len;
 394 cp
 395   if(sscanf(cl->buffer, "%*d "MAX_STRING, buffer) != 1)
 396     {
 397        syslog(LOG_ERR, _("Got bad CHALLENGE from %s (%s)"), cl->name, cl->hostname);
 398        return -1;
 399     }
 400
 401   len = RSA_size(myself->rsa_key);
 402
 403   /* Check if the length of the challenge is all right */
 404
 405   if(strlen(buffer) != len*2)
 406     {
 407       syslog(LOG_ERR, _("Intruder: wrong challenge length from %s (%s)"), cl->name, cl->hostname);
 408       return -1;
 409     }
 410
 411   /* Allocate buffers for the challenge */
 412
 413   if(!cl->mychallenge)
 414     cl->mychallenge = xmalloc(len);
 415
 416   /* Convert the challenge from hexadecimal back to binary */
 417
 418   hex2bin(buffer,cl->mychallenge,len);
 419
 420   cl->allow_request = CHAL_REPLY;
 421
 422   /* Rest is done by send_chal_reply() */
 423 cp
 424   return send_chal_reply(cl);
 425 }
 426
 427 int send_chal_reply(connection_t *cl)
 428 {
 429   char hash[SHA_DIGEST_LENGTH*2+1];
 430 cp
 431   if(!cl->mychallenge)
 432     {
 433       syslog(LOG_ERR, _("Trying to send CHAL_REPLY to %s (%s) without a valid CHALLENGE"), cl->name, cl->hostname);
 434       return -1;
 435     }
 436
 437   /* Calculate the hash from the challenge we received */
 438
 439   SHA1(cl->mychallenge, RSA_size(myself->rsa_key), hash);
 440
 441   /* Convert the hash to a hexadecimal formatted string */
 442
 443   bin2hex(hash,hash,SHA_DIGEST_LENGTH);
 444   hash[SHA_DIGEST_LENGTH*2] = '\0';
 445
 446   /* Send the reply */
 447
 448 cp
 449   return send_request(cl, "%d %s", CHAL_REPLY, hash);
 450 }
 451
 452 int chal_reply_h(connection_t *cl)
 453 {
 454   char hishash[MAX_STRING_SIZE];
 455   char myhash[SHA_DIGEST_LENGTH];
 456 cp
 457   if(sscanf(cl->buffer, "%*d "MAX_STRING, hishash) != 1)
 458     {
 459        syslog(LOG_ERR, _("Got bad CHAL_REPLY from %s (%s)"), cl->name, cl->hostname);
 460        return -1;
 461     }
 462
 463   /* Check if the length of the hash is all right */
 464
 465   if(strlen(hishash) != SHA_DIGEST_LENGTH*2)
 466     {
 467       syslog(LOG_ERR, _("Intruder: wrong challenge reply length from %s (%s)"), cl->name, cl->hostname);
 468       return -1;
 469     }
 470
 471   /* Convert the hash to binary format */
 472
 473   hex2bin(hishash, hishash, SHA_DIGEST_LENGTH);
 474
 475   /* Calculate the hash from the challenge we sent */
 476
 477   SHA1(cl->hischallenge, RSA_size(cl->rsa_key), myhash);
 478
 479   /* Verify the incoming hash with the calculated hash */
 480
 481   if(memcmp(hishash, myhash, SHA_DIGEST_LENGTH))
 482     {
 483       syslog(LOG_ERR, _("Intruder: wrong challenge reply from %s (%s)"), cl->name, cl->hostname);
 484       if(debug_lvl >= DEBUG_SCARY_THINGS)
 485         {
 486           bin2hex(myhash, hishash, SHA_DIGEST_LENGTH);
 487           hishash[SHA_DIGEST_LENGTH*2] = '\0';
 488           syslog(LOG_DEBUG, _("Expected challenge reply: %s"), hishash);
 489         }
 490       return -1;
 491     }
 492
 493   /* Identity has now been positively verified.
 494      ack_h() handles the rest from now on.
 495    */
 496 cp
 497   return ack_h(cl);
 498 }
 499
 500 int send_metakey(connection_t *cl)
 501 {
 502   char *buffer;
 503   int len, x;
 504 cp
 505   len = RSA_size(cl->rsa_key);
 506
 507   /* Allocate buffers for the meta key */
 508
 509   buffer = xmalloc(len*2+1);
 510
 511   if(!cl->cipher_outkey)
 512     cl->cipher_outkey = xmalloc(len);
 513
 514   if(!cl->cipher_outctx)
 515     cl->cipher_outctx = xmalloc(sizeof(*cl->cipher_outctx));
 516 cp
 517   /* Copy random data to the buffer */
 518
 519   RAND_bytes(cl->cipher_outkey, len);
 520
 521   /* The message we send must be smaller than the modulus of the RSA key.
 522      By definition, for a key of k bits, the following formula holds:
 523
 524        2^(k-1) <= modulus < 2^(k)
 525
 526      Where ^ means "to the power of", not "xor".
 527      This means that to be sure, we must choose our message < 2^(k-1).
 528      This can be done by setting the most significant bit to zero.
 529   */
 530
 531   cl->cipher_outkey[0] &= 0x7F;
 532
 533   if(debug_lvl >= DEBUG_SCARY_THINGS)
 534     {
 535       bin2hex(cl->cipher_outkey, buffer, len);
 536       buffer[len*2] = '\0';
 537       syslog(LOG_DEBUG, _("Generated random meta key (unencrypted): %s"), buffer);
 538     }
 539
 540   /* Encrypt the random data
 541
 542      We do not use one of the PKCS padding schemes here.
 543      This is allowed, because we encrypt a totally random string
 544      with a length equal to that of the modulus of the RSA key.
 545   */
 546
 547   if(RSA_public_encrypt(len, cl->cipher_outkey, buffer, cl->rsa_key, RSA_NO_PADDING) != len)
 548     {
 549       syslog(LOG_ERR, _("Error during encryption of meta key for %s (%s)"), cl->name, cl->hostname);
 550       free(buffer);
 551       return -1;
 552     }
 553 cp
 554   /* Convert the encrypted random data to a hexadecimal formatted string */
 555
 556   bin2hex(buffer, buffer, len);
 557   buffer[len*2] = '\0';
 558
 559   /* Send the meta key */
 560
 561   x = send_request(cl, "%d %s", METAKEY, buffer);
 562   free(buffer);
 563
 564   /* Further outgoing requests are encrypted with the key we just generated */
 565
 566   EVP_EncryptInit(cl->cipher_outctx, EVP_bf_cfb(),
 567                   cl->cipher_outkey + len - EVP_bf_cfb()->key_len,
 568                   cl->cipher_outkey + len - EVP_bf_cfb()->key_len - EVP_bf_cfb()->iv_len);
 569
 570   cl->status.encryptout = 1;
 571 cp
 572   return x;
 573 }
 574
 575 int metakey_h(connection_t *cl)
 576 {
 577   char buffer[MAX_STRING_SIZE];
 578   int len;
 579 cp
 580   if(sscanf(cl->buffer, "%*d "MAX_STRING, buffer) != 1)
 581     {
 582        syslog(LOG_ERR, _("Got bad METAKEY from %s (%s)"), cl->name, cl->hostname);
 583        return -1;
 584     }
 585
 586   len = RSA_size(myself->rsa_key);
 587
 588   /* Check if the length of the meta key is all right */
 589
 590   if(strlen(buffer) != len*2)
 591     {
 592       syslog(LOG_ERR, _("Intruder: wrong meta key length from %s (%s)"), cl->name, cl->hostname);
 593       return -1;
 594     }
 595
 596   /* Allocate buffers for the meta key */
 597
 598   if(!cl->cipher_inkey)
 599     cl->cipher_inkey = xmalloc(len);
 600
 601   if(!cl->cipher_inctx)
 602     cl->cipher_inctx = xmalloc(sizeof(*cl->cipher_inctx));
 603
 604   /* Convert the challenge from hexadecimal back to binary */
 605
 606   hex2bin(buffer,buffer,len);
 607
 608   /* Decrypt the meta key */
 609
 610   if(RSA_private_decrypt(len, buffer, cl->cipher_inkey, myself->rsa_key, RSA_NO_PADDING) != len)        /* See challenge() */
 611     {
 612       syslog(LOG_ERR, _("Error during encryption of meta key for %s (%s)"), cl->name, cl->hostname);
 613       return -1;
 614     }
 615
 616   if(debug_lvl >= DEBUG_SCARY_THINGS)
 617     {
 618       bin2hex(cl->cipher_inkey, buffer, len);
 619       buffer[len*2] = '\0';
 620       syslog(LOG_DEBUG, _("Received random meta key (unencrypted): %s"), buffer);
 621     }
 622
 623   /* All incoming requests will now be encrypted. */
 624
 625   EVP_DecryptInit(cl->cipher_inctx, EVP_bf_cfb(),
 626                   cl->cipher_inkey + len - EVP_bf_cfb()->key_len,
 627                   cl->cipher_inkey + len - EVP_bf_cfb()->key_len - EVP_bf_cfb()->iv_len);
 628
 629   cl->status.decryptin = 1;
 630
 631   cl->allow_request = CHALLENGE;
 632 cp
 633   return send_challenge(cl);
 634 }
 635
 636 /* Address and subnet information exchange */
 637
 638 int send_add_subnet(connection_t *cl, subnet_t *subnet)
 639 {
 640   int x;
 641   char *netstr;
 642   char *owner;
 643 cp
 644   if((cl->options | myself->options | subnet->owner->options) & OPTION_INDIRECT)
 645     owner = myself->name;
 646   else
 647     owner = subnet->owner->name;
 648
 649   x = send_request(cl, "%d %s %s", ADD_SUBNET,
 650                       owner, netstr = net2str(subnet));
 651   free(netstr);
 652 cp
 653   return x;
 654 }
 655
 656 int add_subnet_h(connection_t *cl)
 657 {
 658   char subnetstr[MAX_STRING_SIZE];
 659   char name[MAX_STRING_SIZE];
 660   connection_t *owner, *p;
 661   subnet_t *subnet;
 662   avl_node_t *node;
 663 cp
 664   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, name, subnetstr) != 2)
 665     {
 666       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s)"), cl->name, cl->hostname);
 667       return -1;
 668     }
 669
 670   /* Check if owner name is a valid */
 671
 672   if(check_id(name))
 673     {
 674       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s): invalid identity name"), cl->name, cl->hostname);
 675       return -1;
 676     }
 677
 678   /* Check if subnet string is valid */
 679
 680   if(!(subnet = str2net(subnetstr)))
 681     {
 682       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s): invalid subnet string"), cl->name, cl->hostname);
 683       return -1;
 684     }
 685
 686   /* Check if somebody tries to add a subnet of ourself */
 687
 688   if(!strcmp(name, myself->name))
 689     {
 690       syslog(LOG_ERR, _("Warning: got ADD_SUBNET from %s (%s) for ourself, restarting"),
 691              cl->name, cl->hostname);
 692       sighup = 1;
 693       return 0;
 694     }
 695
 696   /* Check if the owner of the new subnet is in the connection list */
 697
 698   if(!(owner = lookup_id(name)))
 699     {
 700       syslog(LOG_ERR, _("Got ADD_SUBNET for %s from %s (%s) which is not in our connection list"),
 701              name, cl->name, cl->hostname);
 702       return -1;
 703     }
 704
 705   /* If everything is correct, add the subnet to the list of the owner */
 706
 707   subnet_add(owner, subnet);
 708
 709   /* Tell the rest */
 710
 711   for(node = connection_tree->head; node; node = node->next)
 712     {
 713       p = (connection_t *)node->data;
 714       if(p->status.meta && p->status.active && p!= cl)
 715         send_add_subnet(p, subnet);
 716     }
 717 cp
 718   return 0;
 719 }
 720
 721 int send_del_subnet(connection_t *cl, subnet_t *subnet)
 722 {
 723   int x;
 724   char *netstr;
 725   char *owner;
 726 cp
 727   if(cl->options & OPTION_INDIRECT)
 728     owner = myself->name;
 729   else
 730     owner = subnet->owner->name;
 731
 732   x = send_request(cl, "%d %s %s", DEL_SUBNET, owner, netstr = net2str(subnet));
 733   free(netstr);
 734 cp
 735   return x;
 736 }
 737
 738 int del_subnet_h(connection_t *cl)
 739 {
 740   char subnetstr[MAX_STRING_SIZE];
 741   char name[MAX_STRING_SIZE];
 742   connection_t *owner, *p;
 743   subnet_t *subnet;
 744   avl_node_t *node;
 745 cp
 746   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, name, subnetstr) != 3)
 747     {
 748       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s)"), cl->name, cl->hostname);
 749       return -1;
 750     }
 751
 752   /* Check if owner name is a valid */
 753
 754   if(check_id(name))
 755     {
 756       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s): invalid identity name"), cl->name, cl->hostname);
 757       return -1;
 758     }
 759
 760   /* Check if subnet string is valid */
 761
 762   if(!(subnet = str2net(subnetstr)))
 763     {
 764       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s): invalid subnet string"), cl->name, cl->hostname);
 765       return -1;
 766     }
 767
 768   free(subnetstr);
 769
 770   /* Check if somebody tries to add a subnet of ourself */
 771
 772   if(!strcmp(name, myself->name))
 773     {
 774       syslog(LOG_ERR, _("Warning: got DEL_SUBNET from %s (%s) for ourself, restarting"),
 775              cl->name, cl->hostname);
 776       sighup = 1;
 777       return 0;
 778     }
 779
 780   /* Check if the owner of the new subnet is in the connection list */
 781
 782   if(!(owner = lookup_id(name)))
 783     {
 784       syslog(LOG_ERR, _("Got DEL_SUBNET for %s from %s (%s) which is not in our connection list"),
 785              name, cl->name, cl->hostname);
 786       return -1;
 787     }
 788
 789   /* If everything is correct, delete the subnet from the list of the owner */
 790
 791   subnet_del(subnet);
 792
 793   /* Tell the rest */
 794
 795   for(node = connection_tree->head; node; node = node->next)
 796     {
 797       p = (connection_t *)node->data;
 798       if(p->status.meta && p->status.active && p!= cl)
 799         send_del_subnet(p, subnet);
 800     }
 801 cp
 802   return 0;
 803 }
 804
 805 /* New and closed connections notification */
 806
 807 int send_add_host(connection_t *cl, connection_t *other)
 808 {
 809 cp
 810   if(!((cl->options | myself->options | other->options) & OPTION_INDIRECT))
 811     return send_request(cl, "%d %s %lx:%d %lx", ADD_HOST,
 812                       other->name, other->address, other->port, other->options);
 813   else
 814     return 0;
 815 }
 816
 817 int add_host_h(connection_t *cl)
 818 {
 819   connection_t *old, *new, *p;
 820   char name[MAX_STRING_SIZE];
 821   avl_node_t *node;
 822 cp
 823   new = new_connection();
 824
 825   if(sscanf(cl->buffer, "%*d "MAX_STRING" %lx:%hd %lx", name, &new->address, &new->port, &new->options) != 4)
 826     {
 827        syslog(LOG_ERR, _("Got bad ADD_HOST from %s (%s)"), cl->name, cl->hostname);
 828        return -1;
 829     }
 830
 831   /* Check if identity is a valid name */
 832
 833   if(check_id(name))
 834     {
 835       syslog(LOG_ERR, _("Got bad ADD_HOST from %s (%s): invalid identity name"), cl->name, cl->hostname);
 836       free_connection(new);
 837       return -1;
 838     }
 839
 840   /* Check if somebody tries to add ourself */
 841
 842   if(!strcmp(name, myself->name))
 843     {
 844       syslog(LOG_ERR, _("Warning: got ADD_HOST from %s (%s) for ourself, restarting"), cl->name, cl->hostname);
 845       sighup = 1;
 846       free_connection(new);
 847       return 0;
 848     }
 849
 850   /* Fill in more of the new connection structure */
 851
 852   new->hostname = hostlookup(htonl(new->address));
 853
 854   /* Check if the new host already exists in the connnection list */
 855
 856   if((old = lookup_id(name)))
 857     {
 858       if((new->address == old->address) && (new->port == old->port))
 859         {
 860           if(debug_lvl >= DEBUG_CONNECTIONS)
 861             syslog(LOG_NOTICE, _("Got duplicate ADD_HOST for %s (%s) from %s (%s)"),
 862                    old->name, old->hostname, name, new->hostname);
 863           free_connection(new);
 864           return 0;
 865         }
 866       else
 867         {
 868           if(debug_lvl >= DEBUG_CONNECTIONS)
 869             syslog(LOG_NOTICE, _("Removing old entry for %s (%s) in favour of new connection"),
 870                    old->name, old->hostname);
 871
 872           terminate_connection(old);
 873         }
 874     }
 875
 876   /* Hook it up into the connection */
 877
 878   new->name = xstrdup(name);
 879   connection_add(new);
 880   id_add(new);
 881
 882   /* Tell the rest about the new host */
 883
 884   for(node = connection_tree->head; node; node = node->next)
 885     {
 886       p = (connection_t *)node->data;
 887       if(p->status.meta && p->status.active && p!=cl)
 888         send_add_host(p, new);
 889     }
 890
 891   /* Fill in rest of connection structure */
 892
 893   new->nexthop = cl;
 894   new->status.active = 1;
 895   new->cipher_pkttype = EVP_bf_cbc();
 896   new->cipher_pktkeylength = cl->cipher_pkttype->key_len + cl->cipher_pkttype->iv_len;
 897 cp
 898   return 0;
 899 }
 900
 901 int send_del_host(connection_t *cl, connection_t *other)
 902 {
 903 cp
 904   if(!((cl->options | myself->options) & OPTION_INDIRECT))
 905     return send_request(cl, "%d %s %lx:%d %lx", DEL_HOST,
 906                       other->name, other->address, other->port, other->options);
 907   else
 908     return 0;
 909 }
 910
 911 int del_host_h(connection_t *cl)
 912 {
 913   char name[MAX_STRING_SIZE];
 914   ipv4_t address;
 915   port_t port;
 916   long int options;
 917   connection_t *old, *p;
 918   avl_node_t *node;
 919 cp
 920   if(sscanf(cl->buffer, "%*d "MAX_STRING" %lx:%hd %lx", name, &address, &port, &options) != 4)
 921     {
 922       syslog(LOG_ERR, _("Got bad DEL_HOST from %s (%s)"),
 923              cl->name, cl->hostname);
 924       return -1;
 925     }
 926
 927   /* Check if identity is a valid name */
 928
 929   if(check_id(name))
 930     {
 931       syslog(LOG_ERR, _("Got bad DEL_HOST from %s (%s): invalid identity name"), cl->name, cl->hostname);
 932       return -1;
 933     }
 934
 935   /* Check if somebody tries to delete ourself */
 936
 937   if(!strcmp(name, myself->name))
 938     {
 939       syslog(LOG_ERR, _("Warning: got DEL_HOST from %s (%s) for ourself, restarting"),
 940              cl->name, cl->hostname);
 941       sighup = 1;
 942       return 0;
 943     }
 944
 945   /* Check if the new host already exists in the connnection list */
 946
 947   if(!(old = lookup_id(name)))
 948     {
 949       syslog(LOG_ERR, _("Got DEL_HOST from %s (%s) for %s which is not in our connection list"),
 950              name, cl->name, cl->hostname);
 951       return -1;
 952     }
 953
 954   /* Check if the rest matches */
 955
 956   if(address!=old->address || port!=old->port || options!=old->options || cl!=old->nexthop)
 957     {
 958       syslog(LOG_WARNING, _("Got DEL_HOST from %s (%s) for %s which doesn't match"), cl->name, cl->hostname, old->name);
 959       return 0;
 960     }
 961
 962   /* Ok, since EVERYTHING seems to check out all right, delete it */
 963
 964   old->status.active = 0;
 965   terminate_connection(old);
 966
 967   /* Tell the rest about the new host */
 968
 969   for(node = connection_tree->head; node; node = node->next)
 970     {
 971       p = (connection_t *)node->data;
 972       if(p->status.meta && p->status.active && p!=cl)
 973         send_del_host(p, old);
 974     }
 975 cp
 976   return 0;
 977 }
 978
 979 /* Status and error notification routines */
 980
 981 int send_status(connection_t *cl, int statusno, char *statusstring)
 982 {
 983 cp
 984   if(!statusstring)
 985     statusstring = status_text[statusno];
 986 cp
 987   return send_request(cl, "%d %d %s", STATUS, statusno, statusstring);
 988 }
 989
 990 int status_h(connection_t *cl)
 991 {
 992   int statusno;
 993   char statusstring[MAX_STRING_SIZE];
 994 cp
 995   if(sscanf(cl->buffer, "%*d %d "MAX_STRING, &statusno, statusstring) != 2)
 996     {
 997        syslog(LOG_ERR, _("Got bad STATUS from %s (%s)"),
 998               cl->name, cl->hostname);
 999        return -1;
1000     }
1001
1002   if(debug_lvl >= DEBUG_STATUS)
1003     {
1004       syslog(LOG_NOTICE, _("Status message from %s (%s): %s: %s"),
1005              cl->name, cl->hostname, status_text[statusno], statusstring);
1006     }
1007
1008 cp
1009   return 0;
1010 }
1011
1012 int send_error(connection_t *cl, int err, char *errstring)
1013 {
1014 cp
1015   if(!errstring)
1016     errstring = strerror(err);
1017   return send_request(cl, "%d %d %s", ERROR, err, errstring);
1018 }
1019
1020 int error_h(connection_t *cl)
1021 {
1022   int err;
1023   char errorstring[MAX_STRING_SIZE];
1024 cp
1025   if(sscanf(cl->buffer, "%*d %d "MAX_STRING, &err, errorstring) != 2)
1026     {
1027        syslog(LOG_ERR, _("Got bad ERROR from %s (%s)"),
1028               cl->name, cl->hostname);
1029        return -1;
1030     }
1031
1032   if(debug_lvl >= DEBUG_ERROR)
1033     {
1034       syslog(LOG_NOTICE, _("Error message from %s (%s): %s: %s"),
1035              cl->name, cl->hostname, strerror(err), errorstring);
1036     }
1037
1038   terminate_connection(cl);
1039 cp
1040   return 0;
1041 }
1042
1043 int send_termreq(connection_t *cl)
1044 {
1045 cp
1046   return send_request(cl, "%d", TERMREQ);
1047 }
1048
1049 int termreq_h(connection_t *cl)
1050 {
1051 cp
1052   terminate_connection(cl);
1053 cp
1054   return 0;
1055 }
1056
1057 int send_ping(connection_t *cl)
1058 {
1059   char salt[SALTLEN*2+1];
1060 cp
1061   cl->status.pinged = 1;
1062   cl->last_ping_time = time(NULL);
1063   RAND_bytes(salt, SALTLEN);
1064   bin2hex(salt, salt, SALTLEN);
1065   salt[SALTLEN*2] = '\0';
1066 cp
1067   return send_request(cl, "%d %s", PING, salt);
1068 }
1069
1070 int ping_h(connection_t *cl)
1071 {
1072 cp
1073   return send_pong(cl);
1074 }
1075
1076 int send_pong(connection_t *cl)
1077 {
1078   char salt[SALTLEN*2+1];
1079 cp
1080   RAND_bytes(salt, SALTLEN);
1081   bin2hex(salt, salt, SALTLEN);
1082   salt[SALTLEN*2] = '\0';
1083 cp
1084   return send_request(cl, "%d %s", PONG, salt);
1085 }
1086
1087 int pong_h(connection_t *cl)
1088 {
1089 cp
1090   cl->status.pinged = 0;
1091 cp
1092   return 0;
1093 }
1094
1095 /* Key exchange */
1096
1097 int send_key_changed(connection_t *from, connection_t *cl)
1098 {
1099   connection_t *p;
1100   avl_node_t *node;
1101 cp
1102   /* Only send this message if some other daemon requested our key previously.
1103      This reduces unnecessary key_changed broadcasts.
1104   */
1105
1106   if(from==myself && !mykeyused)
1107     return 0;
1108
1109   for(node = connection_tree->head; node; node = node->next)
1110     {
1111       p = (connection_t *)node->data;
1112       if(p != cl && p->status.meta && p->status.active)
1113         if(!(p->options & OPTION_INDIRECT) || from == myself)
1114           send_request(p, "%d %s", KEY_CHANGED, from->name);
1115     }
1116 cp
1117   return 0;
1118 }
1119
1120 int key_changed_h(connection_t *cl)
1121 {
1122   char from_id[MAX_STRING_SIZE];
1123   connection_t *from;
1124 cp
1125   if(sscanf(cl->buffer, "%*d "MAX_STRING, from_id) != 1)
1126     {
1127       syslog(LOG_ERR, _("Got bad KEY_CHANGED from %s (%s)"),
1128              cl->name, cl->hostname);
1129       return -1;
1130     }
1131
1132   if(!(from = lookup_id(from_id)))
1133     {
1134       syslog(LOG_ERR, _("Got KEY_CHANGED from %s (%s) origin %s which does not exist in our connection list"),
1135              cl->name, cl->hostname, from_id);
1136       return -1;
1137     }
1138
1139   from->status.validkey = 0;
1140   from->status.waitingforkey = 0;
1141
1142   if(!(from->options | cl->options | myself->options) & OPTION_INDIRECT)
1143     send_key_changed(from, cl);
1144 cp
1145   return 0;
1146 }
1147
1148 int send_req_key(connection_t *from, connection_t *to)
1149 {
1150 cp
1151   return send_request(to->nexthop, "%d %s %s", REQ_KEY,
1152                       from->name, to->name);
1153 }
1154
1155 int req_key_h(connection_t *cl)
1156 {
1157   char from_id[MAX_STRING_SIZE];
1158   char to_id[MAX_STRING_SIZE];
1159   connection_t *from, *to;
1160   char pktkey[129];
1161 cp
1162   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, from_id, to_id) != 2)
1163     {
1164        syslog(LOG_ERR, _("Got bad REQ_KEY from %s (%s)"),
1165               cl->name, cl->hostname);
1166        return -1;
1167     }
1168
1169   if(!(from = lookup_id(from_id)))
1170     {
1171       syslog(LOG_ERR, _("Got REQ_KEY from %s (%s) origin %s which does not exist in our connection list"),
1172              cl->name, cl->hostname, from_id);
1173       return -1;
1174     }
1175
1176   /* Check if this key request is for us */
1177
1178   if(!strcmp(to_id, myself->name))      /* Yes, send our own key back */
1179     {
1180       bin2hex(myself->cipher_pktkey, pktkey, myself->cipher_pktkeylength);
1181       pktkey[myself->cipher_pktkeylength*2] = '\0';
1182       send_ans_key(myself, from, pktkey);
1183       mykeyused = 1;
1184     }
1185   else
1186     {
1187       if(!(to = lookup_id(to_id)))
1188         {
1189           syslog(LOG_ERR, _("Got REQ_KEY from %s (%s) destination %s which does not exist in our connection list"),
1190                  cl->name, cl->hostname, to_id);
1191           return -1;
1192         }
1193
1194       if(to->status.validkey)   /* Proxy keys */
1195         {
1196           bin2hex(to->cipher_pktkey, pktkey, to->cipher_pktkeylength);
1197           pktkey[to->cipher_pktkeylength*2] = '\0';
1198           send_ans_key(to, from, pktkey);
1199         }
1200       else
1201         send_req_key(from, to);
1202     }
1203
1204 cp
1205   return 0;
1206 }
1207
1208 int send_ans_key(connection_t *from, connection_t *to, char *pktkey)
1209 {
1210 cp
1211   return send_request(to->nexthop, "%d %s %s %s", ANS_KEY,
1212                       from->name, to->name, pktkey);
1213 }
1214
1215 int ans_key_h(connection_t *cl)
1216 {
1217   char from_id[MAX_STRING_SIZE];
1218   char to_id[MAX_STRING_SIZE];
1219   char pktkey[MAX_STRING_SIZE];
1220   int keylength;
1221   connection_t *from, *to;
1222 cp
1223   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING" "MAX_STRING, from_id, to_id, pktkey) != 3)
1224     {
1225        syslog(LOG_ERR, _("Got bad ANS_KEY from %s (%s)"),
1226               cl->name, cl->hostname);
1227        return -1;
1228     }
1229
1230   if(!(from = lookup_id(from_id)))
1231     {
1232       syslog(LOG_ERR, _("Got ANS_KEY from %s (%s) origin %s which does not exist in our connection list"),
1233              cl->name, cl->hostname, from_id);
1234       return -1;
1235     }
1236
1237   /* Check correctness of packet key */
1238
1239   keylength = strlen(pktkey);
1240
1241   if(keylength != from->cipher_pktkeylength*2)
1242     {
1243       syslog(LOG_ERR, _("Got bad ANS_KEY from %s (%s) origin %s: invalid key length"),
1244              cl->name, cl->hostname, from->name);
1245       return -1;
1246     }
1247
1248   /* Forward it if necessary */
1249
1250   if(strcmp(to_id, myself->name))
1251     {
1252       if(!(to = lookup_id(to_id)))
1253         {
1254           syslog(LOG_ERR, _("Got ANS_KEY from %s (%s) destination %s which does not exist in our connection list"),
1255                  cl->name, cl->hostname, to_id);
1256           return -1;
1257         }
1258       send_ans_key(from, to, pktkey);
1259     }
1260
1261   /* Update our copy of the origin's packet key */
1262
1263   if(from->cipher_pktkey)
1264     free(from->cipher_pktkey);
1265
1266   from->cipher_pktkey = xstrdup(pktkey);
1267   keylength /= 2;
1268   hex2bin(from->cipher_pktkey, from->cipher_pktkey, keylength);
1269   from->cipher_pktkey[keylength] = '\0';
1270
1271   from->status.validkey = 1;
1272   from->status.waitingforkey = 0;
1273
1274   flush_queue(from);
1275 cp
1276   return 0;
1277 }
1278
1279 int send_tcppacket(connection_t *cl, vpn_packet_t *packet)
1280 {
1281   int x;
1282 cp
1283   /* Evil hack. */
1284
1285   x = send_request(cl->nexthop, "%d %hd", PACKET, packet->len);
1286
1287   if(x)
1288     return x;
1289 cp
1290   return send_meta(cl, packet->data, packet->len);
1291 }
1292
1293 int tcppacket_h(connection_t *cl)
1294 {
1295   short int len;
1296 cp
1297   if(sscanf(cl->buffer, "%*d %hd", &len) != 1)
1298     {
1299       syslog(LOG_ERR, _("Got bad PACKET from %s (%s)"), cl->name, cl->hostname);
1300       return -1;
1301     }
1302
1303   /* Set reqlen to len, this will tell receive_meta() that a tcppacket is coming. */
1304
1305   cl->tcplen = len;
1306 cp
1307   return 0;
1308 }
1309
1310 /* Jumptable for the request handlers */
1311
1312 int (*request_handlers[])(connection_t*) = {
1313   id_h, metakey_h, challenge_h, chal_reply_h,
1314   status_h, error_h, termreq_h,
1315   ping_h, pong_h,
1316   add_host_h, del_host_h,
1317   add_subnet_h, del_subnet_h,
1318   key_changed_h, req_key_h, ans_key_h,
1319   tcppacket_h,
1320 };
1321
1322 /* Request names */
1323
1324 char (*request_name[]) = {
1325   "ID", "METAKEY", "CHALLENGE", "CHAL_REPLY",
1326   "STATUS", "ERROR", "TERMREQ",
1327   "PING", "PONG",
1328   "ADD_HOST", "DEL_HOST",
1329   "ADD_SUBNET", "DEL_SUBNET",
1330   "KEY_CHANGED", "REQ_KEY", "ANS_KEY",
1331   "PACKET",
1332 };
1333
1334 /* Status strings */
1335
1336 char (*status_text[]) = {
1337   "Warning",
1338 };
1339
1340 /* Error strings */
1341
1342 char (*error_text[]) = {
1343   "Error",
1344 };