Recover and verify static collision traversal and body contracts

This commit is contained in:
UnixNight committed 2026-10-26 21:45:57 -04:00
1 parent 7c0d1a4b0c
commit df0263b26e
34 files changed
+1962 -17

No files matched your search

+50
View File
@@ -0,0 +1,50 @@
#!/usr/bin/env python3
"""Read-only full body/support callgraph guards for the isolated component probe."""
import argparse
import hashlib
import json
from pathlib import Path
import struct
from collision_dispatch import collect as dispatch_collect, POINTERS
from collision_response import header
from checkpoint_script_state import find_case, read_va
from pe_inspect import PE
BODIES=(
('body_step',0x479D20,0x47A32A,'5f4b05518bef5e5f0ecc3909ff0de0b43d2c7350c6beae0c4f797d3238a77fa1'),
('friction',0x47A330,0x47A421,'3ac4d0268edb5fa4f5689a87fdc36759c12589caf76b2286b1817f2204a91155'),
('support',0x47B890,0x47BBB0,'5901c9475092af33db8015b58416475e9fa2c527b9e8860e36c0b4cc0ff3f25d'),
('support_query',0x47C6E0,0x47CA8B,'0f6127ef4e4bf7986ef195340002fbd97d3b6f1151377d053b1ad8d0c096cf57'),
('support_triangle',0x469A10,0x469B70,'6acde1608be611364a84ae8dadaa2f2675231f5ee9612445e7cb5e375e5d4e77'))
GLOBALS=sorted(set((*POINTERS,0x48D920,0x4D6A08,0x5CFC00,0x5CFC04,0x5CFC08,
0x695D49,0x695D5C,0x695D84,0x695D54,0x695D58,0x695D68,0x5CFC7C,
*range(0x5CFC40,0x5CFC70,4))))
def collect(original):
report=dispatch_collect(original);pe=PE(find_case(Path(original),'Neutron.exe'))
for name,start,end,digest in BODIES:
body=read_va(pe,start,end-start)
if hashlib.sha256(body).hexdigest()!=digest:raise ValueError(f'Changed body {name}')
report['bodies'].append(dict(name=name,va=hex(start),file_offset=hex(pe.offset(start-pe.base)),length=end-start,sha256=digest))
for target in GLOBALS:
value=struct.pack('<I',target)
for index in range(len(body)-3):
if body[index:index+4]==value:report['probe_operands'].append(dict(va=start+index,target=target))
report['probe_operands'].sort(key=lambda p:p['va'])
return report
if __name__=='__main__':
cli=argparse.ArgumentParser(description=__doc__);cli.add_argument('original',type=Path)
cli.add_argument('--probe-header',type=Path);cli.add_argument('--target-copy',type=Path)
args=cli.parse_args();report=collect(args.original)
if args.target_copy:
target=args.target_copy.resolve(strict=True)
if target.is_relative_to(args.original.resolve()):cli.error('Use a generated copy')
if hashlib.sha256(target.read_bytes()).hexdigest()!=report['sha256']:cli.error('Unexpected copy identity')
if args.probe_header:
output=args.probe_header.resolve()
if output.is_relative_to(args.original.resolve()):cli.error('Header must be outside originals')
output.write_text(header(report))
print(json.dumps(report,indent=2))
+106
View File
@@ -0,0 +1,106 @@
/* Original479D20 with copied code and synthetic ordinary-body virtual contracts.
* No game loader/entrypoint, script, audio or real actor instance is executed. */
#define main isolated_kernel_main
#include "collision_response_probe.c"
#undef main
#define TC __attribute__((thiscall))
typedef struct Node {struct Node *next,*previous;void *value;} Node;
typedef struct {
uintptr_t *table;Vec position,previous,velocity,acceleration,impulse,angular,rotation,anchor;
int supported,support,world,pairs,prevent;float speed,friction,factor,radius,scale;
unsigned landings;float landing_velocity;int landing_supported;
unsigned char reserved[0x500]; // Covers source dispatcher's direct member42C.
} Body;
typedef void (__cdecl *BodyStep)(Body*,float);
static int TC supported(Body*b){return b->supported;}
static int TC support(Body*b){return b->support;}
static int TC world(Body*b){return b->world;}
static int TC pairs(Body*b){return b->pairs;}
static int TC yes(Body*b){(void)b;return 1;}
static int TC no(Body*b){(void)b;return 0;}
static int TC prevent(Body*b){return b->prevent;}
static void TC set_supported(Body*b,int value){b->supported=value;}
static float TC radius(Body*b){return b->radius;}
static float TC factor(Body*b){return b->factor;}
static float TC speed(Body*b){return b->speed;}
static float TC friction(Body*b){return b->friction;}
static float TC scale(Body*b){return b->scale;}
#define GET(name,field) static Vec *TC name(Body*b,Vec*out){*out=b->field;return out;}
GET(position,position) GET(previous,previous) GET(velocity,velocity) GET(acceleration,acceleration)
GET(impulse,impulse) GET(angular,angular) GET(rotation,rotation)
#define SET(name,field) static void TC name(Body*b,Vec v){b->field=v;}
SET(set_position,position) SET(set_previous,previous) SET(set_velocity,velocity) SET(set_acceleration,acceleration)
#define XYZ(name,field) static void TC name(Body*b,float x,float y,float z){b->field.x=x;b->field.y=y;b->field.z=z;}
XYZ(position_xyz,position) XYZ(velocity_xyz,velocity) XYZ(acceleration_xyz,acceleration)
XYZ(impulse_xyz,impulse) XYZ(angular_xyz,angular) XYZ(anchor_xyz,anchor)
#define ADD(name,field) static void TC name(Body*b,float x,float y,float z){b->field.x+=x;b->field.y+=y;b->field.z+=z;}
ADD(add_velocity,velocity) ADD(add_angular,angular) ADD(rotate,rotation)
static void TC move(Body*b,Vec v){b->position.x+=v.x;b->position.y+=v.y;b->position.z+=v.z;}
static void TC landing(Body*b){b->landings++;b->landing_velocity=b->velocity.y;b->landing_supported=b->supported;}
static void TC pointer(Body*b,void*p){(void)b;(void)p;}
static void TC contact(Body*b,Vec normal,void*p){(void)b;(void)normal;(void)p;}
static uintptr_t table[0x500/4];
static void TC missing(Body*b) {
(void)b;uintptr_t call=(uintptr_t)__builtin_return_address(0);
fprintf(stderr,"MISSING fixture virtual after sourceVA %08lx\n",(unsigned long)(call-(uintptr_t)mapped+0x400000));
ExitProcess(2);
}
static Node sentinels[2][260*260];
static unsigned char polygon[0x30],shape[0x90],corners[60];
static Vec points[3]={{-1000,0,-1000,1},{1000,0,-1000,1},{0,0,1000,1}};
static void setup(void) {
for(unsigned i=0;i<sizeof(table)/sizeof(table[0]);i++)table[i]=(uintptr_t)missing;
#define SLOT(n,f) table[(n)/4]=(uintptr_t)(f)
SLOT(0x218,supported);SLOT(0x21c,set_supported);SLOT(0x1c8,support);SLOT(0x210,yes);
SLOT(0x220,pairs);SLOT(0x228,no);SLOT(0x1d0,world);SLOT(0x208,prevent);
SLOT(0x260,radius);SLOT(0x250,factor);SLOT(0x268,speed);SLOT(0x248,friction);SLOT(0x230,scale);
SLOT(0x310,position);SLOT(0x2f8,previous);SLOT(0x2bc,velocity);SLOT(0x270,acceleration);
SLOT(0x284,impulse);SLOT(0x2ac,angular);SLOT(0x314,set_position);SLOT(0x318,position_xyz);
SLOT(0x328,rotation);
SLOT(0x2fc,set_previous);SLOT(0x2c0,set_velocity);SLOT(0x274,set_acceleration);SLOT(0x31c,move);
SLOT(0x2c4,velocity_xyz);SLOT(0x278,acceleration_xyz);SLOT(0x28c,impulse_xyz);
SLOT(0x2b4,angular_xyz);SLOT(0x2f4,anchor_xyz);SLOT(0x334,rotate);
SLOT(0x2cc,add_velocity);SLOT(0x2b8,add_angular);SLOT(0x37c,landing);
SLOT(0x34c,pointer);SLOT(0x33c,pointer);SLOT(0x370,contact);SLOT(0x374,contact);
for(unsigned g=0;g<2;g++)for(unsigned i=0;i<260*260;i++) {
Node*s=&sentinels[g][i];s->next=s->previous=s;
*(Node**)AT((g?0x5cfc7c:0x509b24)+i*12)=s;
}
*(void**)(polygon+0x24)=corners;*(Vec*)(polygon+8)=(Vec){0,1,0,0};
*(void**)(shape+0x68)=points;
for(unsigned i=0;i<3;i++)*(unsigned*)(corners+i*20)=i;
for(int x=127;x<=132;x++)for(int z=127;z<=132;z++) {
Node*s=&sentinels[1][260*x+z],*n=calloc(1,sizeof(Node));void**r=calloc(1,0x1c);
require(n&&r,"support fixture allocation");r[0]=polygon;r[1]=shape;n->value=r;
n->next=s;n->previous=s->previous;s->previous->next=n;s->previous=n;
}
*(Vec*)AT(0x5cfc00)=(Vec){0,-800,0,0};
}
static Body initial(void) {
Body b={0};b.table=table;b.position=(Vec){0,75.9f,0,1};b.previous=b.position;
b.support=b.world=b.pairs=b.prevent=1;b.radius=60;b.factor=1.265f;b.friction=.8f;b.scale=.5f;
return b;
}
static void run(const char*name,Body b,int geometry) {
*(unsigned char*)AT(0x4f69e5)=geometry;
((BodyStep)AT(0x479d20))(&b,1.0f/60);
printf("CASE %s root=%.9g,%.9g,%.9g velocity=%.9g,%.9g,%.9g acceleration=%.9g,%.9g,%.9g impulseY=%.9g angularY=%.9g grounded=%d landings=%u observedVy=%.9g observedSupport=%d\n",
name,b.position.x,b.position.y,b.position.z,b.velocity.x,b.velocity.y,b.velocity.z,
b.acceleration.x,b.acceleration.y,b.acceleration.z,b.impulse.y,b.angular.y,b.supported,
b.landings,b.landing_velocity,b.landing_supported);
require(isfinite(b.position.y)&&isfinite(b.velocity.y),"finite source body output");
}
int main(void) {
setbuf(stdout,NULL);map_copy();setup();Body b=initial();
run("floor_support",b,1);
b=initial();b.position.y=26;b.previous=b.position;run("spawn_settle",b,1);
b=initial();b.supported=1;b.impulse.y=550;b.acceleration.y=-264;run("pending_jump",b,1);
b=initial();b.position.y=100;b.previous=b.position;b.velocity.y=-200;run("fall_above_floor",b,1);
b=initial();b.position.y=76;b.previous=b.position;b.velocity.y=-200;run("fall_land",b,1);
b=initial();b.velocity=(Vec){100,0,50,0};b.angular.y=12;run("ground_friction",b,1);
b=initial();b.velocity=(Vec){100,0,50,0};b.angular.y=12;b.speed=100;run("published_speed",b,1);
b=initial();b.angular.y=12;run("stationary_angular",b,1);
b=initial();b.velocity.x=.125f;run("small_motion",b,1);
b=initial();b.velocity.y=200;b.acceleration.y=-264;run("geometry_disabled",b,0);
puts("BODY_COMPONENT_COMPLETE: copied479D20/support with synthetic virtual contracts");return 0;
}
+275
View File
@@ -0,0 +1,275 @@
#!/usr/bin/env python3
"""Read-only contact callback, friction and publication evidence; bounded projections."""
from __future__ import annotations
import argparse
import hashlib
import json
from pathlib import Path
import struct
import sys
from checkpoint_script_state import EXE_SHA256, find_case, read_va
from pe_inspect import PE
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'extractors'))
from omt import Database, Reader, read_material, read_shape
DLL_SHA256 = '3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943'
DLL_SITES = (
('db_link_chunk', 0x10030070, '8b4424048b54240c89411c8b44240889410c89511089480c8b410c668b502066895122c20c00'),
('header_id_offset_size', 0x1004659f, '8b4b288d54245852e8f4d302008b4b288d44245050e837d402008d4c2454518b4b28e82ad40200'),
('header_record_insert', 0x10046635, '8b4e148d542450528b4104508d44243450e865190000'),
('chunk_id_lookup', 0x10045b98, '8b4c24108b500c3bca7c068d44240ceb08897424048d4424048b003bc65e740a8b401083c00859'),
('object_lookup_chunk', 0x1002df43, '55538bceff50488b3e55538bceff576c508bceff5774538be8'),
('object_db_link_call', 0x1002e0a5, '8b4c24108b075355518bcfff5018'),
('link_reads_fourcc_id', 0x100302ac, '8d4c2410518bcee8383704008d5424148bce52e8dc3604008b5c24108b6c2414'),
('link_get_object', 0x100302e8, '8b0755538bcfff50148b4c2418894104'),
('polygon_link_read', 0x10003f4f, '8d4424388bce50e8a5fe06008b4c243c51e910030000'),
('polygon_material_set', 0x10004275, '8bcbe874010000'),
('material_pointer_publish', 0x10004402, '8b44240485c08941047403ff4014c20400'),
)
# Fixed signatures from independently reviewed original instructions.
SITES = (
('root_before_normal', 0x47b7b1, '89038b442440894b048953088943'),
('normal_threshold', 0x47b7e3, 'd81d48314a00'),
('normal_strict_positive_side', 0x47b7f9, 'f6c441751f'),
('wall374', 0x47b80f, 'ff9774030000'),
('ceiling370', 0x47b82e, 'ff9770030000'),
('ceiling_velocity_read', 0x47269f, 'ff90bc020000'),
('ceiling_velocity_strict', 0x4726c0, 'f6c4417526'),
('ceiling_velocity_write', 0x4726e3, 'ff90c0020000'),
('ceiling_accel_read', 0x4726f6, 'ff9270020000'),
('ceiling_accel_strict', 0x472717, 'f6c4417525'),
('ceiling_accel_write', 0x472734, 'ff9074020000'),
('jimmy_gadget', 0x42a660, '66833d88054f0007'),
('jimmy_common_player_forward', 0x42a70b, 'e830030100'),
('base_guard', 0x458895, 'ff90d801000084c0742a8b4c'),
('base378', 0x4588c3, 'ff9078030000'),
('player_elapsed', 0x43aa4a, 'd98674070000d81da0e54800'),
('player_metadata', 0x43aa69, '8b400485c074658b400c85c00f84520200008b'),
('player_mode', 0x43aad5, '6683be04070000000f85f8040000'),
('landing_root', 0x47bb32, 'ff9018030000'),
('landing_acceleration', 0x47bb4b, 'ff9078020000'),
('landing_previous_ground', 0x47bb51, 'a0495d690084c0750a'),
('landing37c', 0x47bb5e, 'ff907c030000'),
('landing_velocity', 0x47bb74, 'ff92c4020000'),
('landing_support', 0x47bb7c, '6a018bceff921c020000'),
('landing_shape', 0x47bb91, 'ff904c030000'),
('landing_polygon', 0x47bba1, 'ff923c030000'),
('friction_speed_read', 0x47a241, 'ff9268020000'),
('friction_equal_zero', 0x47a24f, 'f6c4407440'),
('friction_call', 0x47a25a, 'e8d1000000'),
('friction_support', 0x47a344, 'ff901802000084c00f84ca000000'),
('friction_coefficient', 0x47a356, 'ff9248020000'),
('friction_magnitude', 0x47a38e, 'ff1504d14800d81d14d94800dfe0f6c441757b'),
('friction_linear_add', 0x47a3cb, 'ff92cc020000'),
('friction_angular_add', 0x47a416, 'ff92b8020000'),
('speed_getter', 0x471b50, 'd98160010000c3'),
('speed_setter', 0x471b60, '8b442404898160010000c20400'),
('speed_publication', 0x437c22, '8b86080600008b16508bceff926c020000'),
('small_motion_scale', 0x471a70, 'd98144010000c3'),
('threshold_minus07', 0x4a3148, '333333bf'),
('threshold_zero', 0x48d914, '00000000'),
('threshold_point1', 0x48d920, 'cdcccc3d'),
('threshold_3', 0x48e5a0, '00004040'),
('ctor_ebx_zero', 0x46fc08, '33db'),
('ctor208_false', 0x46fdbc, '538bcde8ac110000'),
('ctor1c8_true', 0x46fdc4, '6a018bcde8d3110000'),
('ctor1d0_true', 0x46fdcd, '6a018bcde8fa110000'),
('ctor220_true', 0x46fdf0, '6a018bcde8c7120000'),
('ctor228_false', 0x46fdf9, '538bcde8ef120000'),
('ctor42c_false', 0x46ffb1, '889d2c040000'),
('player208_true', 0x43740a, '578bcee85e9b0300'),
)
BODY_HASHES = (
('ceiling370', 0x472690, 0xba, 'febfe9381b19074c41b229b314307c85f95710a35c7907935f76519052d4b50c'),
('jimmy374', 0x42a660, 0xb4, 'd52831057c35afbdb73babff81857a6a3cfb2466f639b8be0a80e6300d386b0c'),
('player374', 0x43aa40, 0x5a3, '2acd114eb62fe67490d9301bc8e68f196830be74eb9076f52f79111467344a78'),
('base374', 0x458890, 0x3d, '250d34ac046749aa9e6d6e22968b1139a98be46d8f31cb2dda287ddc5c2c4b6f'),
('friction', 0x47a330, 0xf1, '3ac4d0268edb5fa4f5689a87fdc36759c12589caf76b2286b1817f2204a91155'),
('landing37c', 0x472970, 0x1, 'ae3f4619b0413d70d3004b9131c3752153074e45725be13b9a148978895e359e'),
)
TABLES = (
('Object', 0x4d3154, 0x370, 0x472690),
('Object', 0x4d3154, 0x374, 0x458890),
('Object', 0x4d3154, 0x378, 0x472750),
('Object', 0x4d3154, 0x37c, 0x472970),
('Object', 0x4d3154, 0x230, 0x471a70),
('Animated', 0x48fe1c, 0x370, 0x472690),
('Animated', 0x48fe1c, 0x374, 0x458890),
('Animated', 0x48fe1c, 0x378, 0x472750),
('Animated', 0x48fe1c, 0x37c, 0x472970),
('Animated', 0x48fe1c, 0x230, 0x471a70),
('Player', 0x4af6c4, 0x370, 0x472690),
('Player', 0x4af6c4, 0x374, 0x43aa40),
('Player', 0x4af6c4, 0x378, 0x472750),
('Player', 0x4af6c4, 0x37c, 0x472970),
('Player', 0x4af6c4, 0x230, 0x471a70),
('Jimmy', 0x4a373c, 0x370, 0x472690),
('Jimmy', 0x4a373c, 0x374, 0x42a660),
('Jimmy', 0x4a373c, 0x378, 0x472750),
('Jimmy', 0x4a373c, 0x37c, 0x472970),
('Jimmy', 0x4a373c, 0x230, 0x471a70),
)
NORMAL_Y_THRESHOLD = struct.unpack('<f', bytes.fromhex('333333bf'))[0]
def normal_callback(normal_y):
"""Finite-input dispatch only; caller already publishes candidate root."""
return 0x374 if normal_y > NORMAL_Y_THRESHOLD else 0x370
def ceiling_projection(velocity, acceleration):
"""472690 changes strictly positive Y only, retaining fourth components."""
def clear_positive_y(v):
return (v[0], 0 if v[1] > 0 else v[1], *v[2:])
return clear_positive_y(velocity), clear_positive_y(acceleration)
def player_material_actions(material_id, elapsed, mode):
"""Classify bounded branches, without inventing unresolved class callbacks."""
if elapsed <= 3:
return ()
actions = []
if 120 <= material_id <= 129:
actions.append('complete160')
if 110 <= material_id <= 119:
actions.append('complete164')
if mode == 0:
if 60 <= material_id <= 69:
actions.append('fence_query')
if material_id == 180:
actions.append('ladder_query')
return tuple(actions)
def jimmy_contact_actions(selected, material_id, elapsed, mode, *, gadget7_active=False):
"""42A660 branch contract; selected -1/3 have no extra gadget behavior."""
actions = player_material_actions(material_id, elapsed, mode)
if selected == 7 and gadget7_active:
actions += ('gadget7_unresolved',)
return actions
def friction_projection(velocity, angular, coefficient, delta, *,
support=True, published_speed=0):
"""47A330 with caller's268 gate; excludes later small-motion suppression.
Finite vectors only. Nonzero quick_magnitude gate is represented by any
nonzero component, not a substitute implementation of imported magnitude.
Python arithmetic is not an x87 bit-identity oracle. No clamp is added.
"""
if published_speed != 0 or not support or not any(velocity[:3]):
return tuple(velocity), tuple(angular)
k = coefficient * delta
return ((velocity[0] - velocity[0]*k, velocity[1],
velocity[2] - velocity[2]*k, *velocity[3:]),
tuple(x-x*k for x in angular[:3]) + tuple(angular[3:]))
def landing_phases(previous_support):
phases = ['root318', 'acceleration278_Y0']
if not previous_support:
phases.append('landing37C_noop_for_Jimmy')
return phases + ['velocity2C4_Y0', 'support21C_true', 'shape34C', 'polygon33C']
def material_identity_report(root):
"""Original table IDs linked by source chunk metadata, not payload flags.
Eligibility is registration+normal only, not evidence a gameplay trajectory
actually contacts a polygon. Preserve explicit source shape/polygon identity.
"""
root = Path(root)
dll = PE(find_case(root, 'OMT2.dll'))
if hashlib.sha256(dll.data).hexdigest() != DLL_SHA256:
raise ValueError('Unsupported original OMT2.dll')
anchors = []
for name, va, expected in DLL_SITES:
if read_va(dll, va, len(bytes.fromhex(expected))).hex() != expected:
raise ValueError(f'Changed DLL instruction {name}')
anchors.append(dict(name=name, va=hex(va), file_offset=hex(dll.offset(va-dll.base)), bytes=expected))
archives = []
for filename in ('level1b.omt', 'VR04.omt', 'level1.omt'):
db = Database(find_case(root, 'omt/' + filename))
# Record the identity's actual table byte offset, separate from payload.
r = Reader(db.data, db.table_offset)
id_offsets = {}
for _ in range(r.count(8)):
kind = r.take(4).decode('latin1')
for _ in range(r.count(13)):
offset = r.position
identity = r.u32()
r.take(8)
r.string()
id_offsets[kind, identity] = offset
materials = {e.id: e for e in db.entries if e.type == '3DMa'}
summaries = {}
special = []
for entry in db.entries:
if entry.type != '3DSh':
continue
shape = read_shape(db.payload(entry))
registered = not entry.name.lower().startswith('nc')
for index, polygon in enumerate(shape['polygons']):
link = polygon['material']
if link is None or link['type'] != '3DMa' or link['id'] not in materials:
continue
identity = link['id']
material = materials[identity]
item = summaries.setdefault(identity, dict(id=identity, name=material.name,
table_id_offset=id_offsets['3DMa', identity], payload_offset=material.offset,
payload_size=material.size, payload_sha256=hashlib.sha256(db.payload(material)).hexdigest(),
payload_trailing=read_material(db.payload(material))['trailing'],
polygons=0, registered_polygons=0, potential374_wall_polygons=0))
item['polygons'] += 1
item['registered_polygons'] += int(registered)
wall374 = registered and NORMAL_Y_THRESHOLD < polygon['normal'][1] < -NORMAL_Y_THRESHOLD
item['potential374_wall_polygons'] += int(wall374)
if player_material_actions(identity, 4, 0):
special.append(dict(shape_id=entry.id, shape_name=entry.name,
shape_payload_offset=entry.offset, polygon_index=index,
material_id=identity, normal=polygon['normal'], registered=registered,
potential374_wall=wall374))
archives.append(dict(name=filename, sha256=hashlib.sha256(db.data).hexdigest(),
materials=list(summaries.values()), special_polygons=special))
return dict(dll_sha256=DLL_SHA256, dll_sites=anchors, archives=archives,
discriminator='signed 3DMa database chunk ID at material+0C->chunk+8; not payload trailing')
def collect(root):
pe = PE(find_case(Path(root), 'Neutron.exe'))
if hashlib.sha256(pe.data).hexdigest() != EXE_SHA256:
raise ValueError('Unsupported original EXE')
sites = []
for name, va, expected in SITES:
actual = read_va(pe, va, len(bytes.fromhex(expected))).hex()
if actual != expected:
raise ValueError(f'Changed instruction {name} at {va:#x}')
sites.append(dict(name=name, va=hex(va), file_offset=hex(pe.offset(va-pe.base)), bytes=actual))
tables = []
for owner, table, slot, target in TABLES:
if struct.unpack('<I', read_va(pe, table+slot, 4))[0] != target:
raise ValueError(f'Changed {owner} slot{slot:x}')
tables.append(dict(owner=owner, table=hex(table), slot=hex(slot), target=hex(target),
file_offset=hex(pe.offset(table+slot-pe.base))))
bodies = []
for name, va, length, expected in BODY_HASHES:
raw = read_va(pe, va, length)
if hashlib.sha256(raw).hexdigest() != expected:
raise ValueError(f'Changed callback {name}')
bodies.append(dict(name=name, va=hex(va), file_offset=hex(pe.offset(va-pe.base)),
length=length, sha256=expected,
raw_control_reference=struct.pack('<I', 0x5099E4) in raw))
return dict(sha256=EXE_SHA256, sites=sites, tables=tables, bodies=bodies,
material_identity=material_identity_report(root),
scope='Static guarded source and bounded state fixtures; no original execution.')
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('original', type=Path)
print(json.dumps(collect(parser.parse_args().original), indent=2))
+46
View File
@@ -0,0 +1,46 @@
#!/usr/bin/env python3
"""Guard the expanded original dispatcher probe callgraph; never execute originals."""
import argparse
import hashlib
import json
from pathlib import Path
import struct
from collision_response import collect as kernel_collect, header, TARGETS
from checkpoint_script_state import find_case, read_va
from pe_inspect import PE
EXTRA=(
('static_dispatch',0x47B4B0,0x47B889,'da4ca56149636d5fc5059403a0ef81a0007c96972e3c12f2a8dedfa7568dd160'),
('polygon_dispatch',0x47BBB0,0x47BD73,'b583bb88a97bef45961ad64a6b21533e9149d3dcb4a292d5dbe27db98d4dd325'),
('polygon_vertex',0x477F10,0x477F5F,'b5460f170b2315a462700d585b0626321186977a7bc192ede831a1e1ba60677c'),
('truncate',0x47F940,0x47F96A,'b1c1cecad44192fa8b32676658fcfea569fa1810741a5a5321c77f488c90b0b7'))
POINTERS=(*TARGETS,0x509B24,0x49B1FC,0x4D6A04,0x4F69E5,0x695D46,0x695D4C,0x695D70,0x695D78)
def collect(original):
report=kernel_collect(original);pe=PE(find_case(Path(original),'Neutron.exe'))
for name,start,end,digest in EXTRA:
body=read_va(pe,start,end-start)
if hashlib.sha256(body).hexdigest()!=digest:raise ValueError(f'Changed body {name}')
report['bodies'].append(dict(name=name,va=hex(start),file_offset=hex(pe.offset(start-pe.base)),length=end-start,sha256=digest))
for target in POINTERS:
value=struct.pack('<I',target)
for index in range(len(body)-3):
if body[index:index+4]==value:report['probe_operands'].append(dict(va=start+index,target=target))
report['probe_operands'].sort(key=lambda p:p['va'])
return report
if __name__=='__main__':
cli=argparse.ArgumentParser(description=__doc__);cli.add_argument('original',type=Path)
cli.add_argument('--probe-header',type=Path);cli.add_argument('--target-copy',type=Path)
args=cli.parse_args();report=collect(args.original)
if args.target_copy:
target=args.target_copy.resolve(strict=True)
if target.is_relative_to(args.original.resolve()):cli.error('Use a generated target copy')
if hashlib.sha256(target.read_bytes()).hexdigest()!=report['sha256']:cli.error('Unexpected target copy hash')
if args.probe_header:
output=args.probe_header.resolve()
if output.is_relative_to(args.original.resolve()):cli.error('Header must be outside originals')
output.write_text(header(report))
print(json.dumps(report,indent=2))
+72
View File
@@ -0,0 +1,72 @@
/* Executes copied original dispatcher/kernel only, with synthetic grid/actor
* fixtures. Reuses the guarded in-memory mapper; no game entry point is run. */
#define main isolated_kernel_main
#include "collision_response_probe.c"
#undef main
#define TC __attribute__((thiscall))
typedef struct Node {struct Node *next,*previous;void *value;} Node;
typedef void (__cdecl *Dispatch)(void*,Vec*,Vec,int);
static unsigned callbacks;
static Vec callback_normal;
static void *callback_polygon;
static float TC radius(void *actor) { (void)actor;return 10; }
static void TC normal(void *actor,Vec value,void *polygon) {
(void)actor;callbacks++;callback_normal=value;callback_polygon=polygon;
}
static Node sentinels[260*260];
static unsigned char actor[0x500],polygon[2][0x30],shape[2][0x90],corners[2][60];
static Vec points[2][3];
static void empty_grid(void) {
for(unsigned i=0;i<260*260;i++) {
sentinels[i].next=sentinels[i].previous=&sentinels[i];
*(Node**)AT(0x509b24+i*12)=&sentinels[i];
}
}
static int cell(float value) {return (short)(int)(value*.0020000000949949026+130);}
static void add_triangle(unsigned id,Vec a,Vec b,Vec c,Vec n) {
points[id][0]=a;points[id][1]=b;points[id][2]=c;
*(Vec*)(polygon[id]+8)=n;*(void**)(polygon[id]+0x24)=corners[id];
*(void**)(shape[id]+0x68)=points[id];
for(unsigned j=0;j<3;j++)*(unsigned*)(corners[id]+20*j)=j;
float minx=fminf(a.x,fminf(b.x,c.x)),maxx=fmaxf(a.x,fmaxf(b.x,c.x));
float minz=fminf(a.z,fminf(b.z,c.z)),maxz=fmaxf(a.z,fmaxf(b.z,c.z));
for(int x=cell(minx);x<=cell(maxx);x++)for(int z=cell(minz);z<=cell(maxz);z++) {
require(x>=0&&x<260&&z>=0&&z<260,"fixture grid bounds");
Node *s=&sentinels[260*x+z],*node=calloc(1,sizeof(Node));
void **registration=calloc(1,0x1c);require(node&&registration,"fixture nodes");
registration[0]=polygon[id];registration[1]=shape[id];node->value=registration;
node->next=s;node->previous=s->previous;s->previous->next=node;s->previous=node;
}
}
static void wall(void) {
add_triangle(0,(Vec){-100,-100,0,1},(Vec){-100,100,0,1},(Vec){100,100,0,1},(Vec){0,0,1,0});
}
static void run(const char *name,Vec p,Vec delta,int edges,int lower) {
*(float*)AT(0x695d5c)=130000;*(float*)AT(0x5cfbe0)=10;
*(void**)AT(0x695d4c)=NULL;*(unsigned*)AT(0x695d70)=0;*(unsigned*)AT(0x695d78)=0;
callbacks=0;callback_polygon=NULL;memset(&callback_normal,0,sizeof(Vec));actor[0x42c]=lower;
((Dispatch)AT(0x47b4b0))(actor,&p,delta,edges);
int last=callback_polygon==polygon[0]?0:callback_polygon==polygon[1]?1:-1;
printf("CASE %s root=%.9g,%.9g,%.9g passes=%u visits=%u callbacks=%u last=%d normal=%.9g,%.9g,%.9g\n",
name,p.x,p.y,p.z,*(unsigned*)AT(0x695d78),*(unsigned*)AT(0x695d70),callbacks,last,
callback_normal.x,callback_normal.y,callback_normal.z);
require(isfinite(p.x)&&isfinite(p.y)&&isfinite(p.z)&&callbacks<=1,"finite terminal publication");
}
int main(void) {
setbuf(stdout,NULL);map_copy();
uintptr_t table[0x400/4]={0};table[0x260/4]=(uintptr_t)radius;
table[0x370/4]=table[0x374/4]=(uintptr_t)normal;*(uintptr_t*)actor=(uintptr_t)table;
*(unsigned char*)AT(0x4f69e5)=1;*(unsigned char*)AT(0x695d46)=0;
empty_grid();wall();
run("face_retry",(Vec){0,20,20,1},(Vec){0,0,-15,0},1,0);
run("edge_retry",(Vec){105,100,20,1},(Vec){0,0,-15,0},1,0);
run("edge_disabled",(Vec){105,100,20,1},(Vec){0,0,-15,0},0,0);
run("zero_delta",(Vec){0,20,20,1},(Vec){0,0,0,0},1,0);
run("forced_zero",(Vec){0,20,20,1},(Vec){0,0,0,0},1,1);
add_triangle(1,(Vec){0,-100,-100,1},(Vec){0,-100,100,1},(Vec){0,100,100,1},(Vec){1,0,0,0});
run("corner_retry",(Vec){20,20,20,1},(Vec){-30,0,-30,0},1,0);
empty_grid();add_triangle(0,(Vec){-100,100,-100,1},(Vec){100,100,100,1},(Vec){100,100,-100,1},(Vec){0,-1,0,0});
run("ceiling_retry",(Vec){0,80,0,1},(Vec){0,15,0,0},1,0);
puts("DISPATCH_COMPONENT_COMPLETE: copied source with synthetic grid/callback fixtures");
return 0;
}
+151
View File
@@ -0,0 +1,151 @@
#!/usr/bin/env python3
"""Read-only source grid/dispatcher anchors and bounded ordering fixtures."""
from __future__ import annotations
import argparse
from dataclasses import dataclass
import hashlib
import json
import math
from pathlib import Path
import struct
from checkpoint_script_state import EXE_SHA256, find_case, read_va
from pe_inspect import PE
BODIES = (
('static_dispatcher', 0x47B4B0, 0x47B889, 'da4ca56149636d5fc5059403a0ef81a0007c96972e3c12f2a8dedfa7568dd160'),
('register_cell', 0x479800, 0x47991C, '078ce274b0135b7fb28ada2e1fb171817683d1435a96916e22253466956b0044'),
('polygon_filter', 0x4797A0, 0x4797FD, 'a654906ad9c89a4744e78eee2a1745e59f9978ed4d28948d18e2a14abba2f63a'),
('corner_accessor', 0x477F10, 0x477F5F, 'b5460f170b2315a462700d585b0626321186977a7bc192ede831a1e1ba60677c'),
)
SITES = (
('delta_magnitude', 0x47B4BB, 'ff1504d14800'),
('force_static_processing_field', 0x47B4C9, '8a812c04000084c07515'),
('epsilon_threshold', 0x47B4D7, 'd81d405e4d00dfe0f6c4010f8599030000'),
('dispatcher_call_statistic', 0x47B4E8, '8b15785d6900'),
('candidate_x', 0x47B507, 'd803d95c2434'),
('candidate_y', 0x47B511, 'd84304d95c2438'),
('candidate_z', 0x47B51C, 'd84308d95c243c'),
('radius_getter', 0x47B523, 'ff9060020000'),
('expansion_radius_plus_magnitude', 0x47B529, 'd9542420d844241c'),
('x_upper_uses_max', 0x47B59B, '663bc78944241c7f04897c241c'),
('z_upper_uses_min', 0x47B61B, '663bf8897c2418ddd87c0489442418'),
('wall_grid_cell', 0x47B697, '8b048d249b5000'),
('per_node_collision_gate', 0x47B6B2, '803de5694f0000'),
('allow_lower_edges', 0x47B6F4, 'c705745d690001000000'),
('forward_edges_flag', 0x47B6FE, '8b442470'),
('call_polygon_wrapper', 0x47B72E, 'e87d040000'),
('clear_lower_edges', 0x47B742, 'c705745d690000000000'),
('next_fifo_node', 0x47B74C, '8b6d00'),
('increment_z', 0x47B76A, '4241663b542418'),
('increment_x', 0x47B77F, '4681c704010000'),
('retry_flag_branch', 0x47B799, '8a44241384c00f8597000000'),
('publish_candidate_x', 0x47B7B1, '8903'),
('publish_candidate_yz', 0x47B7B7, '894b04895308'),
('last_accepted_polygon', 0x47B7C0, '8b0d4c5d6900'),
('last_normal_threshold', 0x47B7E3, 'd81d48314a00'),
('normal_callback374', 0x47B80F, 'ff9774030000'),
('normal_callback370', 0x47B82E, 'ff9770030000'),
('retry_delta_x', 0x47B83C, 'd9442434d823'),
('retry_call_same_dispatcher', 0x47B877, '5350e832fcffff'),
('wrapper_stores_last_polygon_and_retry', 0x47BD65, '89354c5d6900c60101'),
('physics_clear_last_polygon', 0x47A038, '891d4c5d6900'),
('physics_face_distance130000', 0x47A03E, 'c7055c5d690000e8fd47'),
('physics_edge_distance_radius', 0x47A062, 'd91de0fb5c00'),
('dynamic_face_distance_minus1', 0x47AB4B, 'c7055c5d6900000080bf'),
('dynamic_reclip_edges_false', 0x47B30B, '6a00'),
('dynamic_reclip_dispatch', 0x47B364, 'e847010000'),
('registration_checkpoint_filter', 0x4791C9, 'e8f2020000'),
('registration_game_filter', 0x4791DB, 'e8c0050000'),
('registration_polygon_order', 0x479479, '83c530'),
('game_polygon_consumer', 0x4797EC, 'ff9234010000'),
('cell_duplicate_polygon_only', 0x47985E, '8b55008b78083b17'),
('cell_fifo_append', 0x47989F, '8958048947048b48048901'),
('wall_normal_strict', 0x4798BD, 'd81d74d94800'),
('corner_records_stride20', 0x477F1C, '8d04808b5124'),
('shape_vertices_pointer', 0x477F29, '8b5168c1e00403c2'),
)
SCALE = struct.unpack('<f', struct.pack('<f', .002))[0]
EPSILON = struct.unpack('<f', bytes.fromhex('00000034'))[0]
def cell(value):
value = math.trunc(value*SCALE+130)
return (value+32768) % 65536 - 32768
def traversal_bounds(previous, delta, radius, magnitude):
"""Source bounds with supplied quick_magnitude result; x87 boundaries unprobed."""
extent = radius+magnitude
candidate = tuple(a+b for a, b in zip(previous, delta, strict=True))
x0, x1 = cell(previous[0]-extent), cell(candidate[0]-extent)
x2, x3 = cell(previous[0]+extent), cell(candidate[0]+extent)
z0, z1 = cell(previous[2]-extent), cell(candidate[2]-extent)
z2, z3 = cell(previous[2]+extent), cell(candidate[2]+extent)
return min(x0,x1), max(x2,x3), min(z0,z1), min(z2,z3)
def cells(bounds):
x0, x1, z0, z1 = bounds
return [(x,z) for x in range(max(0,x0), min(259,x1)+1)
for z in range(max(0,z0), min(259,z1)+1)]
def visits(grid, bounds):
"""Frozen-cell order, including repeated registrations in different cells."""
return [(xy, polygon) for xy in cells(bounds) for polygon in grid.get(xy, ())]
def append_registration(grid, xy, polygon, shape):
"""479800 compares polygon identity alone within one cell, then appends FIFO."""
registered = grid.setdefault(xy, [])
if any(item[0] == polygon for item in registered):
return False
registered.append((polygon, shape))
return True
@dataclass
class NearestProjection:
face: float
edge: float
last_polygon: int | None = None
def scan_projection(grid, bounds, candidate, nearest, visitor):
"""One dispatcher pass with an injected narrowphase; not original execution."""
changed = False
for xy, polygon in visits(grid, bounds):
candidate, hit = visitor(xy, polygon, candidate, nearest)
changed |= hit
if hit:
nearest.last_polygon = polygon[0]
return candidate, changed
def collect(root):
pe = PE(find_case(Path(root), 'Neutron.exe'))
if hashlib.sha256(pe.data).hexdigest() != EXE_SHA256:
raise ValueError('Unsupported original EXE')
sites, bodies = [], []
for name, va, expected in SITES:
actual = read_va(pe, va, len(bytes.fromhex(expected))).hex()
if actual != expected:
raise ValueError(f'{name} changed at {va:#x}: {actual}')
sites.append(dict(name=name, va=hex(va), file_offset=hex(pe.offset(va-pe.base)), bytes=actual))
for name, begin, end, expected in BODIES:
digest = hashlib.sha256(read_va(pe, begin, end-begin)).hexdigest()
if digest != expected:
raise ValueError(f'{name} body changed: {digest}')
bodies.append(dict(name=name, va=hex(begin), file_offset=hex(pe.offset(begin-pe.base)), length=end-begin, sha256=digest))
return dict(sha256=EXE_SHA256, sites=sites, bodies=bodies,
constants={hex(a):struct.unpack('<f',read_va(pe,a,4))[0] for a in (0x4D5E40,0x4D6A04,0x49B1FC,0x4A3148)},
scope='Static source-byte checks and local algorithm projection; no original grid execution.')
if __name__ == '__main__':
cli = argparse.ArgumentParser(description=__doc__)
cli.add_argument('original', type=Path)
print(json.dumps(collect(cli.parse_args().original), indent=2))