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 |