switch to libsodium implementation of aegis256

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

.gitignore

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

.gitmodules

@@ -1,4 +0,0 @@
-[submodule "aegis256"]
-	path = aegis256
-	url = https://github.com/angt/aegis256
-	ignore = dirty

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016-2019, Adrien Gallouët <adrien@gallouet.fr>
+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

mud.h

@@ -4,8 +4,8 @@
 #include <inttypes.h>
 #include <sys/socket.h>
 
-#define MUD_PATH_MAX (32U)
-#define MUD_PUB_SIZE (32U)
+#define MUD_PATH_MAX    (32U)
+#define MUD_PUBKEY_SIZE (32U)
 
 struct mud;
 
@@ -16,67 +16,91 @@ enum mud_state {
     MUD_UP,
 };
 
-struct mud_public {
-    unsigned char remote[MUD_PUB_SIZE];
-    unsigned char local[MUD_PUB_SIZE];
-};
-
 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;
     struct mud_stat rtt;
-    uint64_t rate_tx;
-    uint64_t rate_rx;
-    uint64_t window;
-    uint64_t window_time;
-    uint64_t window_size;
-    struct {
-        size_t min;
-        size_t max;
-        size_t probe;
-        size_t ok;
-    } mtu;
     struct {
         uint64_t total;
         uint64_t bytes;
         uint64_t time;
-        uint64_t msg_time;
-    } send, recv;
-    struct mud_public pub;
+        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;
-    unsigned msg_sent;
+};
+
+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_get_fd  (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 *);
-
-long mud_send_wait (struct mud *);
-
-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_aes  (struct mud *);
+int mud_set_conf (struct mud *, struct mud_conf *);
 
 int mud_set_state (struct mud *, struct sockaddr *, enum mud_state,
-                   unsigned long, unsigned long);
+                   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, unsigned);
+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;
+}