some refactoring

.gitignore

@@ -1,3 +1,4 @@
 build
 result
 *.o
+.direnv

.gitmodules

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

Makefile

@@ -2,13 +2,15 @@ JC ?= jasminc
 CC ?= gcc
 MAKE ?= make
 
+JASMIN_ARGS = -protect-calls -return-address-kind mmx
+
 .PHONY: clean run
 
 all: build
 	@true
 
-build: build/agent.o syscall/jasmin_syscall.o
+build: build/agent.o
-	ar -crs build/libagent.a build/agent.o syscall/jasmin_syscall.o
+	ar -crs build/libagent.a build/agent.o
 
 build/%.o: build/%.S
 	$(CC) $< -c -o $@
@@ -18,7 +20,6 @@ clean:
 	$(MAKE) -C syscall clean
 
 build/%.S: src/%.jazz
-	JASMINPATH="Jade=libjade/src/" $(JC) $< -o $@
+	$(JC) $(JASMIN_ARGS) $< -o $@
-
+	# remove the remaining ret calls to make sure that we don't execute any return. Those returns should not be called anyways due to the infinit loop
-syscall/jasmin_syscall.o: syscall/jasmin_syscall.c syscall/jasmin_syscall.h
+	sed -i 's/ret/hlt/g' $@ 
-	$(MAKE) -C syscall

default.nix

@@ -2,10 +2,10 @@
 with pkgs;
 let
   jasmin-src = fetchFromGitHub {
-    owner = "Rixxc";
+    owner = "jasmin-lang";
     repo = "jasmin";
-    rev = "244d42d2a8c37d7607abf7dd5e92eddd2c339340";
+    rev = "c2adabafb8df0a60e7cf4e56041d3be3aca387a3";
-    hash = "sha256-EDLsFsRZmSzei2LvgJfI6W+DiErnfrwO7ciom/1+6BQ=";
+    hash = "sha256-ySw4eVbuV7suO8EjyaMOTqeNsPq1D6vsorCZlXffTPU=";
   };
 
   jasmin-drv = callPackage "${jasmin-src}/default.nix" { inherit pkgs; };
@@ -16,6 +16,11 @@ let
       make -C compiler/
     '';
   };
+
+  libjade = fetchzip {
+    url = "https://github.com/formosa-crypto/libjade/releases/download/release%2F2023.05-2/libjade-dist-src-amd64.tar.gz";
+    hash = "sha256-IWLMWExvdZ++V3a9zX0a9xjSDgOA98h3sSmLOj8hKPE=";
+  };
 in
 stdenv.mkDerivation {
   name = "x25519-agent";
@@ -35,4 +40,6 @@ stdenv.mkDerivation {
     mkdir -p $out/lib
     cp build/libagent.a $out/lib
   '';
+
+  JASMINPATH = "Jade=${libjade}/libjade/";
 }

src/agent.jazz

@@ -1,4 +1,17 @@
-from Jade require "crypto_scalarmult/curve25519/amd64/mulx/scalarmult.jazz"
+from Jade require "crypto_scalarmult/curve25519_mulx/curve25519_mulx.jazz"
+
+param int SK_SIZE = 32;
+param int SHARED_MEM_SIZE = 1024;
+param int PRIVATE_MEM_SIZE = 3200;
+
+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;
@@ -8,67 +21,144 @@ inline fn extract_ipc_id(reg u64 sync_mem) -> reg u64 {
     return id;
 }
 
-inline fn generate_key(reg u64 shared_mem sync_mem private_mem key_id) -> reg u64 {
+inline fn generate_keypair(reg u64 shared_mem sync_mem private_mem, stack u64 key_id) -> (stack u64, reg u64) {
     inline int i;
-    stack u8[32] key;
+    stack u8[SK_SIZE] key;
-    reg u64 addr idptr pkptr;
+    reg u64 addr idptr pkptr flag num_bytes return_value;
 
-    key = #randombytes(key);
+    return_value = 0;
+
+    while {
+        flag = 0;
+        key, num_bytes = #randombytes(key, flag);
+    } (num_bytes != SK_SIZE)
     key[0] &= 248;
     key[31] &= 127;
     key[31] |= 64;
 
-    key_id += 1; 
+    addr = key_id * SK_SIZE;
-
-    addr = key_id * 32;
     addr += private_mem;
 
-    for i=0 to 4 {
+    for i=0 to SK_SIZE/8 {
-        (u64)[private_mem + i * 8] = key[u64 i];
+        (u64)[addr + i * 8] = key[u64 i];
     }
 
-    idptr = (u64)[sync_mem + 16];
+    idptr = extract_nth_ptr(sync_mem, shared_mem, 0);
-    idptr += shared_mem;
 
     (u64)[idptr] = key_id;
 
-    pkptr = (u64)[sync_mem + 24];
+    pkptr = extract_nth_ptr(sync_mem, shared_mem, 1);
-    pkptr += shared_mem;
 
-    () = #spill(key_id);
+    jade_scalarmult_curve25519_amd64_mulx_base(pkptr, addr);
 
-    jade_scalarmult_curve25519_amd64_mulx_base(pkptr, private_mem);
+    key_id += 1; 
 
-    () = #unspill(key_id);
+    return_value = 1;
-
+    return key_id, return_value;
-    return key_id;
 }
 
-export fn agent_start(reg u64 shared_mem sync_mem private_mem) {
+inline fn calculate_pubkey(reg u64 shared_mem sync_mem private_mem) -> reg u64 {
-    stack u8[8] unused;
+    reg u64 skptr outptr return_value;
-    reg u64 key_id;
+    return_value = 0;
+
+    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);
+
+    return_value = 1;
+    return return_value;
+}
+
+inline fn x25519(reg u64 shared_mem sync_mem private_mem) -> reg u64 {
+    reg u64 outptr idptr pkptr keyptr return_value;
+    reg u64 keyid;
+
+    return_value = 0;
+
+    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);
+
+    return_value = 1;
+    return return_value;
+}
+
+export fn agent_start(reg u64 shared_mem sync_mem private_mem_fd) {
+    stack u64 key_id return_value;
+    reg u64 private_mem;
+    // Futex varibles
+    reg u64 futex_op val timeout uaddr2 val3 woken_up;
+    // Mmap variables
+    reg u64 addr len prot flag off;
+
+    () = #spill(shared_mem, sync_mem);
+
+    private_mem_fd = private_mem_fd;
+    addr = 0;
+    len = PRIVATE_MEM_SIZE;
+    prot = 3; // PROT_READ | PROT_WRITE
+    flag = 1; // MAP_SHARED;
+    off = 0;
+    private_mem = #mmap(addr, len, prot, flag, private_mem_fd, off);
+
+    () = #spill(private_mem);
 
     key_id = 0;
 
-    () = #spill(shared_mem, sync_mem, private_mem);
+    #no_termination_check
-
      while (true) {
-        unused = unused;
+        while {
-        () = #unspill(sync_mem);
+            () = #unspill(sync_mem);
-        unused = #read(unused, sync_mem);
+            futex_op = 0;
+            val = 0;
+            timeout = 0;
+            uaddr2 = 0;
+            val3 = 0;
+            woken_up = #futex(sync_mem, futex_op, val, timeout, uaddr2, val3);
+        } (woken_up != 0)
 
         () = #unspill(shared_mem, sync_mem, private_mem);
         
         reg u64 id;
-
         id = extract_ipc_id(sync_mem);
 
         if (id == 0) {
-            key_id = generate_key(shared_mem, sync_mem, private_mem, key_id);
+            if (key_id < 100) {
+                key_id, return_value = generate_keypair(shared_mem, sync_mem, private_mem, key_id);
+            }
+        } else {
+            if (id == 1) {
+                return_value = calculate_pubkey(shared_mem, sync_mem, private_mem);
+            } else {
+                if (id == 2) {
+                    return_value = x25519(shared_mem, sync_mem, private_mem);
+                }
+            }
         }
 
         () = #unspill(sync_mem);
 
-        unused = #write(unused, sync_mem);
+        (u64)[sync_mem + 16] = return_value;
+
+        while {
+            () = #unspill(sync_mem);
+            futex_op = 1;
+            val = 1;
+            timeout = 0;
+            uaddr2 = 0;
+            val3 = 0;
+            woken_up = #futex(sync_mem, futex_op, val, timeout, uaddr2, val3);
+        } (woken_up != 1)
     }
 }

syscall/Makefile

@@ -1,8 +0,0 @@
-.PHONY: clean
-
-all: jasmin_syscall.o 
-
-jasmin_syscall.o: jasmin_syscall.c jasmin_syscall.h 
-
-clean:
-	rm jasmin_syscall.o || true

syscall/jasmin_syscall.c

@@ -1,162 +0,0 @@
-
-#include "jasmin_syscall.h"
-
-#if defined(__linux__)
-
-#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;
-
-  while (xlen > 0) {
-    if (xlen < 1048576) i = xlen; else i = 1048576;
-
-    i = getrandom(x,i,0);
-    if (i < 1) {
-      sleep(1);
-      continue;
-    }
-    x += i;
-    xlen -= i;
-  }
-
-  return _x;
-}
-
-// uint64_t __jasmin_syscall_open__(uint8_t* x, uint64_t xlen)
-// {
-//   uint8_t filename[xlen + 1];
-//   memcpy(filename, x, xlen);
-//   filename[xlen] = 0;
-//
-//   return (uint64_t)open(filename, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);
-// }
-//
-// uint8_t __jasmin_syscall_close__(uint64_t fd)
-// {
-//   int success = close(fd);
-//
-//   if (success == 0) {
-//     return 1;
-//   } else {
-//     return 0;
-//   }
-// }
-
-uint64_t __jasmin_syscall_open__(uint8_t *x, uint64_t xlen) {
-  uint8_t *mem =
-      (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);
-  if ((uintptr_t)futex_mem != addr) {
-    puts("mem error 2");
-    exit(1);
-  }
-
-  return (uint64_t)mem;
-}
-
-// uint8_t* __jasmin_syscall_write__(uint8_t* _x, uint64_t xlen, uint64_t fd)
-// {
-//   size_t i;
-//   uint8_t* x = _x;
-//
-//   while (xlen > 0) {
-//     i = write(fd, x, xlen);
-//     if (i < 1) {
-//       continue;
-//     }
-//     x += i;
-//     xlen -= i;
-//   }
-//
-//   return _x;
-// }
-
-uint8_t *__jasmin_syscall_read__(uint8_t *_x, uint64_t xlen, uint64_t fd) {
-  uint32_t *addr = (uint32_t *)(uintptr_t)fd;
-  long ret = syscall(SYS_futex, addr, FUTEX_WAIT, 0, NULL, NULL, 0);
-  if (ret == -1) {
-    printf("Agent futex error: %d\n", errno);
-    perror("futex");
-  }
-
-  return _x;
-}
-
-uint8_t *__jasmin_syscall_write__(uint8_t *_x, uint64_t xlen, uint64_t fd) {
-  uint32_t *addr = (uint32_t *)(uintptr_t)fd;
-  int woken_up = 0;
-  while (woken_up == 0) {
-    woken_up = syscall(SYS_futex, addr, FUTEX_WAKE, 1, NULL, NULL, 0);
-  }
-
-  return _x;
-}
-
-// uint8_t* __jasmin_syscall_read__(uint8_t* _x, uint64_t xlen, uint64_t fd)
-// {
-//   size_t i;
-//   uint8_t* x = _x;
-//
-//   i = read(fd, x, xlen);
-//   if (i < 1) {
-//     // Do something
-//     perror("Something went wrong while reading the file");
-//   }
-//   x += i;
-//   xlen -= i;
-//
-//   memset(x, 0, xlen);
-//
-//   return _x;
-// }
-
-#endif
-
-#if defined(__APPLE__)
-
-#include <stdlib.h>
-
-#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) {
-  arc4random_buf(x, xlen);
-  return x;
-}
-
-#endif

syscall/jasmin_syscall.h

@@ -1,20 +0,0 @@
-#include <stdint.h>
-#ifndef JASMIN_SYSCALL
-#define JASMIN_SYSCALL
-/* FIXME this need xlen to be Uptr */
-uint8_t* __jasmin_syscall_randombytes__(uint8_t* x, uint64_t xlen)
-asm("__jasmin_syscall_randombytes__");
-
-uint64_t __jasmin_syscall_open__(uint8_t* x, uint64_t xlen)
-asm("__jasmin_syscall_open__");
-
-uint8_t __jasmin_syscall_close__(uint64_t fd)
-asm("__jasmin_syscall_close__");
-
-uint8_t* __jasmin_syscall_write__(uint8_t* x, uint64_t xlen, uint64_t fd)
-asm("__jasmin_syscall_write__");
-
-uint8_t* __jasmin_syscall_read__(uint8_t* x, uint64_t xlen, uint64_t fd)
-asm("__jasmin_syscall_read__");
-
-#endif