some refactoring

.gitignore

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

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "libjade"]
-	path = libjade
-	url = https://github.com/Rixxc/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
-	ar -crs build/libagent.a build/agent.o syscall/jasmin_syscall.o
+build: build/agent.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 $@
-
-syscall/jasmin_syscall.o: syscall/jasmin_syscall.c syscall/jasmin_syscall.h
-	$(MAKE) -C syscall
+	$(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
+	sed -i 's/ret/hlt/g' $@ 

default.nix

@@ -2,10 +2,10 @@
 with pkgs;
 let
   jasmin-src = fetchFromGitHub {
-    owner = "Rixxc";
+    owner = "jasmin-lang";
     repo = "jasmin";
-    rev = "244d42d2a8c37d7607abf7dd5e92eddd2c339340";
-    hash = "sha256-EDLsFsRZmSzei2LvgJfI6W+DiErnfrwO7ciom/1+6BQ=";
+    rev = "c2adabafb8df0a60e7cf4e56041d3be3aca387a3";
+    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,26 +1,164 @@
-from Jade require "crypto_scalarmult/curve25519/amd64/mulx/curve25519.jinc"
+from Jade require "crypto_scalarmult/curve25519_mulx/curve25519_mulx.jazz"
 
-export fn agent_start(reg u64 shared_mem sync_mem) {
-    stack u8[8] unused;
-    reg u64 outptr;
-    reg u64 spill_sync_mem spill_shared_mem;
+param int SK_SIZE = 32;
+param int SHARED_MEM_SIZE = 1024;
+param int PRIVATE_MEM_SIZE = 3200;
 
-    spill_sync_mem = sync_mem;
-    spill_shared_mem = shared_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, reg u64) {
+    inline int i;
+    stack u8[SK_SIZE] key;
+    reg u64 addr idptr pkptr flag num_bytes return_value;
+
+    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;
+
+    addr = key_id * SK_SIZE;
+    addr += private_mem;
+
+    for i=0 to SK_SIZE/8 {
+        (u64)[addr + i * 8] = key[u64 i];
+    }
+
+    idptr = extract_nth_ptr(sync_mem, shared_mem, 0);
+
+    (u64)[idptr] = key_id;
+
+    pkptr = extract_nth_ptr(sync_mem, shared_mem, 1);
+
+    jade_scalarmult_curve25519_amd64_mulx_base(pkptr, addr);
+
+    key_id += 1; 
+
+    return_value = 1;
+    return key_id, return_value;
+}
+
+inline fn calculate_pubkey(reg u64 shared_mem sync_mem private_mem) -> reg u64 {
+    reg u64 skptr outptr return_value;
+    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;
+
+    #no_termination_check
      while (true) {
-        unused = unused;
-        sync_mem = spill_sync_mem;
-        unused = #read(unused, sync_mem);
+        while {
+            () = #unspill(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)
 
-        sync_mem = spill_sync_mem;
-        shared_mem = spill_shared_mem;
+        () = #unspill(shared_mem, sync_mem, private_mem);
         
-        outptr = (u64)[sync_mem + 8];
-        outptr = shared_mem + outptr;
+        reg u64 id;
+        id = extract_ipc_id(sync_mem);
 
-        (u64)[outptr] = 0x1337;
-
-        unused = #write(unused, sync_mem);
+        if (id == 0) {
+            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);
+
+        (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,145 +0,0 @@
-
-#include "jasmin_syscall.h"
-
-#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 <stdlib.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;
-}
-
-// 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, 0x1, 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;
-  *addr = 1;
-  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