Projects STRLCPY IDAGolangHelper Commits c8e8b01c
🤬
Revision indexing in progress... (symbol navigation in revisions will be accurate after indexed)
  • ■ ■ ■ ■ ■ ■
    GO_Utils/Gopclntab.py
    1 1  import idc
    2 2  import idautils
    3 3  import idaapi
     4 +import ida_bytes
     5 +import ida_funcs
     6 +import ida_search
    4 7  import Utils
    5 8   
    6 9  info = idaapi.get_inf_structure()
    skipped 18 lines
    25 28  def findGoPcLn():
    26 29   pos = idautils.Functions().next() # Get some valid address in .text segment
    27 30   while True:
    28  - possible_loc = idc.FindBinary(pos, idc.SEARCH_DOWN, lookup) #header of gopclntab
     31 + end_ea = idc.get_segm_end(pos)
     32 + possible_loc = ida_search.find_binary(pos, end_ea, lookup, 16, idc.SEARCH_DOWN) #header of gopclntab
    29 33   if possible_loc == idc.BADADDR:
    30 34   break
    31 35   if check_is_gopclntab(possible_loc):
    skipped 17 lines
    49 53   ptr.maker(base+offset)
    50 54   func_addr = ptr.ptr(base+offset)
    51 55   if make_funcs == True:
    52  - idc.MakeUnknown(func_addr, 1, idc.DOUNK_SIMPLE)
    53  - idc.MakeFunction(func_addr)
    54  - name_offset = idc.Dword(base+offset+ptr.size)
    55  - name = idc.GetString(base + name_offset)
     56 + ida_bytes.del_items(func_addr, 1, ida_bytes.DELIT_SIMPLE)
     57 + ida_funcs.add_func(func_addr)
     58 + name_offset = idc.get_wide_dword(base+offset+ptr.size)
     59 + name = idc.get_strlit_contents(base + name_offset)
    56 60   name = Utils.relaxName(name)
    57 61   Utils.rename(func_addr, name)
  • ■ ■ ■ ■ ■ ■
    GO_Utils/Types.py
    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
  • ■ ■ ■ ■ ■ ■
    GO_Utils/Utils.py
     1 +import ida_enum
     2 +import ida_struct
    1 3  import idc
    2 4  import string
    3 5  import random
    skipped 5 lines
    9 11   self.maker = maker
    10 12   
    11 13   
    12  -bits32 = bitZ(idc.Dword, 4, idc.MakeDword)
    13  -bits64 = bitZ(idc.Qword, 8, idc.MakeQword)
     14 +bits32 = bitZ(idc.get_wide_dword, 4, idc.create_dword)
     15 +bits64 = bitZ(idc.get_qword, 8, idc.create_qword)
    14 16   
    15 17   
    16 18  def id_generator(size=6, chars=string.ascii_uppercase + string.digits):
    skipped 1 lines
    18 20   
    19 21   
    20 22  def rename(offset, name):
    21  - res = idc.MakeNameEx(offset, name, idc.SN_NOWARN)
     23 + res = idc.set_name(offset, name, idc.SN_NOWARN)
    22 24   if res == 0:
    23 25   name = name+"_autogen_"+id_generator()
    24  - idc.MakeNameEx(offset, name, idc.SN_NOWARN)
     26 + idc.set_name(offset, name, idc.SN_NOWARN)
    25 27   
    26 28   
    27 29  def relaxName(name):
    skipped 4 lines
    32 34   
    33 35  def get_bitness(addr):
    34 36   ptr = bits32
    35  - if idc.GetSegmentAttr(addr, idc.SEGATTR_BITNESS) == 2:
     37 + if idc.get_segm_attr(addr, idc.SEGATTR_BITNESS) == 2:
    36 38   ptr = bits64
    37 39   return ptr
    38 40   
    skipped 15 lines
    54 56   def __init__(self, bt_obj):
    55 57   self.types_id = {}
    56 58   if bt_obj.size == 8:
    57  - self.uintptr = (idc.FF_QWRD|idc.FF_DATA, -1, bt_obj.size)
     59 + self.uintptr = (idc.FF_QWORD|idc.FF_DATA, -1, bt_obj.size)
    58 60   else:
    59  - self.uintptr = (idc.FF_DWRD | idc.FF_DATA, -1, bt_obj.size)
     61 + self.uintptr = (idc.FF_DWORD | idc.FF_DATA, -1, bt_obj.size)
    60 62   
    61 63   def createStruct(self, name):
    62  - sid = idc.GetStrucIdByName(name)
     64 + sid = ida_struct.get_struc_id(name)
    63 65   if sid != -1:
    64  - idc.DelStruc(sid)
    65  - sid = idc.AddStrucEx(-1, name, 0)
     66 + idc.del_struc(sid)
     67 + sid = idc.add_struc(-1, name, 0)
    66 68   self.types_id['name'] = sid
    67 69   return sid
    68 70   
    skipped 12 lines
    81 83   new_type = i[1]
    82 84   else:
    83 85   new_type = name + " *"
    84  - res = idc.AddStrucMember(sid, i[0], -1, i1, i2, i3)
     86 + res = idc.add_struc_member(sid, i[0], -1, i1, i2, i3)
    85 87   use_name = i[0]
    86 88   if res == -1: #Bad name
    87 89   #print "Bad name %s for struct member" % i[0]
    88 90   use_name = i[0] + "_autogen_"+id_generator()
    89  - idc.AddStrucMember(sid, use_name, -1, i1, i2, i3)
     91 + idc.add_struc_member(sid, use_name, -1, i1, i2, i3)
    90 92   if new_type is not None:
    91  - offset = idc.GetMemberOffset(sid, use_name)
     93 + offset = idc.get_member_offset(sid, use_name)
    92 94   #print "Setting %s as %s" % (i[0], new_type)
    93  - idc.SetType(idc.GetMemberId(sid, offset), new_type)
     95 + idc.SetType(idc.get_member_id(sid, offset), new_type)
    94 96   
    95 97   def makeStruct(self, i):
    96 98   print "Creating structure %s" % (i[0])
    skipped 5 lines
    102 104   self.makeStruct(i)
    103 105   
    104 106   def createEnum(self, enum):
    105  - eid = idc.AddEnum(-1, enum[0], 0x1100000) #what is this flag?
    106  - idc.SetEnumBf(eid, 1)
     107 + eid = idc.add_enum(-1, enum[0], 0x1100000) #what is this flag?
     108 + ida_enum.set_enum_bf(eid, 1)
    107 109   val = 0
    108 110   mask = 0x1f
    109  - idc.SetEnumWidth(eid, 1)
     111 + ida_enum.set_enum_width(eid, 1)
    110 112   for i in enum[1]:
    111  - idc.AddConstEx(eid, i, val, mask)
     113 + idc.add_enum_member(eid, i, val, mask)
    112 114   val += 1
    113 115   
    114 116   def createEnums(self, enums):
    skipped 4 lines
  • ■ ■ ■ ■ ■ ■
    GO_Utils/__init__.py
    skipped 4 lines
    5 5  import Types
    6 6  import idc
    7 7  import idautils
     8 +import ida_ida
     9 +import ida_search
    8 10   
    9 11  class GoSettings(object):
    10 12   
    11 13   
    12 14   def __init__(self):
    13 15   self.storage = {}
    14  - self.bt_obj = Utils.get_bitness(idc.BeginEA())
     16 + self.bt_obj = Utils.get_bitness(ida_ida.inf_get_min_ea())
    15 17   self.structCreator = Utils.StructCreator(self.bt_obj)
    16 18   self.processor = None
    17 19   self.typer = None
    skipped 36 lines
    54 56   
    55 57   def getVersionByString(self):
    56 58   pos = idautils.Functions().next()
    57  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 31 30") != idc.BADADDR:
     59 + end_ea = idc.get_segm_end(pos)
     60 +
     61 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 31 30", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    58 62   return 'Go 1.10'
    59  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 39") != idc.BADADDR:
     63 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 39", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    60 64   return 'Go 1.9'
    61  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 38") != idc.BADADDR:
     65 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 38", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    62 66   return 'Go 1.8'
    63  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 37") != idc.BADADDR:
     67 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 37", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    64 68   return 'Go 1.7'
    65  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 36") != idc.BADADDR:
     69 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 36", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    66 70   return 'Go 1.6'
    67  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 35") != idc.BADADDR:
     71 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 35", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    68 72   return 'Go 1.5'
    69  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 34") != idc.BADADDR:
     73 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 34", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    70 74   return 'Go 1.4'
    71  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 33") != idc.BADADDR:
     75 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 33", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    72 76   return 'Go 1.3'
    73  - if idc.FindBinary(pos, idc.SEARCH_DOWN, "67 6f 31 2e 32") != idc.BADADDR:
     77 + if ida_search.find_binary(pos, end_ea, "67 6f 31 2e 32", 16, idc.SEARCH_DOWN) != idc.BADADDR:
    74 78   return 'Go 1.2'
    75 79   
    76 80   def createTyper(self, typ):
    skipped 45 lines
Please wait...
Page is in error, reload to recover