www.tinc-vpn.org Git - tinc/blob - src/sptps.c

   1 /*
   2     sptps.c -- Simple Peer-to-Peer Security
   3     Copyright (C) 2011-2013 Guus Sliepen <guus@tinc-vpn.org>,
   4                   2010      Brandon L. Black <blblack@gmail.com>
   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 along
  17     with this program; if not, write to the Free Software Foundation, Inc.,
  18     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "system.h"
  22
  23 #include "cipher.h"
  24 #include "crypto.h"
  25 #include "digest.h"
  26 #include "ecdh.h"
  27 #include "ecdsa.h"
  28 #include "logger.h"
  29 #include "prf.h"
  30 #include "sptps.h"
  31
  32 unsigned int sptps_replaywin = 16;
  33
  34 /*
  35    Nonce MUST be exchanged first (done)
  36    Signatures MUST be done over both nonces, to guarantee the signature is fresh
  37    Otherwise: if ECDHE key of one side is compromised, it can be reused!
  38
  39    Add explicit tag to beginning of structure to distinguish the client and server when signing. (done)
  40
  41    Sign all handshake messages up to ECDHE kex with long-term public keys. (done)
  42
  43    HMACed KEX finished message to prevent downgrade attacks and prove you have the right key material (done by virtue of ECDSA over the whole ECDHE exchange?)
  44
  45    Explicit close message needs to be added.
  46
  47    Maybe do add some alert messages to give helpful error messages? Not more than TLS sends.
  48
  49    Use counter mode instead of OFB. (done)
  50
  51    Make sure ECC operations are fixed time (aka prevent side-channel attacks).
  52 */
  53
  54 void sptps_log_quiet(sptps_t *s, int s_errno, const char *format, va_list ap) {
  55 }
  56
  57 void sptps_log_stderr(sptps_t *s, int s_errno, const char *format, va_list ap) {
  58         vfprintf(stderr, format, ap);
  59         fputc('\n', stderr);
  60 }
  61
  62 void (*sptps_log)(sptps_t *s, int s_errno, const char *format, va_list ap) = sptps_log_stderr;
  63
  64 // Log an error message.
  65 static bool error(sptps_t *s, int s_errno, const char *format, ...) {
  66         if(format) {
  67                 va_list ap;
  68                 va_start(ap, format);
  69                 sptps_log(s, s_errno, format, ap);
  70                 va_end(ap);
  71         }
  72
  73         errno = s_errno;
  74         return false;
  75 }
  76
  77 static void warning(sptps_t *s, const char *format, ...) {
  78         va_list ap;
  79         va_start(ap, format);
  80         sptps_log(s, 0, format, ap);
  81         va_end(ap);
  82 }
  83
  84 // Send a record (datagram version, accepts all record types, handles encryption and authentication).
  85 static bool send_record_priv_datagram(sptps_t *s, uint8_t type, const char *data, uint16_t len) {
  86         char buffer[len + 23UL];
  87
  88         // Create header with sequence number, length and record type
  89         uint32_t seqno = htonl(s->outseqno++);
  90         uint16_t netlen = htons(len);
  91
  92         memcpy(buffer, &netlen, 2);
  93         memcpy(buffer + 2, &seqno, 4);
  94         buffer[6] = type;
  95
  96         // Add plaintext (TODO: avoid unnecessary copy)
  97         memcpy(buffer + 7, data, len);
  98
  99         if(s->outstate) {
 100                 // If first handshake has finished, encrypt and HMAC
 101                 cipher_set_counter(&s->outcipher, &seqno, sizeof seqno);
 102                 if(!cipher_counter_xor(&s->outcipher, buffer + 6, len + 1UL, buffer + 6))
 103                         return false;
 104
 105                 if(!digest_create(&s->outdigest, buffer, len + 7UL, buffer + 7UL + len))
 106                         return false;
 107
 108                 return s->send_data(s->handle, type, buffer + 2, len + 21UL);
 109         } else {
 110                 // Otherwise send as plaintext
 111                 return s->send_data(s->handle, type, buffer + 2, len + 5UL);
 112         }
 113 }
 114 // Send a record (private version, accepts all record types, handles encryption and authentication).
 115 static bool send_record_priv(sptps_t *s, uint8_t type, const char *data, uint16_t len) {
 116         if(s->datagram)
 117                 return send_record_priv_datagram(s, type, data, len);
 118
 119         char buffer[len + 23UL];
 120
 121         // Create header with sequence number, length and record type
 122         uint32_t seqno = htonl(s->outseqno++);
 123         uint16_t netlen = htons(len);
 124
 125         memcpy(buffer, &seqno, 4);
 126         memcpy(buffer + 4, &netlen, 2);
 127         buffer[6] = type;
 128
 129         // Add plaintext (TODO: avoid unnecessary copy)
 130         memcpy(buffer + 7, data, len);
 131
 132         if(s->outstate) {
 133                 // If first handshake has finished, encrypt and HMAC
 134                 if(!cipher_counter_xor(&s->outcipher, buffer + 4, len + 3UL, buffer + 4))
 135                         return false;
 136
 137                 if(!digest_create(&s->outdigest, buffer, len + 7UL, buffer + 7UL + len))
 138                         return false;
 139
 140                 return s->send_data(s->handle, type, buffer + 4, len + 19UL);
 141         } else {
 142                 // Otherwise send as plaintext
 143                 return s->send_data(s->handle, type, buffer + 4, len + 3UL);
 144         }
 145 }
 146
 147 // Send an application record.
 148 bool sptps_send_record(sptps_t *s, uint8_t type, const char *data, uint16_t len) {
 149         // Sanity checks: application cannot send data before handshake is finished,
 150         // and only record types 0..127 are allowed.
 151         if(!s->outstate)
 152                 return error(s, EINVAL, "Handshake phase not finished yet");
 153
 154         if(type >= SPTPS_HANDSHAKE)
 155                 return error(s, EINVAL, "Invalid application record type");
 156
 157         return send_record_priv(s, type, data, len);
 158 }
 159
 160 // Send a Key EXchange record, containing a random nonce and an ECDHE public key.
 161 static bool send_kex(sptps_t *s) {
 162         size_t keylen = ECDH_SIZE;
 163
 164         // Make room for our KEX message, which we will keep around since send_sig() needs it.
 165         if(s->mykex)
 166                 abort();
 167         s->mykex = realloc(s->mykex, 1 + 32 + keylen);
 168         if(!s->mykex)
 169                 return error(s, errno, strerror(errno));
 170
 171         // Set version byte to zero.
 172         s->mykex[0] = SPTPS_VERSION;
 173
 174         // Create a random nonce.
 175         randomize(s->mykex + 1, 32);
 176
 177         // Create a new ECDH public key.
 178         if(!ecdh_generate_public(&s->ecdh, s->mykex + 1 + 32))
 179                 return false;
 180
 181         return send_record_priv(s, SPTPS_HANDSHAKE, s->mykex, 1 + 32 + keylen);
 182 }
 183
 184 // Send a SIGnature record, containing an ECDSA signature over both KEX records.
 185 static bool send_sig(sptps_t *s) {
 186         size_t keylen = ECDH_SIZE;
 187         size_t siglen = ecdsa_size(&s->mykey);
 188
 189         // Concatenate both KEX messages, plus tag indicating if it is from the connection originator, plus label
 190         char msg[(1 + 32 + keylen) * 2 + 1 + s->labellen];
 191         char sig[siglen];
 192
 193         msg[0] = s->initiator;
 194         memcpy(msg + 1, s->mykex, 1 + 32 + keylen);
 195         memcpy(msg + 1 + 33 + keylen, s->hiskex, 1 + 32 + keylen);
 196         memcpy(msg + 1 + 2 * (33 + keylen), s->label, s->labellen);
 197
 198         // Sign the result.
 199         if(!ecdsa_sign(&s->mykey, msg, sizeof msg, sig))
 200                 return false;
 201
 202         // Send the SIG exchange record.
 203         return send_record_priv(s, SPTPS_HANDSHAKE, sig, sizeof sig);
 204 }
 205
 206 // Generate key material from the shared secret created from the ECDHE key exchange.
 207 static bool generate_key_material(sptps_t *s, const char *shared, size_t len) {
 208         // Initialise cipher and digest structures if necessary
 209         if(!s->outstate) {
 210                 bool result
 211                         =  cipher_open_by_name(&s->incipher, "aes-256-ecb")
 212                         && cipher_open_by_name(&s->outcipher, "aes-256-ecb")
 213                         && digest_open_by_name(&s->indigest, "sha256", 16)
 214                         && digest_open_by_name(&s->outdigest, "sha256", 16);
 215                 if(!result)
 216                         return false;
 217         }
 218
 219         // Allocate memory for key material
 220         size_t keylen = digest_keylength(&s->indigest) + digest_keylength(&s->outdigest) + cipher_keylength(&s->incipher) + cipher_keylength(&s->outcipher);
 221
 222         s->key = realloc(s->key, keylen);
 223         if(!s->key)
 224                 return error(s, errno, strerror(errno));
 225
 226         // Create the HMAC seed, which is "key expansion" + session label + server nonce + client nonce
 227         char seed[s->labellen + 64 + 13];
 228         strcpy(seed, "key expansion");
 229         if(s->initiator) {
 230                 memcpy(seed + 13, s->mykex + 1, 32);
 231                 memcpy(seed + 45, s->hiskex + 1, 32);
 232         } else {
 233                 memcpy(seed + 13, s->hiskex + 1, 32);
 234                 memcpy(seed + 45, s->mykex + 1, 32);
 235         }
 236         memcpy(seed + 77, s->label, s->labellen);
 237
 238         // Use PRF to generate the key material
 239         if(!prf(shared, len, seed, s->labellen + 64 + 13, s->key, keylen))
 240                 return false;
 241
 242         return true;
 243 }
 244
 245 // Send an ACKnowledgement record.
 246 static bool send_ack(sptps_t *s) {
 247         return send_record_priv(s, SPTPS_HANDSHAKE, "", 0);
 248 }
 249
 250 // Receive an ACKnowledgement record.
 251 static bool receive_ack(sptps_t *s, const char *data, uint16_t len) {
 252         if(len)
 253                 return error(s, EIO, "Invalid ACK record length");
 254
 255         if(s->initiator) {
 256                 bool result
 257                         = cipher_set_counter_key(&s->incipher, s->key)
 258                         && digest_set_key(&s->indigest, s->key + cipher_keylength(&s->incipher), digest_keylength(&s->indigest));
 259                 if(!result)
 260                         return false;
 261         } else {
 262                 bool result
 263                         = cipher_set_counter_key(&s->incipher, s->key + cipher_keylength(&s->outcipher) + digest_keylength(&s->outdigest))
 264                         && digest_set_key(&s->indigest, s->key + cipher_keylength(&s->outcipher) + digest_keylength(&s->outdigest) + cipher_keylength(&s->incipher), digest_keylength(&s->indigest));
 265                 if(!result)
 266                         return false;
 267         }
 268
 269         free(s->key);
 270         s->key = NULL;
 271         s->instate = true;
 272
 273         return true;
 274 }
 275
 276 // Receive a Key EXchange record, respond by sending a SIG record.
 277 static bool receive_kex(sptps_t *s, const char *data, uint16_t len) {
 278         // Verify length of the HELLO record
 279         if(len != 1 + 32 + ECDH_SIZE)
 280                 return error(s, EIO, "Invalid KEX record length");
 281
 282         // Ignore version number for now.
 283
 284         // Make a copy of the KEX message, send_sig() and receive_sig() need it
 285         if(s->hiskex)
 286                 abort();
 287         s->hiskex = realloc(s->hiskex, len);
 288         if(!s->hiskex)
 289                 return error(s, errno, strerror(errno));
 290
 291         memcpy(s->hiskex, data, len);
 292
 293         return send_sig(s);
 294 }
 295
 296 // Receive a SIGnature record, verify it, if it passed, compute the shared secret and calculate the session keys.
 297 static bool receive_sig(sptps_t *s, const char *data, uint16_t len) {
 298         size_t keylen = ECDH_SIZE;
 299         size_t siglen = ecdsa_size(&s->hiskey);
 300
 301         // Verify length of KEX record.
 302         if(len != siglen)
 303                 return error(s, EIO, "Invalid KEX record length");
 304
 305         // Concatenate both KEX messages, plus tag indicating if it is from the connection originator
 306         char msg[(1 + 32 + keylen) * 2 + 1 + s->labellen];
 307
 308         msg[0] = !s->initiator;
 309         memcpy(msg + 1, s->hiskex, 1 + 32 + keylen);
 310         memcpy(msg + 1 + 33 + keylen, s->mykex, 1 + 32 + keylen);
 311         memcpy(msg + 1 + 2 * (33 + keylen), s->label, s->labellen);
 312
 313         // Verify signature.
 314         if(!ecdsa_verify(&s->hiskey, msg, sizeof msg, data))
 315                 return false;
 316
 317         // Compute shared secret.
 318         char shared[ECDH_SHARED_SIZE];
 319         if(!ecdh_compute_shared(&s->ecdh, s->hiskex + 1 + 32, shared))
 320                 return false;
 321
 322         // Generate key material from shared secret.
 323         if(!generate_key_material(s, shared, sizeof shared))
 324                 return false;
 325
 326         free(s->mykex);
 327         free(s->hiskex);
 328
 329         s->mykex = NULL;
 330         s->hiskex = NULL;
 331
 332         // Send cipher change record
 333         if(s->outstate && !send_ack(s))
 334                 return false;
 335
 336         // TODO: only set new keys after ACK has been set/received
 337         if(s->initiator) {
 338                 bool result
 339                         = cipher_set_counter_key(&s->outcipher, s->key + cipher_keylength(&s->incipher) + digest_keylength(&s->indigest))
 340                         && digest_set_key(&s->outdigest, s->key + cipher_keylength(&s->incipher) + digest_keylength(&s->indigest) + cipher_keylength(&s->outcipher), digest_keylength(&s->outdigest));
 341                 if(!result)
 342                         return false;
 343         } else {
 344                 bool result
 345                         =  cipher_set_counter_key(&s->outcipher, s->key)
 346                         && digest_set_key(&s->outdigest, s->key + cipher_keylength(&s->outcipher), digest_keylength(&s->outdigest));
 347                 if(!result)
 348                         return false;
 349         }
 350
 351         return true;
 352 }
 353
 354 // Force another Key EXchange (for testing purposes).
 355 bool sptps_force_kex(sptps_t *s) {
 356         if(!s->outstate || s->state != SPTPS_SECONDARY_KEX)
 357                 return error(s, EINVAL, "Cannot force KEX in current state");
 358
 359         s->state = SPTPS_KEX;
 360         return send_kex(s);
 361 }
 362
 363 // Receive a handshake record.
 364 static bool receive_handshake(sptps_t *s, const char *data, uint16_t len) {
 365         // Only a few states to deal with handshaking.
 366         switch(s->state) {
 367                 case SPTPS_SECONDARY_KEX:
 368                         // We receive a secondary KEX request, first respond by sending our own.
 369                         if(!send_kex(s))
 370                                 return false;
 371                 case SPTPS_KEX:
 372                         // We have sent our KEX request, we expect our peer to sent one as well.
 373                         if(!receive_kex(s, data, len))
 374                                 return false;
 375                         s->state = SPTPS_SIG;
 376                         return true;
 377                 case SPTPS_SIG:
 378                         // If we already sent our secondary public ECDH key, we expect the peer to send his.
 379                         if(!receive_sig(s, data, len))
 380                                 return false;
 381                         if(s->outstate)
 382                                 s->state = SPTPS_ACK;
 383                         else {
 384                                 s->outstate = true;
 385                                 if(!receive_ack(s, NULL, 0))
 386                                         return false;
 387                                 s->receive_record(s->handle, SPTPS_HANDSHAKE, NULL, 0);
 388                                 s->state = SPTPS_SECONDARY_KEX;
 389                         }
 390
 391                         return true;
 392                 case SPTPS_ACK:
 393                         // We expect a handshake message to indicate transition to the new keys.
 394                         if(!receive_ack(s, data, len))
 395                                 return false;
 396                         s->receive_record(s->handle, SPTPS_HANDSHAKE, NULL, 0);
 397                         s->state = SPTPS_SECONDARY_KEX;
 398                         return true;
 399                 // TODO: split ACK into a VERify and ACK?
 400                 default:
 401                         return error(s, EIO, "Invalid session state");
 402         }
 403 }
 404
 405 // Check datagram for valid HMAC
 406 bool sptps_verify_datagram(sptps_t *s, const char *data, size_t len) {
 407         if(!s->instate || len < 21)
 408                 return false;
 409
 410         char buffer[len + 23];
 411         uint16_t netlen = htons(len - 21);
 412
 413         memcpy(buffer, &netlen, 2);
 414         memcpy(buffer + 2, data, len);
 415
 416         return digest_verify(&s->indigest, buffer, len - 14, buffer + len - 14);
 417 }
 418
 419 // Receive incoming data, datagram version.
 420 static bool sptps_receive_data_datagram(sptps_t *s, const char *data, size_t len) {
 421         if(len < (s->instate ? 21 : 5))
 422                 return error(s, EIO, "Received short packet");
 423
 424         uint32_t seqno;
 425         memcpy(&seqno, data, 4);
 426         seqno = ntohl(seqno);
 427
 428         if(!s->instate) {
 429                 if(seqno != s->inseqno)
 430                         return error(s, EIO, "Invalid packet seqno: %d != %d", seqno, s->inseqno);
 431
 432                 s->inseqno = seqno + 1;
 433
 434                 uint8_t type = data[4];
 435
 436                 if(type != SPTPS_HANDSHAKE)
 437                         return error(s, EIO, "Application record received before handshake finished");
 438
 439                 return receive_handshake(s, data + 5, len - 5);
 440         }
 441
 442         // Check HMAC.
 443         uint16_t netlen = htons(len - 21);
 444
 445         char buffer[len + 23];
 446
 447         memcpy(buffer, &netlen, 2);
 448         memcpy(buffer + 2, data, len);
 449
 450         memcpy(&seqno, buffer + 2, 4);
 451
 452         if(!digest_verify(&s->indigest, buffer, len - 14, buffer + len - 14))
 453                 return error(s, EIO, "Invalid HMAC");
 454
 455         // Replay protection using a sliding window of configurable size.
 456         // s->inseqno is expected sequence number
 457         // seqno is received sequence number
 458         // s->late[] is a circular buffer, a 1 bit means a packet has not been received yet
 459         // The circular buffer contains bits for sequence numbers from s->inseqno - s->replaywin * 8 to (but excluding) s->inseqno.
 460         if(s->replaywin) {
 461                 if(seqno != s->inseqno) {
 462                         if(seqno >= s->inseqno + s->replaywin * 8) {
 463                                 // Prevent packets that jump far ahead of the queue from causing many others to be dropped.
 464                                 if(s->farfuture++ < s->replaywin >> 2)
 465                                         return error(s, EIO, "Packet is %d seqs in the future, dropped (%u)\n", seqno - s->inseqno, s->farfuture);
 466
 467                                 // Unless we have seen lots of them, in which case we consider the others lost.
 468                                 warning(s, "Lost %d packets\n", seqno - s->inseqno);
 469                                 memset(s->late, 0, s->replaywin);
 470                         } else if (seqno < s->inseqno) {
 471                                 // If the sequence number is farther in the past than the bitmap goes, or if the packet was already received, drop it.
 472                                 if((s->inseqno >= s->replaywin * 8 && seqno < s->inseqno - s->replaywin * 8) || !(s->late[(seqno / 8) % s->replaywin] & (1 << seqno % 8)))
 473                                         return error(s, EIO, "Received late or replayed packet, seqno %d, last received %d\n", seqno, s->inseqno);
 474                         } else {
 475                                 // We missed some packets. Mark them in the bitmap as being late.
 476                                 for(int i = s->inseqno; i < seqno; i++)
 477                                         s->late[(i / 8) % s->replaywin] |= 1 << i % 8;
 478                         }
 479                 }
 480
 481                 // Mark the current packet as not being late.
 482                 s->late[(seqno / 8) % s->replaywin] &= ~(1 << seqno % 8);
 483                 s->farfuture = 0;
 484         }
 485
 486         if(seqno > s->inseqno)
 487                 s->inseqno = seqno + 1;
 488
 489         if(!s->inseqno)
 490                 s->received = 0;
 491         else
 492                 s->received++;
 493
 494         // Decrypt.
 495         cipher_set_counter(&s->incipher, &seqno, sizeof seqno);
 496         if(!cipher_counter_xor(&s->incipher, buffer + 6, len - 4, buffer + 6))
 497                 return false;
 498
 499         // Append a NULL byte for safety.
 500         buffer[len - 14] = 0;
 501
 502         uint8_t type = buffer[6];
 503
 504         if(type < SPTPS_HANDSHAKE) {
 505                 if(!s->instate)
 506                         return error(s, EIO, "Application record received before handshake finished");
 507                 if(!s->receive_record(s->handle, type, buffer + 7, len - 21))
 508                         return false;
 509         } else if(type == SPTPS_HANDSHAKE) {
 510                 if(!receive_handshake(s, buffer + 7, len - 21))
 511                         return false;
 512         } else {
 513                 return error(s, EIO, "Invalid record type");
 514         }
 515
 516         return true;
 517 }
 518
 519 // Receive incoming data. Check if it contains a complete record, if so, handle it.
 520 bool sptps_receive_data(sptps_t *s, const char *data, size_t len) {
 521         if(s->datagram)
 522                 return sptps_receive_data_datagram(s, data, len);
 523
 524         while(len) {
 525                 // First read the 2 length bytes.
 526                 if(s->buflen < 6) {
 527                         size_t toread = 6 - s->buflen;
 528                         if(toread > len)
 529                                 toread = len;
 530
 531                         memcpy(s->inbuf + s->buflen, data, toread);
 532
 533                         s->buflen += toread;
 534                         len -= toread;
 535                         data += toread;
 536
 537                         // Exit early if we don't have the full length.
 538                         if(s->buflen < 6)
 539                                 return true;
 540
 541                         // Decrypt the length bytes
 542
 543                         if(s->instate) {
 544                                 if(!cipher_counter_xor(&s->incipher, s->inbuf + 4, 2, &s->reclen))
 545                                         return false;
 546                         } else {
 547                                 memcpy(&s->reclen, s->inbuf + 4, 2);
 548                         }
 549
 550                         s->reclen = ntohs(s->reclen);
 551
 552                         // If we have the length bytes, ensure our buffer can hold the whole request.
 553                         s->inbuf = realloc(s->inbuf, s->reclen + 23UL);
 554                         if(!s->inbuf)
 555                                 return error(s, errno, strerror(errno));
 556
 557                         // Add sequence number.
 558                         uint32_t seqno = htonl(s->inseqno++);
 559                         memcpy(s->inbuf, &seqno, 4);
 560
 561                         // Exit early if we have no more data to process.
 562                         if(!len)
 563                                 return true;
 564                 }
 565
 566                 // Read up to the end of the record.
 567                 size_t toread = s->reclen + (s->instate ? 23UL : 7UL) - s->buflen;
 568                 if(toread > len)
 569                         toread = len;
 570
 571                 memcpy(s->inbuf + s->buflen, data, toread);
 572                 s->buflen += toread;
 573                 len -= toread;
 574                 data += toread;
 575
 576                 // If we don't have a whole record, exit.
 577                 if(s->buflen < s->reclen + (s->instate ? 23UL : 7UL))
 578                         return true;
 579
 580                 // Check HMAC and decrypt.
 581                 if(s->instate) {
 582                         if(!digest_verify(&s->indigest, s->inbuf, s->reclen + 7UL, s->inbuf + s->reclen + 7UL))
 583                                 return error(s, EIO, "Invalid HMAC");
 584
 585                         if(!cipher_counter_xor(&s->incipher, s->inbuf + 6UL, s->reclen + 1UL, s->inbuf + 6UL))
 586                                 return false;
 587                 }
 588
 589                 // Append a NULL byte for safety.
 590                 s->inbuf[s->reclen + 7UL] = 0;
 591
 592                 uint8_t type = s->inbuf[6];
 593
 594                 if(type < SPTPS_HANDSHAKE) {
 595                         if(!s->instate)
 596                                 return error(s, EIO, "Application record received before handshake finished");
 597                         if(!s->receive_record(s->handle, type, s->inbuf + 7, s->reclen))
 598                                 return false;
 599                 } else if(type == SPTPS_HANDSHAKE) {
 600                         if(!receive_handshake(s, s->inbuf + 7, s->reclen))
 601                                 return false;
 602                 } else {
 603                         return error(s, EIO, "Invalid record type");
 604                 }
 605
 606                 s->buflen = 4;
 607         }
 608
 609         return true;
 610 }
 611
 612 // Start a SPTPS session.
 613 bool sptps_start(sptps_t *s, void *handle, bool initiator, bool datagram, ecdsa_t mykey, ecdsa_t hiskey, const char *label, size_t labellen, send_data_t send_data, receive_record_t receive_record) {
 614         // Initialise struct sptps
 615         memset(s, 0, sizeof *s);
 616
 617         s->handle = handle;
 618         s->initiator = initiator;
 619         s->datagram = datagram;
 620         s->mykey = mykey;
 621         s->hiskey = hiskey;
 622         s->replaywin = sptps_replaywin;
 623         if(s->replaywin) {
 624                 s->late = malloc(s->replaywin);
 625                 if(!s->late)
 626                         return error(s, errno, strerror(errno));
 627         }
 628
 629         s->label = malloc(labellen);
 630         if(!s->label)
 631                 return error(s, errno, strerror(errno));
 632
 633         if(!datagram) {
 634                 s->inbuf = malloc(7);
 635                 if(!s->inbuf)
 636                         return error(s, errno, strerror(errno));
 637                 s->buflen = 4;
 638                 memset(s->inbuf, 0, 4);
 639         }
 640
 641         memcpy(s->label, label, labellen);
 642         s->labellen = labellen;
 643
 644         s->send_data = send_data;
 645         s->receive_record = receive_record;
 646
 647         // Do first KEX immediately
 648         s->state = SPTPS_KEX;
 649         return send_kex(s);
 650 }
 651
 652 // Stop a SPTPS session.
 653 bool sptps_stop(sptps_t *s) {
 654         // Clean up any resources.
 655         cipher_close(&s->incipher);
 656         cipher_close(&s->outcipher);
 657         digest_close(&s->indigest);
 658         digest_close(&s->outdigest);
 659         ecdh_free(&s->ecdh);
 660         free(s->inbuf);
 661         free(s->mykex);
 662         free(s->hiskex);
 663         free(s->key);
 664         free(s->label);
 665         free(s->late);
 666         memset(s, 0, sizeof *s);
 667         return true;
 668 }