File size: 10,454 Bytes
6aa6c12 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 | """Evaluator-private, explicit user-reference asset acceptance; never a blanket bypass."""
from __future__ import annotations
import hashlib
import json
from pathlib import Path, PurePosixPath
import re
SCHEMA = "starvla-rsi.robodojo-asset-reference/v1"
KNOWN_UNRESOLVED = (
"/home/kaslensu/Desktop/textures/Image_0.png",
"https://omniverse-content-production.s3.us-west-2.amazonaws.com/Materials/2023_1/Base/Metals/Aluminum_Anodized.mdl",
"https://omniverse-content-production.s3.us-west-2.amazonaws.com/Materials/2023_1/Base/Metals/Aluminum_Cast.mdl",
"https://omniverse-content-production.s3.us-west-2.amazonaws.com/Materials/2023_1/Base/Plastics/Plastic_ABS.mdl",
)
_GRASP_DIRS = ["Geometry/t_cushion/00000", "Rigid/t/00000", "Rigid/t/00001"] + [
f"Rigid/bowl/{index:05d}" for index in (1, 2, 3, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15)]
KNOWN_ANCILLARY = {f"Object/RoboDojo/{directory}/grasps/{name}.json"
for directory in _GRASP_DIRS for name in ("UMI", "XOne", "aloha", "panda", "piper_v1", "proposal")}
KNOWN_ANCILLARY.add("Robots/x5/.ipynb_checkpoints/curobo-checkpoint.yml")
def file_hash(path: Path) -> str:
digest = hashlib.sha256()
before = path.stat()
with path.open("rb") as stream:
for block in iter(lambda: stream.read(4 * 1024 * 1024), b""):
digest.update(block)
after = path.stat()
if (before.st_ino, before.st_size, before.st_mtime_ns, before.st_ctime_ns) != (
after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns):
raise ValueError("asset changed during hashing")
return digest.hexdigest()
def load_reference(path: Path, expected_sha256: str) -> dict:
path = Path(path).absolute()
if (not re.fullmatch(r"[0-9a-f]{64}", expected_sha256 or "")
or path.is_symlink() or not path.is_file() or path.stat().st_size > 8 * 1024 * 1024):
raise ValueError("invalid asset-reference file/hash")
payload = path.read_bytes()
if hashlib.sha256(payload).hexdigest() != expected_sha256:
raise ValueError("asset-reference digest changed")
def unique(pairs):
obj = {}
for key, value in pairs:
if key in obj:
raise ValueError("duplicate asset-reference JSON key")
obj[key] = value
return obj
document = json.loads(payload, object_pairs_hook=unique)
return validate_reference_document(document)
def validate_reference_document(document: dict) -> dict:
"""Validate pinned inventory and provenance before any asset access."""
if (not isinstance(document, dict) or document.get("schema_version") != SCHEMA
or document.get("ready_for_user_reference_track") is not True
or document.get("allowed_unresolved") != list(KNOWN_UNRESOLVED)):
raise ValueError("unapproved asset reference/schema/unresolved set")
reference_root = document.get("reference_root")
if (not isinstance(reference_root, str) or not reference_root
or "\\" in reference_root or "\x00" in reference_root
or not PurePosixPath(reference_root).is_absolute()
or ".." in PurePosixPath(reference_root).parts
or PurePosixPath(reference_root).as_posix() != reference_root):
raise ValueError("reference provenance root must be an absolute normalized path")
rows = document.get("files")
if not isinstance(rows, list) or not 1 <= len(rows) <= 20000:
raise ValueError("invalid reference file inventory")
names = []
for row in rows:
if not isinstance(row, dict) or set(row) != {"path", "bytes", "sha256"}:
raise ValueError("invalid reference file fields")
name = row["path"]
if (not isinstance(name, str) or not name or name == "." or "\\" in name
or PurePosixPath(name).is_absolute() or ".." in PurePosixPath(name).parts
or PurePosixPath(name).as_posix() != name
or type(row["bytes"]) is not int or row["bytes"] < 0
or not isinstance(row["sha256"], str)
or not re.fullmatch(r"[0-9a-f]{64}", row["sha256"])):
raise ValueError("unsafe reference path/size/hash")
names.append(name)
if names != sorted(set(names)):
raise ValueError("reference inventory must be sorted and unique")
required = {"Robots/x5/X5A.urdf", "Robots/x5/curobo.yml"}
required.update(f"Eval_Layout/RoboDojo/arx_x5/0/{task}_0.json" for task in ("stack_bowls", "push_T"))
if not required.issubset(names):
raise ValueError("reference inventory lacks required robot/layout files")
reference_rows = document.get("reference_files")
absent = document.get("reference_absent")
crlf_paths = document.get("crlf_equivalent_paths")
if (not isinstance(reference_rows, list) or not reference_rows
or not isinstance(absent, list) or len(absent) > 100
or any(not isinstance(name, str) for name in absent)
or absent != sorted(set(absent))
or crlf_paths not in ([], ["Robots/x5/X5A.urdf"])):
raise ValueError("invalid reference comparison partition")
own = {row["path"]: row for row in rows}
referenced = []
for row in reference_rows:
if (not isinstance(row, dict) or set(row) != {"path", "bytes", "sha256"}
or not isinstance(row["path"], str) or row["path"] not in own
or type(row["bytes"]) is not int or row["bytes"] < 0
or not isinstance(row["sha256"], str)
or not re.fullmatch(r"[0-9a-f]{64}", row["sha256"])):
raise ValueError("invalid counterpart record")
if row["path"] not in crlf_paths and row != own[row["path"]]:
raise ValueError("non-URDF reference mismatch is not accepted")
referenced.append(row["path"])
if (referenced != sorted(set(referenced)) or set(referenced) & set(absent)
or set(referenced) | set(absent) != set(names)
or not required.issubset(referenced)
or not set(crlf_paths).issubset(referenced)):
raise ValueError("reference partition is incomplete or overlapping")
# Missing counterparts are kept as named, byte-pinned own ancillary files;
# they are not certified reference matches or allowed arbitrary missing geometry.
for name in absent:
if name not in KNOWN_ANCILLARY:
raise ValueError("unapproved reference-absent asset category")
return document
def verify_reference(path: Path, expected_sha256: str, runtime_assets: Path,
*, reference_assets: Path | None = None) -> dict:
document = load_reference(path, expected_sha256)
return _verify_reference_assets(document, runtime_assets, reference_assets=reference_assets)
def verify_reference_document(document: dict, runtime_assets: Path,
*, reference_assets: Path | None = None) -> dict:
"""Verify assets without rewriting the document's original provenance path."""
return _verify_reference_assets(validate_reference_document(document), runtime_assets,
reference_assets=reference_assets)
def _verify_reference_assets(document: dict, runtime_assets: Path,
*, reference_assets: Path | None = None) -> dict:
"""Check materialized assets for an already validated/constructed document.
Normal consumers must use verify_reference for schema/digest validation.
Preparation may check its in-memory document before publishing a ready file.
"""
runtime_assets = Path(runtime_assets).resolve()
# A relocated counterpart keeps the historical manifest bytes and digest.
# Without an override, retain the manifest-directed comparison behavior.
reference = Path(document["reference_root"] if reference_assets is None else reference_assets).absolute()
if reference.is_symlink():
raise ValueError("asset root is not a regular directory")
reference = reference.resolve()
names = []
for item in runtime_assets.rglob("*"):
if item.is_symlink():
raise ValueError("runtime asset symlink is outside frozen reference")
if item.is_file():
names.append(item.relative_to(runtime_assets).as_posix())
elif not item.is_dir():
raise ValueError("nonregular runtime asset")
if sorted(names) != [row["path"] for row in document["files"]]:
raise ValueError("runtime asset set differs from reference inventory")
for root, rows in ((runtime_assets, document["files"]), (reference, document["reference_files"])):
if not root.is_dir() or root.is_symlink():
raise ValueError("asset root is not a regular directory")
for row in rows:
item = root / row["path"]
if (item.is_symlink() or not item.is_file() or item.resolve() != item
or item.stat().st_size != row["bytes"] or file_hash(item) != row["sha256"]):
raise ValueError(f"asset differs from user reference: {root}/{row['path']}")
for name in document["reference_absent"]:
file = reference / name
if file.exists() or file.is_symlink():
raise ValueError("reference-absent counterpart now exists; refreeze comparison")
for name in document["crlf_equivalent_paths"]:
if (runtime_assets / name).read_bytes().replace(b"\r\n", b"\n") != (reference / name).read_bytes():
raise ValueError("URDF difference is not solely the declared CRLF-to-LF conversion")
return document
def accept_unresolved(unresolved, reference: dict | None) -> None:
if unresolved and reference is None:
raise ValueError("unresolved assets require an explicit user-reference track")
if reference is not None and set(unresolved) - set(reference["allowed_unresolved"]):
raise ValueError("new unresolved assets are not in the accepted user reference")
def verify_runtime_records(records: list[dict], reference: dict) -> None:
if any(not row["path"].startswith("Assets/") for row in records):
raise ValueError("asset record escaped Assets")
actual = [{"path": row["path"].removeprefix("Assets/"),
"bytes": row["bytes"], "sha256": row["sha256"]} for row in records]
actual.sort(key=lambda row: row["path"])
if actual != reference["files"]:
raise ValueError("runtime assets changed after reference verification")
|