/*
sptps.c -- Simple Peer-to-Peer Security
- Copyright (C) 2011-2012 Guus Sliepen <guus@tinc-vpn.org>,
+ Copyright (C) 2011-2015 Guus Sliepen <guus@tinc-vpn.org>,
2010 Brandon L. Black <blblack@gmail.com>
This program is free software; you can redistribute it and/or modify
#include "system.h"
-#include "cipher.h"
+#include "chacha-poly1305/chacha-poly1305.h"
#include "crypto.h"
-#include "digest.h"
#include "ecdh.h"
#include "ecdsa.h"
#include "logger.h"
Sign all handshake messages up to ECDHE kex with long-term public keys. (done)
- 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?)
+ 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?)
Explicit close message needs to be added.
}
// Send a record (datagram version, accepts all record types, handles encryption and authentication).
-static bool send_record_priv_datagram(sptps_t *s, uint8_t type, const char *data, uint16_t len) {
- char buffer[len + 23UL];
+static bool send_record_priv_datagram(sptps_t *s, uint8_t type, const void *data, uint16_t len) {
+ char buffer[len + 21UL];
// Create header with sequence number, length and record type
- uint32_t seqno = htonl(s->outseqno++);
- uint16_t netlen = htons(len);
-
- memcpy(buffer, &netlen, 2);
- memcpy(buffer + 2, &seqno, 4);
- buffer[6] = type;
+ uint32_t seqno = s->outseqno++;
+ uint32_t netseqno = ntohl(seqno);
- // Add plaintext (TODO: avoid unnecessary copy)
- memcpy(buffer + 7, data, len);
+ memcpy(buffer, &netseqno, 4);
+ buffer[4] = type;
+ memcpy(buffer + 5, data, len);
if(s->outstate) {
// If first handshake has finished, encrypt and HMAC
- cipher_set_counter(&s->outcipher, &seqno, sizeof seqno);
- if(!cipher_counter_xor(&s->outcipher, buffer + 6, len + 1UL, buffer + 6))
- return false;
-
- if(!digest_create(&s->outdigest, buffer, len + 7UL, buffer + 7UL + len))
- return false;
-
- return s->send_data(s->handle, type, buffer + 2, len + 21UL);
+ chacha_poly1305_encrypt(s->outcipher, seqno, buffer + 4, len + 1, buffer + 4, NULL);
+ return s->send_data(s->handle, type, buffer, len + 21UL);
} else {
// Otherwise send as plaintext
- return s->send_data(s->handle, type, buffer + 2, len + 5UL);
+ return s->send_data(s->handle, type, buffer, len + 5UL);
}
}
// Send a record (private version, accepts all record types, handles encryption and authentication).
-static bool send_record_priv(sptps_t *s, uint8_t type, const char *data, uint16_t len) {
+static bool send_record_priv(sptps_t *s, uint8_t type, const void *data, uint16_t len) {
if(s->datagram)
return send_record_priv_datagram(s, type, data, len);
- char buffer[len + 23UL];
+ char buffer[len + 19UL];
// Create header with sequence number, length and record type
- uint32_t seqno = htonl(s->outseqno++);
+ uint32_t seqno = s->outseqno++;
uint16_t netlen = htons(len);
- memcpy(buffer, &seqno, 4);
- memcpy(buffer + 4, &netlen, 2);
- buffer[6] = type;
-
- // Add plaintext (TODO: avoid unnecessary copy)
- memcpy(buffer + 7, data, len);
+ memcpy(buffer, &netlen, 2);
+ buffer[2] = type;
+ memcpy(buffer + 3, data, len);
if(s->outstate) {
// If first handshake has finished, encrypt and HMAC
- if(!cipher_counter_xor(&s->outcipher, buffer + 4, len + 3UL, buffer + 4))
- return false;
-
- if(!digest_create(&s->outdigest, buffer, len + 7UL, buffer + 7UL + len))
- return false;
-
- return s->send_data(s->handle, type, buffer + 4, len + 19UL);
+ chacha_poly1305_encrypt(s->outcipher, seqno, buffer + 2, len + 1, buffer + 2, NULL);
+ return s->send_data(s->handle, type, buffer, len + 19UL);
} else {
// Otherwise send as plaintext
- return s->send_data(s->handle, type, buffer + 4, len + 3UL);
+ return s->send_data(s->handle, type, buffer, len + 3UL);
}
}
// Send an application record.
-bool sptps_send_record(sptps_t *s, uint8_t type, const char *data, uint16_t len) {
+bool sptps_send_record(sptps_t *s, uint8_t type, const void *data, uint16_t len) {
// Sanity checks: application cannot send data before handshake is finished,
// and only record types 0..127 are allowed.
if(!s->outstate)
// Make room for our KEX message, which we will keep around since send_sig() needs it.
if(s->mykex)
- abort();
+ return false;
s->mykex = realloc(s->mykex, 1 + 32 + keylen);
if(!s->mykex)
return error(s, errno, strerror(errno));
randomize(s->mykex + 1, 32);
// Create a new ECDH public key.
- if(!ecdh_generate_public(&s->ecdh, s->mykex + 1 + 32))
- return false;
+ if(!(s->ecdh = ecdh_generate_public(s->mykex + 1 + 32)))
+ return error(s, EINVAL, "Failed to generate ECDH public key");
return send_record_priv(s, SPTPS_HANDSHAKE, s->mykex, 1 + 32 + keylen);
}
-// Send a SIGnature record, containing an ECDSA signature over both KEX records.
+// Send a SIGnature record, containing an Ed25519 signature over both KEX records.
static bool send_sig(sptps_t *s) {
size_t keylen = ECDH_SIZE;
- size_t siglen = ecdsa_size(&s->mykey);
+ size_t siglen = ecdsa_size(s->mykey);
// Concatenate both KEX messages, plus tag indicating if it is from the connection originator, plus label
char msg[(1 + 32 + keylen) * 2 + 1 + s->labellen];
memcpy(msg + 1 + 2 * (33 + keylen), s->label, s->labellen);
// Sign the result.
- if(!ecdsa_sign(&s->mykey, msg, sizeof msg, sig))
- return false;
+ if(!ecdsa_sign(s->mykey, msg, sizeof msg, sig))
+ return error(s, EINVAL, "Failed to sign SIG record");
// Send the SIG exchange record.
return send_record_priv(s, SPTPS_HANDSHAKE, sig, sizeof sig);
static bool generate_key_material(sptps_t *s, const char *shared, size_t len) {
// Initialise cipher and digest structures if necessary
if(!s->outstate) {
- bool result
- = cipher_open_by_name(&s->incipher, "aes-256-ecb")
- && cipher_open_by_name(&s->outcipher, "aes-256-ecb")
- && digest_open_by_name(&s->indigest, "sha256", 16)
- && digest_open_by_name(&s->outdigest, "sha256", 16);
- if(!result)
- return false;
+ s->incipher = chacha_poly1305_init();
+ s->outcipher = chacha_poly1305_init();
+ if(!s->incipher || !s->outcipher)
+ return error(s, EINVAL, "Failed to open cipher");
}
// Allocate memory for key material
- size_t keylen = digest_keylength(&s->indigest) + digest_keylength(&s->outdigest) + cipher_keylength(&s->incipher) + cipher_keylength(&s->outcipher);
+ size_t keylen = 2 * CHACHA_POLY1305_KEYLEN;
s->key = realloc(s->key, keylen);
if(!s->key)
// Create the HMAC seed, which is "key expansion" + session label + server nonce + client nonce
char seed[s->labellen + 64 + 13];
- strcpy(seed, "key expansion");
+ memcpy(seed, "key expansion", 13);
if(s->initiator) {
memcpy(seed + 13, s->mykex + 1, 32);
memcpy(seed + 45, s->hiskex + 1, 32);
// Use PRF to generate the key material
if(!prf(shared, len, seed, s->labellen + 64 + 13, s->key, keylen))
- return false;
+ return error(s, EINVAL, "Failed to generate key material");
return true;
}
return error(s, EIO, "Invalid ACK record length");
if(s->initiator) {
- bool result
- = cipher_set_counter_key(&s->incipher, s->key)
- && digest_set_key(&s->indigest, s->key + cipher_keylength(&s->incipher), digest_keylength(&s->indigest));
- if(!result)
- return false;
+ if(!chacha_poly1305_set_key(s->incipher, s->key))
+ return error(s, EINVAL, "Failed to set counter");
} else {
- bool result
- = cipher_set_counter_key(&s->incipher, s->key + cipher_keylength(&s->outcipher) + digest_keylength(&s->outdigest))
- && digest_set_key(&s->indigest, s->key + cipher_keylength(&s->outcipher) + digest_keylength(&s->outdigest) + cipher_keylength(&s->incipher), digest_keylength(&s->indigest));
- if(!result)
- return false;
+ if(!chacha_poly1305_set_key(s->incipher, s->key + CHACHA_POLY1305_KEYLEN))
+ return error(s, EINVAL, "Failed to set counter");
}
free(s->key);
// Make a copy of the KEX message, send_sig() and receive_sig() need it
if(s->hiskex)
- abort();
+ return error(s, EINVAL, "Received a second KEX message before first has been processed");
s->hiskex = realloc(s->hiskex, len);
if(!s->hiskex)
return error(s, errno, strerror(errno));
// Receive a SIGnature record, verify it, if it passed, compute the shared secret and calculate the session keys.
static bool receive_sig(sptps_t *s, const char *data, uint16_t len) {
size_t keylen = ECDH_SIZE;
- size_t siglen = ecdsa_size(&s->hiskey);
+ size_t siglen = ecdsa_size(s->hiskey);
// Verify length of KEX record.
if(len != siglen)
memcpy(msg + 1 + 2 * (33 + keylen), s->label, s->labellen);
// Verify signature.
- if(!ecdsa_verify(&s->hiskey, msg, sizeof msg, data))
- return false;
+ if(!ecdsa_verify(s->hiskey, msg, sizeof msg, data))
+ return error(s, EIO, "Failed to verify SIG record");
// Compute shared secret.
char shared[ECDH_SHARED_SIZE];
- if(!ecdh_compute_shared(&s->ecdh, s->hiskex + 1 + 32, shared))
- return false;
+ if(!ecdh_compute_shared(s->ecdh, s->hiskex + 1 + 32, shared))
+ return error(s, EINVAL, "Failed to compute ECDH shared secret");
+ s->ecdh = NULL;
// Generate key material from shared secret.
if(!generate_key_material(s, shared, sizeof shared))
// TODO: only set new keys after ACK has been set/received
if(s->initiator) {
- bool result
- = cipher_set_counter_key(&s->outcipher, s->key + cipher_keylength(&s->incipher) + digest_keylength(&s->indigest))
- && digest_set_key(&s->outdigest, s->key + cipher_keylength(&s->incipher) + digest_keylength(&s->indigest) + cipher_keylength(&s->outcipher), digest_keylength(&s->outdigest));
- if(!result)
- return false;
+ if(!chacha_poly1305_set_key(s->outcipher, s->key + CHACHA_POLY1305_KEYLEN))
+ return error(s, EINVAL, "Failed to set key");
} else {
- bool result
- = cipher_set_counter_key(&s->outcipher, s->key)
- && digest_set_key(&s->outdigest, s->key + cipher_keylength(&s->outcipher), digest_keylength(&s->outdigest));
- if(!result)
- return false;
+ if(!chacha_poly1305_set_key(s->outcipher, s->key))
+ return error(s, EINVAL, "Failed to set key");
}
return true;
return true;
// TODO: split ACK into a VERify and ACK?
default:
- return error(s, EIO, "Invalid session state");
+ return error(s, EIO, "Invalid session state %d", s->state);
}
}
-// Check datagram for valid HMAC
-bool sptps_verify_datagram(sptps_t *s, const char *data, size_t len) {
- if(!s->instate || len < 21)
- return false;
-
- char buffer[len + 23];
- uint16_t netlen = htons(len - 21);
-
- memcpy(buffer, &netlen, 2);
- memcpy(buffer + 2, data, len);
-
- return digest_verify(&s->indigest, buffer, len - 14, buffer + len - 14);
-}
-
-// Receive incoming data, datagram version.
-static bool sptps_receive_data_datagram(sptps_t *s, const char *data, size_t len) {
- if(len < (s->instate ? 21 : 5))
- return error(s, EIO, "Received short packet");
-
- uint32_t seqno;
- memcpy(&seqno, data, 4);
- seqno = ntohl(seqno);
-
- if(!s->instate) {
- if(seqno != s->inseqno)
- return error(s, EIO, "Invalid packet seqno: %d != %d", seqno, s->inseqno);
-
- s->inseqno = seqno + 1;
-
- uint8_t type = data[4];
-
- if(type != SPTPS_HANDSHAKE)
- return error(s, EIO, "Application record received before handshake finished");
-
- return receive_handshake(s, data + 5, len - 5);
- }
-
+static bool sptps_check_seqno(sptps_t *s, uint32_t seqno, bool update_state) {
// Replay protection using a sliding window of configurable size.
// s->inseqno is expected sequence number
// seqno is received sequence number
if(seqno != s->inseqno) {
if(seqno >= s->inseqno + s->replaywin * 8) {
// Prevent packets that jump far ahead of the queue from causing many others to be dropped.
- if(s->farfuture++ < s->replaywin >> 2)
- return error(s, EIO, "Packet is %d seqs in the future, dropped (%u)\n", seqno - s->inseqno, s->farfuture);
+ bool farfuture = s->farfuture < s->replaywin >> 2;
+ if (update_state)
+ s->farfuture++;
+ if(farfuture)
+ return update_state ? error(s, EIO, "Packet is %d seqs in the future, dropped (%u)\n", seqno - s->inseqno, s->farfuture) : false;
// Unless we have seen lots of them, in which case we consider the others lost.
- warning(s, "Lost %d packets\n", seqno - s->inseqno);
- memset(s->late, 0, s->replaywin);
+ if(update_state)
+ warning(s, "Lost %d packets\n", seqno - s->inseqno);
+ if (update_state) {
+ // Mark all packets in the replay window as being late.
+ memset(s->late, 255, s->replaywin);
+ }
} else if (seqno < s->inseqno) {
// If the sequence number is farther in the past than the bitmap goes, or if the packet was already received, drop it.
if((s->inseqno >= s->replaywin * 8 && seqno < s->inseqno - s->replaywin * 8) || !(s->late[(seqno / 8) % s->replaywin] & (1 << seqno % 8)))
- return error(s, EIO, "Received late or replayed packet, seqno %d, last received %d\n", seqno, s->inseqno);
- } else {
+ return update_state ? error(s, EIO, "Received late or replayed packet, seqno %d, last received %d\n", seqno, s->inseqno) : false;
+ } else if (update_state) {
// We missed some packets. Mark them in the bitmap as being late.
for(int i = s->inseqno; i < seqno; i++)
s->late[(i / 8) % s->replaywin] |= 1 << i % 8;
}
}
- // Mark the current packet as not being late.
- s->late[(seqno / 8) % s->replaywin] &= ~(1 << seqno % 8);
- s->farfuture = 0;
+ if (update_state) {
+ // Mark the current packet as not being late.
+ s->late[(seqno / 8) % s->replaywin] &= ~(1 << seqno % 8);
+ s->farfuture = 0;
+ }
+ }
+
+ if (update_state) {
+ if(seqno >= s->inseqno)
+ s->inseqno = seqno + 1;
+
+ if(!s->inseqno)
+ s->received = 0;
+ else
+ s->received++;
}
- if(seqno > s->inseqno)
+ return true;
+}
+
+// Check datagram for valid HMAC
+bool sptps_verify_datagram(sptps_t *s, const void *data, size_t len) {
+ if(!s->instate || len < 21)
+ return error(s, EIO, "Received short packet");
+
+ uint32_t seqno;
+ memcpy(&seqno, data, 4);
+ seqno = ntohl(seqno);
+ if (!sptps_check_seqno(s, seqno, false))
+ return false;
+
+ char buffer[len];
+ size_t outlen;
+ return chacha_poly1305_decrypt(s->incipher, seqno, data + 4, len - 4, buffer, &outlen);
+}
+
+// Receive incoming data, datagram version.
+static bool sptps_receive_data_datagram(sptps_t *s, const char *data, size_t len) {
+ if(len < (s->instate ? 21 : 5))
+ return error(s, EIO, "Received short packet");
+
+ uint32_t seqno;
+ memcpy(&seqno, data, 4);
+ seqno = ntohl(seqno);
+ data += 4; len -= 4;
+
+ if(!s->instate) {
+ if(seqno != s->inseqno)
+ return error(s, EIO, "Invalid packet seqno: %d != %d", seqno, s->inseqno);
+
s->inseqno = seqno + 1;
- uint16_t netlen = htons(len - 21);
+ uint8_t type = *(data++); len--;
- char buffer[len + 23];
+ if(type != SPTPS_HANDSHAKE)
+ return error(s, EIO, "Application record received before handshake finished");
- memcpy(buffer, &netlen, 2);
- memcpy(buffer + 2, data, len);
+ return receive_handshake(s, data, len);
+ }
- memcpy(&seqno, buffer + 2, 4);
+ // Decrypt
- // Check HMAC and decrypt.
- if(!digest_verify(&s->indigest, buffer, len - 14, buffer + len - 14))
- return error(s, EIO, "Invalid HMAC");
+ char buffer[len];
+ size_t outlen;
+ if(!chacha_poly1305_decrypt(s->incipher, seqno, data, len, buffer, &outlen))
+ return error(s, EIO, "Failed to decrypt and verify packet");
- cipher_set_counter(&s->incipher, &seqno, sizeof seqno);
- if(!cipher_counter_xor(&s->incipher, buffer + 6, len - 4, buffer + 6))
+ if(!sptps_check_seqno(s, seqno, true))
return false;
// Append a NULL byte for safety.
- buffer[len - 14] = 0;
+ buffer[outlen] = 0;
+
+ data = buffer;
+ len = outlen;
- uint8_t type = buffer[6];
+ uint8_t type = *(data++); len--;
if(type < SPTPS_HANDSHAKE) {
if(!s->instate)
return error(s, EIO, "Application record received before handshake finished");
- if(!s->receive_record(s->handle, type, buffer + 7, len - 21))
+ if(!s->receive_record(s->handle, type, data, len))
return false;
} else if(type == SPTPS_HANDSHAKE) {
- if(!receive_handshake(s, buffer + 7, len - 21))
+ if(!receive_handshake(s, data, len))
return false;
} else {
- return error(s, EIO, "Invalid record type");
+ return error(s, EIO, "Invalid record type %d", type);
}
return true;
}
// Receive incoming data. Check if it contains a complete record, if so, handle it.
-bool sptps_receive_data(sptps_t *s, const char *data, size_t len) {
- if(s->datagram)
- return sptps_receive_data_datagram(s, data, len);
+size_t sptps_receive_data(sptps_t *s, const void *data, size_t len) {
+ size_t total_read = 0;
- while(len) {
- // First read the 2 length bytes.
- if(s->buflen < 6) {
- size_t toread = 6 - s->buflen;
- if(toread > len)
- toread = len;
+ if(!s->state)
+ return error(s, EIO, "Invalid session state zero");
- memcpy(s->inbuf + s->buflen, data, toread);
+ if(s->datagram)
+ return sptps_receive_data_datagram(s, data, len) ? len : false;
- s->buflen += toread;
- len -= toread;
- data += toread;
+ // First read the 2 length bytes.
+ if(s->buflen < 2) {
+ size_t toread = 2 - s->buflen;
+ if(toread > len)
+ toread = len;
- // Exit early if we don't have the full length.
- if(s->buflen < 6)
- return true;
+ memcpy(s->inbuf + s->buflen, data, toread);
- // Decrypt the length bytes
+ total_read += toread;
+ s->buflen += toread;
+ len -= toread;
+ data += toread;
- if(s->instate) {
- if(!cipher_counter_xor(&s->incipher, s->inbuf + 4, 2, &s->reclen))
- return false;
- } else {
- memcpy(&s->reclen, s->inbuf + 4, 2);
- }
+ // Exit early if we don't have the full length.
+ if(s->buflen < 2)
+ return total_read;
- s->reclen = ntohs(s->reclen);
+ // Get the length bytes
- // If we have the length bytes, ensure our buffer can hold the whole request.
- s->inbuf = realloc(s->inbuf, s->reclen + 23UL);
- if(!s->inbuf)
- return error(s, errno, strerror(errno));
+ memcpy(&s->reclen, s->inbuf, 2);
+ s->reclen = ntohs(s->reclen);
- // Add sequence number.
- uint32_t seqno = htonl(s->inseqno++);
- memcpy(s->inbuf, &seqno, 4);
+ // If we have the length bytes, ensure our buffer can hold the whole request.
+ s->inbuf = realloc(s->inbuf, s->reclen + 19UL);
+ if(!s->inbuf)
+ return error(s, errno, strerror(errno));
- // Exit early if we have no more data to process.
- if(!len)
- return true;
- }
+ // Exit early if we have no more data to process.
+ if(!len)
+ return total_read;
+ }
- // Read up to the end of the record.
- size_t toread = s->reclen + (s->instate ? 23UL : 7UL) - s->buflen;
- if(toread > len)
- toread = len;
+ // Read up to the end of the record.
+ size_t toread = s->reclen + (s->instate ? 19UL : 3UL) - s->buflen;
+ if(toread > len)
+ toread = len;
- memcpy(s->inbuf + s->buflen, data, toread);
- s->buflen += toread;
- len -= toread;
- data += toread;
+ memcpy(s->inbuf + s->buflen, data, toread);
+ total_read += toread;
+ s->buflen += toread;
+ len -= toread;
+ data += toread;
- // If we don't have a whole record, exit.
- if(s->buflen < s->reclen + (s->instate ? 23UL : 7UL))
- return true;
+ // If we don't have a whole record, exit.
+ if(s->buflen < s->reclen + (s->instate ? 19UL : 3UL))
+ return total_read;
- // Check HMAC and decrypt.
- if(s->instate) {
- if(!digest_verify(&s->indigest, s->inbuf, s->reclen + 7UL, s->inbuf + s->reclen + 7UL))
- return error(s, EIO, "Invalid HMAC");
+ // Update sequence number.
- if(!cipher_counter_xor(&s->incipher, s->inbuf + 6UL, s->reclen + 1UL, s->inbuf + 6UL))
- return false;
- }
+ uint32_t seqno = s->inseqno++;
- // Append a NULL byte for safety.
- s->inbuf[s->reclen + 7UL] = 0;
+ // Check HMAC and decrypt.
+ if(s->instate) {
+ if(!chacha_poly1305_decrypt(s->incipher, seqno, s->inbuf + 2UL, s->reclen + 17UL, s->inbuf + 2UL, NULL))
+ return error(s, EINVAL, "Failed to decrypt and verify record");
+ }
- uint8_t type = s->inbuf[6];
+ // Append a NULL byte for safety.
+ s->inbuf[s->reclen + 3UL] = 0;
- if(type < SPTPS_HANDSHAKE) {
- if(!s->instate)
- return error(s, EIO, "Application record received before handshake finished");
- if(!s->receive_record(s->handle, type, s->inbuf + 7, s->reclen))
- return false;
- } else if(type == SPTPS_HANDSHAKE) {
- if(!receive_handshake(s, s->inbuf + 7, s->reclen))
- return false;
- } else {
- return error(s, EIO, "Invalid record type");
- }
+ uint8_t type = s->inbuf[2];
- s->buflen = 4;
+ if(type < SPTPS_HANDSHAKE) {
+ if(!s->instate)
+ return error(s, EIO, "Application record received before handshake finished");
+ if(!s->receive_record(s->handle, type, s->inbuf + 3, s->reclen))
+ return false;
+ } else if(type == SPTPS_HANDSHAKE) {
+ if(!receive_handshake(s, s->inbuf + 3, s->reclen))
+ return false;
+ } else {
+ return error(s, EIO, "Invalid record type %d", type);
}
- return true;
+ s->buflen = 0;
+
+ return total_read;
}
// Start a SPTPS session.
-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) {
+bool sptps_start(sptps_t *s, void *handle, bool initiator, bool datagram, ecdsa_t *mykey, ecdsa_t *hiskey, const void *label, size_t labellen, send_data_t send_data, receive_record_t receive_record) {
// Initialise struct sptps
memset(s, 0, sizeof *s);
s->late = malloc(s->replaywin);
if(!s->late)
return error(s, errno, strerror(errno));
+ memset(s->late, 0, s->replaywin);
}
s->label = malloc(labellen);
s->inbuf = malloc(7);
if(!s->inbuf)
return error(s, errno, strerror(errno));
- s->buflen = 4;
- memset(s->inbuf, 0, 4);
+ s->buflen = 0;
}
memcpy(s->label, label, labellen);
// Stop a SPTPS session.
bool sptps_stop(sptps_t *s) {
// Clean up any resources.
- cipher_close(&s->incipher);
- cipher_close(&s->outcipher);
- digest_close(&s->indigest);
- digest_close(&s->outdigest);
- ecdh_free(&s->ecdh);
+ chacha_poly1305_exit(s->incipher);
+ chacha_poly1305_exit(s->outcipher);
+ ecdh_free(s->ecdh);
free(s->inbuf);
free(s->mykex);
free(s->hiskex);
projects / tinc / blobdiff