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>
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.
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.
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.
23 #include "chacha-poly1305/chacha-poly1305.h"
31 unsigned int sptps_replaywin = 16;
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!
38 Add explicit tag to beginning of structure to distinguish the client and server when signing. (done)
40 Sign all handshake messages up to ECDHE kex with long-term public keys. (done)
42 HMACed KEX finished message to prevent downgrade attacks and prove you have the right key material (done by virtue of Ed25519 over the whole ECDHE exchange?)
44 Explicit close message needs to be added.
46 Maybe do add some alert messages to give helpful error messages? Not more than TLS sends.
48 Use counter mode instead of OFB. (done)
50 Make sure ECC operations are fixed time (aka prevent side-channel attacks).
53 void sptps_log_quiet(sptps_t *s, int s_errno, const char *format, va_list ap) {
56 void sptps_log_stderr(sptps_t *s, int s_errno, const char *format, va_list ap) {
57 vfprintf(stderr, format, ap);
61 void (*sptps_log)(sptps_t *s, int s_errno, const char *format, va_list ap) = sptps_log_stderr;
63 // Log an error message.
64 static bool error(sptps_t *s, int s_errno, const char *format, ...) {
68 sptps_log(s, s_errno, format, ap);
76 static void warning(sptps_t *s, const char *format, ...) {
79 sptps_log(s, 0, format, ap);
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];
87 // Create header with sequence number, length and record type
88 uint32_t seqno = s->outseqno++;
89 uint32_t netseqno = ntohl(seqno);
91 memcpy(buffer, &netseqno, 4);
93 memcpy(buffer + 5, data, len);
96 // If first handshake has finished, encrypt and HMAC
97 chacha_poly1305_encrypt(s->outcipher, seqno, buffer + 4, len + 1, buffer + 4, NULL);
98 return s->send_data(s->handle, type, buffer, len + 21UL);
100 // Otherwise send as plaintext
101 return s->send_data(s->handle, type, buffer, len + 5UL);
104 // Send a record (private version, accepts all record types, handles encryption and authentication).
105 static bool send_record_priv(sptps_t *s, uint8_t type, const char *data, uint16_t len) {
107 return send_record_priv_datagram(s, type, data, len);
109 char buffer[len + 19UL];
111 // Create header with sequence number, length and record type
112 uint32_t seqno = s->outseqno++;
113 uint16_t netlen = htons(len);
115 memcpy(buffer, &netlen, 2);
117 memcpy(buffer + 3, data, len);
120 // If first handshake has finished, encrypt and HMAC
121 chacha_poly1305_encrypt(s->outcipher, seqno, buffer + 2, len + 1, buffer + 2, NULL);
122 return s->send_data(s->handle, type, buffer, len + 19UL);
124 // Otherwise send as plaintext
125 return s->send_data(s->handle, type, buffer, len + 3UL);
129 // Send an application record.
130 bool sptps_send_record(sptps_t *s, uint8_t type, const char *data, uint16_t len) {
131 // Sanity checks: application cannot send data before handshake is finished,
132 // and only record types 0..127 are allowed.
134 return error(s, EINVAL, "Handshake phase not finished yet");
136 if(type >= SPTPS_HANDSHAKE)
137 return error(s, EINVAL, "Invalid application record type");
139 return send_record_priv(s, type, data, len);
142 // Send a Key EXchange record, containing a random nonce and an ECDHE public key.
143 static bool send_kex(sptps_t *s) {
144 size_t keylen = ECDH_SIZE;
146 // Make room for our KEX message, which we will keep around since send_sig() needs it.
149 s->mykex = realloc(s->mykex, 1 + 32 + keylen);
151 return error(s, errno, strerror(errno));
153 // Set version byte to zero.
154 s->mykex[0] = SPTPS_VERSION;
156 // Create a random nonce.
157 randomize(s->mykex + 1, 32);
159 // Create a new ECDH public key.
160 if(!(s->ecdh = ecdh_generate_public(s->mykex + 1 + 32)))
161 return error(s, EINVAL, "Failed to generate ECDH public key");
163 return send_record_priv(s, SPTPS_HANDSHAKE, s->mykex, 1 + 32 + keylen);
166 // Send a SIGnature record, containing an Ed25519 signature over both KEX records.
167 static bool send_sig(sptps_t *s) {
168 size_t keylen = ECDH_SIZE;
169 size_t siglen = ecdsa_size(s->mykey);
171 // Concatenate both KEX messages, plus tag indicating if it is from the connection originator, plus label
172 char msg[(1 + 32 + keylen) * 2 + 1 + s->labellen];
175 msg[0] = s->initiator;
176 memcpy(msg + 1, s->mykex, 1 + 32 + keylen);
177 memcpy(msg + 1 + 33 + keylen, s->hiskex, 1 + 32 + keylen);
178 memcpy(msg + 1 + 2 * (33 + keylen), s->label, s->labellen);
181 if(!ecdsa_sign(s->mykey, msg, sizeof msg, sig))
182 return error(s, EINVAL, "Failed to sign SIG record");
184 // Send the SIG exchange record.
185 return send_record_priv(s, SPTPS_HANDSHAKE, sig, sizeof sig);
188 // Generate key material from the shared secret created from the ECDHE key exchange.
189 static bool generate_key_material(sptps_t *s, const char *shared, size_t len) {
190 // Initialise cipher and digest structures if necessary
192 s->incipher = chacha_poly1305_init();
193 s->outcipher = chacha_poly1305_init();
194 if(!s->incipher || !s->outcipher)
195 return error(s, EINVAL, "Failed to open cipher");
198 // Allocate memory for key material
199 size_t keylen = 2 * CHACHA_POLY1305_KEYLEN;
201 s->key = realloc(s->key, keylen);
203 return error(s, errno, strerror(errno));
205 // Create the HMAC seed, which is "key expansion" + session label + server nonce + client nonce
206 char seed[s->labellen + 64 + 13];
207 strcpy(seed, "key expansion");
209 memcpy(seed + 13, s->mykex + 1, 32);
210 memcpy(seed + 45, s->hiskex + 1, 32);
212 memcpy(seed + 13, s->hiskex + 1, 32);
213 memcpy(seed + 45, s->mykex + 1, 32);
215 memcpy(seed + 77, s->label, s->labellen);
217 // Use PRF to generate the key material
218 if(!prf(shared, len, seed, s->labellen + 64 + 13, s->key, keylen))
219 return error(s, EINVAL, "Failed to generate key material");
224 // Send an ACKnowledgement record.
225 static bool send_ack(sptps_t *s) {
226 return send_record_priv(s, SPTPS_HANDSHAKE, "", 0);
229 // Receive an ACKnowledgement record.
230 static bool receive_ack(sptps_t *s, const char *data, uint16_t len) {
232 return error(s, EIO, "Invalid ACK record length");
235 if(!chacha_poly1305_set_key(s->incipher, s->key))
236 return error(s, EINVAL, "Failed to set counter");
238 if(!chacha_poly1305_set_key(s->incipher, s->key + CHACHA_POLY1305_KEYLEN))
239 return error(s, EINVAL, "Failed to set counter");
249 // Receive a Key EXchange record, respond by sending a SIG record.
250 static bool receive_kex(sptps_t *s, const char *data, uint16_t len) {
251 // Verify length of the HELLO record
252 if(len != 1 + 32 + ECDH_SIZE)
253 return error(s, EIO, "Invalid KEX record length");
255 // Ignore version number for now.
257 // Make a copy of the KEX message, send_sig() and receive_sig() need it
259 return error(s, EINVAL, "Received a second KEX message before first has been processed");
260 s->hiskex = realloc(s->hiskex, len);
262 return error(s, errno, strerror(errno));
264 memcpy(s->hiskex, data, len);
269 // Receive a SIGnature record, verify it, if it passed, compute the shared secret and calculate the session keys.
270 static bool receive_sig(sptps_t *s, const char *data, uint16_t len) {
271 size_t keylen = ECDH_SIZE;
272 size_t siglen = ecdsa_size(s->hiskey);
274 // Verify length of KEX record.
276 return error(s, EIO, "Invalid KEX record length");
278 // Concatenate both KEX messages, plus tag indicating if it is from the connection originator
279 char msg[(1 + 32 + keylen) * 2 + 1 + s->labellen];
281 msg[0] = !s->initiator;
282 memcpy(msg + 1, s->hiskex, 1 + 32 + keylen);
283 memcpy(msg + 1 + 33 + keylen, s->mykex, 1 + 32 + keylen);
284 memcpy(msg + 1 + 2 * (33 + keylen), s->label, s->labellen);
287 if(!ecdsa_verify(s->hiskey, msg, sizeof msg, data))
288 return error(s, EIO, "Failed to verify SIG record");
290 // Compute shared secret.
291 char shared[ECDH_SHARED_SIZE];
292 if(!ecdh_compute_shared(s->ecdh, s->hiskex + 1 + 32, shared))
293 return error(s, EINVAL, "Failed to compute ECDH shared secret");
296 // Generate key material from shared secret.
297 if(!generate_key_material(s, shared, sizeof shared))
306 // Send cipher change record
307 if(s->outstate && !send_ack(s))
310 // TODO: only set new keys after ACK has been set/received
312 if(!chacha_poly1305_set_key(s->outcipher, s->key + CHACHA_POLY1305_KEYLEN))
313 return error(s, EINVAL, "Failed to set key");
315 if(!chacha_poly1305_set_key(s->outcipher, s->key))
316 return error(s, EINVAL, "Failed to set key");
322 // Force another Key EXchange (for testing purposes).
323 bool sptps_force_kex(sptps_t *s) {
324 if(!s->outstate || s->state != SPTPS_SECONDARY_KEX)
325 return error(s, EINVAL, "Cannot force KEX in current state");
327 s->state = SPTPS_KEX;
331 // Receive a handshake record.
332 static bool receive_handshake(sptps_t *s, const char *data, uint16_t len) {
333 // Only a few states to deal with handshaking.
335 case SPTPS_SECONDARY_KEX:
336 // We receive a secondary KEX request, first respond by sending our own.
340 // We have sent our KEX request, we expect our peer to sent one as well.
341 if(!receive_kex(s, data, len))
343 s->state = SPTPS_SIG;
346 // If we already sent our secondary public ECDH key, we expect the peer to send his.
347 if(!receive_sig(s, data, len))
350 s->state = SPTPS_ACK;
353 if(!receive_ack(s, NULL, 0))
355 s->receive_record(s->handle, SPTPS_HANDSHAKE, NULL, 0);
356 s->state = SPTPS_SECONDARY_KEX;
361 // We expect a handshake message to indicate transition to the new keys.
362 if(!receive_ack(s, data, len))
364 s->receive_record(s->handle, SPTPS_HANDSHAKE, NULL, 0);
365 s->state = SPTPS_SECONDARY_KEX;
367 // TODO: split ACK into a VERify and ACK?
369 return error(s, EIO, "Invalid session state %d", s->state);
373 // Check datagram for valid HMAC
374 bool sptps_verify_datagram(sptps_t *s, const char *data, size_t len) {
375 if(!s->instate || len < 21)
376 return error(s, EIO, "Received short packet");
378 // TODO: just decrypt without updating the replay window
383 // Receive incoming data, datagram version.
384 static bool sptps_receive_data_datagram(sptps_t *s, const char *data, size_t len) {
385 if(len < (s->instate ? 21 : 5))
386 return error(s, EIO, "Received short packet");
389 memcpy(&seqno, data, 4);
390 seqno = ntohl(seqno);
393 if(seqno != s->inseqno)
394 return error(s, EIO, "Invalid packet seqno: %d != %d", seqno, s->inseqno);
396 s->inseqno = seqno + 1;
398 uint8_t type = data[4];
400 if(type != SPTPS_HANDSHAKE)
401 return error(s, EIO, "Application record received before handshake finished");
403 return receive_handshake(s, data + 5, len - 5);
412 if(!chacha_poly1305_decrypt(s->incipher, seqno, data + 4, len - 4, buffer, &outlen))
413 return error(s, EIO, "Failed to decrypt and verify packet");
415 // Replay protection using a sliding window of configurable size.
416 // s->inseqno is expected sequence number
417 // seqno is received sequence number
418 // s->late[] is a circular buffer, a 1 bit means a packet has not been received yet
419 // The circular buffer contains bits for sequence numbers from s->inseqno - s->replaywin * 8 to (but excluding) s->inseqno.
421 if(seqno != s->inseqno) {
422 if(seqno >= s->inseqno + s->replaywin * 8) {
423 // Prevent packets that jump far ahead of the queue from causing many others to be dropped.
424 if(s->farfuture++ < s->replaywin >> 2)
425 return error(s, EIO, "Packet is %d seqs in the future, dropped (%u)\n", seqno - s->inseqno, s->farfuture);
427 // Unless we have seen lots of them, in which case we consider the others lost.
428 warning(s, "Lost %d packets\n", seqno - s->inseqno);
429 // Mark all packets in the replay window as being late.
430 memset(s->late, 255, s->replaywin);
431 } else if (seqno < s->inseqno) {
432 // If the sequence number is farther in the past than the bitmap goes, or if the packet was already received, drop it.
433 if((s->inseqno >= s->replaywin * 8 && seqno < s->inseqno - s->replaywin * 8) || !(s->late[(seqno / 8) % s->replaywin] & (1 << seqno % 8)))
434 return error(s, EIO, "Received late or replayed packet, seqno %d, last received %d\n", seqno, s->inseqno);
436 // We missed some packets. Mark them in the bitmap as being late.
437 for(int i = s->inseqno; i < seqno; i++)
438 s->late[(i / 8) % s->replaywin] |= 1 << i % 8;
442 // Mark the current packet as not being late.
443 s->late[(seqno / 8) % s->replaywin] &= ~(1 << seqno % 8);
447 if(seqno >= s->inseqno)
448 s->inseqno = seqno + 1;
455 // Append a NULL byte for safety.
456 buffer[len - 20] = 0;
458 uint8_t type = buffer[0];
460 if(type < SPTPS_HANDSHAKE) {
462 return error(s, EIO, "Application record received before handshake finished");
463 if(!s->receive_record(s->handle, type, buffer + 1, len - 21))
465 } else if(type == SPTPS_HANDSHAKE) {
466 if(!receive_handshake(s, buffer + 1, len - 21))
469 return error(s, EIO, "Invalid record type %d", type);
475 // Receive incoming data. Check if it contains a complete record, if so, handle it.
476 bool sptps_receive_data(sptps_t *s, const char *data, size_t len) {
478 return error(s, EIO, "Invalid session state zero");
481 return sptps_receive_data_datagram(s, data, len);
484 // First read the 2 length bytes.
486 size_t toread = 2 - s->buflen;
490 memcpy(s->inbuf + s->buflen, data, toread);
496 // Exit early if we don't have the full length.
500 // Get the length bytes
502 memcpy(&s->reclen, s->inbuf, 2);
503 s->reclen = ntohs(s->reclen);
505 // If we have the length bytes, ensure our buffer can hold the whole request.
506 s->inbuf = realloc(s->inbuf, s->reclen + 19UL);
508 return error(s, errno, strerror(errno));
510 // Exit early if we have no more data to process.
515 // Read up to the end of the record.
516 size_t toread = s->reclen + (s->instate ? 19UL : 3UL) - s->buflen;
520 memcpy(s->inbuf + s->buflen, data, toread);
525 // If we don't have a whole record, exit.
526 if(s->buflen < s->reclen + (s->instate ? 19UL : 3UL))
529 // Update sequence number.
531 uint32_t seqno = s->inseqno++;
533 // Check HMAC and decrypt.
535 if(!chacha_poly1305_decrypt(s->incipher, seqno, s->inbuf + 2UL, s->reclen + 17UL, s->inbuf + 2UL, NULL))
536 return error(s, EINVAL, "Failed to decrypt and verify record");
539 // Append a NULL byte for safety.
540 s->inbuf[s->reclen + 3UL] = 0;
542 uint8_t type = s->inbuf[2];
544 if(type < SPTPS_HANDSHAKE) {
546 return error(s, EIO, "Application record received before handshake finished");
547 if(!s->receive_record(s->handle, type, s->inbuf + 3, s->reclen))
549 } else if(type == SPTPS_HANDSHAKE) {
550 if(!receive_handshake(s, s->inbuf + 3, s->reclen))
553 return error(s, EIO, "Invalid record type %d", type);
562 // Start a SPTPS session.
563 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) {
564 // Initialise struct sptps
565 memset(s, 0, sizeof *s);
568 s->initiator = initiator;
569 s->datagram = datagram;
572 s->replaywin = sptps_replaywin;
574 s->late = malloc(s->replaywin);
576 return error(s, errno, strerror(errno));
577 memset(s->late, 0, s->replaywin);
580 s->label = malloc(labellen);
582 return error(s, errno, strerror(errno));
585 s->inbuf = malloc(7);
587 return error(s, errno, strerror(errno));
591 memcpy(s->label, label, labellen);
592 s->labellen = labellen;
594 s->send_data = send_data;
595 s->receive_record = receive_record;
597 // Do first KEX immediately
598 s->state = SPTPS_KEX;
602 // Stop a SPTPS session.
603 bool sptps_stop(sptps_t *s) {
604 // Clean up any resources.
605 chacha_poly1305_exit(s->incipher);
606 chacha_poly1305_exit(s->outcipher);
614 memset(s, 0, sizeof *s);