#include "prf.h"
#include "sptps.h"
-unsigned int sptps_replaywin = 32;
-
/*
Nonce MUST be exchanged first (done)
Signatures MUST be done over both nonces, to guarantee the signature is fresh
(void)s_errno;
(void)format;
(void)ap;
+
+ assert(format);
}
void sptps_log_stderr(sptps_t *s, int s_errno, const char *format, va_list ap) {
(void)s;
(void)s_errno;
+
+ assert(format);
+
vfprintf(stderr, format, ap);
fputc('\n', stderr);
}
-void (*sptps_log)(sptps_t *s, int s_errno, const char *format, va_list ap) = sptps_log_stderr;
+void (*sptps_log)(sptps_t *s, int s_errno, const char *format, va_list ap) = sptps_log_quiet;
// Log an error message.
static bool error(sptps_t *s, int s_errno, const char *format, ...) {
+ assert(s_errno);
+ assert(format);
+
if(format) {
va_list ap;
va_start(ap, format);
}
static void warning(sptps_t *s, const char *format, ...) {
+ assert(format);
+
va_list ap;
va_start(ap, format);
sptps_log(s, 0, format, ap);
// 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 void *data, uint16_t len) {
- char buffer[len + 21UL];
+ char buffer[len + SPTPS_DATAGRAM_OVERHEAD];
// Create header with sequence number, length and record type
uint32_t seqno = s->outseqno++;
if(s->outstate) {
// If first handshake has finished, encrypt and HMAC
chacha_poly1305_encrypt(s->outcipher, seqno, buffer + 4, len + 1, buffer + 4, NULL);
- return s->send_data(s->handle, type, buffer, len + 21UL);
+ return s->send_data(s->handle, type, buffer, len + SPTPS_DATAGRAM_OVERHEAD);
} else {
// Otherwise send as plaintext
return s->send_data(s->handle, type, buffer, len + 5UL);
return send_record_priv_datagram(s, type, data, len);
}
- char buffer[len + 19UL];
+ char buffer[len + SPTPS_OVERHEAD];
// Create header with sequence number, length and record type
uint32_t seqno = s->outseqno++;
if(s->outstate) {
// If first handshake has finished, encrypt and HMAC
chacha_poly1305_encrypt(s->outcipher, seqno, buffer + 2, len + 1, buffer + 2, NULL);
- return s->send_data(s->handle, type, buffer, len + 19UL);
+ return s->send_data(s->handle, type, buffer, len + SPTPS_OVERHEAD);
} else {
// Otherwise send as plaintext
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 void *data, uint16_t len) {
+ assert(!len || data);
+
// Sanity checks: application cannot send data before handshake is finished,
// and only record types 0..127 are allowed.
if(!s->outstate) {
// Generate key material from the shared secret created from the ECDHE key exchange.
static bool generate_key_material(sptps_t *s, const char *shared, size_t len) {
+ assert(shared);
+ assert(len);
+
// Initialise cipher and digest structures if necessary
if(!s->outstate) {
s->incipher = chacha_poly1305_init();
// Force another Key EXchange (for testing purposes).
bool sptps_force_kex(sptps_t *s) {
- if(!s->outstate || s->state != SPTPS_SECONDARY_KEX) {
+ if(!s->outstate) {
return error(s, EINVAL, "Cannot force KEX in current state");
}
+ if(s->state != SPTPS_SECONDARY_KEX) {
+ // We are already in the middle of a key exchange
+ return true;
+ }
+
s->state = SPTPS_KEX;
return send_kex(s);
}
return error(s, EIO, "SPTPS state not ready to verify this datagram");
}
- if(len < 21) {
+ if(len < SPTPS_DATAGRAM_OVERHEAD) {
return error(s, EIO, "Received short packet in sptps_verify_datagram");
}
seqno = ntohl(seqno);
// TODO: check whether seqno makes sense, to avoid CPU intensive decrypt
- char buffer[len];
- size_t outlen;
- return chacha_poly1305_decrypt(s->incipher, seqno, (const char *)data + 4, len - 4, buffer, &outlen);
+ return chacha_poly1305_verify(s->incipher, seqno, (const char *)data + 4, len - 4);
}
// Receive incoming data, datagram version.
static bool sptps_receive_data_datagram(sptps_t *s, const void *vdata, size_t len) {
const char *data = vdata;
- if(len < (s->instate ? 21 : 5)) {
+ if(len < (s->instate ? SPTPS_DATAGRAM_OVERHEAD : 5)) {
return error(s, EIO, "Received short packet in sptps_receive_data_datagram");
}
// Decrypt
- char buffer[len];
+ if(len > s->decrypted_buffer_len) {
+ s->decrypted_buffer_len *= 2;
+ char *new_buffer = realloc(s->decrypted_buffer, s->decrypted_buffer_len);
+
+ if(!new_buffer) {
+ return error(s, errno, strerror(errno));
+ }
+
+ s->decrypted_buffer = new_buffer;
+ }
size_t outlen;
- if(!chacha_poly1305_decrypt(s->incipher, seqno, data + 4, len - 4, buffer, &outlen)) {
+ if(!chacha_poly1305_decrypt(s->incipher, seqno, data + 4, len - 4, s->decrypted_buffer, &outlen)) {
return error(s, EIO, "Failed to decrypt and verify packet");
}
}
// Append a NULL byte for safety.
- buffer[len - 20] = 0;
+ s->decrypted_buffer[len - 20] = 0;
- uint8_t type = buffer[0];
+ uint8_t type = s->decrypted_buffer[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, buffer + 1, len - 21)) {
+ if(!s->receive_record(s->handle, type, s->decrypted_buffer + 1, len - SPTPS_DATAGRAM_OVERHEAD)) {
abort();
}
} else if(type == SPTPS_HANDSHAKE) {
- if(!receive_handshake(s, buffer + 1, len - 21)) {
+ if(!receive_handshake(s, s->decrypted_buffer + 1, len - SPTPS_DATAGRAM_OVERHEAD)) {
abort();
}
} else {
s->reclen = ntohs(s->reclen);
// If we have the length bytes, ensure our buffer can hold the whole request.
- s->inbuf = realloc(s->inbuf, s->reclen + 19UL);
+ s->inbuf = realloc(s->inbuf, s->reclen + SPTPS_OVERHEAD);
if(!s->inbuf) {
return error(s, errno, strerror(errno));
}
// Read up to the end of the record.
- size_t toread = s->reclen + (s->instate ? 19UL : 3UL) - s->buflen;
+ size_t toread = s->reclen + (s->instate ? SPTPS_OVERHEAD : 3UL) - s->buflen;
if(toread > len) {
toread = len;
ptr += toread;
// If we don't have a whole record, exit.
- if(s->buflen < s->reclen + (s->instate ? 19UL : 3UL)) {
+ if(s->buflen < s->reclen + (s->instate ? SPTPS_OVERHEAD : 3UL)) {
return true;
}
s->datagram = datagram;
s->mykey = mykey;
s->hiskey = hiskey;
- s->replaywin = sptps_replaywin;
+ s->replaywin = 32;
+ s->decrypted_buffer_len = 1024;
+ s->decrypted_buffer = malloc(s->decrypted_buffer_len);
+
+ if(!s->decrypted_buffer) {
+ return error(s, errno, strerror(errno));
+ }
if(s->replaywin) {
s->late = malloc(s->replaywin);
free(s->key);
free(s->label);
free(s->late);
+ memset(s->decrypted_buffer, 0, s->decrypted_buffer_len);
+ free(s->decrypted_buffer);
memset(s, 0, sizeof(*s));
return true;
}
projects / meshlink / blobdiff