[Immunity Dbg Python Scripting]

Discussion in 'Реверсинг' started by 0x0c0de, 17 Jun 2008.

  1. 0x0c0de

    0x0c0de Elder - Старейшина

    Joined:
    25 May 2007
    Messages:
    441
    Likes Received:
    395
    Reputations:
    297
    [Immunity Dbg Scripts]

    [Intro]

    Извиняюсь за долгое свое отсутствие и слабую активность в последнее время – виной тому экзамены и некоторые финансовые затруднения. Сейчас, настало некое “furore poetico”, образно выражаясь, конечно. Появилось некоторое количество свободного времени, которое можно потратить с пользой.

    [Scripting]

    Решила поднять эту тему, так как имунити дбг и скрипты под него до сего момента не особенно активно обсуждались в разделе. Так же меня не устраивало то, что за все время нашла сборничек из 15 скриптов (кто смотрел, обнаружил, что, например, некоторые там явно под ODbgScript) и 13 плагинов + довольно скудный набор примеров в самом отладчике. Потом все имеющееся плохо откомментировано, если вообще откомментировано. Сей пробел я и собираюсь заполнить.
    В данной теме постим скрипты под иммунити.

    Только просьба – комментируйте подробно код- это необходимое условие. И описание небольшое делайте.

    Начну
    Некогда (не так давно, кстати) на tuts4you выкладывался UnPackMe Mimoza 0.86 – под него писала скрипт сначала под OllyScript, а затем из спортивного интереса написала на питоне

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys
    #------------------------------------------------------------------------------|
    #-------------------0x0c0de (c)  2008-----------------------------------|
    #------------------------------------------------------------------------------|
    #----------Mimoza 0.86 Unpacking script-----------------------------|
    
    def main(args):
      imm = Debugger()
      v_alloc_address = imm.getAddress("kernel32.VirtualAlloc") # получаем адрес VirtualAlloc
      if v_alloc_address>0: # если адрес получен успешно
       imm.Log(" ")
       imm.Log("VirtualAlloc address-> 0x%08X " % v_alloc_address)
       imm.setHardwareBreakpoint(v_alloc_address,1,4)
       imm.Log("Breakpoint at -> 0x%08X " % v_alloc_address)
       imm.Log("Running ..")
       imm.Run()
       regs=imm.getRegs()
       addres_of_region =regs['EAX'] 
       imm.Log("Address Region -> 0x%08X " % addres_of_region) #в лог пишем адрес региона, где лежит наш файл
       size_=regs['ECX']
       imm.Log("Region size-> 0x%08X " % size_) # выводим в лог размер файла
       imm.runTillRet() # Ctrl+F9
       imm.stepIn() # F7
       regs=imm.getRegs() # получаем все регистры
       cur=regs['EIP']+53 # получаем адрес команды REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI] - текущий eip+53
       imm.setHardwareBreakpoint(cur,1,4) # ставим аппаратную точку останова на команду REP MOVSB
       imm.Run() # F9
       imm.setReg('ECX',size_) 
       imm.stepOver() # F8
       imm.stepOver() # F8
       f=open("Mimoza_unpacked.exe", "wb") # создаем файл для дампа
       buff_=imm.readMemory(addres_of_region,size_) #записываем в него содержимое нашего распакованного файла
       f.write(buff_)
       f.close()
       imm.Log("Unpacked file at Mimoza_unpacked.exe")
      else:
        imm.Log("No address")
      return "Done"
      # поместите файл mimoza.py в директорию PyCommands ImmunityDbg и вызывайте командой !mimoza
    
    Обратите внимание на то, что вначале я указываю кодировку. Иначе комментарии на русском не прокатят (о кодировках написано в любом учебнике/документации по питону)

    Скрипт поиска апи-функции во всех загруженных в АП процесса модулях

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import*
    #данный скрипт осуществляет поиск функции, полученной в качестве аргумента во всех загруженных модулях
    #вызов скрипта !apifinder имя_функции в командной строке (сам скрипт поместите в директорию PyCommands)
    def main(args):
     imm = Debugger()
     imm.Log("Simple Api Finder by 0x0c0de")
     modul_list=imm.getAllModules() #получаем имена всех модулей, подгруженных в АП
     for mod in modul_list.keys(): # цикл обработки всех  имен модулей
      lenstr=len(mod)-3 # убираем расширение
      mystr="" #очищаем буфер
      func_addr=0 
      for char_ in mod:
       if lenstr>0:
        mystr=mystr+char_
       else:
        func_addr=imm.getAddress(mystr+args[0]) #получаем адрес функции
        if func_addr>0: # если не возникло ошибки, адрес получен
    	 imm.Log(mod+" function "+args[0]+" address -> 0x%08X " % func_addr)
    	 return "All good. See log window" #завершаем работу скрипта
        else:
    	 imm.Log("No function " +args[0]+" in "+mod)
        break
       lenstr=lenstr-1
     return "No function! See log window" #если получает управление эта команда, то функция не найдена
    

    Мелочь, а приятно. Запуск нужный тулз из имунити.

    Code:
    import sys,os
    
    def usage(imm):
        imm.Log(" Tools runner by 0x0c0de")
    
    def main(args):
    
        os.startfile("C:\Tools\Lord\LordPE.EXE")
        os.startfile("C:\Tools\ImpREC 1.7c\ImpREC 1.7c\ImportREC.exe")
        return "Done!"
    
    Используйте скрипт hidedebug с опцией All_Debug для убийства типичной антиотладки (его здесь не привожу, так как его можно нарыть в вышеупомянутой сборке (в конце поста я приведу все ссылки)

    Next…

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys
    
    #антиотладку убиваете !hidedebug All_Debug (см выше по тексту)
    # обязательно поставьте в опциях игнорирование всех исключений Alt+O вкладка Exceptions - везде галочки
    #скрипт помещаете в директорию PyCommands ImmunityDbg и запускаете командой !имя_скрипта 
    #simple YodaCrypter OEP Finder by 0x0c0de
    
    def main(args):
     imm=Debugger()
     isdebpres = imm.getAddress("kernel32.IsDebuggerPresent") # определяем адрес IsDebuggerPresent
     imm.setBreakpoint(isdebpres) # ставим обычный бряк на функцию
     imm.Run() #F9
     imm.deleteBreakpoint(isdebpres) #удаляем бряк
     imm.runTillRet() # Ctrl+F9
     imm.stepIn() # F7
     imm.runTillRet() # Ctrl+F9
     imm.stepIn() #F7
     cur = imm.getCurrentAddress() #Получаем текущий адрес
     cur = cur+31 #Адрес команды push eax
     imm.setHardwareBreakpoint(cur,1,4) # ставим бряк на push eax
     imm.Run() #запускаем прогу
     regs=imm.getRegs() #получаем все регистры
     addres_of_seh =regs['EAX'] #в eax - адрес нужного нам seh-обработчика 
     imm.setHardwareBreakpoint(addres_of_seh+36,1,4) 
     imm.Run() #запускаем программу
     regs=imm.getRegs() #получаем все регистры
     imm.setHardwareBreakpoint(regs['EDI'],1,4) #ставим breakpoint на oep 
     imm.Run() #Запускаем 
     imm.Log("OEP -> 0x%08X " % regs['EDI'])
     return "Done. See log window"
    
    Итак, так же OEP finder. Читаем комменты к коду. Так как есть определенное искажение текста скрипта при его копипасте из поста и в пост – лучше скачайте архив (ниже ссылки - если не нра файлообменник - я перезалью кому надо)..

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys
    #------------------------------------------------------------------------------|
    #-------------------0x0c0de (c)  2008-----------------------------------|
    #------------------------------------------------------------------------------|
    #----------12311134 OEP Finder script---------------------------------|
    
    def main(args):
      imm = Debugger()
      imm.Log("Running 12311134 oep finder script..")
      gpa_address = imm.getAddress("kernel32.GetProcAddress") # получаем адрес  GetProcAddress
      if gpa_address==0: # произошла ошибка и нельзя получить адрес нужной функции
       return "No address GetProcAddress"
      imm.setBreakpoint(gpa_address) # обычный брекпоинт на GetProcAddress
      imm.Run() # F9
      imm.deleteBreakpoint(gpa_address) #удаляем бряк с GetProcAddress
      imm.runTillRet() # Ctrl+F9
      imm.stepIn() # F7
      cur=imm.getCurrentAddress() # текущий адрес
      oep_per=imm.searchCommandsOnModule(cur,"jmp eax") #поиск команды jmp eax
      for oep_jmpeax in oep_per: # цикл по элементам списка
       imm.Log("Command jmp eax found -> 0x%08X address" % oep_jmpeax[0]) # выводим в лог все адреса с командой jmp eax, но нам нужен только последний
      imm.setHardwareBreakpoint(oep_jmpeax[0],1,4) # ставим на последний в списке jmp eax хардварный бряк
      imm.Run() # F9
      imm.stepIn() # F7
      regs=imm.getRegs() # получаем все регистры
      imm.Log("oep -> 0x%08X " % regs['EIP']) # записываем в лог адрес oep  
      return "EIP is OEP"
    
    MEW
    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys
    #------------------------------------------------------------------------------|
    #-------------------0x0c0de (c)  2008-----------------------------------|
    #------------------------------------------------------------------------------|
    #----------MEW OEP Finder script-------------------------------------|
    
    def main(args):
      imm = Debugger()
      imm.Log("MEW12 Dumper by 0x0c0de...")
      imm.stepIn() # F7
      gpa_address = imm.getAddress("kernel32.GetProcAddress") # получаем адрес  GetProcAddress
      if gpa_address==0: # произошла ошибка и нельзя получить адрес нужной функции
       return "No address GetProcAddress"
      imm.setBreakpoint(gpa_address) # обычный брекпоинт на GetProcAddress
      imm.Run() # F9
      imm.deleteBreakpoint(gpa_address) #удаляем бряк с GetProcAddress
      imm.runTillRet() # Ctrl+F9
      imm.stepIn() # F7
      cur=imm.getCurrentAddress() # текущий адрес
      imm.setBreakpoint(cur+5)
      imm.Run()
      imm.stepIn() # F7
      regs=imm.getRegs() # получаем все регистры
      imm.Log("oep -> 0x%08X " % regs['EIP']) # записываем в лог адрес oep  
      imm.setComment(regs['EIP'],'< - OEP') # коммент на oep 
      return "Script finished! See log window"
    
    NSpack

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys
    #------------------------------------------------------------------------------|
    #-------------------0x0c0de (c)  2008-----------------------------------|
    #------------------------------------------------------------------------------|
    #----------NSPack37 OEP Finder script-------------------------------|
    
    def main(args):
      imm = Debugger()
      regs=imm.getRegs()
      imm.setHardwareBreakpoint(regs['ESP']-4,2,1) # HR ESP-4
      imm.Run() # f9
      imm.Run() #f9
      imm.stepIn() # F7
      regs=imm.getRegs() # получаем все регистры
      imm.Log("oep -> 0x%08X " % regs['EIP']) # записываем в лог адрес oep  
      imm.setComment(regs['EIP'],'< - OEP') # коммент на oep   
      return "Script finished! See log window"
    
    Далее, реализовала простой поиск строки в загруженном в отладчик модуле. Функция getReferencedStrings - функция поиска всех ссылок на строки (Search for-> All referenced text strings в имунити) . Ищется именно вся строка, а не ее часть. Поиск в 2-х кодировках – ASCII и UNICODE.

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys
    
    #Простой скрипт для поиска строки
    #Вызываете скрипт командой !имя_скрипта  строка
    #Поиск в кодировках ASCII, UNICODE
    def main(args):
      imm = Debugger()
      if not args:
       imm.Log("Error search string. No args")
       return "Error. See log window"
      str = " ".join(args)
      imm.Log("Search string -> "+str) #выводим в лог, что ищем
      str_="ASCII \""+str+"\"" #ищем строки в кодировке ASCII 
      cur=imm.getCurrentAddress() # получаем текущий адрес
      mod_=imm.findModule(cur)   #получаем информацию о загруженной в отладчик проге
      hep=imm.getReferencedStrings(mod_[1]) # ищем все строки (а точнее, ссылки на них)
      for info_str in hep: #пробегаемся по всем строкам
       if info_str[2]==str_: #если нашли такую строку
        imm.Log("String found at address (ASCII)-> 0x%08X" % info_str[0]) #выводим в лог где найдена строка
      #если ничего не нашли в ASCII - попробуем найти в UNICODE
      str_="UNICODE \""+str+"\"" #ищем строки в кодировке UNICODE
      for info_str in hep: #пробегаемся по всем строкам
       if info_str[2]==str_: #если нашли такую строку
        imm.Log("String found at address (UNICODE)-> 0x%08X" % info_str[0]) #выводим в лог где найдена строка
      return "Done. See log window"
    
    [Ссылки]

    http://reversengineering.wordpress.com/category/tools/immunity-debugger/ - здесь 15 скриптов и 13 плагов

    http://0x0c0de.net/immscr.rar - скрипты из поста и hidedebugger

    http://0x0c0de.net/examples_packed.rar - здесь примеры для тестирования скриптов


    [Outro]

    Если тема приживется – закреплю..
    Простимулировать активность общественности могу только поощрением репутации . Ставлю от +3 за каждый выложенный рабочий скрипт (проверяйте лично перед тем, как выкладывать!).
    Если у вас есть ко мне какие-либо вопросы по этой теме – пишите в pm или icq (буду только рада указанию на ошибки и неточности). Причем пользоваться лучше вторым средством связи.

    Grazie dell'attenzione, 0x0c0de
     
    #1 0x0c0de, 17 Jun 2008
    Last edited: 28 Jun 2008
    1 person likes this.
  2. 0x0c0de

    0x0c0de Elder - Старейшина

    Joined:
    25 May 2007
    Messages:
    441
    Likes Received:
    395
    Reputations:
    297
    Вменяемый поиск строки и универсальный (в отличие от приведенного выше). Внимательно читаем комменты - там ответы на все потенциальные вопросы=) Результат работы скрипта по обыкновению в Log Window

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys,string
    #------------------------------------------------------------------|
    #Простой скрипт для поиска строки или ее части
    #Вызываете скрипт командой !имя_скрипта  строка
    #------------------------------------------------------------------|
    def main(args):
      imm = Debugger()
      if not args:
       imm.Log("Error search string. No args")
       return "Error. See log window"
      str = " ".join(args)    
      imm.Log("Search string -> "+str) #выводим в лог, что ищем
      cur=imm.getCurrentAddress() # получаем текущий адрес
      mod_=imm.findModule(cur)   #получаем информацию о загруженной в отладчик проге
      hep=imm.getReferencedStrings(mod_[1]) # ищем все строки (а точнее, ссылки на них)
      for info_str in hep: #пробегаемся по всем строкам
       if (info_str[2].count(str))>0: # метод count возвращает число вхождений строки str в строке info_str[2]
        imm.Log("String reference found at address -> 0x%08X" % info_str[0]) #выводим в лог где найдена строка, содержащая введенную строку
      return "Done. See log window"
    
     
    #2 0x0c0de, 18 Jun 2008
    Last edited: 28 Jun 2008
  3. taha

    taha Elder - Старейшина

    Joined:
    20 Aug 2006
    Messages:
    399
    Likes Received:
    330
    Reputations:
    251
    На счет комментирования каждой строчки не согласен! Буду комментировать только то, что необходимо!

    Итак! Наверняка все исследовали CrackME от Great'a, который использует vm. Во время исследования этой вм, мной были написаны следущие скрипты. Скрипты немного кривоваты, но в качестве оправдания скажу, что они были написаны в боевых условиях!

    1: Разбор команд VM от Great'a. Данный скрипт разбирает только те команды, которые использует алгоритм защиты CrackME от Great'a.

    Code:
     Результат:
    
    | Address  | Message
    +----------+------------------------------------------
    |          | ...
    |          |
    |          | -----[ Mnemonics ]-----
    |          |
    | 004014BB | xor r4, r4
    | 004014C5 | mov r5, r0
    | 004014CF | add r5, r2
    | 004014D9 | mov r3, dword [r0]
    | 004014E3 | xor r3, r1
    | 004014ED | add r4, r3
    | 004014F7 | inc r0
    | 00401501 | cmp r0, r5
    |          | Execute if less:
    | 00401515 | mov [eip], 0x004014d9
    | 0040151F | cmp r4, r7
    |          | Execute if equal:
    | 00401533 | mov r8, 0x87148712
    | 0040153D | mov r4, 0x00000000
    |          |
    |          | ---[ End Mnemonics ]---
    Note: Address - это EIP виртуальной машины! Кстати!!! Я разбираю команду за командой и если бы Great применил старенький трюк с прыжком в середину команды или смешивание, то всё накрылось бы пиздой!

    Code:
    # -*- coding: cp1251 -*- 
    
    # Author: taha
    #   Data: 18.o6.2oo8
    #   Note: Разбор команд VM от Great'a. Данный скрипт разбирает только те команды, которые
    #         использует алгоритм защиты CrackME от Great'a.
    
    # Результат:
    
    #| Address  | Message
    #+----------+------------------------------------------
    #|          | ...
    #|          |
    #|          | -----[ Mnemonics ]-----
    #|          |
    #| 004014BB | xor r4, r4
    #| 004014C5 | mov r5, r0
    #| 004014CF | add r5, r2
    #| 004014D9 | mov r3, dword [r0]
    #| 004014E3 | xor r3, r1
    #| 004014ED | add r4, r3
    #| 004014F7 | inc r0
    #| 00401501 | cmp r0, r5
    #|          | Execute if less:
    #| 00401515 | mov [eip], 0x004014d9
    #| 0040151F | cmp r4, r7
    #|          | Execute if equal:
    #| 00401533 | mov r8, 0x87148712
    #| 0040153D | mov r4, 0x00000000
    #|          |
    #|          | ---[ End Mnemonics ]---
    
    # Note: Address - это EIP виртуальной машины! Кстати!!! Я разбираю команду за командой
    #       и  если  бы  Great  применил  старенький трюк с прыжком в середину команды или
    #       смешивание, то всё накрылось бы пиздой!
    
    import immlib
    
    imm = immlib.Debugger()
    
    def get_args(ind, reg, arg):
    	s = ""
    	if reg <= 0x9:
    		s = "r"+str(reg)
    		if ind == 0x1:						# Индикатор говорит нам, что команда берет DWORD по адресу reg+arg
    			s = "dword ["+s
    			if arg != 0:					# При arg равном 0'ю вспоминать о нем не обязательно
    				s = s + " + 0x%08x" % arg
    			s = s+"]"
    	elif reg == 0xC:						# reg равное 0xC, говорит о том, что arg не что иное как Immediate
    		s = "0x%08x" % arg
    	return s
    
    def main(args):
    	imm = immlib.Debugger()
    	imm.Log("")
    	imm.Log(" [ Author: taha", highlight=1)
    	imm.Log("     Data: 18.o6.2oo8", highlight=1)
    	imm.Log("       Special for Antichat ]", highlight=1)
    	imm.Log("")
    	imm.Log("-----[ Mnemonics ]-----", highlight=2)
    	imm.Log("")
    	pCode   = 0x4014BB
    	while 1:
    		a = (imm.readLong(pCode) & 0xFF)
    		opcode = a & 0x3F
    		bit8   = a >> 0x7
    		bit7   = (a >> 0x6) & 0x1
    		a = (imm.readLong(pCode+0x1) & 0xFF)
    		FieldB = a & 0x0F
    		FieldA = a >> 0x4
    		arg1 = imm.readLong(pCode+0x2)
    		arg2 = imm.readLong(pCode+0x6)
    		tReg2 = get_args(bit7,FieldA,arg2)
    		tReg1 = get_args(bit8,FieldB,arg1)
    		c_arg = 2
    		if opcode == 0x6:
    			mnem = "xor "
    		elif opcode == 0x3:
    			mnem = "mov "
    			if FieldB == 0xA:
    				tReg1 = "[eip]"
    				tReg2 = "0x%08x" % arg2
    		elif opcode == 0x4:
    			mnem = "add "
    		elif opcode == 0xA:
    			mnem = "inc "
    			c_arg = 1
    		elif opcode == 0xF:
    			mnem = "cmp "
    		elif opcode == 0x14:
    			mnem = "Execute if less: "
    			c_arg = 0
    		elif opcode == 0x10:
    			mnem = "Execute if equal: "
    			c_arg = 0
    		else:
    			break
    		if c_arg == 0:
    			imm.Log(mnem)
    		elif c_arg == 1:
    			imm.Log(mnem+tReg1, address = pCode)
    		elif c_arg == 2:
    			imm.Log(mnem+tReg1+", "+tReg2, address = pCode)
    		one_arg = 2
    		pCode += 0xA
    	imm.Log("")
    	imm.Log("---[ End Mnemonics ]---", highlight=2)
    2: Далее очень полезно было бы просматривать состояние регистров! Например возьмем | 004014ED | add r4, r3 из результата работы предыдущего скрипта! Поставим условную точку останова с условием "[vm_eip] == 004014ED" и исполним мой скрипт!

    Code:
    # -*- coding: cp1251 -*- 
    # Author: taha
    #   Data: 18.o6.2oo8
    #   Note: Подсматриваем  значения регистров виртуальной машины.
    #         Опять же, просматриваются только те регистры, которые
    #         задействованы в CrackME от Great'a.
    
    import immlib
    
    imm = immlib.Debugger()
    
    regs = ['r0 ','r1 ','r2 ','r3 ','r4 ','r5 ','r6 ','r7 ','r8 ','r9 ',\
    		'eip']
    
    def main(args):
    	imm.Log("")
    	imm.Log("Dump of registers: ", highlight=2)
    	imm.Log("")
    	count, addr_vm_regs = 0x0, 0x401400
    	for x in regs:
    		imm.Log(x+": 0x%08x " % imm.readLong(addr_vm_regs+count*4))
    		count += 0x1
    	return
     
    1 person likes this.
  4. taha

    taha Elder - Старейшина

    Joined:
    20 Aug 2006
    Messages:
    399
    Likes Received:
    330
    Reputations:
    251
    Усовершенствованная мелочь, более приятная))

    Пример: !tools LordPE ImpREC
    Note: Порядок неважен и регистр букв тоже!

    Code:
    # -*- coding: cp1251 -*- 
    # Author: taha
    #   Data: 19.o6.2oo8
    #   Note: Команда для запуска утилит, которые указаны в списке tools в формате alias, patch! 
    
    import os,immlib
    
    imm = immlib.Debugger()
    
    tools = ["LordPE","C:\Program Files\CrackersKit\LordPE\LordPE.EXE",\
                 "ImpRec","C:\Program Files\CrackersKit\ImpRec\ImportREC.exe"]
    
    def main(args):
    	if args:
    		imm.Log("[ Tools runner by taha -> Team Antichat.ru ]", highlight=1)
    		for x in args:
    			x = x.lower()
    			for i in range(len(tools)):
    				if tools[i].lower() == x:
    					os.startfile(tools[i+1])
    					imm.Log(" o %s is started" % tools[i], highlight=2)
    	else:
    		imm.Log("Error!!!")
    
     
    1 person likes this.
  5. taha

    taha Elder - Старейшина

    Joined:
    20 Aug 2006
    Messages:
    399
    Likes Received:
    330
    Reputations:
    251
    Еще одна приятная мелочь!
    Иногда нужно изменить много строчек кода! И изменять каждую, мягко говоря, неудобно. Следущая команда как раз поможет в этом вопросе! Конечно до функциональности plugin'ов типа IDAFicator или NonaWrite далеко, но это-же просто мелочь :)

    Пример: !asmedit 0x401400
    В появившемся окне пишем код и наблюдаем изменения по введенному вами адресу

    Code:
    # -*- coding: cp1251 -*- 
    # Нах комментиовать три строчки легкоусвояимоимоимого кода?
    
    import immlib, string
    
    imm = immlib.Debugger()
    
    def main(args):
    	if args:
    		addr = string.atoi(args[0],16)
    		imm.writeMemory(addr, imm.Assemble(imm.inputBox("Asm text:")))
    		imm.Log("<--[ Edited ]",address=addr, highlight=2)
    	else:
    		imm.Log("Error!")
     
    2 people like this.
  6. 0x0c0de

    0x0c0de Elder - Старейшина

    Joined:
    25 May 2007
    Messages:
    441
    Likes Received:
    395
    Reputations:
    297
    Next….
    Продолжаю. В комментах есть все =)

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys,string
    
    #-----------------------------c0d3d by 0x0c0de 2008---------------------------------------------------
    # Работа с процессами в отладчике-----------------------------------------------------------------
    #[Commands]
    # 1.Аттач к процессу 
    # первый аргумент -a, второй аргумент - вводите имя процесса без расширения
    #2. Перезапуск текущего отлаживаемого процесса - команда -r
    #3. Выход из отладчика -q
    #4. Пауза  - ключ -p
    #5. Справка по коммандам -h
    #---------------------------------------------------------------------------------------------------------------
    
    def main(args):
     imm = Debugger()
     if not args: # если не передано аргументов, то выводим в лог ругательство и завершаемся
      imm.Log("PScript: No args")
      imm.createLogWindow()
      return "Error. See log window"
     elif args[0]=="-a": # если сказали аттачиться к процессу
      process_list = imm.Ps() # получаем информацию о запущенных процессах
      for pr_info in process_list:
        if pr_info[1]==args[1]: # если совпало введенное имя процесса и имя процесса в памяти
         imm.Attach(pr_info[0]) #атачимся
         imm.createLogWindow()	#открываем log window 
         return "Attached =)"
     elif args[0]=="-r": # команда на рестарт текущего процесса
      imm.restartProcess(-2) # рестартим процесс без вывода сообщения-подтверждения (желаете с выводом - ставьте параметр -1)
      d_name = imm.getDebuggedName() # получаем имя загруженного в отладчик процесса
      imm.Log(d_name+" restarted ok")  
     elif args[0]=="-h":
      imm.Log("Process script keys:")
      imm.Log("Attach to process: -a process_name (no extension)")
      imm.Log("Restart current process -r")
      imm.Log("Close debugger -q")
      imm.Log("Pause process -p")
     elif args[0]=="-q": # выход из отладчика
      imm.quitDebugger()
     elif args[0]=="-p": # Pause
      imm.Pause()
      imm.Log("Pause ok")
     else:
      return "Invalid command. Use key -h for more info about commands"
     imm.createLogWindow()
     return "Done. See log window"
    

    Code:
    # -*- coding: cp1251 -*- 
    from immlib import *
    import struct,sys,string
    
    #-----------------------------------cod3d by 0x0c0de--------------------------------------------------------------------
    # собственно, в соседней теме было объяснено в принципе все относительно crack_me by taha
    # но если кто-то вдруг не понял - задачу взлома можно решить с помощью этого скрипта
    # По ходу выполнения появляются комменты по нужным адресам
    # Каков алгоритм генерации s/n - это я уже рассказала и показала (см. keygen) 
    #Все будет работать, если включить игнорирование все исключений
    #все возникшие вопросы - в осеку
    #---------------------------------------Nice Try!----------------------------------------------------------------------------
    
    def main(args):
     imm = Debugger()
     gt_address = imm.getAddress("user32.GetDlgItemTextA")
     if gt_address!=0:
      imm.setBreakpoint(gt_address+5)
      imm.Log("Breakpoint at GetDlgItemTextA -> 0x%08X" % (gt_address+5))
      # потом вы вводите свое имя и ключ какой-нибудь
      imm.Run()
      regs = imm.getRegs()
      imm.setComment(regs['EIP'],'<-Reading input')
      imm.deleteBreakpoint(gt_address+5) # удаляем бряк
      imm.runTillRet()
      imm.stepIn() # F7
      seh_list = imm.getSehChain() # получаем список из обработчиков seh 
      for seh_handler in seh_list:
       imm.Log("Seh handler -> 0x%08X " % seh_handler[1])
       imm.setBreakpoint(seh_handler[1])
       imm.Log("Breakpoint sets at -> 0x%08X" % seh_handler[1])
      imm.Log("Running ...")
      imm.Run()
      for seh_handler in seh_list:
       imm.deleteBreakpoint(seh_handler[1])
       imm.Log("Breakpoint deleted at -> 0x%08X" % seh_handler[1])
      regs = imm.getRegs()
      imm.setComment(regs['EIP'],'<-Seh handler')
      imm.setBreakpoint(regs['EIP']+33) # устанавливаем бряк на call vm_proc
      imm.Run()
      imm.setComment(regs['EIP']+33,'<-vm proc call')
      imm.deleteBreakpoint(regs['EIP']+33)
      imm.setBreakpoint(0x402113) 
      regs = imm.getRegs()
      while regs['EAX']!=0x0BADC0DE: # цикл пока eax не станет равным 0BADC0DE
       imm.Run()
       regs = imm.getRegs()
      imm.deleteBreakpoint(regs['EIP'])
      imm.stepIn()
      regs = imm.getRegs()
      imm.Log("Serial number for your name at address [DWORD]-> 0x%08X " %regs['EDX'])
      # серийный номер - дворд, лежащий по адресу, указанному в логе
      sn = imm.readLong(regs['EDX'])
      imm.Log("Serial number-> %08X " %sn)
      imm.createLogWindow()
      return "This all =)"
     
    Code:
    # -*- coding: cp1251 -*- 
    from immlib import*
    
    #----------------------------------c0d3d by 0x0c0de----------------------------------------------
    # данный скрипт ставит бряки на все команды, указанные в качестве аргумента
    # например !имя_скрипта  push eax
    #bp будут поставлены на все команды push eax в данном модуле
    #---------------------------------------------------------------------------------------------------------
    
    def main(args):
     imm = Debugger()
     if not args:
      return "Error. No args"
     cmm = " ".join(args)
     comm_list = imm.searchCommandsOnModule(imm.getCurrentAddress(),cmm) # находим все команды
     imm.Log("Search command "+cmm)
     for comm_ in comm_list: # обрабатываем все адреса с искомой командой
      imm.setBreakpoint(comm_[0]) # ставим бряки
      imm.Log("Breakpoint sets at -> 0x%08X" % comm_[0]) 
     imm.createLogWindow()
     return "Done"
    
     
    #6 0x0c0de, 28 Jun 2008
    Last edited: 28 Jun 2008
Loading...