src/libipsec/esp_packet.c

   1 /*
   2  * Copyright (C) 2012 Tobias Brunner
   3  * Copyright (C) 2012 Giuliano Grassi
   4  * Copyright (C) 2012 Ralf Sager
   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
  19 #include "esp_packet.h"
  20
  21 #include <library.h>
  22 #include <utils/debug.h>
  23 #include <crypto/crypters/crypter.h>
  24 #include <crypto/signers/signer.h>
  25 #include <bio/bio_reader.h>
  26 #include <bio/bio_writer.h>
  27
  28 #include <netinet/in.h>
  29
  30 typedef struct private_esp_packet_t private_esp_packet_t;
  31
  32 /**
  33  * Private additions to esp_packet_t.
  34  */
  35 struct private_esp_packet_t {
  36
  37         /**
  38          * Public members
  39          */
  40         esp_packet_t public;
  41
  42         /**
  43          * Raw ESP packet
  44          */
  45         packet_t *packet;
  46
  47         /**
  48          * Payload of this packet
  49          */
  50         ip_packet_t *payload;
  51
  52         /**
  53          * Next Header info (e.g. IPPROTO_IPIP)
  54          */
  55         u_int8_t next_header;
  56
  57 };
  58
  59 /**
  60  * Forward declaration for clone()
  61  */
  62 static private_esp_packet_t *esp_packet_create_internal(packet_t *packet);
  63
  64 METHOD(packet_t, set_source, void,
  65         private_esp_packet_t *this, host_t *src)
  66 {
  67         return this->packet->set_source(this->packet, src);
  68 }
  69
  70 METHOD2(esp_packet_t, packet_t, get_source, host_t*,
  71         private_esp_packet_t *this)
  72 {
  73         return this->packet->get_source(this->packet);
  74 }
  75
  76 METHOD(packet_t, set_destination, void,
  77         private_esp_packet_t *this, host_t *dst)
  78 {
  79         return this->packet->set_destination(this->packet, dst);
  80 }
  81
  82 METHOD2(esp_packet_t, packet_t, get_destination, host_t*,
  83         private_esp_packet_t *this)
  84 {
  85         return this->packet->get_destination(this->packet);
  86 }
  87
  88 METHOD(packet_t, get_data, chunk_t,
  89         private_esp_packet_t *this)
  90 {
  91         return this->packet->get_data(this->packet);
  92 }
  93
  94 METHOD(packet_t, set_data, void,
  95         private_esp_packet_t *this, chunk_t data)
  96 {
  97         return this->packet->set_data(this->packet, data);
  98 }
  99
 100 METHOD(packet_t, get_dscp, u_int8_t,
 101         private_esp_packet_t *this)
 102 {
 103         return this->packet->get_dscp(this->packet);
 104 }
 105
 106 METHOD(packet_t, set_dscp, void,
 107         private_esp_packet_t *this, u_int8_t value)
 108 {
 109         this->packet->set_dscp(this->packet, value);
 110 }
 111
 112 METHOD(packet_t, skip_bytes, void,
 113         private_esp_packet_t *this, size_t bytes)
 114 {
 115         return this->packet->skip_bytes(this->packet, bytes);
 116 }
 117
 118 METHOD(packet_t, clone, packet_t*,
 119         private_esp_packet_t *this)
 120 {
 121         private_esp_packet_t *pkt;
 122
 123         pkt = esp_packet_create_internal(this->packet->clone(this->packet));
 124         pkt->payload = this->payload ? this->payload->clone(this->payload) : NULL;
 125         pkt->next_header = this->next_header;
 126         return &pkt->public.packet;
 127 }
 128
 129 METHOD(esp_packet_t, parse_header, bool,
 130         private_esp_packet_t *this, u_int32_t *spi)
 131 {
 132         bio_reader_t *reader;
 133         u_int32_t seq;
 134
 135         reader = bio_reader_create(this->packet->get_data(this->packet));
 136         if (!reader->read_uint32(reader, spi) ||
 137                 !reader->read_uint32(reader, &seq))
 138         {
 139                 DBG1(DBG_ESP, "failed to parse ESP header: invalid length");
 140                 reader->destroy(reader);
 141                 return FALSE;
 142         }
 143         reader->destroy(reader);
 144
 145         DBG2(DBG_ESP, "parsed ESP header with SPI %.8x [seq %u]", *spi, seq);
 146         *spi = htonl(*spi);
 147         return TRUE;
 148 }
 149
 150 /**
 151  * Check padding as specified in RFC 4303
 152  */
 153 static bool check_padding(chunk_t padding)
 154 {
 155         size_t i;
 156
 157         for (i = 0; i < padding.len; ++i)
 158         {
 159                 if (padding.ptr[i] != (u_int8_t)(i + 1))
 160                 {
 161                         return FALSE;
 162                 }
 163         }
 164         return TRUE;
 165 }
 166
 167 /**
 168  * Remove the padding from the payload and set the next header info
 169  */
 170 static bool remove_padding(private_esp_packet_t *this, chunk_t plaintext)
 171 {
 172         u_int8_t next_header, pad_length;
 173         chunk_t padding, payload;
 174         bio_reader_t *reader;
 175
 176         reader = bio_reader_create(plaintext);
 177         if (!reader->read_uint8_end(reader, &next_header) ||
 178                 !reader->read_uint8_end(reader, &pad_length))
 179         {
 180                 DBG1(DBG_ESP, "parsing ESP payload failed: invalid length");
 181                 goto failed;
 182         }
 183         if (!reader->read_data_end(reader, pad_length, &padding) ||
 184                 !check_padding(padding))
 185         {
 186                 DBG1(DBG_ESP, "parsing ESP payload failed: invalid padding");
 187                 goto failed;
 188         }
 189         this->payload = ip_packet_create(reader->peek(reader));
 190         reader->destroy(reader);
 191         if (!this->payload)
 192         {
 193                 DBG1(DBG_ESP, "parsing ESP payload failed: unsupported payload");
 194                 return FALSE;
 195         }
 196         this->next_header = next_header;
 197         payload = this->payload->get_encoding(this->payload);
 198
 199         DBG3(DBG_ESP, "ESP payload:\n  payload %B\n  padding %B\n  "
 200                  "padding length = %hhu, next header = %hhu", &payload, &padding,
 201                  pad_length, this->next_header);
 202         return TRUE;
 203
 204 failed:
 205         reader->destroy(reader);
 206         chunk_free(&plaintext);
 207         return FALSE;
 208 }
 209
 210 METHOD(esp_packet_t, decrypt, status_t,
 211         private_esp_packet_t *this, esp_context_t *esp_context)
 212 {
 213         bio_reader_t *reader;
 214         u_int32_t spi, seq;
 215         chunk_t data, iv, icv, ciphertext, plaintext;
 216         crypter_t *crypter;
 217         signer_t *signer;
 218
 219         DESTROY_IF(this->payload);
 220         this->payload = NULL;
 221
 222         data = this->packet->get_data(this->packet);
 223         crypter = esp_context->get_crypter(esp_context);
 224         signer = esp_context->get_signer(esp_context);
 225
 226         reader = bio_reader_create(data);
 227         if (!reader->read_uint32(reader, &spi) ||
 228                 !reader->read_uint32(reader, &seq) ||
 229                 !reader->read_data(reader, crypter->get_iv_size(crypter), &iv) ||
 230                 !reader->read_data_end(reader, signer->get_block_size(signer), &icv) ||
 231                 reader->remaining(reader) % crypter->get_block_size(crypter))
 232         {
 233                 DBG1(DBG_ESP, "ESP decryption failed: invalid length");
 234                 return PARSE_ERROR;
 235         }
 236         ciphertext = reader->peek(reader);
 237         reader->destroy(reader);
 238
 239         if (!esp_context->verify_seqno(esp_context, seq))
 240         {
 241                 DBG1(DBG_ESP, "ESP sequence number verification failed:\n  "
 242                          "src %H, dst %H, SPI %.8x [seq %u]",
 243                          get_source(this), get_destination(this), spi, seq);
 244                 return VERIFY_ERROR;
 245         }
 246         DBG3(DBG_ESP, "ESP decryption:\n  SPI %.8x [seq %u]\n  IV %B\n  "
 247                  "encrypted %B\n  ICV %B", spi, seq, &iv, &ciphertext, &icv);
 248
 249         if (!signer->get_signature(signer, chunk_create(data.ptr, 8), NULL) ||
 250                 !signer->get_signature(signer, iv, NULL) ||
 251                 !signer->verify_signature(signer, ciphertext, icv))
 252         {
 253                 DBG1(DBG_ESP, "ICV verification failed!");
 254                 return FAILED;
 255         }
 256         esp_context->set_authenticated_seqno(esp_context, seq);
 257
 258         if (!crypter->decrypt(crypter, ciphertext, iv, &plaintext))
 259         {
 260                 DBG1(DBG_ESP, "ESP decryption failed");
 261                 return FAILED;
 262         }
 263
 264         if (!remove_padding(this, plaintext))
 265         {
 266                 return PARSE_ERROR;
 267         }
 268         return SUCCESS;
 269 }
 270
 271 /**
 272  * Generate the padding as specified in RFC4303
 273  */
 274 static void generate_padding(chunk_t padding)
 275 {
 276         size_t i;
 277
 278         for (i = 0; i < padding.len; ++i)
 279         {
 280                 padding.ptr[i] = (u_int8_t)(i + 1);
 281         }
 282 }
 283
 284 METHOD(esp_packet_t, encrypt, status_t,
 285         private_esp_packet_t *this, esp_context_t *esp_context, u_int32_t spi)
 286 {
 287         chunk_t iv, icv, padding, payload, ciphertext, auth_data;
 288         bio_writer_t *writer;
 289         u_int32_t next_seqno;
 290         size_t blocksize, plainlen;
 291         crypter_t *crypter;
 292         signer_t *signer;
 293         rng_t *rng;
 294
 295         this->packet->set_data(this->packet, chunk_empty);
 296
 297         if (!esp_context->next_seqno(esp_context, &next_seqno))
 298         {
 299                 DBG1(DBG_ESP, "ESP encapsulation failed: sequence numbers cycled");
 300                 return FAILED;
 301         }
 302
 303         rng = lib->crypto->create_rng(lib->crypto, RNG_WEAK);
 304         if (!rng)
 305         {
 306                 DBG1(DBG_ESP, "ESP encryption failed: could not find RNG");
 307                 return NOT_FOUND;
 308         }
 309         crypter = esp_context->get_crypter(esp_context);
 310         signer = esp_context->get_signer(esp_context);
 311
 312         blocksize = crypter->get_block_size(crypter);
 313         iv.len = crypter->get_iv_size(crypter);
 314         icv.len = signer->get_block_size(signer);
 315
 316         /* plaintext = payload, padding, pad_length, next_header */
 317         payload = this->payload ? this->payload->get_encoding(this->payload)
 318                                                         : chunk_empty;
 319         plainlen = payload.len + 2;
 320         padding.len = blocksize - (plainlen % blocksize);
 321         plainlen += padding.len;
 322
 323         /* len = spi, seq, IV, plaintext, ICV */
 324         writer = bio_writer_create(2 * sizeof(u_int32_t) + iv.len + plainlen +
 325                                                            icv.len);
 326         writer->write_uint32(writer, ntohl(spi));
 327         writer->write_uint32(writer, next_seqno);
 328
 329         iv = writer->skip(writer, iv.len);
 330         if (!rng->get_bytes(rng, iv.len, iv.ptr))
 331         {
 332                 DBG1(DBG_ESP, "ESP encryption failed: could not generate IV");
 333                 writer->destroy(writer);
 334                 rng->destroy(rng);
 335                 return FAILED;
 336         }
 337         rng->destroy(rng);
 338
 339         /* plain-/ciphertext will start here */
 340         ciphertext = writer->get_buf(writer);
 341         ciphertext.ptr += ciphertext.len;
 342         ciphertext.len = plainlen;
 343
 344         writer->write_data(writer, payload);
 345
 346         padding = writer->skip(writer, padding.len);
 347         generate_padding(padding);
 348
 349         writer->write_uint8(writer, padding.len);
 350         writer->write_uint8(writer, this->next_header);
 351
 352         DBG3(DBG_ESP, "ESP before encryption:\n  payload = %B\n  padding = %B\n  "
 353                  "padding length = %hhu, next header = %hhu", &payload, &padding,
 354                  (u_int8_t)padding.len, this->next_header);
 355
 356         /* encrypt the content inline */
 357         if (!crypter->encrypt(crypter, ciphertext, iv, NULL))
 358         {
 359                 DBG1(DBG_ESP, "ESP encryption failed");
 360                 writer->destroy(writer);
 361                 return FAILED;
 362         }
 363
 364         /* calculate signature */
 365         auth_data = writer->get_buf(writer);
 366         icv = writer->skip(writer, icv.len);
 367         if (!signer->get_signature(signer, auth_data, icv.ptr))
 368         {
 369                 DBG1(DBG_ESP, "ESP encryption failed: signature generation failed");
 370                 writer->destroy(writer);
 371                 return FAILED;
 372         }
 373
 374         DBG3(DBG_ESP, "ESP packet:\n  SPI %.8x [seq %u]\n  IV %B\n  "
 375                  "encrypted %B\n  ICV %B", ntohl(spi), next_seqno, &iv,
 376                  &ciphertext, &icv);
 377
 378         this->packet->set_data(this->packet, writer->extract_buf(writer));
 379         writer->destroy(writer);
 380         return SUCCESS;
 381 }
 382
 383 METHOD(esp_packet_t, get_next_header, u_int8_t,
 384         private_esp_packet_t *this)
 385 {
 386         return this->next_header;
 387 }
 388
 389 METHOD(esp_packet_t, get_payload, ip_packet_t*,
 390         private_esp_packet_t *this)
 391 {
 392         return this->payload;
 393 }
 394
 395 METHOD(esp_packet_t, extract_payload, ip_packet_t*,
 396         private_esp_packet_t *this)
 397 {
 398         ip_packet_t *payload;
 399
 400         payload = this->payload;
 401         this->payload = NULL;
 402         return payload;
 403 }
 404
 405 METHOD2(esp_packet_t, packet_t, destroy, void,
 406         private_esp_packet_t *this)
 407 {
 408         DESTROY_IF(this->payload);
 409         this->packet->destroy(this->packet);
 410         free(this);
 411 }
 412
 413 static private_esp_packet_t *esp_packet_create_internal(packet_t *packet)
 414 {
 415         private_esp_packet_t *this;
 416
 417         INIT(this,
 418                 .public = {
 419                         .packet = {
 420                                 .set_source = _set_source,
 421                                 .get_source = _get_source,
 422                                 .set_destination = _set_destination,
 423                                 .get_destination = _get_destination,
 424                                 .get_data = _get_data,
 425                                 .set_data = _set_data,
 426                                 .get_dscp = _get_dscp,
 427                                 .set_dscp = _set_dscp,
 428                                 .skip_bytes = _skip_bytes,
 429                                 .clone = _clone,
 430                                 .destroy = _destroy,
 431                         },
 432                         .get_source = _get_source,
 433                         .get_destination = _get_destination,
 434                         .get_next_header = _get_next_header,
 435                         .parse_header = _parse_header,
 436                         .decrypt = _decrypt,
 437                         .encrypt = _encrypt,
 438                         .get_payload = _get_payload,
 439                         .extract_payload = _extract_payload,
 440                         .destroy = _destroy,
 441                 },
 442                 .packet = packet,
 443                 .next_header = IPPROTO_NONE,
 444         );
 445         return this;
 446 }
 447
 448 /**
 449  * Described in header.
 450  */
 451 esp_packet_t *esp_packet_create_from_packet(packet_t *packet)
 452 {
 453         private_esp_packet_t *this;
 454
 455         this = esp_packet_create_internal(packet);
 456
 457         return &this->public;
 458 }
 459
 460 /**
 461  * Described in header.
 462  */
 463 esp_packet_t *esp_packet_create_from_payload(host_t *src, host_t *dst,
 464                                                                                          ip_packet_t *payload)
 465 {
 466         private_esp_packet_t *this;
 467         packet_t *packet;
 468
 469         packet = packet_create_from_data(src, dst, chunk_empty);
 470         this = esp_packet_create_internal(packet);
 471         this->payload = payload;
 472         if (payload)
 473         {
 474                 this->next_header = payload->get_version(payload) == 4 ? IPPROTO_IPIP
 475                                                                                                                            : IPPROTO_IPV6;
 476         }
 477         else
 478         {
 479                 this->next_header = IPPROTO_NONE;
 480         }
 481         return &this->public;
 482 }