├── InstructionCounter ├── InstructionCounter.py └── readme.txt ├── antlr_x86 ├── readme.txt └── x86.g ├── api_stats ├── apistats.py └── readme.txt ├── asmgen ├── asmgen.hs └── readme.txt ├── pe_finder ├── pe_finder.py └── readme.txt ├── pemap ├── pemap.txt └── readme.txt ├── readme.txt └── rublib ├── doc ├── classes │ ├── CreateHelper.html │ ├── Function.html │ ├── Function.src │ │ ├── M000113.html │ │ ├── M000114.html │ │ ├── M000115.html │ │ ├── M000116.html │ │ ├── M000117.html │ │ ├── M000118.html │ │ ├── M000119.html │ │ ├── M000120.html │ │ ├── M000121.html │ │ ├── M000122.html │ │ ├── M000123.html │ │ ├── M000124.html │ │ └── M000125.html │ ├── FunctionChunk.html │ ├── FunctionChunk.src │ │ ├── M000126.html │ │ ├── M000127.html │ │ ├── M000128.html │ │ ├── M000129.html │ │ ├── M000130.html │ │ ├── M000131.html │ │ ├── M000132.html │ │ └── M000133.html │ ├── Helper_X86.html │ ├── Helper_X86.src │ │ ├── M000105.html │ │ └── M000106.html │ ├── IdaFile.html │ ├── IdaFile.src │ │ ├── M000061.html │ │ ├── M000062.html │ │ ├── M000063.html │ │ ├── M000064.html │ │ ├── M000065.html │ │ ├── M000066.html │ │ ├── M000067.html │ │ ├── M000068.html │ │ ├── M000069.html │ │ ├── M000070.html │ │ ├── M000071.html │ │ ├── M000072.html │ │ ├── M000073.html │ │ ├── M000074.html │ │ ├── M000075.html │ │ ├── M000076.html │ │ ├── M000077.html │ │ ├── M000078.html │ │ └── M000079.html │ ├── IdaString.html │ ├── IdaString.src │ │ ├── M000100.html │ │ ├── M000101.html │ │ ├── M000102.html │ │ ├── M000103.html │ │ └── M000104.html │ ├── Instruction.html │ ├── Instruction.src │ │ ├── M000080.html │ │ ├── M000081.html │ │ ├── M000082.html │ │ ├── M000083.html │ │ ├── M000084.html │ │ ├── M000085.html │ │ ├── M000086.html │ │ ├── M000087.html │ │ ├── M000088.html │ │ ├── M000089.html │ │ ├── M000090.html │ │ ├── M000091.html │ │ ├── M000092.html │ │ ├── M000093.html │ │ ├── M000094.html │ │ └── M000095.html │ ├── Offset.html │ ├── Offset.src │ │ ├── M000012.html │ │ ├── M000013.html │ │ ├── M000014.html │ │ ├── M000015.html │ │ ├── M000016.html │ │ ├── M000017.html │ │ ├── M000018.html │ │ ├── M000019.html │ │ ├── M000020.html │ │ ├── M000021.html │ │ ├── M000022.html │ │ ├── M000023.html │ │ ├── M000024.html │ │ ├── M000025.html │ │ ├── M000026.html │ │ ├── M000027.html │ │ ├── M000028.html │ │ ├── M000029.html │ │ ├── M000030.html │ │ ├── M000031.html │ │ ├── M000032.html │ │ ├── M000033.html │ │ ├── M000034.html │ │ ├── M000035.html │ │ ├── M000036.html │ │ ├── M000037.html │ │ ├── M000038.html │ │ ├── M000039.html │ │ ├── M000040.html │ │ ├── M000041.html │ │ ├── M000042.html │ │ ├── M000043.html │ │ ├── M000044.html │ │ ├── M000045.html │ │ ├── M000046.html │ │ ├── M000047.html │ │ ├── M000048.html │ │ ├── M000049.html │ │ ├── M000050.html │ │ ├── M000051.html │ │ ├── M000052.html │ │ ├── M000053.html │ │ ├── M000054.html │ │ ├── M000055.html │ │ ├── M000056.html │ │ ├── M000057.html │ │ ├── M000058.html │ │ ├── M000059.html │ │ └── M000060.html │ ├── ReadString.html │ ├── Segment.html │ ├── Segment.src │ │ ├── M000001.html │ │ ├── M000002.html │ │ ├── M000003.html │ │ ├── M000004.html │ │ ├── M000005.html │ │ ├── M000006.html │ │ ├── M000007.html │ │ ├── M000008.html │ │ ├── M000009.html │ │ ├── M000010.html │ │ └── M000011.html │ ├── SegmentList.html │ ├── SegmentList.src │ │ ├── M000107.html │ │ ├── M000108.html │ │ ├── M000109.html │ │ ├── M000110.html │ │ ├── M000111.html │ │ └── M000112.html │ ├── Shared.html │ ├── Shared.src │ │ ├── M000134.html │ │ ├── M000135.html │ │ ├── M000136.html │ │ ├── M000137.html │ │ ├── M000138.html │ │ ├── M000139.html │ │ ├── M000140.html │ │ ├── M000141.html │ │ ├── M000142.html │ │ ├── M000143.html │ │ ├── M000144.html │ │ ├── M000145.html │ │ ├── M000146.html │ │ ├── M000147.html │ │ ├── M000148.html │ │ ├── M000149.html │ │ ├── M000150.html │ │ ├── M000151.html │ │ ├── M000152.html │ │ └── M000153.html │ ├── StringList.html │ └── StringList.src │ │ ├── M000096.html │ │ ├── M000097.html │ │ ├── M000098.html │ │ └── M000099.html ├── created.rid ├── files │ └── rublib_rb.html ├── fr_class_index.html ├── fr_file_index.html ├── fr_method_index.html ├── index.html └── rdoc-style.css ├── index.htm ├── readme.txt └── rublib.rb /InstructionCounter/InstructionCounter.py: -------------------------------------------------------------------------------- 1 | # 2 | # InstructionCounter for IDAPython 3 | # 4 | # Copyright (c) 2006 Sebastian Porst (webmaster@the-interweb.com) 5 | # All rights reserved. 6 | # 7 | # This software is licensed under the zlib/libpng License. 8 | # For more details see http://www.opensource.org/licenses/zlib-license.php 9 | 10 | from idautils import * 11 | 12 | try: 13 | print "Starting..." 14 | 15 | opcodes = {} 16 | 17 | total = 0 18 | 19 | for fnr in range(0, get_func_qty()): 20 | func = getn_func(fnr) 21 | 22 | for addr in range(func.startEA, func.endEA): 23 | 24 | flags = getFlags(addr) 25 | 26 | if isHead(flags) and isCode(flags): 27 | line = GetDisasm(addr) 28 | index = line.find(" ") 29 | opcode = line[:index + 1000 * (index == -1)] # Kill me for this line 30 | 31 | if opcodes.has_key(opcode): 32 | opcodes[opcode] = opcodes[opcode] + 1 33 | else: 34 | opcodes[opcode] = 1 35 | 36 | total = total + 1 37 | 38 | c = opcodes.items() 39 | c.sort(lambda x,y: y[1] - x[1]) 40 | 41 | print "Done." 42 | 43 | filename = AskFile(1, "*.*", "Save result to...") 44 | 45 | if filename != None: 46 | file = open(filename, "w") 47 | 48 | file.write("Opcode distribution of file: " + GetInputFilePath() + "\n") 49 | file.write("Total number of opcodes: " + str(total) + "\n\n") 50 | 51 | for i, v in enumerate(c): 52 | file.write("%04i. %06i %8.2f%% %s\n" % ((i+1), v[1], 100.0 * v[1] / total, v[0])) 53 | 54 | file.close() 55 | 56 | except: 57 | print "Unexpected error: ", sys.exc_info()[0] -------------------------------------------------------------------------------- /InstructionCounter/readme.txt: -------------------------------------------------------------------------------- 1 | Python script for counting the assembler instructions in an IDB file. -------------------------------------------------------------------------------- /antlr_x86/readme.txt: -------------------------------------------------------------------------------- 1 | This ANTLR grammar can be used to parse x86 assembler instructions given 2 | in a slightly modified MASM/IDA Pro syntax. -------------------------------------------------------------------------------- /api_stats/readme.txt: -------------------------------------------------------------------------------- 1 | This script collects exported functions from Windows DLL files and matches 2 | them with imported functions from various directories. 3 | 4 | I used this script to figure out what Windows API functions are pretty much 5 | never used and can therefore be abused for anti-emulation trickery. Turns 6 | out a whole lot of API functions are never used. -------------------------------------------------------------------------------- /asmgen/readme.txt: -------------------------------------------------------------------------------- 1 | Small Haskell program for generating many thousands of different x86 assembler 2 | instructions. The output can then be assembled into a binary file with MASM. 3 | 4 | I used this script to test disassemblers. -------------------------------------------------------------------------------- /pe_finder/pe_finder.py: -------------------------------------------------------------------------------- 1 | import os 2 | import sys 3 | import pefile 4 | import shutil 5 | 6 | from os.path import join, getsize 7 | 8 | # Directories where the PE files are located. 9 | # If the second tuple-member is True, this directory is traversed recursively. 10 | input_dirs = [('C:\program files', True), ('C:\windows', False), ('C:\windows\system32', False)] 11 | 12 | output_dir = None 13 | 14 | # Valid extensions of PE files which import functions 15 | input_extensions = [ 'exe', 'dll' ] 16 | 17 | verbose_mode = True 18 | 19 | def file_qualifies(filename, valid_extensions): 20 | """ 21 | Checks whether a file ends with one of the file extensions 22 | from the valid_extensions argument. 23 | """ 24 | for extension in valid_extensions: 25 | if filename.endswith(extension): 26 | return True 27 | 28 | return False 29 | 30 | def process_file(filename): 31 | """ 32 | Copies the file to the output directory if it is a valid PE file. 33 | """ 34 | if verbose_mode: 35 | print "Processing file %s" % filename 36 | 37 | try: 38 | pe = pefile.PE(filename, fast_load=True) 39 | 40 | parts = filename.split("\\") 41 | 42 | shutil.copyfile(filename, join(output_dir, parts[-1])) 43 | 44 | except pefile.PEFormatError: 45 | if verbose_mode: 46 | print "Skipping: File could not be read (probably a 16bit file)" 47 | 48 | if not output_dir: 49 | print "Error: Please configure the output directory" 50 | sys.exit(0) 51 | 52 | for input_dir, do_walk in input_dirs: 53 | 54 | if do_walk: 55 | for root, dirs, files in os.walk(input_dir): 56 | for file in [file for file in files if file_qualifies(file.lower(), input_extensions)]: 57 | process_file(join(root, file)) 58 | else: 59 | for file in [file for file in os.listdir(input_dir) if file_qualifies(file.lower(), input_extensions)]: 60 | process_file(join(input_dir, file)) 61 | -------------------------------------------------------------------------------- /pe_finder/readme.txt: -------------------------------------------------------------------------------- 1 | Script that uses Ero Carrera's pefile library to search for PE files. 2 | This is useful for creating test sets of PE files for automatically 3 | testing tools that parse or manipulate PE files. -------------------------------------------------------------------------------- /pemap/pemap.txt: -------------------------------------------------------------------------------- 1 | Overview of the addresses of MZ header fields and PE header fields - v1.00 by sp; http://www.the-interweb.com 2 | 3 | MZ Header 4 | 5 | 0x0000 Magic 6 | 0x0002 Bytes on last page of file 7 | 0x0004 Pages in file 8 | 0x0006 Relocations 9 | 0x0008 Size of header in paragraphs 10 | 0x000A Minimum extra paragraphs needed 11 | 0x000C Maximum extra paragraphs needed 12 | 0x000E Initial (relative) SS value 13 | 0x0010 Initial SP value 14 | 0x0012 Checksum 15 | 0x0014 Initial IP value 16 | 0x0016 Initial (relative) CS value 17 | 0x0018 File address of relocation table 18 | 0x001A Overlay number 19 | 0x001C Reserved words 1a 20 | 0x001E Reserved words 1b 21 | 0x0020 Reserved words 1c 22 | 0x0022 Reserved words 1d 23 | 0x0024 OEM Identifier 24 | 0x0026 OEM Information 25 | 0x0028 Reserved words 2a 26 | 0x002A Reserved words 2b 27 | 0x002C Reserved words 2c 28 | 0x002E Reserved words 2d 29 | 0x0030 Reserved words 2e 30 | 0x0032 Reserved words 2f 31 | 0x0034 Reserved words 2g 32 | 0x0036 Reserved words 2h 33 | 0x0038 Reserved words 2i 34 | 0x003A Reserved words 2j 35 | 0x003C File address of new exe header 36 | 37 | PE Header 38 | 39 | 0x0000 NT Signature 40 | 0x0004 Machine 41 | 0x0006 NumberOfSections 42 | 0x0008 TimeDateStamp 43 | 0x000C PointerToSymbolTable 44 | 0x0010 NumberOfSymbols 45 | 0x0014 SizeOfOptionalHeader 46 | 0x0016 Characteristics 47 | 0x0018 Magic 48 | 0x001A MajorLinkerVersion 49 | 0x001B MinorLinkerVersion 50 | 0x001C SizeOfCode 51 | 0x0020 SizeOfInitializedData 52 | 0x0024 SizeOfUninitializedData 53 | 0x0028 AddressOfEntryPoint 54 | 0x002C BaseOfCode 55 | 0x0030 BaseOfData 56 | 0x0034 ImageBase 57 | 0x0038 SectionAlignment 58 | 0x003C FileAlignment 59 | 0x0040 MajorOperatingSystemVersion 60 | 0x0042 MinorOperatingSystemVersion 61 | 0x0044 MajorImageVersion 62 | 0x0046 MinorImageVersion 63 | 0x0048 MajorSubsystemVersion 64 | 0x004A MinorSubsystemVersion 65 | 0x004C Reserved 66 | 0x0050 SizeOfImage 67 | 0x0054 SizeOfHeaders 68 | 0x0058 CheckSum 69 | 0x005C Subsystem 70 | 0x005E DLL Characteristics 71 | 0x0060 SizeOfStackReserve 72 | 0x0064 SizeOfStackCommit 73 | 0x0068 SizeOfHeapReserve 74 | 0x006C SizeOfHeapCommit 75 | 0x0070 LoaderFlags 76 | 0x0074 NumberOfRvaAndSizes 77 | 78 | Data Directories (Assuming 0x10 Data Directories exist in the file) 79 | 80 | 0x0078 Export Table (Address) 81 | 0x007C Export Table (Size) 82 | 0x0080 Import Table (Address) 83 | 0x0084 Import Table (Size) 84 | 0x0088 Resource Table (Address) 85 | 0x008C Resource Table (Size) 86 | 0x0090 Exception Table (Address) 87 | 0x0094 Exception Table (Size) 88 | 0x0098 Certificate Table (Address) 89 | 0x009C Certificate Table (Size) 90 | 0x00A0 Base Relocation Table (Address) 91 | 0x00A4 Base Relocation Table (Size) 92 | 0x00A8 Debug (Address) 93 | 0x00AC Debug (Size) 94 | 0x00B0 Architecture (Address) 95 | 0x00B4 Architecture (Size) 96 | 0x00B8 Global Ptr (Address) 97 | 0x00BC Global Ptr (Size) 98 | 0x00C0 TLS Table (Address) 99 | 0x00C4 TLS Table (Size) 100 | 0x00C8 Load Config Table (Address) 101 | 0x00CC Load Config Table (Size) 102 | 0x00D0 Bound Import (Address) 103 | 0x00D4 Bound Import (Size) 104 | 0x00D8 IAT (Address) 105 | 0x00DC IAT (Size) 106 | 0x00E0 Delay Import Descriptor (Address) 107 | 0x00E4 Delay Import Descriptor (Size) 108 | 0x00E8 COM+ Runtime Header (Address) 109 | 0x00EC COM+ Runtime Header (Size) 110 | 0x00F0 Reserved 111 | 0x00F4 Reserved 112 | 113 | Sections (Assuming 3 sections) 114 | 115 | 0x00F8 Name (Section 1) 116 | 0x0100 VirtualSize (Section 1) 117 | 0x0104 VirtualAddress (Section 1) 118 | 0x0108 SizeOfRawData (Section 1) 119 | 0x010C PointerToRawData (Section 1) 120 | 0x0110 PointerToRelocations (Section 1) 121 | 0x0114 PointerToLinenumbers (Section 1) 122 | 0x0118 NumberOfRelocations (Section 1) 123 | 0x011A NumberOfLinenumbers (Section 1) 124 | 0x011C Characteristics (Section 1) 125 | 126 | 0x0120 Name (Section 2) 127 | 0x0128 VirtualSize (Section 2) 128 | 0x012C VirtualAddress (Section 2) 129 | 0x0130 SizeOfRawData (Section 2) 130 | 0x0134 PointerToRawData (Section 2) 131 | 0x0138 PointerToRelocations (Section 2) 132 | 0x013C PointerToLinenumbers (Section 2) 133 | 0x0140 NumberOfRelocations (Section 2) 134 | 0x0142 NumberOfLinenumbers (Section 2) 135 | 0x0144 Characteristics (Section 2) 136 | 137 | 0x0148 Name (Section 3) 138 | 0x0150 VirtualSize (Section 3) 139 | 0x0154 VirtualAddress (Section 3) 140 | 0x0158 SizeOfRawData (Section 3) 141 | 0x015C PointerToRawData (Section 3) 142 | 0x0160 PointerToRelocations (Section 3) 143 | 0x0164 PointerToLinenumbers (Section 3) 144 | 0x0166 NumberOfRelocations (Section 3) 145 | 0x0168 NumberOfLinenumbers (Section 3) 146 | 0x016C Characteristics (Section 3) -------------------------------------------------------------------------------- /pemap/readme.txt: -------------------------------------------------------------------------------- 1 | Simple overview of the addresses of structure entries in PE files. -------------------------------------------------------------------------------- /readme.txt: -------------------------------------------------------------------------------- 1 | Collection of scripts I used at one point for reverse engineering. 2 | For more information about the individual scripts, please check 3 | the readme.txt files in the corresponding directories. 4 | 5 | api_stats 6 | Python script for finding unused Win32 API functions. 7 | 8 | antlr_x86 9 | ANTLR grammar file for parsing x86 assembler instructions. 10 | 11 | asmgen 12 | Haskell program for generating x86 assembler instructions. 13 | 14 | InstructionCounter 15 | Python script for counting the assembler instructions in an IDB file. 16 | 17 | pe_finder 18 | Python script to find PE files. 19 | 20 | pemap 21 | Simple overview of the addresses of structure entries in PE files. 22 | 23 | rublib 24 | A high-level API for writing IDA Pro scripts in Ruby. -------------------------------------------------------------------------------- /rublib/doc/classes/CreateHelper.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | Module: CreateHelper 9 | 10 | 11 | 12 | 43 | 44 | 45 | 46 | 47 | 48 | 49 |
50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 63 | 64 | 65 |
ModuleCreateHelper
In: 58 | 59 | rublib.rb 60 | 61 |
62 |
66 |
67 | 68 | 69 |
70 | 71 | 72 | 73 |
74 | 75 |
76 |

77 | Creates helper objects 78 |

79 | 80 |
81 | 82 | 83 |
84 | 85 | 86 |
87 | 88 | 89 | 90 | 91 |
92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 |
104 | 105 | 106 |
107 |

[Validate]

108 |
109 | 110 | 111 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000113.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | reset (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 848
14 |         def reset
15 |                 @inst_num = -1
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000114.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 860
14 |         def initialize(ida, index)
15 |                 raise "Invalid index" if index < 0 || index >= ida.get_func_qty
16 |         
17 |                 @ida = ida
18 |                 @index = index
19 |                 @func = @ida.getn_func(index)
20 |                 @inst_num = -1
21 |         end
22 | 23 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000115.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | [] (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 925
14 |         def [](index)
15 |         
16 |                 if index.kind_of? Range
17 |                         return index.map{|i| at(i)}
18 |                 end
19 |                 
20 |                 at(index)
21 |         end
22 | 23 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000116.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | name (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 937
14 |         def name
15 |                 @ida.get_func_name(address)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000117.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | name= (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 944
14 |         def name=(value)
15 |                 start.name = value
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000118.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | comment (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 951
14 |         def comment
15 |                 @ida.get_func_cmt(@func, false)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000119.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | comment= (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 958
14 |         def comment=(value)
15 |                 @ida.set_func_cmt(@func, value, false)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000120.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | contains_offset? (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 969
14 |         def contains_offset?(offset)
15 |                 @ida.func_contains(@func, offset)
16 | #               start.offset <= offset && self.end.offset >= offset
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000121.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | number_of_instructions (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 975
14 |         def number_of_instructions
15 |         
16 |                 if @inst_num != -1
17 |                         return @inst_num
18 |                 end
19 |         
20 |                 iter = @ida.Func_tail_iterator_t.new(@func)
21 |                 ctr = 0
22 |                 
23 |                 begin 
24 |                         start_offset = iter.chunk().startEA
25 |                         end_offset = iter.chunk().endEA
26 |                         
27 |                         for addr in (start_offset ... end_offset)
28 |                                 
29 |                                 flags = @ida.getFlags(addr)
30 |                                 
31 |                                 if @ida.isHead(flags) and @ida.isCode(flags)
32 |                                         ctr = ctr + 1
33 |                                 end
34 |                                 
35 |                         end
36 |                 end while iter.next()
37 |                 
38 |                 @inst_num = ctr
39 |                 
40 |                 return ctr
41 |         end
42 | 43 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000122.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | each (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1007
14 |         def each
15 |                 iter = @ida.Func_tail_iterator_t.new(@func)
16 |                 
17 |                 begin 
18 |                         start_offset = iter.chunk().startEA
19 |                         end_offset = iter.chunk().endEA
20 |                         
21 |                         for addr in (start_offset ... end_offset)
22 |                                 
23 |                                 flags = @ida.getFlags(addr)
24 |                                 
25 |                                 if @ida.isHead(flags) and @ida.isCode(flags)
26 |                                         yield Instruction.new(@ida, addr)
27 |                                 end
28 |                                 
29 |                         end
30 |                 end while iter.next()
31 | 
32 | #               for addr in (start .. self.end)
33 | #                       if addr.head? and addr.code?
34 | #                               yield Line.new(@ida, addr.offset)
35 | #                       end
36 | #               end
37 |         end
38 | 39 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000123.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | chunks (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1035
14 |         def chunks
15 |                 iter = @ida.Func_tail_iterator_t.new(@func)
16 |                 
17 |                 c = [ ]
18 |                 
19 |                 iter.main()
20 |                 
21 |                 c << FunctionChunk.new(@ida, iter.chunk())
22 |                 
23 |                 while iter.next()
24 |                         c << FunctionChunk.new(@ida, iter.chunk())
25 |                 end
26 |                 
27 |                 return c
28 |         end
29 | 30 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000124.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | instructions (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1054
14 |         def instructions
15 |         
16 |                 inst = [ ]
17 |                 
18 |                 self.each{|i| inst << i }
19 |                 
20 |                 return inst
21 |         
22 |         end
23 | 24 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000125.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | address (Function) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1065
14 |         def address
15 |                 @func.startEA
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000126.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | reset (FunctionChunk) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1079
14 |         def reset
15 |                 @inst_num = -1
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000127.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (FunctionChunk) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1087
14 |         def initialize(ida, chunk)
15 |                 @ida = ida
16 |                 @chunk = chunk
17 |                 @inst_num = -1
18 |         end
19 | 20 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000128.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | first_offset (FunctionChunk) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1096
14 |         def first_offset
15 |                 Offset.new(@ida, @chunk.startEA)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000129.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | last_offset (FunctionChunk) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1103
14 |         def last_offset
15 |                 Offset.new(@ida, @chunk.endEA - 1)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000130.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | number_of_instructions (FunctionChunk) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1108
14 |         def number_of_instructions
15 |         
16 |                 if @inst_num != -1
17 |                         return @inst_num
18 |                 end
19 |         
20 |                 start_offset = address
21 |                 end_offset = last_offset.address
22 |                 ctr = 0
23 |                 
24 |                 for addr in (start_offset ... end_offset)
25 |                         
26 |                         flags = @ida.getFlags(addr)
27 |                         
28 |                         if @ida.isHead(flags) and @ida.isCode(flags)
29 |                                 ctr = ctr + 1
30 |                         end
31 |                         
32 |                 end
33 |                 
34 |                 @inst_num = ctr
35 |                 
36 |                 return ctr
37 |         end
38 | 39 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000131.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | each (FunctionChunk) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1136
14 |         def each
15 |                 for addr in (first_offset.address .. last_offset.address)
16 |                 
17 |                         flags = @ida.getFlags(addr)
18 |                         
19 |                         if @ida.isHead(flags) and @ida.isCode(flags)
20 |                                 yield Instruction.new(@ida, addr)
21 |                         end
22 |                 end
23 |         end
24 | 25 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000132.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | [] (FunctionChunk) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1203
14 |         def [](index)
15 |                 if index.kind_of? Range
16 |                         return index.map{|i| at(i)}
17 |                 end
18 |                 
19 |                 at(index)
20 |         end
21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000133.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | address (FunctionChunk) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1212
14 |         def address
15 |                 @chunk.startEA
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Helper_X86.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | Class: Helper_X86 9 | 10 | 11 | 12 | 43 | 44 | 45 | 46 | 47 | 48 | 49 |
50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 63 | 64 | 65 | 66 | 67 | 70 | 71 |
ClassHelper_X86
In: 58 | 59 | rublib.rb 60 | 61 |
62 |
Parent: 68 | Object 69 |
72 |
73 | 74 | 75 |
76 | 77 | 78 | 79 |
80 | 81 |
82 |

83 | Helps to create x86 specific instruction information 84 |

85 | 86 |
87 | 88 | 89 |
90 | 91 |
92 |

Methods

93 | 94 |
95 | mnemonic   96 | new   97 |
98 |
99 | 100 |
101 | 102 | 103 | 104 | 105 |
106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 |
116 |

Public Class methods

117 | 118 |
119 | 120 | 121 |
122 | 124 | new(ida) 125 | 126 |
127 | 128 |
129 |

130 | Creates a new Helper_X86 object 132 |

133 | 
134 |  The parameter ida is an IdaRub object.
135 | 
136 |  An exception is raised if ida is nil
137 |
138 |
139 |
140 | 141 |

Public Instance methods

142 | 143 |
144 | 145 | 146 |
147 | 149 | mnemonic(instruction) 150 | 151 |
152 | 153 |
154 |

155 | Returns the mnemonic belonging to a 156 | instruction 157 |

158 |
159 |
160 | 161 | 162 |
163 | 164 | 165 |
166 | 167 | 168 |
169 |

[Validate]

170 |
171 | 172 | 173 | -------------------------------------------------------------------------------- /rublib/doc/classes/Helper_X86.src/M000105.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (Helper_X86) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 20
14 |         def initialize(ida)
15 |         
16 |                 raise "Invalid IdaRub object" if ida == nil
17 |                 
18 |                 @ida = ida
19 |                 
20 |         end
21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/Helper_X86.src/M000106.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | mnemonic (Helper_X86) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 29
14 |         def mnemonic(instruction)
15 |                 if @ida.ua_mnem(instruction.offset) != nil:
16 |                         mnem = @ida.cmd.get_canon_mnem
17 | 
18 |                         byte = instruction.byte
19 |                         
20 |                         if byte == 0xF3
21 |                                 if mnem == "scas"
22 |                                         return "repe " + mnem
23 |                                 else
24 |                                         return "rep " + mnem
25 |                                 end
26 |                         elsif byte == 0xF2
27 |                                         return "repne " + mnem
28 |                         elsif byte == 0xF0
29 |                                         return "lock " + mnem
30 |                         else
31 |                                 return mnem
32 |                         end
33 |                 else
34 |                         return nil
35 |                 end
36 |         end
37 | 38 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000061.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1381
14 |         def initialize(ida)
15 |         
16 |                 raise "Error: Invalid IdaRub object" if ida == nil
17 |         
18 |                 @ida = ida
19 |         end
20 | 21 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000062.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | [] (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1400
14 |         def [](index)
15 |                 if index.kind_of? Range
16 |                         index.map{|i| at(i)}
17 |                 else
18 |                         at(index)
19 |                 end
20 |         end
21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000063.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | name (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1425
14 |         def name
15 |                 @ida.get_root_filename
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000064.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | path (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1432
14 |         def path
15 |                 @ida.get_input_file_path
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000065.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | screen_ea (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1439
14 |         def screen_ea
15 |                 Offset.new(@ida, @ida.get_screen_ea)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000066.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | number_of_functions (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1446
14 |         def number_of_functions
15 |                 @ida.get_func_qty
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000067.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | function_by_name (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1455
14 |         def function_by_name(function_name)
15 |         
16 |                 self.each { |function| return function if function.name == function_name }
17 |                 
18 |                 return nil
19 |         end
20 | 21 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000068.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | crc32 (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1465
14 |         def crc32
15 |                 @ida.retrieve_input_file_crc32
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000069.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | processor_name (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1477
14 |         def processor_name
15 |                 @ida.inf.procName
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000070.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | filetype (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1484
14 |         def filetype
15 |                 @ida.inf.filetype
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000071.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | start_offset (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1491
14 |         def start_offset
15 |                 Offset.new(@ida, @ida.inf.beginEA)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000072.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | first_offset (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1498
14 |         def first_offset
15 |                 Offset.new(@ida, @ida.inf.minEA)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000073.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | last_offset (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1505
14 |         def last_offset
15 |                 Offset.new(@ida, @ida.inf.maxEA - 1)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000074.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | segments (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1512
14 |         def segments
15 |                 SegmentList.new(@ida)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000075.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | number_of_entry_points (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1519
14 |         def number_of_entry_points
15 |                 @ida.get_entry_qty()
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000076.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | entry_points (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1526
14 |         def entry_points
15 |                 (0 ... number_of_entry_points).map{|i| Offset.new(@ida, @ida.get_entry(@ida.get_entry_ordinal(i)))}
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000077.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | each (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1533
14 |         def each
15 |                 number_of_functions.times {|i| yield Function.new(@ida, i)}
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000078.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | string_list (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1540
14 |         def string_list
15 |                 StringList.new(@ida)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000079.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | helper (IdaFile) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1545
14 |         def helper
15 |                 @helper
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000100.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (IdaString) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1559
14 |         def initialize(ida, index)
15 |                 @ida = ida
16 |                 @index = index
17 |                 
18 |                 @str = @ida.String_info_t.new
19 |                 @ida.get_strlist_item(@index, @str)
20 |         end
21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000101.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | address (IdaString) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1568
14 |         def address
15 |                 @str.ea
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000102.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | offset (IdaString) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1575
14 |         def offset
15 |                 Offset.new(@ida, @str.ea)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000103.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | type (IdaString) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1582
14 |         def type
15 |                 @str.type
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000104.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | value (IdaString) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1589
14 |         def value
15 |                 return read_ascii(@ida, offset.address) if type == 0
16 |                 return read_unicode(@ida, offset.address) if type == 3
17 | 
18 |                 raise "Invalid string type"
19 |         end
20 | 21 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000080.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | address (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 682
14 |         def address
15 |                 @ea
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000081.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 690
14 |         def initialize(ida, ea)
15 |                 @ida = ida
16 |                 @ea = ea
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000082.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | == (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 698
14 |         def ==(rhs)
15 |                 @ea == rhs[0].address
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000083.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | mnemonic (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 705
14 |         def mnemonic
15 |                 if @helper == nil
16 |                         @ida.ua_mnem(@ea)
17 |                         @ida.cmd.get_canon_mnem
18 |                 else
19 |                         @helper.mnemonic(self)
20 |                 end
21 |         end
22 | 23 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000084.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | instruction_type (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 715
14 |         def instruction_type
15 |                 @ida.ua_mnem(@ea)
16 |                 @ida.cmd.itype
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000085.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | instruction_size (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 723
14 |         def instruction_size
15 |                 @ida.ua_mnem(@ea)
16 |                 @ida.cmd.size
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000086.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | operand (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 729
14 |         def operand(index)
15 |                 @ida.ua_mnem(@ea)
16 |                 @ida.cmd.Operands.remote_methods
17 | #               @ida.cmd.Operands.type
18 | #               @ida.cmd.Operands.ea
19 | #               @ida.cmd.ir_get_operand(0).to_s
20 |         end
21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000087.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | line (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 740
14 |         def line
15 |                 @ida.tag_remove(unstripped_line)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000088.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | unstripped_line (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 747
14 |         def unstripped_line
15 |                 @ida.generate_disasm_line(@ea)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000089.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | manual? (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 754
14 |         def manual?
15 |                 @ida.is_manual_insn(@ea)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000090.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | manual_line (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 761
14 |         def manual_line
15 |                 @ida.get_manual_insn(@ea)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000091.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | manual_line= (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 768
14 |         def manual_line=(line)
15 |                 @ida.set_manual_insn(@ea, line)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000092.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | split_instruction (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 774
14 |         def split_instruction
15 |                 tline = line
16 |                 
17 |                 tline, comm = tline.split(/; /, 2)
18 | 
19 |                 while (tline.include?("   "))
20 |                         tline.gsub!(/   /, "  ")
21 |                 end
22 |                 
23 |                 tline.split(/  /) << comm
24 |         end
25 | 26 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000093.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | bytes (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 789
14 |         def bytes
15 |                 @ida.get_many_bytes(self[0].address, instruction_size).unpack("C*")
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000094.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | byte_objects (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 796
14 |         def byte_objects
15 |                 offsets = [ ]
16 |                 
17 |                 for i in ( 0 ... instruction_size)
18 |                         offsets << Offset.new(@ida, self[0].address + i)
19 |                 end
20 |                 
21 |                 return offsets
22 |         end
23 | 24 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000095.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | [] (Instruction) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 812
14 |         def [](index)
15 |                 if index.kind_of? Range
16 |                         return index.map{|i| at(i)}
17 |                 end
18 |                 
19 |                 at(index)
20 |         end
21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000012.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | address (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 324
14 |         def address
15 |                 @offset
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000013.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 333
14 |         def initialize(ida, offset)
15 |                 @ida = ida
16 |                 @offset = offset
17 |                 @helper = create_helper(ida)
18 |         end
19 | 20 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000014.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | <=> (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 343
14 |         def <=>(rhs)
15 |                 @offset <=> rhs.offset
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000015.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | succ (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 349
14 |         def succ
15 |                 Offset.new(@ida, @offset + 1)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000016.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | enabled? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 356
14 |         def enabled?
15 |                 @ida.isEnabled(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000017.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | ascii (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 363
14 |         def ascii
15 |                 read_ascii(@ida, @offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000018.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | unicode (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 370
14 |         def unicode
15 |                 read_unicode(@ida, @offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000019.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | byte (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 377
14 |         def byte
15 |                 @ida.get_byte(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000020.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | byte= (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 384
14 |         def byte=(value)
15 |                 @ida.patch_byte(@offset, value)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000021.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | word (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 392
14 |         def word
15 |                 @ida.get_word(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000022.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | word= (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 399
14 |         def word=(value)
15 |                 @ida.patch_word(@offset, value)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000023.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | three_bytes (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 407
14 |         def three_bytes
15 |                 @ida.get_3byte(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000024.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | word= (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 414
14 |         def word=(value)
15 |                 @ida.patch_word(@offset, value)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000025.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | dword (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 422
14 |         def dword
15 |                 @ida.get_long(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000026.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | dword= (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 429
14 |         def dword=(value)
15 |                 @ida.patch_long(@offset, value)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000027.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | qword (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 435
14 |         def qword
15 |                 @ida.get_qword(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000028.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | dword= (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 442
14 |         def dword=(value)
15 |                 @ida.patch_long(@offset, value)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000029.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | original_byte (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 450
14 |         def original_byte
15 |                 @ida.get_original_byte(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000030.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | original_word (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 457
14 |         def original_word
15 |                 @ida.get_original_word(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000031.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | original_dword (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 464
14 |         def original_dword
15 |                 @ida.get_original_long(@offset)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000032.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | head? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 471
14 |         def head?
15 |                 @ida.isHead(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000033.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | tail? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 478
14 |         def tail?
15 |                 @ida.isTail(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000034.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | not_tail? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 485
14 |         def not_tail?
15 |                 @ida.isNotTail(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000035.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | code? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 492
14 |         def code?
15 |                 @ida.isCode(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000036.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | data? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 499
14 |         def data?
15 |                 @ida.isData(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000037.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | unknown? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 506
14 |         def unknown?
15 |                 @ida.isUnknown(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000038.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | flow? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 513
14 |         def flow?
15 |                 @ida.isFlow(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000039.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_byte (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 520
14 |         def do_byte(length)
15 |                 @ida.doByte(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000040.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_word (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 527
14 |         def do_word(length)
15 |                 @ida.doWord(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000041.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_dword (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 534
14 |         def do_dword(length)
15 |                 @ida.doDwrd(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000042.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_qword (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 541
14 |         def do_qword(length)
15 |                 @ida.doQwrd(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000043.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_oword (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 548
14 |         def do_oword(length)
15 |                 @ida.doOwrd(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000044.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_tbyte (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 555
14 |         def do_tbyte(length)
15 |                 @ida.doTbyt(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000045.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_float (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 562
14 |         def do_float(length)
15 |                 @ida.doFloat(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000046.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_double (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 569
14 |         def do_double(length)
15 |                 @ida.doDouble(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000047.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_packed_real (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 576
14 |         def do_packed_real(length)
15 |                 @ida.doPackReal(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000048.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_ascii (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 580
14 |         def do_ascii(length)
15 |                 @ida.doASCI(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000049.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | do_three_byte (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 587
14 |         def do_three_byte(length)
15 |                 @ida.do3byte(@offset, length)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000050.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | byte? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 594
14 |         def byte?
15 |                 @ida.isByte(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000051.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | word? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 601
14 |         def word?
15 |                 @ida.isWord(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000052.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | dword? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 608
14 |         def dword?
15 |                 @ida.isDwrd(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000053.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | qword? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 615
14 |         def qword?
15 |                 @ida.isQwrd(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000054.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | oword? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 622
14 |         def oword?
15 |                 @ida.isOwrd(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000055.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | tbyte? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 629
14 |         def tbyte?
15 |                 @ida.isTbyt(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000056.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | float? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 636
14 |         def float?
15 |                 @ida.isFloat(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000057.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | double? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 643
14 |         def double?
15 |                 @ida.isDouble(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000058.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | packed_real? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 650
14 |         def packed_real?
15 |                 @ida.isPackReal(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000059.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | ascii? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 654
14 |         def ascii?
15 |                 @ida.isASCII(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000060.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | three_byte? (Offset) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 661
14 |         def three_byte?
15 |                 @ida.is3byte(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/ReadString.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | Module: ReadString 9 | 10 | 11 | 12 | 43 | 44 | 45 | 46 | 47 | 48 | 49 |
50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 63 | 64 | 65 |
ModuleReadString
In: 58 | 59 | rublib.rb 60 | 61 |
62 |
66 |
67 | 68 | 69 |
70 | 71 | 72 | 73 |
74 | 75 |
76 |

77 | This module can be used to read strings from arbitrary offsets 78 |

79 | 80 |
81 | 82 | 83 |
84 | 85 | 86 |
87 | 88 | 89 | 90 | 91 |
92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 |
104 | 105 | 106 |
107 |

[Validate]

108 |
109 | 110 | 111 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000001.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1226
14 |         def initialize(ida, segment)
15 |         
16 |                 raise "Invalid IdaRub object" if ida == nil
17 |                 raise "Invalid segment" if segment == nil
18 |         
19 |                 @ida = ida
20 |                 @segment = segment
21 |         end
22 | 23 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000002.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | first_offset (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1238
14 |         def first_offset
15 |                 Offset.new(@ida, @segment.startEA)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000003.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | last_offset (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1245
14 |         def last_offset
15 |                 Offset.new(@ida, @segment.endEA - 1)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000004.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | name (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1252
14 |         def name
15 |                 # True name or untrue name here?
16 |                 @ida.get_true_segm_name(@segment)
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000005.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | class (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1260
14 |         def class
15 |                 @ida.get_segm_class(@segment)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000006.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | base (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1267
14 |         def base
15 |                 @ida.get_segm_base(@segment)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000007.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | comment (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1274
14 |         def comment
15 |                 @ida.get_segment_cmt(@segment, false)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000008.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | comment= (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1281
14 |         def comment=(cmt)
15 |                 @ida.set_segment_cmt(@segment, cmt, false)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000009.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | repeatable_comment (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1289
14 |         def repeatable_comment
15 |                 @ida.get_segment_cmt(@segment, true)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000010.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | repeatable_comment= (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1296
14 |         def repeatable_comment=(cmt)
15 |                 @ida.set_segment_cmt(@segment, cmt, true)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000011.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | remove (Segment) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1305
14 |         def remove(flags = 5)
15 |                 @ida.del_segm(start, flags)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000107.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (SegmentList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1322
14 |         def initialize(ida)
15 |                 
16 |                 raise "Invalid IdaRub object" if ida == nil
17 |         
18 |                 @ida = ida
19 |         end
20 | 21 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000108.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | number_of_segments (SegmentList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1332
14 |         def number_of_segments
15 |                 @ida.get_segm_qty()
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000109.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | [] (SegmentList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1341
14 |         def [](index)
15 |                 Segment.new(@ida, @ida.getnseg(index))
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000110.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | segment_by_offset (SegmentList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1350
14 |         def segment_by_offset(offset)
15 |                 Segment.new(@ida, @ida.getseg(offset))
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000111.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | add (SegmentList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1361
14 |         def add(para, startea, endea, name, sclass)
15 |                 @ida.add_segm(para, startea, endea, name, sclass)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000112.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | each (SegmentList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1367
14 |         def each
15 |                 number_of_segments.times{|i| yield self[i]}
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000134.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | flags (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 123
14 |         def flags
15 |                 @ida.getFlags(address)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000135.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | extra_lines? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 130
14 |         def extra_lines?
15 |                 @ida.hasExtra(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000136.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | comment? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 137
14 |         def comment?
15 |                 @ida.has_cmt(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000137.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | references? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 144
14 |         def references?
15 |                 @ida.hasRef(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000138.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | name (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 151
14 |         def name
15 |                 @ida.get_name(@ida.BADADDR, address)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000139.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | name= (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 158
14 |         def name=(name)
15 |                 @ida.set_name(address, name)
16 |                 @ida.refresh_idaview_anyway
17 |         end
18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000140.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | name? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 166
14 |         def name?
15 |                 @ida.has_name(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000141.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | dummy_name? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 173
14 |         def dummy_name?
15 |                 @ida.has_dummy_name(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000142.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | auto_name? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 180
14 |         def auto_name?
15 |                 @ida.has_auto_name(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000143.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | user_name? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 187
14 |         def user_name?
15 |                 @ida.has_user_name(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000144.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | any_name? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 194
14 |         def any_name?
15 |                 @ida.has_any_name(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000145.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | function_start? (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 200
14 |         def function_start?
15 |                 @ida.isFunc(flags)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000146.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | comment (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 207
14 |         def comment
15 |                 @ida.get_cmt(address, false)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000147.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | repeatable_comment (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 214
14 |         def repeatable_comment
15 |                 @ida.get_cmt(address, true)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000148.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | anterior_lines (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 240
14 |         def anterior_lines
15 |                 extra_lines(@ida.E_PREV)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000149.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | posterior_lines (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 247
14 |         def posterior_lines
15 |                 extra_lines(@ida.E_NEXT)
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000150.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | crefs_to (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 254
14 |         def crefs_to
15 |                 refs = []
16 |                 
17 |                 curr = @ida.get_first_cref_to(address)
18 |                 
19 |                 while curr != @ida.BADADDR
20 |                         refs << Instruction.new(@ida, curr)
21 |                         curr = @ida.get_next_cref_to(address, curr)
22 |                 end
23 |                 
24 |                 refs
25 |         end
26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000151.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | crefs_from (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 270
14 |         def crefs_from
15 |                 refs = []
16 |                 
17 |                 curr = @ida.get_first_cref_from(address)
18 |                 
19 |                 while curr != @ida.BADADDR
20 |                         refs << Instruction.new(@ida, curr)
21 |                         curr = @ida.get_next_cref_from(address, curr)
22 |                 end
23 |                 
24 |                 refs
25 |         end
26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000152.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | drefs_to (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 286
14 |         def drefs_to
15 |                 refs = []
16 |                 
17 |                 curr = @ida.get_first_dref_to(address)
18 |                 
19 |                 while curr != @ida.BADADDR
20 |                         refs << Offset.new(@ida, curr)
21 |                         curr = @ida.get_next_dref_to(address, curr)
22 |                 end
23 |                 
24 |                 refs
25 |         end
26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000153.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | drefs_from (Shared) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 302
14 |         def drefs_from
15 |                 refs = []
16 |                 
17 |                 curr = @ida.get_first_dref_from(address)
18 |                 
19 |                 while curr != @ida.BADADDR
20 |                         refs << Offset.new(@ida, curr)
21 |                         curr = @ida.get_next_dref_from(address, curr)
22 |                 end
23 |                 
24 |                 refs
25 |         end
26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/classes/StringList.src/M000096.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | new (StringList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1606
14 |         def initialize(ida)
15 |                 @ida = ida
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/StringList.src/M000097.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | [] (StringList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1627
14 |         def[](index)
15 |                 if index.kind_of? Range
16 |                         return index.map{|i| at(i)}
17 |                 end
18 |                 
19 |                 at(index)
20 |         end
21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/StringList.src/M000098.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | number_of_strings (StringList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1638
14 |         def number_of_strings
15 |                 @ida.get_strlist_qty()
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/StringList.src/M000099.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | each (StringList) 9 | 10 | 11 | 12 | 13 | 
# File rublib.rb, line 1645
14 |         def each
15 |                 number_of_strings.times{|i| yield IdaString.new(@ida, i) }
16 |         end
17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/created.rid: -------------------------------------------------------------------------------- 1 | Sat Feb 10 20:03:55 +0100 2007 2 | -------------------------------------------------------------------------------- /rublib/doc/files/rublib_rb.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | File: rublib.rb 9 | 10 | 11 | 12 | 43 | 44 | 45 | 46 | 47 | 48 | 49 |
50 |

rublib.rb

51 | 52 | 53 | 54 | 56 | 57 | 58 | 59 | 60 | 61 |
Path:rublib.rb 55 |
Last Update:Sat Feb 10 20:02:44 +0100 2007
62 |
63 | 64 | 65 |
66 | 67 | 68 | 69 |
70 | 71 |
72 |

73 | RubLib 0.04 74 |

75 |

76 | Copyright (c) 2006 - 2007 Sebastian Porst (webmaster@the-interweb.com) All 77 | rights reserved. 78 |

79 |

80 | This software is licensed under the zlib/libpng License. For more details 81 | see www.opensource.org/licenses/zlib-license.php 83 | or the readme file in the root directory. 84 |

85 | 86 |
87 | 88 |
89 |

Required files

90 | 91 |
92 | idarub   93 |
94 |
95 | 96 |
97 | 98 | 99 |
100 | 101 | 102 | 103 | 104 |
105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 |
117 | 118 | 119 |
120 |

[Validate]

121 |
122 | 123 | 124 | -------------------------------------------------------------------------------- /rublib/doc/fr_class_index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 6 | 7 | 12 | 13 | 14 | Classes 15 | 16 | 17 | 18 | 19 | 20 |
21 |

Classes

22 |
23 | CreateHelper
24 | Function
25 | FunctionChunk
26 | Helper_X86
27 | IdaFile
28 | IdaString
29 | Instruction
30 | Offset
31 | ReadString
32 | Segment
33 | SegmentList
34 | Shared
35 | StringList
36 |
37 |
38 | 39 | -------------------------------------------------------------------------------- /rublib/doc/fr_file_index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 6 | 7 | 12 | 13 | 14 | Files 15 | 16 | 17 | 18 | 19 | 20 |
21 |

Files

22 |
23 | rublib.rb
24 |
25 |
26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/index.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 11 | 12 | 13 | RDoc Documentation 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /rublib/doc/rdoc-style.css: -------------------------------------------------------------------------------- 1 | 2 | body { 3 | font-family: Verdana,Arial,Helvetica,sans-serif; 4 | font-size: 90%; 5 | margin: 0; 6 | margin-left: 40px; 7 | padding: 0; 8 | background: white; 9 | } 10 | 11 | h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; } 12 | h1 { font-size: 150%; } 13 | h2,h3,h4 { margin-top: 1em; } 14 | 15 | a { background: #eef; color: #039; text-decoration: none; } 16 | a:hover { background: #039; color: #eef; } 17 | 18 | /* Override the base stylesheet's Anchor inside a table cell */ 19 | td > a { 20 | background: transparent; 21 | color: #039; 22 | text-decoration: none; 23 | } 24 | 25 | /* and inside a section title */ 26 | .section-title > a { 27 | background: transparent; 28 | color: #eee; 29 | text-decoration: none; 30 | } 31 | 32 | /* === Structural elements =================================== */ 33 | 34 | div#index { 35 | margin: 0; 36 | margin-left: -40px; 37 | padding: 0; 38 | font-size: 90%; 39 | } 40 | 41 | 42 | div#index a { 43 | margin-left: 0.7em; 44 | } 45 | 46 | div#index .section-bar { 47 | margin-left: 0px; 48 | padding-left: 0.7em; 49 | background: #ccc; 50 | font-size: small; 51 | } 52 | 53 | 54 | div#classHeader, div#fileHeader { 55 | width: auto; 56 | color: white; 57 | padding: 0.5em 1.5em 0.5em 1.5em; 58 | margin: 0; 59 | margin-left: -40px; 60 | border-bottom: 3px solid #006; 61 | } 62 | 63 | div#classHeader a, div#fileHeader a { 64 | background: inherit; 65 | color: white; 66 | } 67 | 68 | div#classHeader td, div#fileHeader td { 69 | background: inherit; 70 | color: white; 71 | } 72 | 73 | 74 | div#fileHeader { 75 | background: #057; 76 | } 77 | 78 | div#classHeader { 79 | background: #048; 80 | } 81 | 82 | 83 | .class-name-in-header { 84 | font-size: 180%; 85 | font-weight: bold; 86 | } 87 | 88 | 89 | div#bodyContent { 90 | padding: 0 1.5em 0 1.5em; 91 | } 92 | 93 | div#description { 94 | padding: 0.5em 1.5em; 95 | background: #efefef; 96 | border: 1px dotted #999; 97 | } 98 | 99 | div#description h1,h2,h3,h4,h5,h6 { 100 | color: #125;; 101 | background: transparent; 102 | } 103 | 104 | div#validator-badges { 105 | text-align: center; 106 | } 107 | div#validator-badges img { border: 0; } 108 | 109 | div#copyright { 110 | color: #333; 111 | background: #efefef; 112 | font: 0.75em sans-serif; 113 | margin-top: 5em; 114 | margin-bottom: 0; 115 | padding: 0.5em 2em; 116 | } 117 | 118 | 119 | /* === Classes =================================== */ 120 | 121 | table.header-table { 122 | color: white; 123 | font-size: small; 124 | } 125 | 126 | .type-note { 127 | font-size: small; 128 | color: #DEDEDE; 129 | } 130 | 131 | .xxsection-bar { 132 | background: #eee; 133 | color: #333; 134 | padding: 3px; 135 | } 136 | 137 | .section-bar { 138 | color: #333; 139 | border-bottom: 1px solid #999; 140 | margin-left: -20px; 141 | } 142 | 143 | 144 | .section-title { 145 | background: #79a; 146 | color: #eee; 147 | padding: 3px; 148 | margin-top: 2em; 149 | margin-left: -30px; 150 | border: 1px solid #999; 151 | } 152 | 153 | .top-aligned-row { vertical-align: top } 154 | .bottom-aligned-row { vertical-align: bottom } 155 | 156 | /* --- Context section classes ----------------------- */ 157 | 158 | .context-row { } 159 | .context-item-name { font-family: monospace; font-weight: bold; color: black; } 160 | .context-item-value { font-size: small; color: #448; } 161 | .context-item-desc { color: #333; padding-left: 2em; } 162 | 163 | /* --- Method classes -------------------------- */ 164 | .method-detail { 165 | background: #efefef; 166 | padding: 0; 167 | margin-top: 0.5em; 168 | margin-bottom: 1em; 169 | border: 1px dotted #ccc; 170 | } 171 | .method-heading { 172 | color: black; 173 | background: #ccc; 174 | border-bottom: 1px solid #666; 175 | padding: 0.2em 0.5em 0 0.5em; 176 | } 177 | .method-signature { color: black; background: inherit; } 178 | .method-name { font-weight: bold; } 179 | .method-args { font-style: italic; } 180 | .method-description { padding: 0 0.5em 0 0.5em; } 181 | 182 | /* --- Source code sections -------------------- */ 183 | 184 | a.source-toggle { font-size: 90%; } 185 | div.method-source-code { 186 | background: #262626; 187 | color: #ffdead; 188 | margin: 1em; 189 | padding: 0.5em; 190 | border: 1px dashed #999; 191 | overflow: hidden; 192 | } 193 | 194 | div.method-source-code pre { color: #ffdead; overflow: hidden; } 195 | 196 | /* --- Ruby keyword styles --------------------- */ 197 | 198 | .standalone-code { background: #221111; color: #ffdead; overflow: hidden; } 199 | 200 | .ruby-constant { color: #7fffd4; background: transparent; } 201 | .ruby-keyword { color: #00ffff; background: transparent; } 202 | .ruby-ivar { color: #eedd82; background: transparent; } 203 | .ruby-operator { color: #00ffee; background: transparent; } 204 | .ruby-identifier { color: #ffdead; background: transparent; } 205 | .ruby-node { color: #ffa07a; background: transparent; } 206 | .ruby-comment { color: #b22222; font-weight: bold; background: transparent; } 207 | .ruby-regexp { color: #ffa07a; background: transparent; } 208 | .ruby-value { color: #7fffd4; background: transparent; } -------------------------------------------------------------------------------- /rublib/readme.txt: -------------------------------------------------------------------------------- 1 | Version 0.04 of RubLib, a high-level API for writing IDA Pro scripts in Ruby. 2 | 3 | See: http://www.the-interweb.com/bdump/ida/rublib/index.htm --------------------------------------------------------------------------------