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