Merge branch 'master' into fix/compile_issue

Author: mimoo

Makefile

@@ -1,17 +1,15 @@
 # This is a draft of a Makefile
 # it contains stuff like -g and -std=c11 and -fsanitize=address that are not
 # useful for production binaries
-
-# for some reason -Os gives me  larger library
-CFLAGS= -g -fPIC -Os -Wall -Werror -std=c99 -fsanitize=address
+CFLAGS= -g -fPIC -Os -Wall -Werror -std=c99 -fsanitize=address,undefined
 
 .PHONY: all clean test test_strobe
 
 all: disco.so
 
 # make a library
 disco.so: disco_symmetric.o disco_asymmetric.o tweetstrobe.o tweetX25519.o randombytes.o
-	$(CC) -shared disco_symmetric.o disco_asymmetric.o tweetstrobe.o tweetX25519.o randombytes.o -o disco.so
+	$(CC) $(CFLAGS) -shared disco_symmetric.o disco_asymmetric.o tweetstrobe.o tweetX25519.o randombytes.o -o disco.so
 
 # Disco protocol
 disco_asymmetric.o: lib/disco_asymmetric.c lib/disco_asymmetric.h
@@ -35,8 +33,8 @@ tweetstrobe.o: lib/tweetstrobe.c lib/tweetstrobe.h lib/keccak_f.c.inc
 
 # test is probably how you should compile your own program
 test: tests/test_disco.c disco_asymmetric.o tweetstrobe.o tweetX25519.o randombytes.o disco_symmetric.o
-	$(CC) $(CFLAGS) -g tests/test_disco.c -c -o test_disco.o -I lib
-	$(CC) $(CFLAGS) -g test_disco.o disco_asymmetric.o disco_symmetric.o tweetstrobe.o tweetX25519.o randombytes.o -o test
+	$(CC) $(CFLAGS) tests/test_disco.c -c -o test_disco.o -I lib
+	$(CC) $(CFLAGS) test_disco.o disco_asymmetric.o disco_symmetric.o tweetstrobe.o tweetX25519.o randombytes.o -o test
 	./test
 
 # test our implementation of tweetstrobe

README.md

@@ -27,7 +27,7 @@ int main() {
                    NULL, NULL, NULL);
 
   // process the first handshake message → e, es, s, ss
-  u8 in[500];
+  uint8_t in[500];
   size_t in_len
   bool ret = disco_ReadMessage(&hs_server, out, out_len, in, &in_len, NULL, NULL);
   if (!ret) {
@@ -41,7 +41,7 @@ int main() {
   strobe_s s_write;
   strobe_s s_read;
   size_t out_len;
-  ret = disco_WriteMessage(&hs_server, (u8 *)"second payload", 15,
+  ret = disco_WriteMessage(&hs_server, (uint8_t *)"second payload", 15,
                                        out, &out_len, &s_read, &s_write);
   if (!ret) {
     abort();
@@ -86,10 +86,10 @@ int main() {
                    NULL, &server_keypair, NULL);
 
   // write the first handshake message → e, es, s, ss
-  u8 out[500];
+  uint8_t out[500];
   size_t out_len;
   bool ret =
-      disco_WriteMessage(&hs_client, (u8*)"hey!", 5, out, &out_len, NULL, NULL);
+      disco_WriteMessage(&hs_client, (uint8_t*)"hey!", 5, out, &out_len, NULL, NULL);
   if (!ret) {
     abort();
   }
@@ -110,8 +110,8 @@ int main() {
   assert(c_write.initialized && c_read.initialized);
 
   // send a post-handshake message
-  u8 plaintext[] = "just a simple message";
-  u8* ciphertext = (u8*)malloc(sizeof(plaintext) + 16);
+  uint8_t plaintext[] = "just a simple message";
+  uint8_t* ciphertext = (uint8_t*)malloc(sizeof(plaintext) + 16);
   memcpy(ciphertext, plaintext, sizeof(plaintext));
 
   disco_EncryptInPlace(&c_write, ciphertext, sizeof(plaintext),

docs/index.md

@@ -27,7 +27,7 @@ int main() {
                    NULL, NULL, NULL);
 
   // process the first handshake message → e, es, s, ss
-  u8 in[500];
+  uint8_t in[500];
   size_t in_len
   bool ret = disco_ReadMessage(&hs_server, out, out_len, in, &in_len, NULL, NULL);
   if (!ret) {
@@ -41,7 +41,7 @@ int main() {
   strobe_s s_write;
   strobe_s s_read;
   size_t out_len;
-  ret = disco_WriteMessage(&hs_server, (u8 *)"second payload", 15,
+  ret = disco_WriteMessage(&hs_server, (uint8_t *)"second payload", 15,
                                        out, &out_len, &s_read, &s_write);
   if (!ret) {
     abort();
@@ -86,10 +86,10 @@ int main() {
                    NULL, &server_keypair, NULL);
 
   // write the first handshake message → e, es, s, ss
-  u8 out[500];
+  uint8_t out[500];
   size_t out_len;
   bool ret =
-      disco_WriteMessage(&hs_client, (u8*)"hey!", 5, out, &out_len, NULL, NULL);
+      disco_WriteMessage(&hs_client, (uint8_t*)"hey!", 5, out, &out_len, NULL, NULL);
   if (!ret) {
     abort();
   }
@@ -110,8 +110,8 @@ int main() {
   assert(c_write.initialized && c_read.initialized);
 
   // send a post-handshake message
-  u8 plaintext[] = "just a simple message";
-  u8* ciphertext = (u8*)malloc(sizeof(plaintext) + 16);
+  uint8_t plaintext[] = "just a simple message";
+  uint8_t* ciphertext = (uint8_t*)malloc(sizeof(plaintext) + 16);
   memcpy(ciphertext, plaintext, sizeof(plaintext));
 
   disco_EncryptInPlace(&c_write, ciphertext, sizeof(plaintext),
@@ -134,6 +134,12 @@ int main() {
 }
 ```
 
+## Testing and Production
+
+**EmbeddedDisco is not stable yet, it is not ready for production**.
+
+Do not use optimizations for testing, as the code contains asserts to pick common mistakes.
+
 ## Need help?
 
 This library is still heavily experimental. Its goal is to support as many platforms as possible. If you need help making it work for a specific platform please post an issue. If you have feedback, or suggestions, please post an issue as well.

examples/golang_interop/Makefile

@@ -6,14 +6,14 @@ all:
 	@echo "   then ./client server_address server_port server_public_key"
 	@echo "- make server"
 
-client:
+client: client.c
 	cd ../.. && make && cp *.o $(curdir) && cd $(curdir)
-	$(CC) client.c -fsanitize=address -I ../../lib -c -o client.o
-	$(CC) -fsanitize=address client.o tweetdisco.o tweetstrobe.o tweet25519.o randombytes.o -o client
+	$(CC) client.c -fsanitize=address,undefined -g -I ../../lib -c -o client.o
+	$(CC) -fsanitize=address,undefined -g client.o disco_asymmetric.o tweetstrobe.o tweetX25519.o randombytes.o -o client
 
 server:
 	go run server.go
 
 clean: 
 	rm *.o 
-	rm client
+	rm client

examples/golang_interop/client.c

@@ -74,9 +74,10 @@ int main(int argc, char const *argv[]) {
 
   // generate the first handshake message → e, es
   uint8_t out[500];
-  ssize_t out_len =
-      disco_WriteMessage(&hs_client, NULL, 0, out + 2, NULL, NULL);
-  if (out_len < 0) {
+  size_t out_len;
+  bool ret =
+      disco_WriteMessage(&hs_client, NULL, 0, out + 2, &out_len, NULL, NULL);
+  if (!ret) {
     printf("can't generate first handshake message\n");
     return 1;
   }
@@ -132,9 +133,10 @@ int main(int argc, char const *argv[]) {
     printf("\nwe don't suppor this yet\n");
     return 1;
   }
-  ssize_t payload_len =
-      disco_ReadMessage(&hs_client, in + 2, in_len, payload, &c_write, &c_read);
-  if (payload_len < 0) {
+  size_t payload_len;
+  ret = disco_ReadMessage(&hs_client, in + 2, in_len, payload, &payload_len,
+                          &c_write, &c_read);
+  if (!ret) {
     printf("can't read handshake message\n");
     abort();
   }
@@ -147,18 +149,24 @@ int main(int argc, char const *argv[]) {
   // loop: receive a line from the terminal and send it to the server
   while (true) {
     // get line
-    unsigned char *buffer = NULL;
-    size_t size;
-    getline(&buffer, &size, stdin);
+    char *buffer = NULL;
+    size_t size = 0;
+    ssize_t nread = getline(&buffer, &size, stdin);
+    if (nread < 0) {
+      printf("error reading the line\n");
+      return 1;
+    }
     // encrypt
-    out_len = sizeof(buffer) + 16;  // plaintext + tag
-    uint8_t *ct_and_mac = (uint8_t *)malloc(out_len + 2);
-    memcpy(ct_and_mac + 2, buffer, sizeof(buffer));
-    disco_EncryptInPlace(&c_write, ct_and_mac + 2, sizeof(buffer), out_len + 2);
+    printf("sizeof(buffer)=%lu\n", nread);
+    out_len = nread + 16;                                  // plaintext + tag
+    uint8_t *ct_and_mac = (uint8_t *)malloc(out_len + 2);  // +2 (length)
+    memcpy(ct_and_mac + 2, (uint8_t *)buffer, nread);
+    disco_EncryptInPlace(&c_write, ct_and_mac + 2, nread, out_len);
 
     // length framing
     ct_and_mac[0] = (out_len >> 8) & 0xFF;
     ct_and_mac[1] = out_len & 0xFF;
+    printf("debug: %d, %d\n", ct_and_mac[0], ct_and_mac[1]);
 
     // send
     sent = send(sock, ct_and_mac, out_len + 2, 0);
@@ -170,6 +178,7 @@ int main(int argc, char const *argv[]) {
 
     // free
     free(buffer);
+    free(ct_and_mac);
   }
 
   //

lib/devurandom.c

@@ -1,9 +1,10 @@
 #include <fcntl.h>
 #include <unistd.h>
+#include <stdint.h>
 
 static int fd = -1;
 
-void randombytes(unsigned char *x, unsigned long long xlen) {
+void randombytes(uint8_t *x, uint64_t xlen) {
   int i;
 
   if (fd == -1) {

lib/disco_asymmetric.c

@@ -32,18 +32,7 @@
 // ======
 // Used for key exchanges.
 
-/**
- * disco_generateKeyPair can be used to generate a X25519 keypair. This is
- * useful for creating long-term keypairs for a peer.
- * @kp an initialized keyPair struct. It is over-written by the function.
- */
-inline void disco_generateKeyPair(keyPair *kp) {
-  crypto_box_keypair(kp->pub, kp->priv);
-  kp->isSet = true;  // TODO: is this useful? If it is, should we use a magic
-                     // number here in case it's not initialized to false?
-}
-
-inline void DH(keyPair mine, keyPair theirs, uint8_t *output) {
+static inline void DH(keyPair mine, keyPair theirs, uint8_t *output) {
   crypto_scalarmult(output, mine.priv, theirs.pub);
 }
 
@@ -53,33 +42,37 @@ inline void DH(keyPair mine, keyPair theirs, uint8_t *output) {
 // Refer to the Disco specification to understand the meaning of these
 // functions.
 
-inline void initializeSymmetric(symmetricState *ss, const char *protocol_name,
-                                size_t protocol_name_len) {
+static inline void initializeSymmetric(symmetricState *ss,
+                                       const char *protocol_name,
+                                       size_t protocol_name_len) {
   strobe_init(&(ss->strobe), protocol_name, protocol_name_len);
 }
 
-inline void mixKey(symmetricState *ss, uint8_t *input_key_material) {
+static inline void mixKey(symmetricState *ss, uint8_t *input_key_material) {
   strobe_operate(&(ss->strobe), TYPE_AD, input_key_material, 32, false);
   ss->isKeyed = true;
 }
 
-inline void mixHash(symmetricState *ss, uint8_t *data, size_t data_len) {
+static inline void mixHash(symmetricState *ss, uint8_t *data, size_t data_len) {
   strobe_operate(&(ss->strobe), TYPE_AD, data, data_len, false);
 }
 
-inline void mixKeyAndHash(symmetricState *ss, uint8_t *input_key_material) {
+/*
+static inline void mixKeyAndHash(symmetricState *ss,
+                                 uint8_t *input_key_material) {
   strobe_operate(&(ss->strobe), TYPE_AD, input_key_material, 32, false);
 }
 
-inline void getHandshakeHash(symmetricState *ss, uint8_t *result) {
+static inline void getHandshakeHash(symmetricState *ss, uint8_t *result) {
   strobe_operate(&(ss->strobe), TYPE_PRF, result, 32, false);
 }
+*/
 
 // note that this function modifies the plaintext in place, and requires the
 // plaintext buffer to have 16 more bytes of capacity for the authentication tag
 // if the symmetric state is keyed
-inline void encryptAndHash(symmetricState *ss, uint8_t *plaintext,
-                           size_t plaintext_len) {
+static inline void encryptAndHash(symmetricState *ss, uint8_t *plaintext,
+                                  size_t plaintext_len) {
   if (!ss->isKeyed) {
     strobe_operate(&(ss->strobe), TYPE_CLR, plaintext, plaintext_len, false);
   } else {
@@ -91,8 +84,8 @@ inline void encryptAndHash(symmetricState *ss, uint8_t *plaintext,
 
 // note that the decryption occurs in place, and the the result is
 // `ciphertext_len-16` in case the symmetric state is keyed.
-inline bool decryptAndHash(symmetricState *ss, uint8_t *ciphertext,
-                           size_t ciphertext_len) {
+static inline bool decryptAndHash(symmetricState *ss, uint8_t *ciphertext,
+                                  size_t ciphertext_len) {
   if (!ss->isKeyed) {
     return strobe_operate(&(ss->strobe), TYPE_CLR | FLAG_I, ciphertext,
                           ciphertext_len, false);
@@ -200,11 +193,9 @@ void disco_Initialize(handshakeState *hs, const char *handshake_pattern,
 
   // handshake_pattern is of the following form:
   // "protocol_name \x00 pre-message patterns \x00 message patterns"
-  printf("debug1:%s\n", handshake_pattern);
   initializeSymmetric(&(hs->symmetric_state), handshake_pattern,
                       strlen(handshake_pattern));
   handshake_pattern = handshake_pattern + strlen(handshake_pattern) + 1;
-  printf("debug2:%s\n", handshake_pattern);
 
   hs->symmetric_state.isKeyed = false;
 

lib/disco_asymmetric.h

@@ -12,6 +12,7 @@
 #define __DISCO_H__
 
 #include "tweetstrobe.h"
+#include "tweetX25519.h"
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -80,8 +81,12 @@ typedef struct handshakeState_ {
 // Public API
 // ==========
 
-// used to generate long-term key pairs
-void disco_generateKeyPair(keyPair *kp);
+// used to generate long-term key pairs for a peer
+inline void disco_generateKeyPair(keyPair *kp) {
+  crypto_box_keypair(kp->pub, kp->priv);
+  kp->isSet = true;  // TODO: is this useful? If it is, should we use a magic
+                     // number here in case it's not initialized to false?
+}
 
 // used to initialized your handshakeState with a handshake pattern
 void disco_Initialize(handshakeState *hs, const char *handshake_pattern,