Move libjade dependency into nix

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "libjade"]
-	path = libjade
-	url = https://github.com/Rixxc/libjade.git

Makefile

@@ -18,7 +18,7 @@ clean:
 	$(MAKE) -C syscall clean
 
 build/%.S: src/%.jazz
-	JASMINPATH="Jade=libjade/src/" $(JC) $< -o $@
+	$(JC) $< -o $@
 
 syscall/jasmin_syscall.o: syscall/jasmin_syscall.c syscall/jasmin_syscall.h
 	$(MAKE) -C syscall

default.nix

@@ -4,8 +4,8 @@ let
   jasmin-src = fetchFromGitHub {
     owner = "Rixxc";
     repo = "jasmin";
-    rev = "244d42d2a8c37d7607abf7dd5e92eddd2c339340";
+    rev = "783aea97836f5ddf7b62de24ab94768cb606adf8";
-    hash = "sha256-EDLsFsRZmSzei2LvgJfI6W+DiErnfrwO7ciom/1+6BQ=";
+    hash = "sha256-5XXZ2IYXCixJHaswdYkG8ivh3fIftaibOgkpz2TKGMI=";
   };
 
   jasmin-drv = callPackage "${jasmin-src}/default.nix" { inherit pkgs; };
@@ -16,6 +16,13 @@ let
       make -C compiler/
     '';
   };
+
+  libjade = fetchFromGitHub {
+    owner = "formosa-crypto";
+    repo = "libjade";
+    rev = "b0940068243f01dc3c185d166f1450936eec3eed";
+    hash = "sha256-w71QmJn5TG1cJ+SGXJyjh86uge177uRGSvwgnJXpKYg=";
+  };
 in
 stdenv.mkDerivation {
   name = "x25519-agent";
@@ -25,6 +32,7 @@ stdenv.mkDerivation {
     gnumake
     gcc
     jasmin
+    libjade
   ];
 
   configurePhase = ''
@@ -35,4 +43,6 @@ stdenv.mkDerivation {
     mkdir -p $out/lib
     cp build/libagent.a $out/lib
   '';
+
+  JASMINPATH = "Jade=${libjade}/src/";
 }

src/agent.jazz

@@ -1,25 +1,113 @@
-from Jade require "crypto_scalarmult/curve25519/amd64/mulx/curve25519.jinc"
+from Jade require "crypto_scalarmult/curve25519/amd64/mulx/scalarmult.jazz"
 
-export fn agent_start(reg u64 shared_mem sync_mem) {
+inline fn extract_nth_ptr(reg u64 sync_mem shared_mem, inline int i) -> reg u64 {
+    reg u64 p;
+
+    p = (u64)[sync_mem + (16 + i * 8)];
+    p += shared_mem;
+
+    return p;
+}
+
+inline fn extract_ipc_id(reg u64 sync_mem) -> reg u64 {
+    reg u64 id;
+
+    id = (u64)[sync_mem + 8];
+
+    return id;
+}
+
+inline fn generate_keypair(reg u64 shared_mem sync_mem private_mem, stack u64 key_id) -> stack u64 {
+    inline int i;
+    stack u8[32] key;
+    reg u64 addr idptr pkptr;
+
+    key = #randombytes(key);
+    key[0] &= 248;
+    key[31] &= 127;
+    key[31] |= 64;
+
+    addr = key_id * 32;
+    addr += private_mem;
+
+    for i=0 to 4 {
+        (u64)[addr + i * 8] = key[u64 i];
+    }
+
+    idptr = (u64)[sync_mem + 16];
+    idptr += shared_mem;
+
+    (u64)[idptr] = key_id;
+
+    pkptr = (u64)[sync_mem + 24];
+    pkptr += shared_mem;
+
+    jade_scalarmult_curve25519_amd64_mulx_base(pkptr, addr);
+
+    key_id += 1; 
+
+    return key_id;
+}
+
+inline fn calculate_pubkey(reg u64 shared_mem sync_mem private_mem) {
+    reg u64 skptr outptr;
+
+    skptr = extract_nth_ptr(sync_mem, shared_mem, 0);
+    outptr = extract_nth_ptr(sync_mem, shared_mem, 1);
+
+    skptr = (u64)[skptr];
+    skptr *= 32;
+    skptr += private_mem;
+
+    jade_scalarmult_curve25519_amd64_mulx_base(outptr, skptr);
+}
+
+inline fn x25519(reg u64 shared_mem sync_mem private_mem) {
+    reg u64 outptr idptr pkptr keyptr;
+    reg u64 keyid;
+
+    outptr = extract_nth_ptr(sync_mem, shared_mem, 0);
+    idptr = extract_nth_ptr(sync_mem, shared_mem, 1);
+    pkptr = extract_nth_ptr(sync_mem, shared_mem, 2);
+
+    keyid = (u64)[idptr];
+    keyid *= 32;
+    keyptr = private_mem + keyid;
+
+    jade_scalarmult_curve25519_amd64_mulx(outptr, keyptr, pkptr);
+}
+
+export fn agent_start(reg u64 shared_mem sync_mem private_mem) {
     stack u8[8] unused;
-    reg u64 outptr;
+    stack u64 key_id;
-    reg u64 spill_sync_mem spill_shared_mem;
 
-    spill_sync_mem = sync_mem;
+    key_id = 0;
-    spill_shared_mem = shared_mem;
+
+    () = #spill(shared_mem, sync_mem, private_mem);
 
      while (true) {
         unused = unused;
-        sync_mem = spill_sync_mem;
+        () = #unspill(sync_mem);
         unused = #read(unused, sync_mem);
 
-        sync_mem = spill_sync_mem;
+        () = #unspill(shared_mem, sync_mem, private_mem);
-        shared_mem = spill_shared_mem;
+        
+        reg u64 id;
+        id = extract_ipc_id(sync_mem);
 
-        outptr = (u64)[sync_mem + 8];
+        if (id == 0) {
-        outptr = shared_mem + outptr;
+            key_id = generate_keypair(shared_mem, sync_mem, private_mem, key_id);
+        } else {
+            if (id == 1) {
+                calculate_pubkey(shared_mem, sync_mem, private_mem);
+            } else {
+                if (id == 2) {
+                    x25519(shared_mem, sync_mem, private_mem);
+                }
+            }
+        }
 
-        (u64)[outptr] = 0x1337;
+        () = #unspill(sync_mem);
 
         unused = #write(unused, sync_mem);
     }

syscall/jasmin_syscall.c

@@ -1,35 +1,50 @@
 
 #include "jasmin_syscall.h"
 
-#if defined(__linux__) 
+#if defined(__linux__)
 
-#include <unistd.h>
-#include <stdint.h>
-#include <string.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <sys/random.h>
-#include <sys/mman.h>
-#include <sys/syscall.h>
-#include <linux/futex.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <linux/futex.h>
+#include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/random.h>
+#include <sys/syscall.h>
+#include <unistd.h>
 
-
+// uint8_t *__jasmin_syscall_randombytes__(uint8_t *_x, uint64_t xlen) {
-
+//   int i;
+//   uint8_t *x = _x;
+//
+//   printf("%lx:\n", x);
+//
+//   for (i = 0; i < xlen; i++) {
+//     printf("%02X", _x[i]);
+//   }
+//   printf("\n");
+//
+//   return _x;
+// }
+//
 uint8_t* __jasmin_syscall_randombytes__(uint8_t* _x, uint64_t xlen)
 {
   int i;
   uint8_t* x = _x;
 
-  printf("%lx:\n", x);
+  while (xlen > 0) {
+    if (xlen < 1048576) i = xlen; else i = 1048576;
 
-  for (i = 0; i < xlen; i++)
+    i = getrandom(x,i,0);
-  {
+    if (i < 1) {
-    printf("%02X", _x[i]);
+      sleep(1);
+      continue;
+    }
+    x += i;
+    xlen -= i;
   }
-  printf("\n");
-
 
   return _x;
 }
@@ -54,15 +69,16 @@ uint8_t* __jasmin_syscall_randombytes__(uint8_t* _x, uint64_t xlen)
 //   }
 // }
 
-uint64_t __jasmin_syscall_open__(uint8_t* x, uint64_t xlen)
+uint64_t __jasmin_syscall_open__(uint8_t *x, uint64_t xlen) {
-{
+  uint8_t *mem =
-  uint8_t* mem = (uint8_t*)mmap(NULL, 1024, PROT_READ|PROT_WRITE, MAP_SHARED, 3, 0);
+      (uint8_t *)mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, 3, 0);
   if (mem == NULL) {
     puts("mem error");
     exit(1);
   }
   uintptr_t addr = (uintptr_t)(mem - 4096);
-  void* futex_mem = mmap((void*)addr, 1024, PROT_READ|PROT_WRITE, MAP_SHARED, 4, 0);
+  void *futex_mem =
+      mmap((void *)addr, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, 4, 0);
   if ((uintptr_t)futex_mem != addr) {
     puts("mem error 2");
     exit(1);
@@ -88,10 +104,9 @@ uint64_t __jasmin_syscall_open__(uint8_t* x, uint64_t xlen)
 //   return _x;
 // }
 
-uint8_t* __jasmin_syscall_read__(uint8_t* _x, uint64_t xlen, uint64_t fd)
+uint8_t *__jasmin_syscall_read__(uint8_t *_x, uint64_t xlen, uint64_t fd) {
-{
+  uint32_t *addr = (uint32_t *)(uintptr_t)fd;
-  uint32_t* addr = (uint32_t*)(uintptr_t)fd;
+  long ret = syscall(SYS_futex, addr, FUTEX_WAIT, 0, NULL, NULL, 0);
-  long ret = syscall(SYS_futex, addr, FUTEX_WAIT, 0x1, NULL, NULL, 0);
   if (ret == -1) {
     printf("Agent futex error: %d\n", errno);
     perror("futex");
@@ -100,11 +115,12 @@ uint8_t* __jasmin_syscall_read__(uint8_t* _x, uint64_t xlen, uint64_t fd)
   return _x;
 }
 
-uint8_t* __jasmin_syscall_write__(uint8_t* _x, uint64_t xlen, uint64_t fd)
+uint8_t *__jasmin_syscall_write__(uint8_t *_x, uint64_t xlen, uint64_t fd) {
-{
+  uint32_t *addr = (uint32_t *)(uintptr_t)fd;
-  uint32_t* addr = (uint32_t*)(uintptr_t)fd;
+  int woken_up = 0;
-  *addr = 1;
+  while (woken_up == 0) {
-  syscall(SYS_futex, addr, FUTEX_WAKE, 1, NULL, NULL, 0);
+    woken_up = syscall(SYS_futex, addr, FUTEX_WAKE, 1, NULL, NULL, 0);
+  }
 
   return _x;
 }
@@ -133,11 +149,12 @@ uint8_t* __jasmin_syscall_write__(uint8_t* _x, uint64_t xlen, uint64_t fd)
 
 #include <stdlib.h>
 
-#if !(defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
+#if !(defined(__MAC_OS_X_VERSION_MIN_REQUIRED) &&                              \
+      __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
 #error "macOS version not supported (>= 10.12)"
 #endif
 
-uint8_t* __jasmin_syscall_randombytes__(uint8_t* x, uint64_t xlen){
+uint8_t *__jasmin_syscall_randombytes__(uint8_t *x, uint64_t xlen) {
   arc4random_buf(x, xlen);
   return x;
 }