Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦
C
fix(loader): reject incomplete safetensors metadata JSON
Rudy Celekliac1929496b56
diff --git a/c/st.h b/c/st.hindex 5d914550..1460a876 100644--- a/c/st.h+++ b/c/st.h@@ -454,7 +454,7 @@ static void st_fmt_stamp_ingest(shards *S, jval *root, const char *shard_path) {fprintf(stderr, "%s: __metadata__[\"colibri.fmt\"] is not a JSON string -- malformed stamp, refusing (untrusted container)\n",shard_path); exit(1); }char *arena2 = NULL;- jval *inner = json_parse(stamp->str, &arena2);+ jval *inner = json_parse_checked(stamp->str);if (!inner || inner->t != J_OBJ) {fprintf(stderr, "%s: __metadata__[\"colibri.fmt\"] does not parse as a JSON object -- malformed stamp, refusing (untrusted container)\n",shard_path); exit(1); }@@ -581,7 +581,7 @@ static void st_index_load(st_index *ix, const char *dir) {char *text = malloc((size_t)size + 1);if (!text || fread(text, 1, (size_t)size, f) != (size_t)size) { free(text); fclose(f); return; }text[size] = 0; fclose(f);- ix->root = json_parse(text, &ix->arena);+ ix->root = memchr(text, 0, (size_t)size) ? NULL : json_parse_checked(text);free(text);jval *map = ix->root ? json_get(ix->root, "weight_map") : NULL;if (!map || map->t != J_OBJ) { json_free(ix->root); ix->root = NULL; free(ix->arena); ix->arena = NULL; return; }@@ -721,7 +721,9 @@ static void st_init_multi(shards *S, const char *snap_dir, const char *extra_dirhdr[hlen] = 0;int64_t data_start = 8 + (int64_t)hlen;char *arena = NULL;- jval *root = json_parse(hdr, &arena);+ /* A partial object must not index weights or authorize an overlay.+ * Header padding is JSON whitespace; embedded NUL is not padding. */+ jval *root = memchr(hdr, 0, (size_t)hlen) ? NULL : json_parse_checked(hdr);if (!root || root->t != J_OBJ) {fprintf(stderr, "%s: safetensors header is not a JSON object\n", files[fi]); exit(1); }st_fmt_stamp_ingest(S, root, files[fi]);diff --git a/c/tests/test_st_json_integrity.py b/c/tests/test_st_json_integrity.pynew file mode 100644index 00000000..94dd0f67--- /dev/null+++ b/c/tests/test_st_json_integrity.py@@ -0,0 +1,92 @@+"""Corrupt container JSON must not become a partial tensor index."""+import json+import os+from pathlib import Path+import shlex+import shutil+import struct+import subprocess+import tempfile+import unittest++C_DIR = Path(__file__).resolve().parents[1]+TENSOR = {"dtype": "F32", "shape": [1], "data_offsets": [0, 4]}+++class SafetensorsJsonIntegrity(unittest.TestCase):+ @classmethod+ def setUpClass(cls):+ cc = shlex.split(os.environ.get("CC", "cc"))+ if not cc or not shutil.which(cc[0]):+ raise unittest.SkipTest("a C compiler is required")+ cls.tmp = tempfile.TemporaryDirectory()+ cls.addClassCleanup(cls.tmp.cleanup)+ cls.root = Path(cls.tmp.name)+ source = cls.root / "load.c"+ source.write_text('#include "st.h"\nint main(int n,char **v){'+ 'if(n!=2)return 2; shards s; st_init(&s,v[1]);'+ 'float x=0; st_read_f32_cap(&s,"tensor",&x,1,0);'+ 'printf("%g\\n",x); return 0;}\n')+ cls.binary = cls.root / ("load.exe" if os.name == "nt" else "load")+ subprocess.run(cc + ["-O1", "-Wall", "-Wextra", "-Wno-unused-function",+ "-Wno-unused-parameter", "-Wno-misleading-indentation",+ "-I", str(C_DIR), str(source), "-o", str(cls.binary), "-lm"],+ check=True, capture_output=True, text=True)++ def load(self, header, index=None):+ with tempfile.TemporaryDirectory(dir=self.root) as directory:+ directory = Path(directory)+ header = header.encode() if isinstance(header, str) else header+ (directory / "a.safetensors").write_bytes(struct.pack("<Q", len(header))+ + header + struct.pack("<f", 2.5))+ if index is not None:+ valid = json.dumps({"tensor": TENSOR}).encode()+ (directory / "b.safetensors").write_bytes(struct.pack("<Q", len(valid))+ + valid + struct.pack("<f", 7.5))+ (directory / "model.safetensors.index.json").write_text(index)+ return subprocess.run([str(self.binary), str(directory)], capture_output=True,+ text=True, timeout=10)++ def test_corrupt_header(self):+ valid = json.dumps({"tensor": TENSOR})+ for header in (valid[:-1], valid + " trailing", valid[:-1] + ",}",+ valid.encode() + b"\0garbage"):+ with self.subTest(header=header):+ result = self.load(header)+ self.assertEqual(result.returncode, 1, result.stderr)+ self.assertIn("safetensors header", result.stderr)++ def test_corrupt_stamp(self):+ for stamp in ('{"tensor":"int8"', '{"tensor":"int8"} trailing'):+ with self.subTest(stamp=stamp):+ result = self.load(json.dumps({"__metadata__": {"colibri.fmt": stamp},+ "tensor": TENSOR}))+ self.assertEqual(result.returncode, 1, result.stderr)+ self.assertIn("malformed stamp", result.stderr)++ def test_corrupt_overlay_index(self):+ result = self.load(json.dumps({"tensor": TENSOR}),+ '{"weight_map":{"tensor":"b.safetensors"}')+ self.assertEqual(result.returncode, 1, result.stderr)+ self.assertIn("duplicate tensor name", result.stderr)++ def test_valid_header_and_padding(self):+ result = self.load(json.dumps({"tensor": TENSOR}) + " \n")+ self.assertEqual(result.returncode, 0, result.stderr)+ self.assertEqual(result.stdout.strip(), "2.5")++ def test_valid_stamp(self):+ result = self.load(json.dumps({"__metadata__": {"colibri.fmt": '{"tensor":"int8"}'},+ "tensor": TENSOR}))+ self.assertEqual(result.returncode, 0, result.stderr)+ self.assertEqual(result.stdout.strip(), "2.5")++ def test_valid_overlay_index(self):+ result = self.load(json.dumps({"tensor": TENSOR}),+ '{"weight_map":{"tensor":"b.safetensors"}}')+ self.assertEqual(result.returncode, 0, result.stderr)+ self.assertEqual(result.stdout.strip(), "7.5")+++if __name__ == "__main__":+ unittest.main()