Use a new random secret key without keyfile

src/common.c

@@ -41,17 +41,20 @@ void gt_na (const char *name)
 
 int gt_tohex (char *dst, size_t dst_size, const uint8_t *src, size_t src_size)
 {
-    if _0_(dst_size<2*src_size+1)
+    if _0_(!dst_size)
         return -1;
 
-    const char tbl[] = "0123456789ABCDEF";
+    if _0_(((dst_size-1)/2)<src_size)
+        return -1;
+
+    static const char tbl[] = "0123456789ABCDEF";
 
     for (size_t i=0; i<src_size; i++) {
-        dst[(i<<1)+0] = tbl[0xF&(src[i]>>4)];
+        *dst++ = tbl[0xF&(src[i]>>4)];
-        dst[(i<<1)+1] = tbl[0xF&(src[i])];
+        *dst++ = tbl[0xF&(src[i])];
     }
 
-    dst[2*src_size] = 0;
+    *dst = 0;
 
     return 0;
 }
@@ -63,6 +66,9 @@ static inline int fromhex (const char c)
         return c-'0';
 
     if (c>='A' && c<='F')
+        return c-'A'+10;
+
+    if (c>='a' && c<='f')
         return c-'a'+10;
 
     return -1;
@@ -73,7 +79,7 @@ int gt_fromhex (uint8_t *dst, size_t dst_size, const char *src, size_t src_size)
     if _0_(src_size&1)
         return -1;
 
-    if _0_(src_size>2*dst_size)
+    if _0_(dst_size<(src_size/2))
         return -1;
 
     for (size_t i=0; i<src_size; i+=2) {
@@ -83,7 +89,7 @@ int gt_fromhex (uint8_t *dst, size_t dst_size, const char *src, size_t src_size)
         if _0_(a==-1 || b==-1)
             return -1;
 
-        dst[i>>1] = (a<<4)|b;
+        *dst++ = (a<<4)|b;
     }
 
     return 0;

src/ip-static.h

@@ -12,9 +12,9 @@ static inline int ip_get_version (const uint8_t *data, size_t size)
 }
 
 _pure_
-static inline ssize_t ip_get_size (const uint8_t *data, size_t size)
+static inline ssize_t ip_get_size (const int ip_version, const uint8_t *data, size_t size)
 {
-    switch (ip_get_version(data, size)) {
+    switch (ip_version) {
     case 4:
         return ((data[2]<<8)|data[3]);
     case 6:
@@ -27,9 +27,9 @@ static inline ssize_t ip_get_size (const uint8_t *data, size_t size)
 }
 
 _pure_
-static inline ssize_t ip_get_proto (const uint8_t *data, size_t size)
+static inline ssize_t ip_get_proto (const int ip_version, const uint8_t *data, size_t size)
 {
-    switch (ip_get_version(data, size)) {
+    switch (ip_version) {
     case 4:
         return data[9];
     case 6:
@@ -42,9 +42,9 @@ static inline ssize_t ip_get_proto (const uint8_t *data, size_t size)
 }
 
 _pure_
-static inline ssize_t ip_get_hdr_size (const uint8_t *data, size_t size)
+static inline ssize_t ip_get_hdr_size (const int ip_version, const uint8_t *data, size_t size)
 {
-    switch (ip_get_version(data, size)) {
+    switch (ip_version) {
     case 4:
         return (data[0]&0xF)<<2;
     case 6:

src/main.c

@@ -5,9 +5,15 @@
 #include <poll.h>
 #include <sys/time.h>
 #include <sys/fcntl.h>
-#include <sys/socket.h>
+
+#ifndef __FAVOR_BSD
+#define __FAVOR_BSD 1
+#endif
+
 #include <netinet/in.h>
 #include <netinet/tcp.h>
+#include <netinet/udp.h>
+
 #include <arpa/inet.h>
 #include <netdb.h>
 
@@ -362,15 +368,10 @@ static ssize_t fd_write (int fd, const void *data, size_t size)
     return ret;
 }
 
-static ssize_t fd_read_all (int fd, void *data, size_t size)
+static size_t fd_read_all (int fd, void *data, size_t size)
 {
     size_t done = 0;
 
-    struct pollfd pollfd = {
-        .fd = fd,
-        .events = POLLIN,
-    };
-
     while (done<size) {
         ssize_t ret = fd_read(fd, (uint8_t *)data+done, size-done);
 
@@ -378,8 +379,14 @@ static ssize_t fd_read_all (int fd, void *data, size_t size)
             break;
 
         if (ret<0) {
+            struct pollfd pollfd = {
+                .fd = fd,
+                .events = POLLIN,
+            };
+
             if (!poll(&pollfd, 1, GT_TIMEOUT))
                 break;
+
             continue;
         }
 
@@ -389,15 +396,10 @@ static ssize_t fd_read_all (int fd, void *data, size_t size)
     return done;
 }
 
-static ssize_t fd_write_all (int fd, const void *data, size_t size)
+static size_t fd_write_all (int fd, const void *data, size_t size)
 {
     size_t done = 0;
 
-    struct pollfd pollfd = {
-        .fd = fd,
-        .events = POLLOUT,
-    };
-
     while (done<size) {
         ssize_t ret = fd_write(fd, (const uint8_t *)data+done, size-done);
 
@@ -405,8 +407,14 @@ static ssize_t fd_write_all (int fd, const void *data, size_t size)
             break;
 
         if (ret<0) {
+            struct pollfd pollfd = {
+                .fd = fd,
+                .events = POLLOUT,
+            };
+
             if (!poll(&pollfd, 1, GT_TIMEOUT))
                 break;
+
             continue;
         }
 
@@ -483,11 +491,10 @@ static int gt_decrypt (struct crypto_ctx *ctx, buffer_t *dst, buffer_t *src)
     return 0;
 }
 
-static void gt_print_hdr (uint8_t *data, size_t ip_size, const char *sockname)
+static void gt_print_hdr (const int ip_version, uint8_t *data, size_t ip_size, const char *sockname)
 {
-    const int ip_version = ip_get_version(data, GT_MTU_MAX);
+    const ssize_t ip_proto = ip_get_proto(ip_version, data, ip_size);
-    const ssize_t ip_proto = ip_get_proto(data, GT_MTU_MAX);
+    const ssize_t ip_hdr_size = ip_get_hdr_size(ip_version, data, ip_size);
-    const ssize_t ip_hdr_size = ip_get_hdr_size(data, GT_MTU_MAX);
 
     char ip_src[33];
     char ip_dst[33];
@@ -505,33 +512,58 @@ static void gt_print_hdr (uint8_t *data, size_t ip_size, const char *sockname)
 
     gt_log("%s: version=%i size=%zi proto=%zi src=%s dst=%s\n", sockname, ip_version, ip_size, ip_proto, ip_src, ip_dst);
 
-    if (ip_hdr_size<=0 || ip_proto!=6)
+    if (ip_hdr_size<=0)
         return;
 
-    struct tcphdr tcp;
+    if (ip_proto==6) {
+        struct tcphdr tcp;
 
-    byte_cpy(&tcp, &data[ip_hdr_size], sizeof(tcp));
+        byte_cpy(&tcp, &data[ip_hdr_size], sizeof(tcp));
 
-    tcp.source = ntohs(tcp.source);
+        tcp.th_sport = ntohs(tcp.th_sport);
-    tcp.dest = ntohs(tcp.dest);
+        tcp.th_dport = ntohs(tcp.th_dport);
-    tcp.seq = ntohl(tcp.seq);
+        tcp.th_seq = ntohl(tcp.th_seq);
-    tcp.ack_seq = ntohl(tcp.ack_seq);
+        tcp.th_ack = ntohl(tcp.th_ack);
-    tcp.window = ntohs(tcp.window);
+        tcp.th_win = ntohs(tcp.th_win);
 
-    gt_log("%s: tcp src=%i dst=%i seq=%u ack=%u win=%u %s%s%s%s%s%s\n",
+        gt_log("%s: tcp src=%u dst=%u seq=%u ack=%u win=%u %c%c%c%c%c%c\n",
-            sockname, tcp.source, tcp.dest, tcp.seq, tcp.ack_seq, tcp.window,
+                sockname, tcp.th_sport, tcp.th_dport, tcp.th_seq, tcp.th_ack, tcp.th_win,
-            tcp.fin?"FIN ":"", tcp.syn?"SYN ":"", tcp.rst?"RST ":"",
+                (tcp.th_flags&TH_FIN) ?'F':'.',
-            tcp.psh?"PSH ":"", tcp.ack?"ACK ":"", tcp.urg?"URG ":"");
+                (tcp.th_flags&TH_SYN) ?'S':'.',
+                (tcp.th_flags&TH_RST) ?'R':'.',
+                (tcp.th_flags&TH_PUSH)?'P':'.',
+                (tcp.th_flags&TH_ACK) ?'A':'.',
+                (tcp.th_flags&TH_URG) ?'U':'.');
+    }
+
+    if (ip_proto==17) {
+        struct udphdr udp;
+
+        byte_cpy(&udp, &data[ip_hdr_size], sizeof(udp));
+
+        udp.uh_sport = ntohs(udp.uh_sport);
+        udp.uh_dport = ntohs(udp.uh_dport);
+        udp.uh_ulen = ntohs(udp.uh_ulen);
+
+        gt_log("%s: udp src=%u dst=%u len=%u\n",
+                sockname, udp.uh_sport, udp.uh_dport, udp.uh_ulen);
+    }
 }
 
 static int gt_setup_secretkey (struct crypto_ctx *ctx, char *keyfile)
 {
     const size_t size = sizeof(ctx->skey);
 
-    byte_set(ctx->skey, 1, size);
+    if (!keyfile) {
+        char buf[2*size+1];
+
+        randombytes_buf(ctx->skey, size);
+        gt_tohex(buf, sizeof(buf), ctx->skey, size);
+
+        gt_print("new secret key: %s\n", buf);
 
-    if (!keyfile)
         return 0;
+    }
 
     int fd;
 
@@ -730,11 +762,6 @@ int main (int argc, char **argv)
         return 1;
     }
 
-    struct crypto_ctx ctx;
-
-    if (gt_setup_secretkey(&ctx, keyfile))
-        return 1;
-
     struct addrinfo *ai = ai_create(host, port, listener);
 
     if (!ai)
@@ -773,6 +800,11 @@ int main (int argc, char **argv)
             return 1;
     }
 
+    struct crypto_ctx ctx;
+
+    if (gt_setup_secretkey(&ctx, keyfile))
+        return 1;
+
     if (option_is_set(opts, "daemon")) {
         switch (fork()) {
         case -1:
@@ -916,7 +948,8 @@ int main (int argc, char **argv)
                         break;
                     }
 
-                    const ssize_t ip_size = ip_get_size(data, GT_MTU_MAX);
+                    const int ip_version = ip_get_version(data, GT_MTU_MAX);
+                    const ssize_t ip_size = ip_get_size(ip_version, data, GT_MTU_MAX);
 
                     if _0_(ip_size<=0)
                         continue;
@@ -929,8 +962,7 @@ int main (int argc, char **argv)
                     }
 
                     if _0_(debug)
-                        gt_print_hdr(data, ip_size, sockname);
+                        gt_print_hdr(ip_version, data, ip_size, sockname);
-
 
                     blks[blk_write++].size = r;
                     blk_count++;
@@ -1005,7 +1037,9 @@ int main (int argc, char **argv)
                 }
 
                 size_t size = buffer_read_size(&tun.write);
-                ssize_t ip_size = ip_get_size(tun.write.read, size);
+
+                const int ip_version = ip_get_version(tun.write.read, size);
+                ssize_t ip_size = ip_get_size(ip_version, tun.write.read, size);
 
                 if _0_(!ip_size) {
                     gt_log("%s: bad packet!\n", sockname);