Skip to content

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.h
index 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_dir
hdr[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.py
new file mode 100644
index 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()