def PrefixedBytes(lengthfield): """ Defines a length prefixed bytearray. Args: lengthfield (:class:`Subconstruct`): The length subcon. Returns: PrefixedBytes: A length prefixed bytesarray """ return construct.Prefixed(lengthfield, construct.GreedyBytes)
high = obj >> 32 IdaVarInt32._build(high, stream, context, path) return obj ####################################### # # Basic types & helpers # ####################################### # String prefixed with a variable int size VarString = con.PascalString(IdaVarInt32, "utf8") # Bytes buffer prefixed with a variable int size VarBuff = con.Prefixed(IdaVarInt32, con.GreedyBytes) # IDA typedefs ea_t = asize_t = adiff_t = con.ExprAdapter(IdaVarInt64, con.obj_ - 1, con.obj_ + 1) # "template" for defining object list, prefixed with a variable int size def ObjectList(obj): return con.PrefixedArray(IdaVarInt32, obj) ####################################### # # Lumina types # #######################################
construct.Aligned( 3, construct.Struct( header=construct.BitStruct( has_seed_hash=construct.Rebuild( construct.Flag, construct.this._.seed_hash != None), bytes_rotation=construct.Rebuild( construct.BitsInteger(7), lambda ctx: single_byte_hash(ctx._.generator_params) >> 1, )), seed_hash=construct.If(construct.this.header.has_seed_hash, construct.Bytes(5)), randovania_version=construct.Bytes(4), # short git hash generator_params=construct.ExprAdapter( construct.Prefixed(construct.VarInt, construct.GreedyBytes), # parsing decoder=create_rotator(inverse=True), # building encoder=create_rotator(inverse=False), ), ))), permalink_checksum=construct.Checksum( construct.Bytes(2), lambda data: hashlib.blake2b(data, digest_size=2).digest(), construct.this.fields.data, ), end=construct.Terminated, )
import construct as c from . import CompactUint, ConstFlag, Optional BitcoinBytes = c.Prefixed(CompactUint, c.GreedyBytes) """Bitcoin string of bytes. Encoded as a CompactUint length followed by that many bytes. """ TxHash = c.Transformed(c.Bytes(32), lambda b: b[::-1], 32, lambda b: b[::-1], 32) """Transaction hash, encoded as a reversed sequence of bytes.""" TxInput = c.Struct( "tx" / TxHash, "index" / c.Int32ul, "script_sig" / BitcoinBytes, "sequence" / c.Int32ul, ) """Transaction input.""" TxOutput = c.Struct("value" / c.Int64ul, "script_pubkey" / BitcoinBytes) """Transaction output.""" TxInputWitness = c.PrefixedArray(CompactUint, BitcoinBytes) """Array of witness records.""" Transaction = c.Struct( "version" / c.Int32ul, "segwit" / ConstFlag(b"\x00\x01"), "inputs" / c.PrefixedArray(CompactUint, TxInput),
super().__init__(c.Optional(c.Const(const))) def _encode(self, obj, context, path): return self.const if obj else None def _decode(self, obj, context, path): return obj is not None CompactUint = CompactUintAdapter(CompactUintStruct) TxInput = c.Struct( "tx" / c.Bytes(32), "index" / c.Int32ul, # TODO coinbase tx "script" / c.Prefixed(CompactUint, c.GreedyBytes), "sequence" / c.Int32ul, ) TxOutput = c.Struct( "value" / c.Int64ul, "pk_script" / c.Prefixed(CompactUint, c.GreedyBytes), ) StackItem = c.Prefixed(CompactUint, c.GreedyBytes) TxInputWitness = c.PrefixedArray(CompactUint, StackItem) Transaction = c.Struct( "version" / c.Int32ul, "segwit" / ConstFlag(b"\x00\x01"), "inputs" / c.PrefixedArray(CompactUint, TxInput),
u8 = partial(unsigned, 8) u16 = partial(unsigned, 16) u32 = partial(unsigned, 32) u64 = partial(unsigned, 64) i8 = partial(signed, 8) i16 = partial(signed, 16) i32 = partial(signed, 32) i64 = partial(signed, 64) string = partial(attribute, construct.PascalString(construct.Int16ul, "utf8"), str) data = partial( attribute, construct.Prefixed(construct.Int32ul, construct.GreedyBytes), bytes ) def enum(constructor, type, **kwargs): return attribute(constructor, type, converter=type, **kwargs) def struct(type, **kwargs): return attribute(type._construct, type, converter=lambda x: type(**x), **kwargs) def constructify(class_): """ A decorator that assembles the individual field constructs into one Struct construct. """
_is_init_reply = _create_matcher(_INIT_RESPONSE, b'\x01') _is_keepalive_response = _create_matcher(_KEEPALIVE_RESPONSE, b'\x05') _is_uknown_message_error = _create_matcher(_UNKNOWN_MESSAGE_RESPONSE, b'\x85') _is_encryption_missing_error = _create_matcher(_ENCRYPTION_SETUP_RESPONSE, b'\x15') _is_encryption_setup_error = _create_matcher(_ENCRYPTION_SETUP_RESPONSE, b'\x14') _FREESTYLE_MESSAGE = construct.Struct( 'hid_report' / construct.Const(0, construct.Byte), 'message_type' / construct.Byte, 'command' / construct.Padded( 63, # command can only be up to 62 bytes, but one is used for length. construct.Prefixed(construct.Byte, construct.GreedyBytes)), ) _FREESTYLE_ENCRYPTED_MESSAGE = construct.Struct( 'hid_report' / construct.Const(0, construct.Byte), 'message_type' / construct.Byte, 'command' / construct.Padded( 63, # command can only be up to 62 bytes, but one is used for length. construct.GreedyBytes), ) _TEXT_COMPLETION_RE = re.compile(b'CMD (?:OK|Fail!)') _TEXT_REPLY_FORMAT = re.compile( b'^(?P<message>.*)CKSM:(?P<checksum>[0-9A-F]{8})\r\n' b'CMD (?P<status>OK|Fail!)\r\n$', re.DOTALL)
TOKEN_CON, "command_data_length" / construct.Rebuild( construct.Int16ub, construct.len_(construct.this.command_data) ), construct.Const(bytes([0x00, 0x00])), "command_data" / construct.Byte[construct.this.command_data_length], ), ) MSC_TRANSPORT_RESPONSE_PACKET = construct.Padded( BLOCK_SIZE, construct.Struct( HEADER_CON, RANDOM_TOKEN_CON, "response_data" / construct.Prefixed(construct.Int16ub, construct.GreedyBytes), ), ) def _format_hex_for_log(data: bytes, length=200) -> str: return " ".join(re.findall("....", data.hex()[:length])) class MscTransport: """Transport adapter that implements the mass storage class (MSC) interface to the TSE. This transport adapter uses a single file in the root directory of the user-accessible portion of the TSE, named ``TSE-IO.bin``, for communication. By writing to and reading from this file (bypassing OS buffers) request/response cycles can be exchanged with the TSE."""
"_unknData" / C.Default(Byte[69], [0 for _ in range(69)]), ) ClassDefinition = DataPointer( Int64ul, Struct("hash" / Int64ul, "members" / C.PrefixedArray(Int64ul, ClassMemberDefinition)), "definitionData") ClassDefinitionList = C.FocusedSeq( "definitions", "_count" / C.Rebuild(Int32ul, C.len_(this.definitions)), "definitions" / C.Prefixed( Int32ul, C.Aligned( 8, C.FocusedSeq( "definitions", "definitions" / ClassDefinition[this._._count], DataEntries("definitionData"), DataEntries("names"), )))) # Hierarchy handling varcount = 0 def varHandling(this): global varcount ret = varcount varcount += 1 return ret
import functools import socket import construct try: import anyio except ImportError: ASYNC_AVAILABLE = False else: ASYNC_AVAILABLE = True PACKET_PARSER = construct.GreedyRange( construct.Prefixed( construct.Int32sl, construct.Struct("id" / construct.Int32sl, "type" / construct.Int32sl, "body" / construct.CString("utf8"), construct.Default(construct.CString("utf8"), "")))) class RCONBaseError(Exception): """Exception base for all exceptions in this library""" class ClientBusy(RCONBaseError): """Client is already busy with another call""" class InvalidPassword(RCONBaseError): """RCON password is incorrect"""
def struct(cls): return construct.Struct( "signature" / construct.Const(b"vf"), "version" / _LMArchiveVersionValidator(construct.Int32ul), "count" / construct.Int32ul, "filenames" / construct.Array( construct.this.count, construct.IfThenElse( construct.this.version >= 100, construct.Prefixed( construct.Int32ul, construct.Transformed( construct.GreedyString('cp932'), LMObfuscator().transform_bytes, None, LMObfuscator().transform_bytes, None, ), ), construct.PascalString(construct.Int32ul, 'cp932'), )), "offsets" / construct.Array( construct.this.count + 1, construct.Struct( "offset_low" / construct.IfThenElse( construct.this._.version >= 100, construct.Transformed( construct.Int32ul, LMObfuscator().transform_int, 4, LMObfuscator().transform_int, 4, ), construct.Int32ul, ), # offset_high always 0 if ver < 101 "offset_high" / construct.IfThenElse( construct.this._.version >= 101, construct.Transformed( construct.Int32ul, LMObfuscator().transform_int, 4, LMObfuscator().transform_int_high, 4, ), construct.Int32ul, ), ), ), "compress_types" / construct.Array(construct.this.count, construct.Enum(construct.Byte, LMCompressType)), "unk1s" / construct.Array( construct.this.count, # construct.Transformed( # construct.Int32ul, # LMObfuscator().transform_int, # 4, # LMObfuscator().transform_int, # 4, # ), construct.Int32ul, ), "checksums" / construct.Array( construct.this.count, construct.Int32ul, ), "encrypt_flags" / construct.Array( construct.this.count, construct.Byte, ), )
construct.PascalString(construct.Int16ub, 'utf-8'))), })) RequestPacket = construct.Struct( 'request_type' / construct.Enum(construct.Int8ub, RequestType), 'data' / construct.Switch( lambda ctx: int(ctx.request_type), { RequestType.UPLOAD_IDB_START.value: construct.Struct( 'idb_name' / construct.PascalString(construct.Int16ub, 'utf-8'), 'idb_hash' / construct.Bytes(SHA1_HASH_BYTES_LENGTH), 'idb_size' / construct.Int32ub), RequestType.IDB_CHUNK.value: construct.Struct('data' / construct.Prefixed( construct.VarInt, construct.Compressed(construct.GreedyBytes, 'zlib'))), RequestType.DOWNLOAD_IDB_START.value: construct.Struct('idb_name' / construct.PascalString( construct.Int16ub, 'utf-8')), RequestType.GET_ALL_IDBS_RESPONSE.value: construct.GreedyRange( construct.Struct( "name" / construct.PascalString(construct.VarInt, "utf-8"), "size" / construct.Int32ub)) })) RevetherPacket = construct.Struct( 'header' / construct.Struct( 'version' / construct.Const(LATEST_VERSION, construct.Int8ub), 'type' / construct.Enum(construct.Int8ub, PacketType),
@attr.s class Stat: type = u16() dev = u16() qid = struct(Qid) mode = file_mode() atime = u32() mtime = u32() length = u64() name = string() uid = string() gid = string() muid = string() Stat._construct = construct.Prefixed( construct.Int16ul, construct.Prefixed(construct.Int16ul, Stat._construct)) # Tversion tag[2] msize[4] version[s] # Rversion tag[2] msize[4] version[s] @constructify @attr.s class Version: tag = u16() msize = u32() version = string() Tversion = Version Rversion = Version
import os, sys, binascii from io import BytesIO import construct as c from formats.compact_uint import CompactUint from formats.transaction import Transaction from formats import bip174, protobuf HARDENED_FLAG = 1 << 31 # current key-value based format: KeyValue = c.Struct( "key" / c.Prefixed(CompactUint, c.Struct( "type" / c.Byte, "data" / c.GreedyBytes, )), "value" / c.Prefixed(CompactUint, c.GreedyBytes), "ofs" / c.Tell, ) Sequence = c.FocusedSeq("content", "content" / c.GreedyRange( c.FocusedSeq( "keyvalue", "terminator" / c.Peek(c.Byte), c.StopIf(c.this.terminator == 0), "keyvalue" / KeyValue, ) ), c.Const(b'\0'),
from . import CompactUint, Optional from .transaction import Transaction, TxOutput PSBT_PROPRIETARY_BYTE = 0xFC class PsbtError(Exception): pass # fmt: off PsbtKeyValue = c.Struct( "key" / c.Prefixed( CompactUint, c.Struct( "type" / CompactUint, "data" / Optional(c.GreedyBytes), )), "value" / c.Prefixed(CompactUint, c.GreedyBytes), ) PsbtProprietaryKey = c.Struct( "prefix" / c.CString("utf-8"), "subtype" / CompactUint, "data" / Optional(c.GreedyBytes), ) PsbtSequence = c.FocusedSeq( "content", "content" / c.GreedyRange(PsbtKeyValue), c.Const(b"\0"),
with the added twist that 0 means set and 1 means unset. We feed it to a `BitStruct` that expects a big-endian sequence where bits have the traditional meaning. We must therefore do a bitwise negation of each byte, and return them in reverse order. This is the same transformation both ways, fortunately, so we don't need two separate functions. """ return bytes(~b & 0xFF for b in data)[::-1] # fmt: off Toif = c.Struct( "magic" / c.Const(b"TOI"), "format" / c.Enum(c.Byte, full_color=b"f", grayscale=b"g"), "width" / c.Int16ul, "height" / c.Int16ul, "data" / c.Prefixed(c.Int32ul, c.GreedyBytes), ) VendorTrust = c.Transformed( c.BitStruct( "reserved" / c.Default(c.BitsInteger(9), 0), "show_vendor_string" / c.Flag, "require_user_click" / c.Flag, "red_background" / c.Flag, "delay" / c.BitsInteger(4), ), _transform_vendor_trust, 2, _transform_vendor_trust, 2) VendorHeader = c.Struct( "_start_offset" / c.Tell, "magic" / c.Const(b"TRZV"), "_header_len" / c.Padding(4),
TransportDataTupleType = Tuple[TransportDataType, Union[bytes, int, str, List[int]]] TRANSPORT_DATA_PARAMETER = construct.Select( # BYTE construct.Struct( "data_type" / construct.Const(bytes([TransportDataType.BYTE])), construct.Const(bytes([0x00, 0x01])), "data" / construct.Byte, ), # BYTE_ARRAY construct.Struct( "data_type" / construct.Const(bytes([TransportDataType.BYTE_ARRAY])), "data" / construct.Prefixed(construct.Int16ub, construct.GreedyBytes), ), # SHORT construct.Struct( "data_type" / construct.Const(bytes([TransportDataType.SHORT])), construct.Const(bytes([0x00, 0x02])), "data" / construct.Int16ub, ), # STRING construct.Struct( "data_type" / construct.Const(bytes([TransportDataType.STRING])), "data" / construct.Prefixed(construct.Int16ub, construct.GreedyString("ascii")), ), # LONG_ARRAY construct.Struct(