1 1 import Utils 2 + import ida_bytes 3 + import ida_struct 2 4 import idc 3 5 4 6 class GoTypes_BASE(object): skipped 268 lines 273 275 return self.handle_offset(value) 274 276 275 277 def getDword(self, sid, addr, name): 276 - name_off = idc.GetMemberOffset (sid, name) 277 - return idc.Dword (addr+name_off) 278 + name_off = idc.get_member_offset (sid, name) 279 + return idc.get_wide_dword (addr+name_off) 278 280 279 281 def getPtr(self, sid, addr, name): 280 - name_off = idc.GetMemberOffset (sid, name) 282 + name_off = idc.get_member_offset (sid, name) 281 283 return self.stepper.ptr(addr+name_off) 282 284 283 285 def getPtrToThis(self, sid, offset): skipped 3 lines 287 289 return offset 288 290 289 291 def make_arr(self, addr, arr_size, struc_size, type): 290 - res = idc.MakeArray (addr, arr_size) 292 + res = idc.make_array (addr, arr_size) 291 293 if res == False: 292 - idc.MakeUnknown(addr, arr_size*struc_size, idc.DOUNK_SIMPLE) 294 + ida_bytes.del_items(addr, arr_size*struc_size, ida_bytes.DELIT_SIMPLE) 293 295 idc.SetType(addr, type) 294 - idc.MakeArray (addr, arr_size) 296 + idc.make_array (addr, arr_size) 295 297 296 298 297 299 def getName(self, offset): 298 - sid = idc.GetStrucIdByName("type") 299 - string_addr = offset + idc.GetMemberOffset (sid, "string") 300 + sid = ida_struct.get_struc_id("type") 301 + string_addr = offset + idc.get_member_offset (sid, "string") 300 302 ptr = self.stepper.ptr(string_addr) 301 303 idc.SetType(ptr, "string") 302 304 name = self.stepper.ptr(ptr) 303 305 return idc.GetString(name) 304 306 305 307 def getKindEnumName(self, addr): 306 - struc_id = idc.GetStrucIdByName("type") 307 - offset_kind = idc.GetMemberOffset (struc_id, "kind") 308 - kind = idc.Byte (addr + offset_kind) & 0x1f 308 + struc_id = ida_struct.get_struc_id("type") 309 + offset_kind = idc.get_member_offset (struc_id, "kind") 310 + kind = idc.get_wide_byte (addr + offset_kind) & 0x1f 309 311 return self.settings.typer.standardEnums[0][1][kind] 310 312 311 313 skipped 7 lines 319 321 #Set type and get name 320 322 idc.SetType(offset, "type") 321 323 name = self.getName(offset) 322 - idc.MakeComm (offset, name) 324 + idc.set_cmt (offset, name, 0 ) 323 325 324 326 #get kind name 325 327 kind_name = self.getKindEnumName(offset) skipped 3 lines 329 331 name = Utils.relaxName(name) 330 332 Utils.rename(offset, name) 331 333 self.betterTypePlease(offset) 332 - sid = idc.GetStrucIdByName("type") 334 + sid = ida_struct.get_struc_id("type") 333 335 addr = self.getPtrToThis(sid, offset) 334 336 if addr != 0: 335 337 addr = self.getOffset(addr) skipped 9 lines 345 347 346 348 def makeChanType(self, offset): 347 349 idc.SetType(offset, "chanType") 348 - sid = idc.GetStrucIdByName("chanType") 350 + sid = ida_struct.get_struc_id("chanType") 349 351 addr = self.getPtr(sid, offset, "elem") 350 352 self.handle_offset(addr) 351 353 352 354 def makeSliceType(self, offset): 353 355 idc.SetType(offset, "sliceType") 354 - sid = idc.GetStrucIdByName("sliceType") 356 + sid = ida_struct.get_struc_id("sliceType") 355 357 addr = self.getPtr(sid, offset, "elem") 356 358 self.handle_offset(addr) 357 359 358 360 def makeArrType(self, offset): 359 361 idc.SetType(offset, "arrayType") 360 - sid = idc.GetStrucIdByName("arrayType") 362 + sid = ida_struct.get_struc_id("arrayType") 361 363 addr = self.getPtr(sid, offset, "elem") 362 364 self.handle_offset(addr) 363 365 addr = self.getPtr(sid, offset, "slice") skipped 1 lines 365 367 366 368 def makePtrType(self, offset): 367 369 idc.SetType(offset, "ptrType") 368 - sid = idc.GetStrucIdByName("ptrType") 370 + sid = ida_struct.get_struc_id("ptrType") 369 371 addr = self.getPtr(sid, offset, "elem") 370 372 self.handle_offset(addr) 371 373 372 374 def makeStructType(self, offset): 373 375 idc.SetType(offset, "structType") 374 - sid = idc.GetStrucIdByName("structType") 375 - slice_id = idc.GetStrucIdByName("slice") 376 - offset_elem = idc.GetMemberOffset (sid, "fields") 377 - inner_offset = idc.GetMemberOffset (slice_id, "data") 376 + sid = ida_struct.get_struc_id("structType") 377 + slice_id = ida_struct.get_struc_id("slice") 378 + offset_elem = idc.get_member_offset (sid, "fields") 379 + inner_offset = idc.get_member_offset (slice_id, "data") 378 380 addr = self.stepper.ptr(offset_elem + offset + inner_offset) 379 381 380 - inner_offset = idc.GetMemberOffset (slice_id, "len") 382 + inner_offset = idc.get_member_offset (slice_id, "len") 381 383 size = self.stepper.ptr(offset+offset_elem+inner_offset) 382 384 if size == 0: 383 385 return 384 386 idc.SetType(addr, "structField") 385 - sz = idc.GetStrucSize(idc.GetStrucIdByName("structField")) 387 + sz = ida_struct.get_struc_size(ida_struct.get_struc_id("structField")) 386 388 self.make_arr(addr, size, sz, "structField") 387 - sid_type = idc.GetStrucIdByName("type") 389 + sid_type = ida_struct.get_struc_id("type") 388 390 size_new_struct = self.getPtr(sid_type, offset, "size") 389 391 for i in xrange(size): 390 392 self.processStructField(addr, i*sz) skipped 4 lines 395 397 396 398 def processStructField(self, addr, index): 397 399 offset = addr + index 398 - sid = idc.GetStrucIdByName("structField") 400 + sid = ida_struct.get_struc_id("structField") 399 401 ptr = self.getPtr(sid, offset, "Name") 400 402 if ptr != 0: 401 403 idc.SetType(ptr, "string") skipped 8 lines 410 412 411 413 def createUserTypeStruct(self, addr, name, size, self_size): 412 414 fields = [] 413 - sid = idc.GetStrucIdByName("structField") 414 - sz = idc.GetStrucSize(sid) 415 - sid_type = idc.GetStrucIdByName("type") 415 + sid = ida_struct.get_struc_id("structField") 416 + sz = ida_struct.get_struc_size(sid) 417 + sid_type = ida_struct.get_struc_id("type") 416 418 fields = [] 417 419 curr_offset = 0 418 - idc.MakeComm (addr, name) 420 + idc.set_cmt (addr, name, 0 ) 419 421 for i in xrange(size): 420 422 fieldname = self.nameFromOffset(self.getPtr(sid, addr+i*sz,"Name")) 421 423 type_addr = self.getPtr(sid, addr+i*sz, "typ") skipped 11 lines 433 435 curr_offset += 1 434 436 curr_offset += size 435 437 if size != 0: 436 - offset_kind = idc.GetMemberOffset (sid_type, "kind") 438 + offset_kind = idc.get_member_offset (sid_type, "kind") 437 439 kind_of_type = self.getKindEnumName(type_addr) 438 440 print kind_of_type 439 441 if kind_of_type == "STRUCT_": #Disabled for now skipped 21 lines 461 463 curr_offset += 1 462 464 new_type = [(name, fields)] 463 465 self.settings.structCreator.createTypes(new_type) 464 - new_type_sid = idc.GetStrucIdByName(name) 465 - sz = idc.GetStrucSize(new_type_sid) 466 + new_type_sid = ida_struct.get_struc_id(name) 467 + sz = ida_struct.get_struc_size(new_type_sid) 466 468 if sz != self_size: 467 469 print "%x" % addr 468 470 raise("Error at creating structure") 469 471 470 472 def getType(self, addr): 471 473 print "%x" % addr 472 - sid = idc.GetStrucIdByName("type") 474 + sid = ida_struct.get_struc_id("type") 473 475 name = self.getName(addr) 474 476 if self.getKindEnumName(addr) != "PTR": 475 477 while name[0] == "*": skipped 2 lines 478 480 479 481 def makeInterface(self, offset): 480 482 idc.SetType(offset, "interfaceType") 481 - ifaceid = idc .GetStrucIdByName ("interfaceType") 482 - meth_offs = idc.GetMemberOffset (ifaceid, "methods") 483 - slice_id = idc.GetStrucIdByName("slice") 484 - size_off = idc.GetMemberOffset (slice_id, "len") 483 + ifaceid = ida_struct .get_struc_id ("interfaceType") 484 + meth_offs = idc.get_member_offset (ifaceid, "methods") 485 + slice_id = ida_struct.get_struc_id("slice") 486 + size_off = idc.get_member_offset (slice_id, "len") 485 487 size = self.stepper.ptr(offset + meth_offs + size_off) 486 488 if size != 0: 487 489 addr = self.getPtr(slice_id, offset + meth_offs, "data") 488 490 idc.SetType(addr, "imethod") 489 - sz = idc.GetStrucSize(idc.GetStrucIdByName("imethod")) 491 + sz = ida_struct.get_struc_size(ida_struct.get_struc_id("imethod")) 490 492 self.make_arr(addr, size, sz, "imethod") 491 493 names = self.processIMethods(addr, size) 492 494 # For now only for go1.7 skipped 35 lines 528 530 def next(self): 529 531 if self.pos >= self.end: 530 532 raise StopIteration 531 - value = idc.Dword (self.pos) 533 + value = idc.get_wide_dword (self.pos) 532 534 self.pos += 4 533 535 value = self.getOffset(value) 534 536 return self.handle_offset(value) skipped 5 lines 540 542 def get_str(self, pos, len): 541 543 out = "" 542 544 for i in xrange(len): 543 - out += chr(idc.Byte (pos+i)) 545 + out += chr(idc.get_wide_byte (pos+i)) 544 546 return out 545 547 546 548 def getName(self, offset): 547 - sid = idc.GetStrucIdByName("type") 549 + sid = ida_struct.get_struc_id("type") 548 550 name_off = self.getDword(sid, offset, "string") 549 551 string_addr = self.getOffset(name_off) + 3 550 - ln = idc.Byte (string_addr-1) 552 + ln = idc.get_wide_byte (string_addr-1) 551 553 return self.get_str(string_addr, ln) 552 554 553 555 def nameFromOffset(self, offset): 554 556 addr = offset 555 - return self.get_str(addr + 3, idc.Byte (addr + 2)) 557 + return self.get_str(addr + 3, idc.get_wide_byte (addr + 2)) 556 558 557 559 def getPtrToThis(self, sid, offset): 558 - memb_offs = idc.GetMemberOffset (sid, "ptrtothis") 559 - return idc.Dword (offset + memb_offs) 560 + memb_offs = idc.get_member_offset (sid, "ptrtothis") 561 + return idc.get_wide_dword (offset + memb_offs) 560 562 561 563 def processStructField(self, addr, index): 562 564 offset = addr + index 563 - sid = idc.GetStrucIdByName("structField") 565 + sid = ida_struct.get_struc_id("structField") 564 566 ptr = self.getPtr(sid, offset, "Name") 565 - ln = idc.Byte (ptr + 2) 567 + ln = idc.get_wide_byte (ptr + 2) 566 568 fieldName = self.get_str(ptr + 3, ln) 567 569 Utils.rename(ptr, fieldName) 568 570 ptr = self.getPtr(sid, offset, "typ") 569 571 self.handle_offset(ptr) 570 572 571 573 def processIMethods(self, offst, size): 572 - sz = idc.GetStrucSize(idc.GetStrucIdByName("imethod")) 574 + sz = ida_struct.get_struc_size(ida_struct.get_struc_id("imethod")) 573 575 comm = [] 574 576 for i in xrange(size): 575 577 comm.append(self.processIMethod(offst + i * sz)) 576 - idc.MakeComm (offst, "\n".join(comm)) 578 + idc.set_cmt (offst, "\n".join(comm), 0 ) 577 579 return comm 578 580 579 581 def processIMethod(self, offst): 580 - sid = idc.GetStrucIdByName("imethod") 582 + sid = ida_struct.get_struc_id("imethod") 581 583 name = self.getDword(sid, offst, "name") 582 584 name += self.robase 583 - name = self.get_str(name + 3, idc.Byte (name + 2)) 585 + name = self.get_str(name + 3, idc.get_wide_byte (name + 2)) 584 586 return name 585 587 586 588 def processMethods(self, offst): 587 - sid = idc.GetStrucIdByName("method__") 589 + sid = ida_struct.get_struc_id("method__") 588 590 name = self.getDword(sid, offst, "name") 589 591 name += self.robase 590 - name = self.get_str(name + 3, idc.Byte (name + 2)) 592 + name = self.get_str(name + 3, idc.get_wide_byte (name + 2)) 591 593 type_meth = self.getDword(sid, offst, "mtyp") 592 594 type_meth_addr1 = self.robase + type_meth 593 595 func_body1 = self.getDword(sid, offst, "ifn") skipped 4 lines 598 600 599 601 def makeMap(self, offset): 600 602 idc.SetType(offset, "mapType") 601 - sid = idc.GetStrucIdByName("mapType") 603 + sid = ida_struct.get_struc_id("mapType") 602 604 addr = self.getPtr(sid, offset, "key") 603 605 self.handle_offset(addr) 604 606 addr = self.getPtr(sid, offset, "elem") skipped 5 lines 610 612 611 613 def parseFuncType(self, offset): 612 614 return 613 - sid = idc.GetStrucIdByName("funcType") 614 - in_size = idc.Word(offset + idc.GetMemberOffset (sid, "incount")) 615 - out_size = idc.Word(offset + idc.GetMemberOffset (sid, "outcount")) 616 - sz = idc.GetStrucSize(sid) 615 + sid = ida_struct.get_struc_id("funcType") 616 + in_size = idc.Word(offset + idc.get_member_offset (sid, "incount")) 617 + out_size = idc.Word(offset + idc.get_member_offset (sid, "outcount")) 618 + sz = ida_struct.get_struc_size(sid) 617 619 for i in xrange(in_size + out_size): 618 620 idc.SetType(offset + sz + i * self.stepper.size, "type *") 619 621 skipped 9 lines