vivisect/vstruct2

Vivisect Structure Definition/Parsing Library

vstruct2's Issues

vbytes default size is 0

This issue can serve as a discussion point for the following behavior, which I was surprised by, and find inconsistent.

An uninitialized vbytes instance emits 0 bytes, while an uninitialized number instance emits a non-zero number of bytes. For example:

import vstruct.types as v_types

# initialized vbytes should have `size` bytes emitted
a = v_types.vbytes(size=8)
a.vsParse(b"\x00" * 8)
assert(len(a.vsEmit()) == 8)  # --> OK

# uninitialized vbytes should have `size` bytes emitted???
b = v_types.vbytes(size=8)
assert(len(b.vsEmit()) == 8)  # --> AssertionError: the size is 0

# initialized uint64 should have 8 bytes emitted
c = v_types.uint64()
c.vsParse(b"\x00" * 8)
assert(len(c.vsEmit()) == 8)  # --> OK

# uninitialized uint64 should have 8 bytes emitted
d = v_types.uint64()
assert(len(d.vsEmit()) == 8)  # --> OK

This surprised me while writing parsers because if I created a new instance of a VStruct that contained both number and vbytes members, I only had to explicitly initialize some of them. (Actually, I started with vstructs that only contained numbers, and didn't have to initialize the struct to emit a buffer of correct length. This changed when I added a vbytes member.)

I think the API would be more consistent if vbytes emitted size 0x00 bytes if its not been initialized; however, I can also understand the argument that structs should be initialized or undefined behavior results.

What are your thoughts?

proposal: add vsCast method

via: vivisect/dissect#1

i had used the following function to cast the bytes from one vstruct to another:

def cast_vstruct(src_instance, dst_instance):
    '''
    load the bytes that back `src_instance` into `dst_instance`.
    note that subsequent changes made to `dst_instance` are not reflected in `src_instance`.
    so this is useful in 'by-value' situations, but not for situations expecting writeback support.
    modifies `dst_instance`. does not modify src_instance.
    type src_instance: v_types.VStruct
    type dst_instance: v_types.VStruct
    '''
    d = src_instance.vsEmit()
    dst_instance.vsParse(d)

a vsCast method on vstruct might enable the passing of the fd/bytes and offset to the destination object, and therefore:

1. be higher performant, since the serialization/deserialization is avoided.
2. support writeback on the destination instance (though this may result in sync issues)