Merge 849055d0b7 into 4fe9018b6f

- memset is disabled for now as it causes hangs
- underlying functions were copied from isoalloc, licensed Apache-2.0
	- credit Chris Rohlf for memcpy/memset
	- credit David Carlier for memmove
- use the fast path as some programs crash otherwise

Signed-off-by: Tavi <tavi@divested.dev>

.github/workflows/build-and-test.yml

@@ -52,4 +52,4 @@ jobs:
       - name: Install dependencies
         run: sudo apt-get update && sudo apt-get install -y --no-install-recommends gcc-aarch64-linux-gnu g++-aarch64-linux-gnu libgcc-s1-arm64-cross cpp-aarch64-linux-gnu
       - name: Build
-        run: CC=aarch64-linux-gnu-gcc CXX=aarch64-linux-gnu-gcc++ make CONFIG_NATIVE=false test
+        run: CC=aarch64-linux-gnu-gcc CXX=aarch64-linux-gnu-gcc++ make CONFIG_NATIVE=false

README.md

@@ -276,7 +276,7 @@ The following boolean configuration options are available:
   hardware, which may become drastically lower in the future. Whether or not
   this feature is enabled, the metadata is all contained within an isolated
   memory region with high entropy random guard regions around it.
-* `CONFIG_BLOCK_OPS_CHECK_SIZE`: `true` (default) or `false` to ensure length
+* `CONFIG_BLOCK_OPS_CHECK_SIZE`: `true` or `false` (default) to ensure length
   parameter of the memcpy/memmove/memset block operations are within
   approximate bounds to minimize buffer overflows. Note, memset override is
   currently disabled due to improper behavior.

config/default.mk

@@ -21,4 +21,4 @@ CONFIG_CLASS_REGION_SIZE := 34359738368 # 32GiB
 CONFIG_N_ARENA := 4
 CONFIG_STATS := false
 CONFIG_SELF_INIT := true
-CONFIG_BLOCK_OPS_CHECK_SIZE := true
+CONFIG_BLOCK_OPS_CHECK_SIZE := false

test/test_smc.py

@@ -238,38 +238,38 @@ class TestSimpleMemoryCorruption(unittest.TestCase):
             "realloc_init")
         self.assertEqual(returncode, 0)
 
-    def test_memcpy_buffer_overflow(self):
+    #def test_memcpy_buffer_overflow(self):
-        _stdout, stderr, returncode = self.run_test(
+    #    _stdout, stderr, returncode = self.run_test(
-            "memcpy_buffer_overflow")
+    #        "memcpy_buffer_overflow")
-        self.assertEqual(returncode, -6)
+    #    self.assertEqual(returncode, -6)
-        self.assertEqual(stderr.decode(
+    #    self.assertEqual(stderr.decode(
-            "utf-8"), "fatal allocator error: memcpy buffer overflow\n")
+    #        "utf-8"), "fatal allocator error: memcpy buffer overflow\n")
 
-    def test_memcpy_read_overflow(self):
+    #def test_memcpy_read_overflow(self):
-        _stdout, stderr, returncode = self.run_test(
+    #    _stdout, stderr, returncode = self.run_test(
-            "memcpy_read_overflow")
+    #        "memcpy_read_overflow")
-        self.assertEqual(returncode, -6)
+    #    self.assertEqual(returncode, -6)
-        self.assertEqual(stderr.decode(
+    #    self.assertEqual(stderr.decode(
-            "utf-8"), "fatal allocator error: memcpy read overflow\n")
+    #        "utf-8"), "fatal allocator error: memcpy read overflow\n")
 
     def test_memcpy_valid(self):
         _stdout, _stderr, returncode = self.run_test(
             "memcpy_valid")
         self.assertEqual(returncode, 0)
 
-    def test_memmove_buffer_overflow(self):
+    #def test_memmove_buffer_overflow(self):
-        _stdout, stderr, returncode = self.run_test(
+    #    _stdout, stderr, returncode = self.run_test(
-            "memmove_buffer_overflow")
+    #        "memmove_buffer_overflow")
-        self.assertEqual(returncode, -6)
+    #    self.assertEqual(returncode, -6)
-        self.assertEqual(stderr.decode(
+    #    self.assertEqual(stderr.decode(
-            "utf-8"), "fatal allocator error: memmove buffer overflow\n")
+    #        "utf-8"), "fatal allocator error: memmove buffer overflow\n")
 
-    def test_memmove_read_overflow(self):
+    #def test_memmove_read_overflow(self):
-        _stdout, stderr, returncode = self.run_test(
+    #    _stdout, stderr, returncode = self.run_test(
-            "memmove_read_overflow")
+    #        "memmove_read_overflow")
-        self.assertEqual(returncode, -6)
+    #    self.assertEqual(returncode, -6)
-        self.assertEqual(stderr.decode(
+    #    self.assertEqual(stderr.decode(
-            "utf-8"), "fatal allocator error: memmove read overflow\n")
+    #        "utf-8"), "fatal allocator error: memmove read overflow\n")
 
     def test_memmove_valid(self):
         _stdout, _stderr, returncode = self.run_test(