├── 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 | 53 |CreateHelper | 54 |
In: | 57 |
58 |
59 | rublib.rb
60 |
61 | 62 | |
63 |
77 | Creates helper objects 78 |
79 | 80 |# File rublib.rb, line 848 14 | def reset 15 | @inst_num = -1 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000114.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end22 | 23 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000115.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end22 | 23 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000116.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 937 14 | def name 15 | @ida.get_func_name(address) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000117.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 944 14 | def name=(value) 15 | start.name = value 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000118.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 951 14 | def comment 15 | @ida.get_func_cmt(@func, false) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000119.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 958 14 | def comment=(value) 15 | @ida.set_func_cmt(@func, value, false) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000120.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000121.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end42 | 43 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000122.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end38 | 39 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000123.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end29 | 30 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000124.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1054 14 | def instructions 15 | 16 | inst = [ ] 17 | 18 | self.each{|i| inst << i } 19 | 20 | return inst 21 | 22 | end23 | 24 | -------------------------------------------------------------------------------- /rublib/doc/classes/Function.src/M000125.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1065 14 | def address 15 | @func.startEA 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000126.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1079 14 | def reset 15 | @inst_num = -1 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000127.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1087 14 | def initialize(ida, chunk) 15 | @ida = ida 16 | @chunk = chunk 17 | @inst_num = -1 18 | end19 | 20 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000128.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1096 14 | def first_offset 15 | Offset.new(@ida, @chunk.startEA) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000129.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1103 14 | def last_offset 15 | Offset.new(@ida, @chunk.endEA - 1) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000130.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end38 | 39 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000131.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end24 | 25 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000132.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/FunctionChunk.src/M000133.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1212 14 | def address 15 | @chunk.startEA 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Helper_X86.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
Class | 53 |Helper_X86 | 54 |
In: | 57 |
58 |
59 | rublib.rb
60 |
61 | 62 | |
63 |
Parent: | 67 |68 | Object 69 | | 70 |
83 | Helps to create x86 specific instruction information 84 |
85 | 86 |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 |
155 | Returns the mnemonic belonging to a 156 | instruction 157 |
158 |# File rublib.rb, line 20 14 | def initialize(ida) 15 | 16 | raise "Invalid IdaRub object" if ida == nil 17 | 18 | @ida = ida 19 | 20 | end21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/Helper_X86.src/M000106.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end37 | 38 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000061.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1381 14 | def initialize(ida) 15 | 16 | raise "Error: Invalid IdaRub object" if ida == nil 17 | 18 | @ida = ida 19 | end20 | 21 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000062.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000063.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1425 14 | def name 15 | @ida.get_root_filename 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000064.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1432 14 | def path 15 | @ida.get_input_file_path 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000065.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1439 14 | def screen_ea 15 | Offset.new(@ida, @ida.get_screen_ea) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000066.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1446 14 | def number_of_functions 15 | @ida.get_func_qty 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000067.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end20 | 21 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000068.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1465 14 | def crc32 15 | @ida.retrieve_input_file_crc32 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000069.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1477 14 | def processor_name 15 | @ida.inf.procName 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000070.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1484 14 | def filetype 15 | @ida.inf.filetype 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000071.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1491 14 | def start_offset 15 | Offset.new(@ida, @ida.inf.beginEA) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000072.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1498 14 | def first_offset 15 | Offset.new(@ida, @ida.inf.minEA) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000073.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1505 14 | def last_offset 15 | Offset.new(@ida, @ida.inf.maxEA - 1) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000074.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1512 14 | def segments 15 | SegmentList.new(@ida) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000075.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1519 14 | def number_of_entry_points 15 | @ida.get_entry_qty() 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000076.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000077.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1533 14 | def each 15 | number_of_functions.times {|i| yield Function.new(@ida, i)} 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000078.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1540 14 | def string_list 15 | StringList.new(@ida) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaFile.src/M000079.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1545 14 | def helper 15 | @helper 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000100.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000101.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1568 14 | def address 15 | @str.ea 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000102.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1575 14 | def offset 15 | Offset.new(@ida, @str.ea) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000103.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1582 14 | def type 15 | @str.type 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/IdaString.src/M000104.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end20 | 21 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000080.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 682 14 | def address 15 | @ea 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000081.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 690 14 | def initialize(ida, ea) 15 | @ida = ida 16 | @ea = ea 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000082.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 698 14 | def ==(rhs) 15 | @ea == rhs[0].address 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000083.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end22 | 23 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000084.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 715 14 | def instruction_type 15 | @ida.ua_mnem(@ea) 16 | @ida.cmd.itype 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000085.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 723 14 | def instruction_size 15 | @ida.ua_mnem(@ea) 16 | @ida.cmd.size 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000086.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000087.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 740 14 | def line 15 | @ida.tag_remove(unstripped_line) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000088.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 747 14 | def unstripped_line 15 | @ida.generate_disasm_line(@ea) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000089.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 754 14 | def manual? 15 | @ida.is_manual_insn(@ea) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000090.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 761 14 | def manual_line 15 | @ida.get_manual_insn(@ea) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000091.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 768 14 | def manual_line=(line) 15 | @ida.set_manual_insn(@ea, line) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000092.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end25 | 26 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000093.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 789 14 | def bytes 15 | @ida.get_many_bytes(self[0].address, instruction_size).unpack("C*") 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000094.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end23 | 24 | -------------------------------------------------------------------------------- /rublib/doc/classes/Instruction.src/M000095.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000012.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 324 14 | def address 15 | @offset 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000013.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 333 14 | def initialize(ida, offset) 15 | @ida = ida 16 | @offset = offset 17 | @helper = create_helper(ida) 18 | end19 | 20 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000014.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 343 14 | def <=>(rhs) 15 | @offset <=> rhs.offset 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000015.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 349 14 | def succ 15 | Offset.new(@ida, @offset + 1) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000016.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 356 14 | def enabled? 15 | @ida.isEnabled(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000017.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 363 14 | def ascii 15 | read_ascii(@ida, @offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000018.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 370 14 | def unicode 15 | read_unicode(@ida, @offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000019.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 377 14 | def byte 15 | @ida.get_byte(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000020.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 384 14 | def byte=(value) 15 | @ida.patch_byte(@offset, value) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000021.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 392 14 | def word 15 | @ida.get_word(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000022.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 399 14 | def word=(value) 15 | @ida.patch_word(@offset, value) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000023.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 407 14 | def three_bytes 15 | @ida.get_3byte(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000024.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 414 14 | def word=(value) 15 | @ida.patch_word(@offset, value) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000025.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 422 14 | def dword 15 | @ida.get_long(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000026.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 429 14 | def dword=(value) 15 | @ida.patch_long(@offset, value) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000027.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 435 14 | def qword 15 | @ida.get_qword(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000028.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 442 14 | def dword=(value) 15 | @ida.patch_long(@offset, value) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000029.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 450 14 | def original_byte 15 | @ida.get_original_byte(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000030.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 457 14 | def original_word 15 | @ida.get_original_word(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000031.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 464 14 | def original_dword 15 | @ida.get_original_long(@offset) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000032.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 471 14 | def head? 15 | @ida.isHead(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000033.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 478 14 | def tail? 15 | @ida.isTail(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000034.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 485 14 | def not_tail? 15 | @ida.isNotTail(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000035.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 492 14 | def code? 15 | @ida.isCode(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000036.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 499 14 | def data? 15 | @ida.isData(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000037.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 506 14 | def unknown? 15 | @ida.isUnknown(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000038.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 513 14 | def flow? 15 | @ida.isFlow(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000039.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 520 14 | def do_byte(length) 15 | @ida.doByte(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000040.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 527 14 | def do_word(length) 15 | @ida.doWord(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000041.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 534 14 | def do_dword(length) 15 | @ida.doDwrd(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000042.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 541 14 | def do_qword(length) 15 | @ida.doQwrd(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000043.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 548 14 | def do_oword(length) 15 | @ida.doOwrd(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000044.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 555 14 | def do_tbyte(length) 15 | @ida.doTbyt(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000045.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 562 14 | def do_float(length) 15 | @ida.doFloat(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000046.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 569 14 | def do_double(length) 15 | @ida.doDouble(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000047.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 576 14 | def do_packed_real(length) 15 | @ida.doPackReal(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000048.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 580 14 | def do_ascii(length) 15 | @ida.doASCI(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000049.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 587 14 | def do_three_byte(length) 15 | @ida.do3byte(@offset, length) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000050.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 594 14 | def byte? 15 | @ida.isByte(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000051.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 601 14 | def word? 15 | @ida.isWord(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000052.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 608 14 | def dword? 15 | @ida.isDwrd(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000053.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 615 14 | def qword? 15 | @ida.isQwrd(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000054.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 622 14 | def oword? 15 | @ida.isOwrd(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000055.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 629 14 | def tbyte? 15 | @ida.isTbyt(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000056.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 636 14 | def float? 15 | @ida.isFloat(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000057.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 643 14 | def double? 15 | @ida.isDouble(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000058.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 650 14 | def packed_real? 15 | @ida.isPackReal(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000059.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 654 14 | def ascii? 15 | @ida.isASCII(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Offset.src/M000060.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 661 14 | def three_byte? 15 | @ida.is3byte(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/ReadString.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
Module | 53 |ReadString | 54 |
In: | 57 |
58 |
59 | rublib.rb
60 |
61 | 62 | |
63 |
77 | This module can be used to read strings from arbitrary offsets 78 |
79 | 80 |# 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 | end22 | 23 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000002.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1238 14 | def first_offset 15 | Offset.new(@ida, @segment.startEA) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000003.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1245 14 | def last_offset 15 | Offset.new(@ida, @segment.endEA - 1) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000004.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1252 14 | def name 15 | # True name or untrue name here? 16 | @ida.get_true_segm_name(@segment) 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000005.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1260 14 | def class 15 | @ida.get_segm_class(@segment) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000006.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1267 14 | def base 15 | @ida.get_segm_base(@segment) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000007.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1274 14 | def comment 15 | @ida.get_segment_cmt(@segment, false) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000008.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1281 14 | def comment=(cmt) 15 | @ida.set_segment_cmt(@segment, cmt, false) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000009.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1289 14 | def repeatable_comment 15 | @ida.get_segment_cmt(@segment, true) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000010.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1296 14 | def repeatable_comment=(cmt) 15 | @ida.set_segment_cmt(@segment, cmt, true) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Segment.src/M000011.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1305 14 | def remove(flags = 5) 15 | @ida.del_segm(start, flags) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000107.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1322 14 | def initialize(ida) 15 | 16 | raise "Invalid IdaRub object" if ida == nil 17 | 18 | @ida = ida 19 | end20 | 21 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000108.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1332 14 | def number_of_segments 15 | @ida.get_segm_qty() 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000109.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1341 14 | def [](index) 15 | Segment.new(@ida, @ida.getnseg(index)) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000110.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1350 14 | def segment_by_offset(offset) 15 | Segment.new(@ida, @ida.getseg(offset)) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000111.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/SegmentList.src/M000112.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1367 14 | def each 15 | number_of_segments.times{|i| yield self[i]} 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000134.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 123 14 | def flags 15 | @ida.getFlags(address) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000135.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 130 14 | def extra_lines? 15 | @ida.hasExtra(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000136.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 137 14 | def comment? 15 | @ida.has_cmt(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000137.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 144 14 | def references? 15 | @ida.hasRef(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000138.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 151 14 | def name 15 | @ida.get_name(@ida.BADADDR, address) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000139.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 158 14 | def name=(name) 15 | @ida.set_name(address, name) 16 | @ida.refresh_idaview_anyway 17 | end18 | 19 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000140.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 166 14 | def name? 15 | @ida.has_name(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000141.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 173 14 | def dummy_name? 15 | @ida.has_dummy_name(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000142.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 180 14 | def auto_name? 15 | @ida.has_auto_name(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000143.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 187 14 | def user_name? 15 | @ida.has_user_name(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000144.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 194 14 | def any_name? 15 | @ida.has_any_name(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000145.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 200 14 | def function_start? 15 | @ida.isFunc(flags) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000146.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 207 14 | def comment 15 | @ida.get_cmt(address, false) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000147.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 214 14 | def repeatable_comment 15 | @ida.get_cmt(address, true) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000148.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 240 14 | def anterior_lines 15 | extra_lines(@ida.E_PREV) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000149.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 247 14 | def posterior_lines 15 | extra_lines(@ida.E_NEXT) 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000150.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000151.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000152.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/classes/Shared.src/M000153.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end26 | 27 | -------------------------------------------------------------------------------- /rublib/doc/classes/StringList.src/M000096.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1606 14 | def initialize(ida) 15 | @ida = ida 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/StringList.src/M000097.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# 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 | end21 | 22 | -------------------------------------------------------------------------------- /rublib/doc/classes/StringList.src/M000098.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1638 14 | def number_of_strings 15 | @ida.get_strlist_qty() 16 | end17 | 18 | -------------------------------------------------------------------------------- /rublib/doc/classes/StringList.src/M000099.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 |
# File rublib.rb, line 1645 14 | def each 15 | number_of_strings.times{|i| yield IdaString.new(@ida, i) } 16 | end17 | 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 |
Path: | 54 |rublib.rb 55 | | 56 |
Last Update: | 59 |Sat Feb 10 20:02:44 +0100 2007 | 60 |
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 |