feat: add functions for x25519 agent

src/agent.rs

@@ -1,7 +1,7 @@
 use anyhow::{bail, Result};
 use libc::{
-    c_char, c_void, execve, fork, ftruncate, memfd_create, mmap, syscall, SYS_futex, FUTEX_WAIT,
-    FUTEX_WAKE, MAP_SHARED, PROT_READ,
+    c_char, c_void, execve, fork, ftruncate, memfd_create, mmap, perror, syscall, SYS_futex,
+    FUTEX_WAIT, FUTEX_WAKE, MAP_FAILED, MAP_SHARED, PROT_READ, PROT_WRITE,
 };
 use shared_memory_heap::get_shared_mem_fd;
 use std::{ffi::CString, path::Path, ptr, usize};
@@ -17,6 +17,10 @@ impl Agent {
         let data_fd = get_shared_mem_fd();
         let sync_fd = memfd_create("sync\x00".as_ptr() as *const c_char, 0);
 
+        if sync_fd <= 0 {
+            bail!("creating memfd failed");
+        }
+
         let err = ftruncate(sync_fd, 1024);
         if err != 0 {
             bail!("ftruncate failed");
@@ -25,16 +29,18 @@ impl Agent {
         let sync_mem = mmap(
             ptr::null_mut::<c_void>(),
             1024,
-            PROT_READ | PROT_READ,
+            PROT_READ | PROT_WRITE,
             MAP_SHARED,
             sync_fd,
             0,
         ) as *mut usize;
 
-        if sync_mem == ptr::null_mut() {
+        if sync_mem == MAP_FAILED as *mut usize {
             bail!("mmap failed");
         }
 
+        *sync_mem = 0;
+
         let child = fork();
 
         if child == 0 {
@@ -42,7 +48,7 @@ impl Agent {
 
             let data_fd = CString::new(data_fd.to_string()).unwrap();
             let sync_fd = CString::new(sync_fd.to_string()).unwrap();
-            let args = [data_fd.as_ptr(), sync_fd.as_ptr()];
+            let args = [data_fd.as_ptr(), sync_fd.as_ptr(), ptr::null()];
 
             execve(
                 path.as_os_str().as_encoded_bytes().as_ptr() as *const c_char,
@@ -50,35 +56,40 @@ impl Agent {
                 ptr::null(),
             );
 
+            perror("execve:\x00".as_ptr() as *const c_char);
+
             panic!("execve failed");
         }
 
         // parent
 
-        Ok(Agent {
-            sync_mem,
-        })
+        Ok(Agent { sync_mem })
     }
 
     pub(crate) unsafe fn perform_ipc_call(&mut self, call_id: usize, ptrs: &[usize]) {
         *self.sync_mem.add(1) = call_id;
 
         for (i, ptr) in ptrs.iter().enumerate() {
-            *self.sync_mem.add(i + 1) = *ptr;
+            *self.sync_mem.add(i + 2) = *ptr;
         }
 
         // wake agent
-        syscall(
-            SYS_futex,
-            self.sync_mem,
-            FUTEX_WAKE,
-            1,
-            ptr::null::<u8>(),
-            ptr::null::<u8>(),
-            0,
-        );
+        println!("Client: waking agent");
+        let mut woken_up = 0;
+        while woken_up == 0 {
+            woken_up = syscall(
+                SYS_futex,
+                self.sync_mem,
+                FUTEX_WAKE,
+                1,
+                ptr::null::<u8>(),
+                ptr::null::<u8>(),
+                0,
+            );
+        }
 
         // wait for agent to be finished
+        println!("Client: sleeping...");
         syscall(
             SYS_futex,
             self.sync_mem,
@@ -88,5 +99,6 @@ impl Agent {
             ptr::null::<u8>(),
             0,
         );
+        println!("Client: agent finished work");
     }
 }

src/lib.rs

@@ -16,6 +16,14 @@ static AGENT: LazyLock<Mutex<Agent>> = LazyLock::new(|| {
     Mutex::new(agent)
 });
 
+pub fn x25519_keygen(keyid: &mut SharedPtr, pk: &mut SharedPtr) {
+    let mut agent = AGENT.lock().unwrap();
+
+    unsafe {
+        agent.perform_ipc_call(0, &[keyid.get_offset(), pk.get_offset()]);
+    }
+}
+
 pub fn x25519(out: &mut SharedPtr, pk: &SharedPtr, sk: &SharedPtr) {
     let mut agent = AGENT.lock().unwrap();