src/libcharon/network/receiver.c

   1 /*
   2  * Copyright (C) 2008 Tobias Brunner
   3  * Copyright (C) 2005-2006 Martin Willi
   4  * Copyright (C) 2005 Jan Hutter
   5  * Hochschule fuer Technik Rapperswil
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2 of the License, or (at your
  10  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15  * for more details.
  16  */
  17
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20
  21 #include "receiver.h"
  22
  23 #include <daemon.h>
  24 #include <network/socket.h>
  25 #include <network/packet.h>
  26 #include <processing/jobs/job.h>
  27 #include <processing/jobs/process_message_job.h>
  28 #include <processing/jobs/callback_job.h>
  29 #include <crypto/hashers/hasher.h>
  30
  31 /** lifetime of a cookie, in seconds */
  32 #define COOKIE_LIFETIME 10
  33 /** how many times to reuse the secret */
  34 #define COOKIE_REUSE 10000
  35 /** default value for private_receiver_t.cookie_threshold */
  36 #define COOKIE_THRESHOLD_DEFAULT 10
  37 /** default value for private_receiver_t.block_threshold */
  38 #define BLOCK_THRESHOLD_DEFAULT 5
  39 /** length of the secret to use for cookie calculation */
  40 #define SECRET_LENGTH 16
  41
  42 typedef struct private_receiver_t private_receiver_t;
  43
  44 /**
  45  * Private data of a receiver_t object.
  46  */
  47 struct private_receiver_t {
  48         /**
  49          * Public part of a receiver_t object.
  50          */
  51         receiver_t public;
  52
  53         /**
  54          * Threads job receiving packets
  55          */
  56         callback_job_t *job;
  57
  58         /**
  59          * current secret to use for cookie calculation
  60          */
  61         char secret[SECRET_LENGTH];
  62
  63         /**
  64          * previous secret used to verify older cookies
  65          */
  66         char secret_old[SECRET_LENGTH];
  67
  68         /**
  69          * how many times we have used "secret" so far
  70          */
  71         u_int32_t secret_used;
  72
  73         /**
  74          * time we did the cookie switch
  75          */
  76         u_int32_t secret_switch;
  77
  78         /**
  79          * time offset to use, hides our system time
  80          */
  81         u_int32_t secret_offset;
  82
  83         /**
  84          * the RNG to use for secret generation
  85          */
  86         rng_t *rng;
  87
  88         /**
  89          * hasher to use for cookie calculation
  90          */
  91         hasher_t *hasher;
  92
  93         /**
  94          * require cookies after this many half open IKE_SAs
  95          */
  96         u_int32_t cookie_threshold;
  97
  98         /**
  99          * how many half open IKE_SAs per peer before blocking
 100          */
 101         u_int32_t block_threshold;
 102
 103         /**
 104          * Delay for receiving incoming packets, to simulate larger RTT
 105          */
 106         u_int receive_delay;
 107 };
 108
 109 /**
 110  * send a notify back to the sender
 111  */
 112 static void send_notify(message_t *request, notify_type_t type, chunk_t data)
 113 {
 114         if (request->get_request(request) &&
 115                 request->get_exchange_type(request) == IKE_SA_INIT)
 116         {
 117                 message_t *response;
 118                 host_t *src, *dst;
 119                 packet_t *packet;
 120                 ike_sa_id_t *ike_sa_id;
 121
 122                 response = message_create();
 123                 dst = request->get_source(request);
 124                 src = request->get_destination(request);
 125                 response->set_source(response, src->clone(src));
 126                 response->set_destination(response, dst->clone(dst));
 127                 response->set_exchange_type(response, request->get_exchange_type(request));
 128                 response->set_request(response, FALSE);
 129                 response->set_message_id(response, 0);
 130                 ike_sa_id = request->get_ike_sa_id(request);
 131                 ike_sa_id->switch_initiator(ike_sa_id);
 132                 response->set_ike_sa_id(response, ike_sa_id);
 133                 response->add_notify(response, FALSE, type, data);
 134                 if (response->generate(response, NULL, NULL, &packet) == SUCCESS)
 135                 {
 136                         charon->sender->send(charon->sender, packet);
 137                         response->destroy(response);
 138                 }
 139         }
 140 }
 141
 142 /**
 143  * build a cookie
 144  */
 145 static chunk_t cookie_build(private_receiver_t *this, message_t *message,
 146                                                         u_int32_t t, chunk_t secret)
 147 {
 148         u_int64_t spi = message->get_initiator_spi(message);
 149         host_t *ip = message->get_source(message);
 150         chunk_t input, hash;
 151
 152         /* COOKIE = t | sha1( IPi | SPIi | t | secret ) */
 153         input = chunk_cata("cccc", ip->get_address(ip), chunk_from_thing(spi),
 154                                           chunk_from_thing(t), secret);
 155         hash = chunk_alloca(this->hasher->get_hash_size(this->hasher));
 156         this->hasher->get_hash(this->hasher, input, hash.ptr);
 157         return chunk_cat("cc", chunk_from_thing(t), hash);
 158 }
 159
 160 /**
 161  * verify a received cookie
 162  */
 163 static bool cookie_verify(private_receiver_t *this, message_t *message,
 164                                                   chunk_t cookie)
 165 {
 166         u_int32_t t, now;
 167         chunk_t reference;
 168         chunk_t secret;
 169
 170         now = time_monotonic(NULL);
 171         t = *(u_int32_t*)cookie.ptr;
 172
 173         if (cookie.len != sizeof(u_int32_t) +
 174                         this->hasher->get_hash_size(this->hasher) ||
 175                 t < now - this->secret_offset - COOKIE_LIFETIME)
 176         {
 177                 DBG2(DBG_NET, "received cookie lifetime expired, rejecting");
 178                 return FALSE;
 179         }
 180
 181         /* check if cookie is derived from old_secret */
 182         if (t + this->secret_offset > this->secret_switch)
 183         {
 184                 secret = chunk_from_thing(this->secret);
 185         }
 186         else
 187         {
 188                 secret = chunk_from_thing(this->secret_old);
 189         }
 190
 191         /* compare own calculation against received */
 192         reference = cookie_build(this, message, t, secret);
 193         if (chunk_equals(reference, cookie))
 194         {
 195                 chunk_free(&reference);
 196                 return TRUE;
 197         }
 198         chunk_free(&reference);
 199         return FALSE;
 200 }
 201
 202 /**
 203  * check if cookies are required, and if so, a valid cookie is included
 204  */
 205 static bool cookie_required(private_receiver_t *this, message_t *message)
 206 {
 207         bool failed = FALSE;
 208
 209         if (charon->ike_sa_manager->get_half_open_count(charon->ike_sa_manager,
 210                                                                                                 NULL) >= this->cookie_threshold)
 211         {
 212                 /* check for a cookie. We don't use our parser here and do it
 213                  * quick and dirty for performance reasons.
 214                  * we assume the cookie is the first payload (which is a MUST), and
 215                  * the cookie's SPI length is zero. */
 216                 packet_t *packet = message->get_packet(message);
 217                 chunk_t data = packet->get_data(packet);
 218                 if (data.len <
 219                          IKE_HEADER_LENGTH + NOTIFY_PAYLOAD_HEADER_LENGTH +
 220                          sizeof(u_int32_t) + this->hasher->get_hash_size(this->hasher) ||
 221                         *(data.ptr + 16) != NOTIFY ||
 222                         *(u_int16_t*)(data.ptr + IKE_HEADER_LENGTH + 6) != htons(COOKIE))
 223                 {
 224                         /* no cookie found */
 225                         failed = TRUE;
 226                 }
 227                 else
 228                 {
 229                         data.ptr += IKE_HEADER_LENGTH + NOTIFY_PAYLOAD_HEADER_LENGTH;
 230                         data.len = sizeof(u_int32_t) + this->hasher->get_hash_size(this->hasher);
 231                         if (!cookie_verify(this, message, data))
 232                         {
 233                                 DBG2(DBG_NET, "found cookie, but content invalid");
 234                                 failed = TRUE;
 235                         }
 236                 }
 237                 packet->destroy(packet);
 238         }
 239         return failed;
 240 }
 241
 242 /**
 243  * check if peer has to many half open IKE_SAs
 244  */
 245 static bool peer_to_aggressive(private_receiver_t *this, message_t *message)
 246 {
 247         if (charon->ike_sa_manager->get_half_open_count(charon->ike_sa_manager,
 248                                                 message->get_source(message)) >= this->block_threshold)
 249         {
 250                 return TRUE;
 251         }
 252         return FALSE;
 253 }
 254
 255 /**
 256  * Job callback to receive packets
 257  */
 258 static job_requeue_t receive_packets(private_receiver_t *this)
 259 {
 260         packet_t *packet;
 261         message_t *message;
 262         job_t *job;
 263
 264         /* read in a packet */
 265         if (charon->socket->receive(charon->socket, &packet) != SUCCESS)
 266         {
 267                 DBG2(DBG_NET, "receiving from socket failed!");
 268                 return JOB_REQUEUE_FAIR;
 269         }
 270
 271         /* parse message header */
 272         message = message_create_from_packet(packet);
 273         if (message->parse_header(message) != SUCCESS)
 274         {
 275                 DBG1(DBG_NET, "received invalid IKE header from %H - ignored",
 276                          packet->get_source(packet));
 277                 message->destroy(message);
 278                 return JOB_REQUEUE_DIRECT;
 279         }
 280
 281         /* check IKE major version */
 282         if (message->get_major_version(message) != IKE_MAJOR_VERSION)
 283         {
 284                 DBG1(DBG_NET, "received unsupported IKE version %d.%d from %H, "
 285                          "sending INVALID_MAJOR_VERSION", message->get_major_version(message),
 286                          message->get_minor_version(message), packet->get_source(packet));
 287                 send_notify(message, INVALID_MAJOR_VERSION, chunk_empty);
 288                 message->destroy(message);
 289                 return JOB_REQUEUE_DIRECT;
 290         }
 291
 292         if (message->get_request(message) &&
 293                 message->get_exchange_type(message) == IKE_SA_INIT)
 294         {
 295                 /* check for cookies */
 296                 if (this->cookie_threshold && cookie_required(this, message))
 297                 {
 298                         u_int32_t now = time_monotonic(NULL);
 299                         chunk_t cookie = cookie_build(this, message, now - this->secret_offset,
 300                                                                                   chunk_from_thing(this->secret));
 301
 302                         DBG2(DBG_NET, "received packet from: %#H to %#H",
 303                                  message->get_source(message),
 304                                  message->get_destination(message));
 305                         DBG2(DBG_NET, "sending COOKIE notify to %H",
 306                                  message->get_source(message));
 307                         send_notify(message, COOKIE, cookie);
 308                         chunk_free(&cookie);
 309                         if (++this->secret_used > COOKIE_REUSE)
 310                         {
 311                                 /* create new cookie */
 312                                 DBG1(DBG_NET, "generating new cookie secret after %d uses",
 313                                          this->secret_used);
 314                                 memcpy(this->secret_old, this->secret, SECRET_LENGTH);
 315                                 this->rng->get_bytes(this->rng, SECRET_LENGTH, this->secret);
 316                                 this->secret_switch = now;
 317                                 this->secret_used = 0;
 318                         }
 319                         message->destroy(message);
 320                         return JOB_REQUEUE_DIRECT;
 321                 }
 322
 323                 /* check if peer has not too many IKE_SAs half open */
 324                 if (this->block_threshold && peer_to_aggressive(this, message))
 325                 {
 326                         DBG1(DBG_NET, "ignoring IKE_SA setup from %H, "
 327                                  "peer too aggressive", message->get_source(message));
 328                         message->destroy(message);
 329                         return JOB_REQUEUE_DIRECT;
 330                 }
 331         }
 332         job = (job_t*)process_message_job_create(message);
 333         if (this->receive_delay)
 334         {
 335                 charon->scheduler->schedule_job_ms(charon->scheduler,
 336                                                                                    job, this->receive_delay);
 337         }
 338         else
 339         {
 340                 charon->processor->queue_job(charon->processor, job);
 341         }
 342         return JOB_REQUEUE_DIRECT;
 343 }
 344
 345 METHOD(receiver_t, destroy, void,
 346         private_receiver_t *this)
 347 {
 348         this->job->cancel(this->job);
 349         this->rng->destroy(this->rng);
 350         this->hasher->destroy(this->hasher);
 351         free(this);
 352 }
 353
 354 /*
 355  * Described in header.
 356  */
 357 receiver_t *receiver_create()
 358 {
 359         private_receiver_t *this;
 360         u_int32_t now = time_monotonic(NULL);
 361
 362         INIT(this,
 363                 .public.destroy = _destroy,
 364                 .secret_switch = now,
 365                 .secret_offset = random() % now,
 366         );
 367
 368         if (lib->settings->get_bool(lib->settings, "charon.dos_protection", TRUE))
 369         {
 370                 this->cookie_threshold = lib->settings->get_int(lib->settings,
 371                                                 "charon.cookie_threshold", COOKIE_THRESHOLD_DEFAULT);
 372                 this->block_threshold = lib->settings->get_int(lib->settings,
 373                                                 "charon.block_threshold", BLOCK_THRESHOLD_DEFAULT);
 374         }
 375         this->receive_delay = lib->settings->get_int(lib->settings,
 376                                                 "charon.receive_delay", 0);
 377
 378         this->hasher = lib->crypto->create_hasher(lib->crypto, HASH_PREFERRED);
 379         if (this->hasher == NULL)
 380         {
 381                 DBG1(DBG_NET, "creating cookie hasher failed, no hashers supported");
 382                 free(this);
 383                 return NULL;
 384         }
 385         this->rng = lib->crypto->create_rng(lib->crypto, RNG_STRONG);
 386         if (this->rng == NULL)
 387         {
 388                 DBG1(DBG_NET, "creating cookie RNG failed, no RNG supported");
 389                 this->hasher->destroy(this->hasher);
 390                 free(this);
 391                 return NULL;
 392         }
 393         this->rng->get_bytes(this->rng, SECRET_LENGTH, this->secret);
 394         memcpy(this->secret_old, this->secret, SECRET_LENGTH);
 395
 396         this->job = callback_job_create((callback_job_cb_t)receive_packets,
 397                                                                         this, NULL, NULL);
 398         charon->processor->queue_job(charon->processor, (job_t*)this->job);
 399
 400         return &this->public;
 401 }
 402