switch to libsodium implementation of aegis256

Signed-off-by: Adrien Gallouët <adrien@gallouet.fr>

.gitignore

@@ -0,0 +1,4 @@
+.deps
+.dirstamp
+*.[ios]
+test

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016, angt
+Copyright (c) 2016-2020, Adrien Gallouët <adrien@gallouet.fr>
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Makefile

@@ -0,0 +1,8 @@
+CFLAGS=-march=native -O2
+LDLIBS=-lsodium
+
+test:
+
+.PHONY: clean
+clean:
+	rm -f test

README.md

@@ -1,23 +1,22 @@
 # MUD
 
-MUD is a secure, connectionless network protocol over UDP.
-It enables the distribution of packets on multiple paths while maintaining a low latency (the bandwidth is sacrificed in favor of latency).
+MUD is a secure, multipath network protocol over UDP.
+See [glorytun](https://github.com/angt/glorytun) for details.
 
 ### Compatibility
 
 Linux is the platform of choice but it was successfully ported to OpenBSD and OSX.
 
+### Dependencies
+
+ * A recent version of GCC or Clang.
+ * [libsodium](https://github.com/jedisct1/libsodium).
+
 ### Security
 
-MUD uses [libsodium](https://github.com/jedisct1/libsodium) for all cryptographic operations.
-Encryption (and authentication) is done with AES256-GCM when aesni is available otherwise ChaCha20-Poly1305 is used.
+Encryption and authentication is done with AEGIS256 when aesni is available otherwise ChaCha20-Poly1305 is used.
 The Diffie-Hellman function X25519 is used for key exchange.
 
-### Performance
-
-The scheduler is still in development but you will find some measurements to give you an idea of the performance [here](https://github.com/angt/mud/wiki/Perf).
-
-
 ### Issues
 
 For feature requests and bug reports, please create an [issue](https://github.com/angt/mud/issues).

mud.h

@@ -4,7 +4,8 @@
 #include <inttypes.h>
 #include <sys/socket.h>
 
-#define MUD_KISS_SIZE (8U)
+#define MUD_PATH_MAX    (32U)
+#define MUD_PUBKEY_SIZE (32U)
 
 struct mud;
 
@@ -15,56 +16,91 @@ enum mud_state {
     MUD_UP,
 };
 
+struct mud_stat {
+    uint64_t val;
+    uint64_t var;
+    int setup;
+};
+
+struct mud_conf {
+    uint64_t keepalive;
+    uint64_t timetolerance;
+    uint64_t kxtimeout;
+    int tc;
+};
+
 struct mud_path {
     enum mud_state state;
     struct sockaddr_storage local_addr, addr, r_addr;
-    unsigned char kiss[MUD_KISS_SIZE];
+    struct mud_stat rtt;
     struct {
-        uint64_t send_time;
-        int remote;
-    } conf;
-    uint64_t send_max;
-    uint64_t send_max_time;
-    uint64_t recv_max;
-    uint64_t recv_max_time;
-    uint64_t rtt;
-    uint64_t rst;
-    uint64_t r_rst;
-    uint64_t r_rms;
-    uint64_t r_rmt;
-    uint64_t limit;
-    uint64_t recv_time;
-    uint64_t send_time;
-    uint64_t stat_time;
-    struct {
-        size_t ok;
-        size_t probe;
+        uint64_t total;
+        uint64_t bytes;
         uint64_t time;
+        uint64_t rate;
+        uint64_t loss;
+    } tx, rx;
+    struct {
+        struct {
+            uint64_t total;
+            uint64_t bytes;
+            uint64_t time;
+            uint64_t acc;
+            uint64_t acc_time;
+        } tx, rx;
+        uint64_t time;
+        uint64_t sent;
+        uint64_t set;
+    } msg;
+    struct {
+        size_t min;
+        size_t max;
+        size_t probe;
+        size_t last;
+        size_t ok;
     } mtu;
+    struct {
+        uint64_t tx_max_rate;
+        uint64_t rx_max_rate;
+        uint64_t beat;
+        unsigned char fixed_rate;
+        unsigned char loss_limit;
+    } conf;
+    uint64_t idle;
+    unsigned char ok;
+};
+
+struct mud_bad {
+    struct {
+        struct sockaddr_storage addr;
+        uint64_t time;
+        uint64_t count;
+    } decrypt, difftime, keyx;
 };
 
 struct mud *mud_create (struct sockaddr *);
 void        mud_delete (struct mud *);
 
+int mud_update    (struct mud *);
+int mud_send_wait (struct mud *);
+
 int    mud_get_fd  (struct mud *);
+size_t mud_get_mtu (struct mud *);
+int    mud_get_bad (struct mud *, struct mud_bad *);
 
 int mud_set_key (struct mud *, unsigned char *, size_t);
 int mud_get_key (struct mud *, unsigned char *, size_t *);
 
-void   mud_set_mtu (struct mud *, size_t);
-size_t mud_get_mtu (struct mud *);
-
-int mud_set_send_timeout   (struct mud *, unsigned long);
-int mud_set_time_tolerance (struct mud *, unsigned long);
-int mud_set_keyx_timeout   (struct mud *, unsigned long);
-int mud_set_tc             (struct mud *, int);
 int mud_set_aes  (struct mud *);
+int mud_set_conf (struct mud *, struct mud_conf *);
 
-int mud_set_state (struct mud *, struct sockaddr *, enum mud_state);
+int mud_set_state (struct mud *, struct sockaddr *, enum mud_state,
+                   unsigned long, unsigned long, unsigned long,
+                   unsigned char, unsigned char);
 
 int mud_peer (struct mud *, struct sockaddr *);
 
 int mud_recv (struct mud *, void *, size_t);
-int mud_send (struct mud *, const void *, size_t, int);
+int mud_send (struct mud *, const void *, size_t);
 
 struct mud_path *mud_get_paths(struct mud *, unsigned *);

test.c

@@ -0,0 +1,121 @@
+#include "mud.c"
+
+#include <stdio.h>
+#include <poll.h>
+
+int
+main(int argc, char **argv)
+{
+    if (argc > 2)
+        return -1;
+
+    int client = argc == 2;
+
+    struct sockaddr_in local = {
+        .sin_family = AF_INET,
+        .sin_port = htons(client + 20000),
+        .sin_addr = {
+            .s_addr = htonl(INADDR_LOOPBACK),
+        },
+    };
+
+    struct mud *mud = mud_create((struct sockaddr *)&local);
+
+    if (!mud) {
+        perror("mud_create");
+        return -1;
+    }
+
+    unsigned char key[] = "0123456789ABCDEF0123456789ABCDEF";
+
+    if (mud_set_key(mud, key, sizeof(key))) {
+        perror("mud_set_key");
+        return -1;
+    }
+
+    // client is little harder to setup
+    if (client) {
+        struct sockaddr_in remote = {
+            .sin_family = AF_INET,
+            .sin_port = htons(20000),
+            .sin_addr = {
+                .s_addr = htonl(INADDR_LOOPBACK),
+            },
+        };
+
+        // we are going to connect to remote...
+        if (mud_peer(mud, (struct sockaddr *)&remote)) {
+            perror("mud_peer");
+            return -1;
+        }
+
+        // ...from loopback at 1MBps (not 1Mbps)
+        if (mud_set_state(mud, (struct sockaddr *)&local,
+                    MUD_UP, 1000 * 1000, 1000 * 1000, 0, 0, 0)) {
+            perror("mud_set_state");
+            return -1;
+        }
+    }
+
+    unsigned char buf[1500];
+
+    for (;;) {
+        // mandatory, mud have lot of work to do.
+        if (mud_update(mud))
+            usleep(100000); // don't use all the cpu
+
+        if (client) {
+            // when there is data, mud_recv() is mandatory
+            struct pollfd pollfd = {
+                .fd = mud_get_fd(mud),
+                .events = POLLIN,
+            };
+
+            switch (poll(&pollfd, 1, 0)) {
+            case -1:
+                perror("poll");
+                return -1;
+            case 1:
+                if (mud_recv(mud, buf, sizeof(buf)) == -1) {
+                    perror("mud_recv");
+                    return -1;
+                }
+            }
+
+            // we can safely call mud_send()
+            // even if the link is not ready
+            int r = mud_send(mud, argv[1], strlen(argv[1]));
+
+            if (r == -1) {
+                if (errno == EAGAIN)
+                    continue;
+
+                perror("mud_send");
+                return -1;
+            }
+
+            // we sent everything, bye :)
+            if (r)
+                break;
+        } else {
+            int r = mud_recv(mud, buf, sizeof(buf));
+
+            if (r == -1) {
+                if (errno == EAGAIN)
+                    continue;
+
+                perror("mud_recv");
+                return -1;
+            }
+
+            if (r) {
+                buf[r] = 0;
+                printf("%s\n", buf);
+            }
+        }
+    }
+
+    mud_delete(mud);
+
+    return 0;
+}