func (s *state) executeLNE(op DW_LNE, length LEB128, br *binary.BinaryReader) error { switch op { case DW_LNE_end_sequence: s.end_sequence = true s.header.matrix = append(s.header.matrix, s.lineEntry) s.reset() case DW_LNE_set_address: var err error if length == 8 { s.address, err = br.Uint64() } else { var v uint32 v, err = br.Uint32() s.address = uint64(v) } s.op_index = 0 return err case DW_LNE_define_file: var fe fileEntry if err := br.ReadInterface(&fe); err != nil { return err } else { s.header.file_names = append(s.header.file_names, fe) } case DW_LNE_set_discriminator: var arg LEB128 if err := br.ReadInterface(&arg); err != nil { return err } s.discriminator = uint(arg) default: panic(fmt.Errorf("%s", op)) } return nil }
func (m *MetadataUtil) ReadIndex(br *binary.BinaryReader, size uint) (uint32, error) { if size != 2 { return br.Uint32() } else if v, e := br.Uint16(); e != nil { return 0, e } else { return uint32(v), nil } }
func LoadAssembly(r io.ReadSeeker) (*Assembly, error) { var ( br = binary.BinaryReader{r, binary.LittleEndian} err error pe_offset uint32 coff coff_file_header cor20 image_cor20 t MetadataHeader ) if _, err := r.Seek(pe_signature_offset, 0); err != nil { return nil, err } if pe_offset, err = br.Uint32(); err != nil { return nil, err } else if _, err := r.Seek(int64(pe_offset), 0); err != nil { return nil, err } if err := br.ReadInterface(&coff); err != nil { return nil, err } net := coff.OptionalHeader.RVAS[14] off := coff.VirtualToFileOffset(net.VirtualAddress) if _, err := br.Seek(int64(off), 0); err != nil { return nil, err } if err := br.ReadInterface(&cor20); err != nil { return nil, err } off = coff.VirtualToFileOffset(cor20.MetaData.VirtualAddress) if _, err := br.Seek(int64(off), 0); err != nil { return nil, err } if err := br.ReadInterface(&t); err != nil { return nil, err } if _, err := br.Seek(int64(off), 0); err != nil { return nil, err } md, err := t.MetadataUtil(&br) if err != nil { return nil, err } a := Assembly{*md, make(map[string]*TypeDef)} idx := ConcreteTableIndex{&a.MetadataUtil, 0, id_TypeDef} for i := uint32(0); i < a.Tables[id_TypeDef].Rows; i++ { idx.index = 1 + i if td, err := TypeDefFromIndex(&idx); err == nil { a.typelut[td.Name().Absolute] = td } } return &a, nil }
func (ih *Header) Read(br *binary.BinaryReader) error { if v, err := br.Uint32(); err != nil { return err } else if v != 0xffffffff { ih.Length = uint64(v) } else if v, err := br.Uint64(); err != nil { return err } else { ih.is64 = true ih.Length = v } var err error ih.Version, err = br.Uint16() return err }
func (ih *InfoHeader) Read(br *binary.BinaryReader) error { err := br.ReadInterface(&ih.Header) if err != nil { return err } if ih.is64 { ih.DebugAbbrevOffset, err = br.Int64() } else { var v uint32 v, err = br.Uint32() ih.DebugAbbrevOffset = int64(v) } if err != nil { return err } ih.AddressSize, err = br.Uint8() return err }
func (mh *MetadataHeader) MetadataUtil(br *binary.BinaryReader) (*MetadataUtil, error) { var ( ret MetadataUtil ) off, err := br.Seek(0, 1) if err != nil { return nil, err } base := off for _, h := range mh.StreamHeaders { switch h.Name { case "#~": off += int64(h.Offset) case "#Strings": if _, err := br.Seek(base+int64(h.Offset), 0); err != nil { return nil, err } else if ret.StringHeap.data, err = br.Read(int(h.Size)); err != nil { return nil, err } ret.StringHeap.Rows = h.Size case "#Blob": if _, err := br.Seek(base+int64(h.Offset), 0); err != nil { return nil, err } else if ret.BlobHeap.data, err = br.Read(int(h.Size)); err != nil { return nil, err } ret.BlobHeap.Rows = h.Size case "#GUID": if _, err := br.Seek(base+int64(h.Offset), 0); err != nil { return nil, err } else if ret.GuidHeap.data, err = br.Read(int(h.Size)); err != nil { return nil, err } ret.GuidHeap.Rows = h.Size } } if _, err := br.Seek(off, 0); err != nil { return nil, err } h := hash_tilde_stream_header{} if err := br.ReadInterface(&h); err != nil { return nil, err } if h.HeapSizes&bit_stringHeapIndexSize != 0 { ret.StringHeap.RowSize = 4 } else { ret.StringHeap.RowSize = 2 } if h.HeapSizes&bit_blobHeapIndexSize != 0 { ret.BlobHeap.RowSize = 4 } else { ret.BlobHeap.RowSize = 2 } if h.HeapSizes&bit_guidHeapIndexSize != 0 { ret.GuidHeap.RowSize = 4 } else { ret.GuidHeap.RowSize = 2 } for i := range ret.Tables { if valid := (h.Valid >> uint(i)) & 1; valid == 0 { continue } if ret.Tables[i].Rows, err = br.Uint32(); err != nil { return nil, err } ret.Tables[i].RowType = table_row_type_lut[i] } for i := range ret.Tables { if ret.Tables[i].Rows == 0 { continue } size, err := ret.Size(ret.Tables[i].RowType) if err != nil { return nil, err } ret.Tables[i].RowSize = uint32(size) if ret.Tables[i].data, err = br.Read(int(ret.Tables[i].RowSize * ret.Tables[i].Rows)); err != nil { return nil, err } } return &ret, nil }
func (t *TextFile) parse(r io.ReadSeeker) (err error) { nifl, err := TagRead(r) if err != nil { return err } if nifl.Tag != "NIFL" { return errors.New("NIFL tag expected") } reader := binary.BinaryReader{Reader: nifl.Data, Endianess: binary.LittleEndian} type niflHeaderType struct { Unk, OffsetREL0, SizeREL0, OffsetNOF0, SizeNOF0 uint32 } var niflHeader niflHeaderType if err = reader.ReadInterface(&niflHeader); err != nil { return err } if niflHeader.Unk != 1 { return errors.New("NIFL header magic != 1") } r.Seek(int64(niflHeader.OffsetREL0), 0) rel0, err := TagRead(r) if rel0.Tag != "REL0" { return errors.New("REL0 tag expected") } var rel0data io.ReadSeeker var rel0strings io.ReadSeeker reader = binary.BinaryReader{Reader: rel0.Data, Endianess: binary.LittleEndian} rel0size, err := reader.Uint32() rel0data = io.NewSectionReader(util.ReaderAt(rel0.Data), 8, int64(rel0size)-8) rel0strings = io.NewSectionReader(util.ReaderAt(rel0.Data), int64(rel0size), int64(rel0.Size-rel0size)) if rel0size < textBufferDataThreshold { rel0data, err = util.MemReader(rel0data) if err != nil { return err } } if rel0.Size-rel0size < textBufferThreshold { rel0strings, err = util.MemReader(rel0strings) if err != nil { return err } } r.Seek(int64(niflHeader.OffsetNOF0), 0) nof0, err := TagRead(r) if nof0.Tag != "NOF0" { return errors.New("NOF0 tag expected") } nof0reader := binary.BinaryReader{Reader: nof0.Data, Endianess: binary.LittleEndian} count, err := nof0reader.Uint32() offsets := make([]uint32, int(count)+1) i := 0 for offset, _ := nof0reader.Uint32(); i < int(count); i++ { end, _ := nof0reader.Uint32() offsets[i] = end - offset offset = end if offsets[i]%4 != 0 { return errors.New("nof0 entry not a multiple of 32 bits") } } offsets[i] = 8 t.Entries = make([]TextEntry, len(offsets)) rel0reader := binary.BinaryReader{Reader: rel0data, Endianess: binary.LittleEndian} pairMode := false var pair *string var pairi int for i, offset := range offsets { entry := &t.Entries[i] entry.Value = make([]uint32, offset/4) for i := 0; i < int(offset/4); i++ { entry.Value[i], err = rel0reader.Uint32() } if entry.Value[0] == 0xffffffff { pairMode = true } else if entry.Value[0] == 0x14 { pairMode = false pair = nil } if len(entry.Value) == 1 && entry.Value[0] != 0xffffffff { rel0strings.Seek(int64(entry.Value[0]-rel0size-8), 0) charSize := 1 if pair != nil { charSize = 2 } entry.Text, _ = readString(charSize, rel0strings) if pair != nil { entry.TextStatus = TextEntryString t.Pairs = append(t.Pairs, TextPair{*pair, entry.Text, pairi, i}) pair = nil } else { entry.TextStatus = TextEntryIdentifier if pairMode { pair = &entry.Text pairi = i } } } } _, err = r.Seek(int64((nof0.Size+8+0x0f)/0x10*0x10)-8, 1) nend, err := TagRead(r) if nend.Tag != "NEND" { return errors.New("NEND tag expected") } return err }
func (ie *InfoEntry) data(form DW_FORM, br binary.BinaryReader) interface{} { if form == DW_FORM_ref_addr && ie.header.Version < 3 { form = DW_FORM_addr } switch form { case DW_FORM_flag_present: return true case DW_FORM_exprloc, DW_FORM_block: var size LEB128 br.ReadInterface(&size) r, _ := br.Read(int(size)) return r case DW_FORM_block1: size, _ := br.Uint8() r, _ := br.Read(int(size)) return r case DW_FORM_block2: size, _ := br.Uint16() r, _ := br.Read(int(size)) return r case DW_FORM_block4: size, _ := br.Uint32() r, _ := br.Read(int(size)) return r case DW_FORM_addr: if ie.header.AddressSize == 8 { v, _ := br.Uint64() return v } else { v, _ := br.Uint32() return uint64(v) } case DW_FORM_ref_addr, DW_FORM_strp, DW_FORM_sec_offset: if ie.header.is64 { v, _ := br.Uint64() return v } else { v, _ := br.Uint32() return uint64(v) } case DW_FORM_ref1, DW_FORM_flag, DW_FORM_data1: v, _ := br.Uint8() return uint64(v) case DW_FORM_ref2, DW_FORM_data2: v, _ := br.Uint16() return uint64(v) case DW_FORM_ref4, DW_FORM_data4: v, _ := br.Uint32() return uint64(v) case DW_FORM_ref8, DW_FORM_data8: v, _ := br.Uint64() return v case DW_FORM_sdata, DW_FORM_udata: var r LEB128 br.ReadInterface(&r) return uint64(r) case DW_FORM_string: buf := make([]byte, 4096) for i := range buf { if v, err := br.Uint8(); err != nil { return err } else if v == 0 { buf = buf[:i] break } else { buf[i] = byte(v) } } return string(buf) } panic(fmt.Errorf("Unimplemented format: %s", form)) }
func (lh *lineHeader) Read(br *binary.BinaryReader) error { start, _ := br.Seek(0, 1) err := br.ReadInterface(&lh.Header) if err != nil { return err } if lh.is64 { lh.header_length, err = br.Int64() } else { var v uint32 v, err = br.Uint32() lh.header_length = int64(v) } if err != nil { return err } if lh.minimum_instruction_length, err = br.Uint8(); err != nil { return err } lh.maximum_operations_per_instruction = 1 // TODO: // if lh.maximum_operations_per_instruction, err = br.Uint8(); err != nil { // return err // } if err = br.ReadInterface(&lh.default_is_stmt); err != nil { return err } else if lh.line_base, err = br.Int8(); err != nil { return err } else if lh.line_range, err = br.Uint8(); err != nil { return err } else if lh.opcode_base, err = br.Uint8(); err != nil { return err } lh.standard_opcode_lengths = make([]uint8, lh.opcode_base-1) if err := br.ReadInterface(&lh.standard_opcode_lengths); err != nil { return err } for { var s string if err := br.ReadInterface(&s); err != nil { return err } else if s == "" { break } else { lh.include_directories = append(lh.include_directories, s) } } for { var f fileEntry pos, _ := br.Seek(0, 1) if v, err := br.Uint8(); err != nil { return err } else if v == '\u0000' { break } else { br.Seek(pos, 0) } if err := br.ReadInterface(&f); err != nil { return err } else { lh.file_names = append(lh.file_names, f) } } var s state s.header = lh s.reset() pos, _ := br.Seek(0, 1) for (pos - 4 - start) < int64(lh.Length) { var op DW_LNS if err := br.ReadInterface(&op); err != nil { return err } if op == 0 { var length LEB128 if err := br.ReadInterface(&length); err != nil { return err } var op2 DW_LNE if err := br.ReadInterface(&op2); err != nil { return err } s.executeLNE(op2, length-1, br) } else { s.execute(op, br) } pos, _ = br.Seek(0, 1) } return nil }