mirror of
https://github.com/morluto/rea.git
synced 2026-10-26 17:35:11 +00:00
gensokyo-dev
4a041ae753
* perf(artifacts): read stable files into one bounded buffer * perf(artifacts): fill stable snapshots through direct descriptor reads * docs(perf): qualify stable snapshot memory with real ELF and BEAM tasks * test(artifacts): count descriptor close retries from admission * test(artifacts): capture the retained descriptor after asynchronous admission * docs(perf): record integrated qualification and cleanup fixture correction
109 lines
5.1 KiB
Python
109 lines
5.1 KiB
Python
"""Independent ELF64 little-endian note oracle for the fixed Linux corpus."""
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import struct
|
|
|
|
|
|
def inspect(path):
|
|
before = path.stat()
|
|
data = path.read_bytes()
|
|
header = struct.unpack_from('<16sHHIQQQIHHHHHH', data)
|
|
ident, kind, machine, version, _, phoff, shoff, _, _, phsize, phnum, shsize, shnum, names_index = header
|
|
assert ident[:7] == b'\x7fELF\x02\x01\x01' and version == 1 and kind == 3
|
|
assert phsize == 56 and shsize == 64 and 0 < phnum < 65535 and 0 < shnum < 65535
|
|
sections = [struct.unpack_from('<IIQQQQIIQQ', data, shoff + i * shsize) for i in range(shnum)]
|
|
names = sections[names_index]
|
|
assert names[1] == 3 and not names[2] & 0x800
|
|
strings = data[names[4]:names[4] + names[5]]
|
|
tables = []
|
|
for i in range(phnum):
|
|
program = struct.unpack_from('<IIQQQQQQ', data, phoff + i * phsize)
|
|
if program[0] == 4:
|
|
assert program[7] in [4, 8]
|
|
tables.append({'kind':'program','index':i,'name':None,'location':{'offset':program[2],'bytes':program[5]},'alignment':program[7]})
|
|
for i, section in enumerate(sections):
|
|
if section[1] == 7:
|
|
assert section[8] in [4, 8] and not section[2] & 0x800
|
|
name_end = strings.index(0, section[0])
|
|
tables.append({'kind':'section','index':i,'name':strings[section[0]:name_end].decode('ascii'),'location':{'offset':section[4],'bytes':section[5]},'alignment':section[8]})
|
|
entries = []
|
|
type_names = {1:'gnu_abi_tag',2:'gnu_hwcap',3:'gnu_build_id',4:'gnu_gold_version',5:'gnu_property'}
|
|
for table in tables:
|
|
pos = table['location']['offset']
|
|
end = pos + table['location']['bytes']
|
|
alignment = table['alignment']
|
|
while pos < end:
|
|
namesz, descsz, tag = struct.unpack_from('<III', data, pos)
|
|
descriptor_offset = ((12 + namesz + alignment - 1) // alignment) * alignment
|
|
next_offset = ((descriptor_offset + descsz + alignment - 1) // alignment) * alignment
|
|
assert pos + next_offset <= end and namesz == 4 and descsz <= 64
|
|
owner = data[pos + 12:pos + 12 + namesz]
|
|
assert owner == b'GNU\0'
|
|
descriptor = data[pos + descriptor_offset:pos + descriptor_offset + descsz]
|
|
gnu = {'build_id_hex':None,'abi_tag':None,'gold_version':None}
|
|
if tag == 3:
|
|
gnu['build_id_hex'] = descriptor.hex()
|
|
elif tag == 4:
|
|
gnu['gold_version'] = descriptor.split(b'\0', 1)[0].decode('ascii')
|
|
elif tag == 1:
|
|
os_id, major, minor, subminor = struct.unpack('<IIII', descriptor)
|
|
assert os_id == 0
|
|
gnu['abi_tag'] = {'os':os_id,'os_name':'linux','major':major,'minor':minor,'subminor':subminor}
|
|
entries.append({
|
|
'index': len(entries),
|
|
'table_kind': table['kind'],
|
|
'table_index': table['index'],
|
|
'location': {'offset': pos, 'bytes': next_offset},
|
|
'namesz': namesz,
|
|
'descsz': descsz,
|
|
'type': tag,
|
|
'type_name': type_names.get(tag, 'unknown'),
|
|
'owner': 'GNU',
|
|
'owner_bytes_hex': owner.hex(),
|
|
'descriptor': {
|
|
'location': {'offset': pos + descriptor_offset, 'bytes': descsz},
|
|
'bytes': descsz,
|
|
'sha256': hashlib.sha256(descriptor).hexdigest(),
|
|
'hex': descriptor.hex(),
|
|
},
|
|
'gnu': gnu,
|
|
})
|
|
pos += next_offset
|
|
assert pos == end
|
|
after = path.stat()
|
|
assert (before.st_dev,before.st_ino,before.st_size,before.st_mtime_ns,before.st_ctime_ns) == (after.st_dev,after.st_ino,after.st_size,after.st_mtime_ns,after.st_ctime_ns)
|
|
return {
|
|
'artifact': {'path': str(path), 'sha256': hashlib.sha256(data).hexdigest(), 'bytes': len(data)},
|
|
'format': 'elf64',
|
|
'byte_order': 'little',
|
|
'machine': machine,
|
|
'type': kind,
|
|
'type_name': 'shared',
|
|
'tables': tables,
|
|
'entries': entries,
|
|
'coverage': {'status': 'complete', 'examined_tables': len(tables), 'examined_entries': len(entries)},
|
|
}
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument('--path', type=Path, required=True)
|
|
parser.add_argument('--output', type=Path, required=True)
|
|
args = parser.parse_args()
|
|
assert args.path.is_absolute()
|
|
expected = inspect(args.path)
|
|
result = {
|
|
'operation': 'inspect_elf_notes',
|
|
'input': {'path': str(args.path), 'max_file_bytes': 268435456},
|
|
'expected': expected,
|
|
'question': 'Return every declared ELF note table and note, preserving program/section identity, file ranges, raw owner bytes, descriptor digests, GNU fields and complete source Evidence.',
|
|
}
|
|
args.output.write_text(json.dumps(result,indent=2)+'\n')
|
|
print(json.dumps({'artifact':expected['artifact'],'tables':len(expected['tables']),'entries':len(expected['entries'])}))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|