Пример #1
0
                 construct.ULInt32('attr_unknown_4')),
    construct.ULInt32('size'),
    construct.If(lambda ctx: ctx.size > 0,
                 construct.Embed(VAULT_ATTRIBUTE_ENCRYPTED)),
    construct.Anchor('stream_end'))

VAULT_ATTRIBUTE_EXTRA = construct.Struct('VAULT_ATTRIBUTE_EXTRA',
                                         construct.ULInt32('id'),
                                         construct.ULInt32('attr_unknown_1'),
                                         construct.ULInt32('attr_unknown_2'),
                                         construct.Embed(SIZED_DATA))

VAULT_ATTRIBUTE_MAP_ENTRY = construct.Struct(
    'VAULT_ATTRIBUTE_MAP_ENTRY', construct.ULInt32('id'),
    construct.ULInt32('offset'), construct.ULInt32('attr_map_entry_unknown_1'),
    construct.Pointer(lambda ctx: ctx.offset, VAULT_ATTRIBUTE))

VAULT_VCRD = construct.Struct(
    'VAULT_VCRD', GUID('schema_guid'), construct.ULInt32('vcrd_unknown_1'),
    FILETIME('last_update'), construct.ULInt32('vcrd_unknown_2'),
    construct.ULInt32('vcrd_unknown_3'),
    construct.Rename('description', UNICODE_STRING),
    construct.ULInt32('attributes_array_size'),
    construct.Value(
        'attributes_num', lambda ctx:
        (ctx.attributes_array_size / VAULT_ATTRIBUTE_MAP_ENTRY.sizeof())),
    construct.Rename(
        'attributes',
        construct.Array(lambda ctx: ctx.attributes_num,
                        VAULT_ATTRIBUTE_MAP_ENTRY)),
    construct.Pointer(
Пример #2
0
        "minor" / c.Int8ul,
    ),
    "vendor_sigs_required" / c.Int8ul,
    "vendor_sigs_n" / c.Rebuild(c.Int8ul, c.len_(c.this.pubkeys)),
    "vendor_trust" / VendorTrust,
    "reserved" / c.Padding(14),
    "pubkeys" / c.Bytes(32)[c.this.vendor_sigs_n],
    "vendor_string" / c.Aligned(4, c.PascalString(c.Int8ul, "utf-8")),
    "vendor_image" / Toif,
    "_data_end_offset" / c.Tell,
    c.Padding(-(c.this._data_end_offset + 65) % 512),
    "sigmask" / c.Byte,
    "signature" / c.Bytes(64),
    "_end_offset" / c.Tell,
    "header_len" /
    c.Pointer(c.this._start_offset + 4,
              c.Rebuild(c.Int32ul, c.this._end_offset - c.this._start_offset)),
)

VersionLong = c.Struct(
    "major" / c.Int8ul,
    "minor" / c.Int8ul,
    "patch" / c.Int8ul,
    "build" / c.Int8ul,
)

FirmwareHeader = c.Struct(
    "_start_offset" / c.Tell,
    "magic" / c.Const(b"TRZF"),
    "_header_len" / c.Padding(4),
    "expiry" / c.Int32ul,
    "code_length" / c.Rebuild(
Пример #3
0
 def _parse(self, stream, context, path):
     ptrVal = super()._parse(stream, context, path)
     return C.Pointer(ptrVal, self.pointed)._parse(stream, context, path)
Пример #4
0
import construct as cs
import construct_typed as cst
import dataclasses
import typing as t
from . import GalleryItem

constr = cs.Struct(
    "signature" / cs.Bytes(23),
    "data_start_pos" / cs.Tell,
    "data_peek" / cs.Peek(cs.Array(5, cs.Int24ub)),
    cs.Seek(15, 1),
    "pos_after_seek" / cs.Tell,
    "data_pointer" /
    cs.Pointer(lambda ctx: ctx.data_start_pos, cs.Array(5, cs.Int24ub)),
)

gallery_item = GalleryItem(
    construct=constr,
    example_binarys={
        "Zeros": bytes(23 + 15),
        "1": b"TestPointerPeekSeekTell0123456789abcde",
    },
)
Пример #5
0
            default=C.StopFieldError)[this._count],
    )


# Top-level stuff
Header = Struct(
    "sig" / Byte[4],
    "version" / Int16ul,
    "type" / Int16ul,
    "_classCountPos" / C.Tell,
    "_classCount" / C.Rebuild(Int64ul, lambda _: 0),
)

topLevel = Struct(
    "header" / Header, "defs" / ClassDefinitionList, "root" / ClassEntry(),
    C.Pointer(this.header._classCountPos, C.Rebuild(Int64ul, varHandling)))


def filterVariables(node):
    if isinstance(node, dict):
        for key in {**node}:
            if isinstance(key, str) and key.startswith("_"):
                node.pop(key)
        for key in node:
            filterVariables(node[key])
    if isinstance(node, list):
        for val in node:
            filterVariables(val)
    return

Пример #6
0
)

MetaFrameIndex = lambda x: C.Struct("frameIndices" / C.Int32sl[x])
MapIndex = C.Struct("mapIndices" / C.Int32sl[4])
Group = C.Struct(
    "frameDataOffset" / C.Int64sl,
    "frameCount" / C.Int64sl,
    "frameIndexOffset" / C.Int64sl,
    "frameIndexCount" / C.Int64sl,
    "dataOffset" / C.Int64sl,
    "mapCount" / C.Int64sl,
    "unkn32_0" / C.Float32l,
    "unkn32_1" / C.Float32l,
    "unkn3" / C.Int64sl,
    "frameData" /
    C.Pointer(C.this.frameDataOffset, Primary[C.this.frameCount]),
    "frameIndex" /
    C.Pointer(C.this.frameIndexOffset,
              C.Int32sl[C.this.frameIndexCount]),  #32-Padded to next
    "mapIndices" /
    C.IfThenElse(C.this.frameCount != 0,
                 C.Pointer(C.this.dataOffset, C.Int32sl[4]), C.Int32sl[0]),
)


def defaultMapIndices(l):
    return l + [0] * (4 - len(l))


StringHead = C.Struct("blank" / C.Int64sl, "stringOffset" / C.Int64sl,
                      "type" / C.Int32sl)
Пример #7
0
    cons.ULInt32('offset'),
    cons.ULInt32('size'),
    #    cons.OnDemand(
    #        cons.Pointer(lambda ctx: ctx['offset'],
    #            cons.MetaField('data', lambda ctx: ctx['size'])
    #        )
    #    )
    # We're not parsing it on demand anymore cause we don't want
    # construct to keep a reference to the file stream forever.
)

TABLE = cons.Struct(
    'tables', cons.ULInt32('resource_type'), cons.ULInt32('offset'),
    cons.ULInt32('number_of_files'),
    cons.Pointer(lambda ctx: ctx['offset'],
                 cons.Array(lambda ctx: ctx['number_of_files'],
                            EMBEDDED_FILE)))

HEADER = cons.Struct(
    'header',
    cons.String('copyright', 40, padchar='\0'),
    cons.String('version', 4),
    cons.String('file_type', 12, padchar='\0'),
    cons.ULInt32('number_of_tables'),
    cons.ULInt32('offset'),
    cons.Array(lambda ctx: ctx['number_of_tables'], TableAdapter(TABLE)),
)


def get_file_extension(resource_type):
    """
Пример #8
0
    "vendor_sigs_required" / c.Int8ul,
    "vendor_sigs_n" / c.Rebuild(c.Int8ul, c.len_(c.this.pubkeys)),
    "vendor_trust" / VendorTrust,
    "reserved" / c.Padding(14),
    "pubkeys" / c.Bytes(32)[c.this.vendor_sigs_n],
    "vendor_string" / c.Aligned(4, c.PascalString(c.Int8ul, "utf-8")),
    "vendor_image" / Toif,
    "_data_end_offset" / c.Tell,

    c.Padding(-(c.this._data_end_offset + 65) % 512),
    "sigmask" / c.Byte,
    "signature" / c.Bytes(64),

    "_end_offset" / c.Tell,
    "header_len" / c.Pointer(
        c.this._start_offset + 4,
        c.Rebuild(c.Int32ul, c.this._end_offset - c.this._start_offset)
    ),
)


VersionLong = c.Struct(
    "major" / c.Int8ul,
    "minor" / c.Int8ul,
    "patch" / c.Int8ul,
    "build" / c.Int8ul,
)


FirmwareHeader = c.Struct(
    "_start_offset" / c.Tell,
    "magic" / c.Const(b"TRZF"),
Пример #9
0
    'VAULT_ATTRIBUTE_EXTRA', construct.ULInt32('id'),
    construct.ULInt32('attr_unknown_1'), construct.ULInt32('attr_unknown_2'),
    construct.ULInt32('size'),
    construct.If(lambda ctx: ctx.size > 0,
                 construct.Embed(VAULT_ATTRIBUTE_ENCRYPTED)))

# VCRD Mapping.

VAULT_ATTRIBUTE_MAP_COMMON = construct.Struct(
    'VAULT_ATTRIBUTE_MAP_COMMON', construct.ULInt32('id'),
    construct.ULInt32('offset'),
    construct.ULInt32('attr_map_common_unknown_1'))

VAULT_ATTRIBUTE_MAP_ENTRY = construct.Struct(
    'VAULT_ATTRIBUTE_MAP_ENTRY', construct.Embed(VAULT_ATTRIBUTE_MAP_COMMON),
    construct.Pointer(lambda ctx: ctx.offset, VAULT_ATTRIBUTE))

VAULT_ATTRIBUTE_MAP_LAST = construct.Struct(
    'VAULT_ATTRIBUTE_MAP_LAST', construct.Embed(VAULT_ATTRIBUTE_MAP_COMMON),
    construct.Pointer(lambda ctx: ctx.offset, VAULT_ATTRIBUTE_EX))

# Ok, this is bad, but till now I have not understood how to distinguish
# the different structs used. Actually the last ATTRIBUTE is different.

VAULT_ATTRIBUTES_MAP = construct.Struct(
    'VAULT_ATTRIBUTES_MAP',
    construct.Rename(
        'entries',
        construct.Array(lambda ctx: ctx.attributes_num,
                        VAULT_ATTRIBUTE_MAP_ENTRY)))