c22926a84184353ee59fbad823442074dc561a37
[tinc] / 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         // 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 }