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

   1 /*
   2     sptps.c -- Simple Peer-to-Peer Security
   3     Copyright (C) 2011-2012 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         // Replay protection using a sliding window of configurable size.
 443         // s->inseqno is expected sequence number
 444         // seqno is received sequence number
 445         // s->late[] is a circular buffer, a 1 bit means a packet has not been received yet
 446         // The circular buffer contains bits for sequence numbers from s->inseqno - s->replaywin * 8 to (but excluding) s->inseqno.
 447         if(s->replaywin) {
 448                 if(seqno != s->inseqno) {
 449                         if(seqno >= s->inseqno + s->replaywin * 8) {
 450                                 // Prevent packets that jump far ahead of the queue from causing many others to be dropped.
 451                                 if(s->farfuture++ < s->replaywin >> 2)
 452                                         return error(s, EIO, "Packet is %d seqs in the future, dropped (%u)\n", seqno - s->inseqno, s->farfuture);
 453
 454                                 // Unless we have seen lots of them, in which case we consider the others lost.
 455                                 warning(s, "Lost %d packets\n", seqno - s->inseqno);
 456                                 memset(s->late, 0, s->replaywin);
 457                         } else if (seqno < s->inseqno) {
 458                                 // If the sequence number is farther in the past than the bitmap goes, or if the packet was already received, drop it.
 459                                 if((s->inseqno >= s->replaywin * 8 && seqno < s->inseqno - s->replaywin * 8) || !(s->late[(seqno / 8) % s->replaywin] & (1 << seqno % 8)))
 460                                         return error(s, EIO, "Received late or replayed packet, seqno %d, last received %d\n", seqno, s->inseqno);
 461                         } else {
 462                                 // We missed some packets. Mark them in the bitmap as being late.
 463                                 for(int i = s->inseqno; i < seqno; i++)
 464                                         s->late[(i / 8) % s->replaywin] |= 1 << i % 8;
 465                         }
 466                 }
 467
 468                 // Mark the current packet as not being late.
 469                 s->late[(seqno / 8) % s->replaywin] &= ~(1 << seqno % 8);
 470                 s->farfuture = 0;
 471         }
 472
 473         if(seqno > s->inseqno)
 474                 s->inseqno = seqno + 1;
 475
 476         uint16_t netlen = htons(len - 21);
 477
 478         char buffer[len + 23];
 479
 480         memcpy(buffer, &netlen, 2);
 481         memcpy(buffer + 2, data, len);
 482
 483         memcpy(&seqno, buffer + 2, 4);
 484
 485         // Check HMAC and decrypt.
 486         if(!digest_verify(&s->indigest, buffer, len - 14, buffer + len - 14))
 487                 return error(s, EIO, "Invalid HMAC");
 488
 489         cipher_set_counter(&s->incipher, &seqno, sizeof seqno);
 490         if(!cipher_counter_xor(&s->incipher, buffer + 6, len - 4, buffer + 6))
 491                 return false;
 492
 493         // Append a NULL byte for safety.
 494         buffer[len - 14] = 0;
 495
 496         uint8_t type = buffer[6];
 497
 498         if(type < SPTPS_HANDSHAKE) {
 499                 if(!s->instate)
 500                         return error(s, EIO, "Application record received before handshake finished");
 501                 if(!s->receive_record(s->handle, type, buffer + 7, len - 21))
 502                         return false;
 503         } else if(type == SPTPS_HANDSHAKE) {
 504                 if(!receive_handshake(s, buffer + 7, len - 21))
 505                         return false;
 506         } else {
 507                 return error(s, EIO, "Invalid record type");
 508         }
 509
 510         return true;
 511 }
 512
 513 // Receive incoming data. Check if it contains a complete record, if so, handle it.
 514 bool sptps_receive_data(sptps_t *s, const char *data, size_t len) {
 515         if(s->datagram)
 516                 return sptps_receive_data_datagram(s, data, len);
 517
 518         while(len) {
 519                 // First read the 2 length bytes.
 520                 if(s->buflen < 6) {
 521                         size_t toread = 6 - s->buflen;
 522                         if(toread > len)
 523                                 toread = len;
 524
 525                         memcpy(s->inbuf + s->buflen, data, toread);
 526
 527                         s->buflen += toread;
 528                         len -= toread;
 529                         data += toread;
 530
 531                         // Exit early if we don't have the full length.
 532                         if(s->buflen < 6)
 533                                 return true;
 534
 535                         // Decrypt the length bytes
 536
 537                         if(s->instate) {
 538                                 if(!cipher_counter_xor(&s->incipher, s->inbuf + 4, 2, &s->reclen))
 539                                         return false;
 540                         } else {
 541                                 memcpy(&s->reclen, s->inbuf + 4, 2);
 542                         }
 543
 544                         s->reclen = ntohs(s->reclen);
 545
 546                         // If we have the length bytes, ensure our buffer can hold the whole request.
 547                         s->inbuf = realloc(s->inbuf, s->reclen + 23UL);
 548                         if(!s->inbuf)
 549                                 return error(s, errno, strerror(errno));
 550
 551                         // Add sequence number.
 552                         uint32_t seqno = htonl(s->inseqno++);
 553                         memcpy(s->inbuf, &seqno, 4);
 554
 555                         // Exit early if we have no more data to process.
 556                         if(!len)
 557                                 return true;
 558                 }
 559
 560                 // Read up to the end of the record.
 561                 size_t toread = s->reclen + (s->instate ? 23UL : 7UL) - s->buflen;
 562                 if(toread > len)
 563                         toread = len;
 564
 565                 memcpy(s->inbuf + s->buflen, data, toread);
 566                 s->buflen += toread;
 567                 len -= toread;
 568                 data += toread;
 569
 570                 // If we don't have a whole record, exit.
 571                 if(s->buflen < s->reclen + (s->instate ? 23UL : 7UL))
 572                         return true;
 573
 574                 // Check HMAC and decrypt.
 575                 if(s->instate) {
 576                         if(!digest_verify(&s->indigest, s->inbuf, s->reclen + 7UL, s->inbuf + s->reclen + 7UL))
 577                                 return error(s, EIO, "Invalid HMAC");
 578
 579                         if(!cipher_counter_xor(&s->incipher, s->inbuf + 6UL, s->reclen + 1UL, s->inbuf + 6UL))
 580                                 return false;
 581                 }
 582
 583                 // Append a NULL byte for safety.
 584                 s->inbuf[s->reclen + 7UL] = 0;
 585
 586                 uint8_t type = s->inbuf[6];
 587
 588                 if(type < SPTPS_HANDSHAKE) {
 589                         if(!s->instate)
 590                                 return error(s, EIO, "Application record received before handshake finished");
 591                         if(!s->receive_record(s->handle, type, s->inbuf + 7, s->reclen))
 592                                 return false;
 593                 } else if(type == SPTPS_HANDSHAKE) {
 594                         if(!receive_handshake(s, s->inbuf + 7, s->reclen))
 595                                 return false;
 596                 } else {
 597                         return error(s, EIO, "Invalid record type");
 598                 }
 599
 600                 s->buflen = 4;
 601         }
 602
 603         return true;
 604 }
 605
 606 // Start a SPTPS session.
 607 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) {
 608         // Initialise struct sptps
 609         memset(s, 0, sizeof *s);
 610
 611         s->handle = handle;
 612         s->initiator = initiator;
 613         s->datagram = datagram;
 614         s->mykey = mykey;
 615         s->hiskey = hiskey;
 616         s->replaywin = sptps_replaywin;
 617         if(s->replaywin) {
 618                 s->late = malloc(s->replaywin);
 619                 if(!s->late)
 620                         return error(s, errno, strerror(errno));
 621         }
 622
 623         s->label = malloc(labellen);
 624         if(!s->label)
 625                 return error(s, errno, strerror(errno));
 626
 627         if(!datagram) {
 628                 s->inbuf = malloc(7);
 629                 if(!s->inbuf)
 630                         return error(s, errno, strerror(errno));
 631                 s->buflen = 4;
 632                 memset(s->inbuf, 0, 4);
 633         }
 634
 635         memcpy(s->label, label, labellen);
 636         s->labellen = labellen;
 637
 638         s->send_data = send_data;
 639         s->receive_record = receive_record;
 640
 641         // Do first KEX immediately
 642         s->state = SPTPS_KEX;
 643         return send_kex(s);
 644 }
 645
 646 // Stop a SPTPS session.
 647 bool sptps_stop(sptps_t *s) {
 648         // Clean up any resources.
 649         cipher_close(&s->incipher);
 650         cipher_close(&s->outcipher);
 651         digest_close(&s->indigest);
 652         digest_close(&s->outdigest);
 653         ecdh_free(&s->ecdh);
 654         free(s->inbuf);
 655         free(s->mykex);
 656         free(s->hiskex);
 657         free(s->key);
 658         free(s->label);
 659         free(s->late);
 660         memset(s, 0, sizeof *s);
 661         return true;
 662 }