resedit 1.7.3 → 1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77669d3b3c572c15f14392c6bb44ded2e682e993
-  data.tar.gz: 600dd6a10b2c2c6c2a051b1e8f1ee3b04afaa651
+  metadata.gz: d5bb82eb4e37c29d800e45d61d1fd8359afb224d
+  data.tar.gz: 206c81a15f6e4bc8f50893ce9c8900fb89ec4ad4
 SHA512:
-  metadata.gz: e98241f942125af594613c729bee32dd5aaeb10eff2a6532dec135c0c052663e3267d9f28d3585cfcc60a84f80fe0c83ad67e0343aee31f89c6e130de5ef4a88
-  data.tar.gz: b47a0ed36ab4c03a5ce709ec90aa970f313a5c4c95dc728ee693efb6365c9e70d81233fd600fea07536f5c8cf1c42e0a3600c566f968f7a2092daa3513960482
+  metadata.gz: c28f9d26f1e08a3980b254ada58e772a2a65efec98ca6e4b9008625ca1f7790a61777d9dd882a618c001abcfa3a71b9d07ecacaf321c176fcfcbcb3f90d713cd
+  data.tar.gz: 05c2a94a3fba256b35e624d2477678d3210a3009f994fa347f500afae29dbbb7eabe79789ade857336e9ed1ecb9ab872da30d58b6ebe1d3bcf3c93de71716ce0

data/lib/resedit.rb

@@ -8,16 +8,22 @@ require 'resedit/app/app'
 require 'resedit/text/huffman'
 require 'resedit/app/font_convert'
 require 'resedit/app/text_convert'
+require 'resedit/classes/env'
+require 'resedit/classes/colorizer'
+require 'resedit/classes/hexwriter'
+require 'resedit/classes/changeable'
+require 'resedit/classes/exefile'
+require 'resedit/classes/config'
 require 'resedit/convert/bitconv'
 require 'resedit/convert/bitstream'
 require 'resedit/convert/codepatch'
 require 'resedit/convert/colors'
 require 'resedit/mz/mz'
-require 'resedit/classes/colorizer'
-require 'resedit/classes/hexwriter'
-require 'resedit/classes/changeable'
+require 'resedit/mz/bw'
+require 'resedit/mz/le'
+require 'resedit/mz/multiexe'
 
 
 module Resedit
-    VERSION = "1.7.3"
+    VERSION = "1.8"
 end

data/lib/resedit/app/mz_command.rb

@@ -1,7 +1,6 @@
 require 'resedit/app/app_command'
-require 'resedit/mz/mz'
-require 'resedit/mz/mzenv'
-
+require 'resedit/mz/multiexe'
+require 'resedit/classes/env'
 
 module Resedit
 
@@ -28,7 +27,9 @@ module Resedit
                 "revert"=>[method(:revert), "revert changes", {"ofs"=>"change offset/all"}],
                 "hex"=>[method(:hex), "print hex file", {"ofs" => "data offset", "size" => "data size", "how"=>"original/modified", "disp" => "code/file"}],
                 "dasm"=>[method(:dasm), "print disasm", {"ofs" => "data offset", "size" => "data size", "how"=>"original/modified"}],
+                "eval"=>[method(:expr), "print expression", {"expr" => "expression"}],
             }
+            @shorters = {"p"=>"print", "e"=>"eval"}
             @files = []
             @cur = nil
         end
@@ -58,7 +59,9 @@ module Resedit
 
         def getfile(id)
             return @cur if id == nil
-            i,res=MZEnv.instance.s2i_nt(id)
+            #env = !@cur ? Env.new(self) : @cur.env
+            env = Env.new()
+            i,res =  env.s2i_nt(id)
             if res
                 raise "Bad file id: " + i.to_s if @files.length < i || i < 0
                 return @files[i]
@@ -95,7 +98,7 @@ module Resedit
         def use(params)
             mz = getfile(params['file'])
             if mz==nil
-                mz = MZ.new(params['file'])
+                mz = Multiexe.new(params['file'])
                 @files+=[mz]
             end
             @cur = mz
@@ -105,7 +108,7 @@ module Resedit
 
         def close(params)
             mz = getfile(params['file'])
-            raise "File not found: "+fn if nil == fl
+            raise "File not found: "+fn if nil == mz
             @files -= [mz]
             @cur = nil if @cur == mz
             mz.close()
@@ -158,9 +161,15 @@ module Resedit
             cur().dasm(params['ofs'], params['size'], params['how'])
         end
 
+        def expr(params)
+            env = @cur && @cur.env ? @cur.env : Env.new()
+            puts env.s2i(params['expr'])
+        end
+
 
         def job(params)
             cmd = params['cmd']
+            cmd = @shorters[cmd] if @shorters[cmd]
             if cmd.length==0 || File.exist?(cmd)
                 App::get().setShell('mz')
                 return if cmd.length == 0

data/lib/resedit/classes/changeable.rb

@@ -224,6 +224,8 @@ module Resedit
 
         def debug(); LOG.level = Logger::DEBUG end
 
+        def size; @root.size end
+
         def dbgdump
             LOG.debug("---#{@root.size()}---\n")
             @root.dump()
@@ -294,27 +296,39 @@ module Resedit
             file.write(bytes())
         end
 
-        def saveChanges(file)
+        def hexify(bts)
+            bts.each_byte.map { |b| sprintf("%02X",b) }.join
+        end
+
+        def unhexify(str)
+            str.scan(/../).collect { |c| c.to_i(16).chr }.join
+        end
+
+        def saveChanges()
             mode(HOW_CHANGED)
+            cfg = {}
             chs = getChanges()
-            file.write([chs.length].pack('V'))
             chs.each{|o,bts|
-                flg = bts[0].length==0 ? 0x80000000 : 0
-                file.write([o, bts[1].length | flg ].pack('VV'))
-                file.write(bts[0]) if flg==0
+                obj = {}
+                obj["insert"] = bts[1].length if bts[0].length==0
+                obj["change"] = hexify(bts[0]) if bts[0].length>0
+                cfg[o] = obj
             }
+            return cfg
         end
 
-        def loadChanges(file)
+        def loadChanges(hs)
             mode(HOW_CHANGED)
             @root.revert
-            clen = file.read(4).unpack('V')[0]
-            for _ in 0..clen-1
-                ofs, len = file.read(8).unpack('VV')
-                isNu = len & 0x80000000 !=0
-                len &= 0x7FFFFFFF
-                @root.cload(ofs, isNu ? "" : file.read(len), len)
-            end
+            hs.each{|ofs, obj|
+                if obj['insert']
+                    len = obj['insert']
+                    @root.cload(ofs.to_i, "", len)
+                elsif obj['change']
+                    bts = unhexify(obj['change'])
+                    @root.cload(ofs.to_i, bts, bts.length)
+                end
+            }
             mode(HOW_CHANGED)
         end
 

data/lib/resedit/classes/config.rb

@@ -0,0 +1,35 @@
+require 'json'
+
+module Resedit
+
+    class Config
+
+        attr_accessor :cfg
+        def initialize(fname, section=nil)
+            @fname, @section = fname, section
+            @cfg = load()
+            @cfg = (@cfg[@section] or {}) if @section
+        end
+
+        def [](nm); @cfg[nm] end
+        def []=(nm, value); @cfg[nm]=value end
+
+        def load();
+            File.exists?(@fname) ? JSON.parse(File.read(@fname)) : {}
+        end
+
+        def save()
+            if @section
+                c = load()
+                c[@section] = @cfg
+            else
+                c = cfg
+            end
+            open(@fname, "w"){|f|
+                f.write(JSON.pretty_generate(c))
+            }
+        end
+
+    end
+
+end

data/lib/resedit/{mz/mzenv.rb → classes/env.rb}

@@ -1,15 +1,17 @@
-require 'singleton'
+require 'ostruct'
 
 module Resedit
 
-    class MZEnv
+    class Env < OpenStruct
 
-        include Singleton
+        def initialize(owner=nil)
+            super()
+            @owner = owner
+            @mode = @owner ? @owner.class::MODE : 16
+        end
 
-        def set(name,value)
-            MZEnv.class_eval{
-                define_method(name){ s2i(value) }
-            }
+        def set(name, value)
+            self[name] = s2i(value)
         end
 
         def s2i_nt(str)
@@ -18,17 +20,30 @@ module Resedit
             return [0, false]
         end
 
+        def addr2raw16(ss)
+            ss[0] = '0x'+ss[0] if ss[0][0,2]!='0x'
+            ss[1] = '0x'+ss[1] if ss[1][0,2]!='0x'
+            fix = 0
+            if ss.length == 3
+                raise "Dont known how to #{ss[2]} address" if ss[2]!="fix"
+                fix = relocFix
+            end
+            return ((s2i(ss[0])+fix) << 4) + s2i(ss[1])
+        end
+
+        def addr2raw32(ss)
+            ss[1] = '0x'+ss[1] if ss[1][0,2]!='0x'
+            if ss[0]==''
+                return @owner.body.addr2raw(s2i(ss[1]))
+            end
+            ss[0] = 'seg'+ss[0] if ss[0][0,3]!='seg'
+            return eval(ss[0]+"+"+ss[1])
+        end
+
         def s2i(str)
             ss=str.split(':')
             if ss.length == 2 || ss.length == 3
-                ss[0] = '0x'+ss[0] if ss[0][0,2]!='0x'
-                ss[1] = '0x'+ss[1] if ss[1][0,2]!='0x'
-                fix = 0
-                if ss.length == 3
-                    raise "Dont known how to #{ss[2]} address" if ss[2]!="fix"
-                    fix = relocFix
-                end
-                return ((s2i(ss[0])+fix) << 4) + s2i(ss[1])
+                return @mode==32 ? addr2raw32(ss) : addr2raw16(ss)
             end
             return eval(str, binding())
         end

data/lib/resedit/classes/exefile.rb

@@ -0,0 +1,339 @@
+require 'resedit/classes/changeable'
+require 'resedit/classes/hexwriter'
+require 'resedit/classes/env'
+require 'json'
+
+begin
+    require 'crabstone'
+    include Crabstone
+    $nocrabstone = false
+rescue LoadError
+    $nocrabstone = true
+end
+
+module Resedit
+
+    class ExeHeader < Changeable
+        BLK = 0x200
+        PARA = 0x10
+        HDRDESCR = [:Magic]
+        HDRUNPACK = "v*"
+
+        attr_reader :info, :exe
+
+        def initialize(exe, file, fsize)
+            raise "Not EXE file" if fsize < self.class::HSIZE
+            @exe = exe
+            super(file, self.class::HSIZE)
+            @_infoOrig = loadInfo()
+            @_info = nil
+            @info = @_infoOrig
+            @relocFix = 0
+            raise "Not EXE file" if self.class::MAGIC != @info[:Magic] && (!self.class::MAGIC.is_a?(Array) || !self.class::MAGIC.include?(@info[:Magic]))
+            loadTables(file)
+            loadTail(file)
+        end
+
+        def mode(how)
+            super(how)
+            if @mode == HOW_ORIGINAL
+                @info = @_infoOrig
+            else
+                @_info = loadInfo() if  !@_info
+                @info = @_info
+            end
+        end
+
+
+        def change(ofs, bytes)
+            super(ofs, bytes)
+            @_info = nil if (ofs < HSIZE)
+        end
+
+
+        def loadInfo()
+            v = getData(0, self.class::HSIZE).unpack(self.class::HDRUNPACK)
+            ret = self.class::HDRDESCR.map.with_index { |x, i| [x, v[i]] }.to_h
+            return ret
+        end
+        def loadTables(file); end
+        def loadTail(file);
+            addData(file, headerSize() - self.class::HSIZE)
+        end
+
+
+        def setInfo(field, values, pack="v*")
+            raise "Unknown header field #{field}" if !self.class::HDRDESCR.include?(field)
+            values = [values] if !values.is_a?(Array)
+            change(self.class::HDRDESCR.index(field)*2, values.pack(pack))
+        end
+
+        def setBodySize(size); setFileSize(size + headerSize()) end
+
+        def headerSize(); self.class::HSIZE end
+
+        def print(what, how)
+            return false if what!="header"
+            mode(parseHow(how))
+            ofs=0
+            wsz = @exe.wsize
+            @info.each{|k,v|
+                printf("%20s:\t%s\n", k.to_s, colStr(v, changed?(ofs,wsz)))
+                ofs+=2
+            }
+            puts
+            return true
+        end
+
+        def setHeaderSize(size); raise "NotImplemented" end
+        def fileSize(); raise "NotImplemented"  end
+        def setFileSize(size); raise "NotImplemented" end
+        def entry(size); raise "NotImplemented" end
+    end
+
+
+    class ExeBody < Changeable
+
+        attr_reader :exe
+
+        def initialize(exe, file, size)
+            @exe = exe
+            super(file, size)
+            @addsz = 0
+        end
+
+        def removeAppend()
+            mode(HOW_CHANGED)
+            undo(0) if @root.obuf.length==0
+            @addsz = 0
+        end
+
+        def revert(what)
+            super(what)
+            @addsz = 0
+        end
+
+        def printDasm(inst, str)
+            printf("%08X %s\n",inst.address, str)
+        end
+
+        def hex(wr, ofs, size, how)
+            wr.addressFormatter = self
+            if how && (how[0]='r' || how[0]='R')
+                wr.addBytes(readRelocated(ofs, size))
+                return
+            end
+            super(wr, ofs, size, how)
+        end
+
+        def formatAddress(raw)
+            return sprintf("%08X", raw)
+        end
+
+        def dasm(ofs, size, how, mode)
+            raise "Crabstone gem required to disasm." if $nocrabstone
+            relocated = false
+            if how && how[0]='r' || how[0]='R'
+                relocated = true
+                how = nil
+            end
+            mode(parseHow(how))
+            cs = Disassembler.new(ARCH_X86, mode==16 ? MODE_16 : MODE_32)
+            begin
+                while true
+                    begin
+                        d = relocated ? readRelocated(ofs, size) : getData(ofs, size)
+                        cs.disasm(d, ofs).each {|i|
+                            bts = i.bytes.map { |b| sprintf("%02X",b) }.join
+                            inst = colStr(sprintf("%14s\t%s\t%s", bts, i.mnemonic, i.op_str), changed?(i.address, i.bytes.length))
+                            printDasm(i, inst)
+                        }
+                        break
+                    rescue
+                        ofs-=1
+                    end
+                end
+            ensure
+                cs.close()
+            end
+        end
+
+        def raw2addr(ofs); raise "Not implemented" end
+        def addr2raw(addr); raise "Not implemented" end
+        def append(bytes, where=nil); raise "NotImplemented" end
+        def addrFormatter(hofs); nil end
+        def readRelocated(ofs, size); raise "NotImplemented" end
+    end
+
+    class ExeFile
+        HDRCLASS = nil
+        BODYCLASS = nil
+        CFGEXT = ".mzcfg.json"
+        MODE = 16
+
+        attr_reader :header, :body, :fname, :path, :name, :env
+
+        def initialize(path=nil, quiet = false)
+            @quiet = quiet
+            @path=path
+            @env = Env.new(self)
+            if @path!=nil
+                @path = path.downcase()
+                fsize = File.size(path)
+                open(@path,"rb:ascii-8bit"){|f|
+                    load(f, fsize)
+                }
+                if File.exist?(@path+CFGEXT)
+                    cfg = JSON.parse(File.read(@path+CFGEXT))
+                    loadConfig(cfg)
+                end
+                @fname = File.basename(@path)
+                @name = File.basename(@path, ".*")
+            end
+        end
+
+        def wsize; self.class::MODE/8 end
+
+        def load(f, fsize, prev=nil)
+            @header = self.class::HDRCLASS.new(self, f, fsize)
+            @body = self.class::BODYCLASS.new(self, f, @header.fileSize() - @header.headerSize())
+            @env.set(:entry, @header.entry())
+            @env.set(:append, sprintf("0"))
+        end
+
+        def loadConfig(cfg)
+            cfg = cfg[self.class.name]
+            raise "Wrong config: #{self.class.name} expected" if !cfg
+            @header.loadChanges(cfg['header'])
+            @body.loadChanges(cfg['body'])
+        end
+
+        def close(); end
+        def log(fmt, *args); App::get().log(fmt, *args) if !@quiet end
+        def s2i(str) return @env.s2i(str) end
+
+
+        def is?(id)
+            id = id.downcase
+            return id == @path || id == @fname || id == @name
+        end
+
+        def print(what, how=nil)
+            puts "Header changes:" if what=="changes"
+            res = @header.print(what, how)
+            puts "Code changes:" if what=="changes"
+            res |= @body.print(what, how)
+            raise "Don't know how to print: " + what if !res
+        end
+
+
+        def hex(ofs, size=nil, how=nil, disp=nil)
+            ofs = ofs ? s2i(ofs) : 0
+            size = size ? s2i(size) : 0x100
+            isfile = disp && (disp[0]=='f' || disp[0]=='F') ? true : false
+            wr = HexWriter.new(ofs)
+            hsz = 0
+            if isfile
+                @header.mode(@header.parseHow(how))
+                hsz = @header.headerSize()
+                size = @header.hex(wr, ofs, size, how) if ofs < hsz
+                ofs -= hsz
+                ofs = 0 if ofs < 0
+                wr.addr = 0
+            end
+            @body.hex(wr, ofs, size, how) if size > 0
+            wr.finish()
+        end
+
+        def hexify(str); @header.hexify(str) end
+
+        def getValue(value, type)
+            s = @env.value2bytes(value, type)
+            return s.force_encoding(Encoding::ASCII_8BIT)
+        end
+
+
+        def append(value, type=nil, where=nil)
+            where = s2i(where) if where
+            res = @body.append(getValue(value,type), where)
+            s = ""
+            res.each{|a|
+                if a.is_a?(Array)
+                    s += sprintf(" %04X:%04X", a[1], a[0])
+                else
+                    s += sprintf(" %08X", a)
+                end
+            }
+            log("Appended at %s",s)
+            return res
+        end
+
+
+        def replace(value, type=nil, where=nil)
+            @body.removeAppend()
+            return append(value, type, where)
+        end
+
+
+        def change(ofs, value, disp=nil, type=nil)
+            ofs = s2i(ofs)
+            isfile = disp && (disp[0]=='f' || disp[0]=='F') ? true : false
+            value = getValue(value, type)
+            if isfile
+                res = @header.change(ofs,value)
+            else
+                res = @body.change(ofs,value) + @header.headerSize()
+            end
+            log("Change added at %08X", res) if res
+        end
+
+        def reloc(ofs); raise "NotImplemented" end
+
+        def readRelocated(ofs, size); @body.readRelocated(ofs, size) end
+
+        def dasm(ofs, size=nil, how=nil)
+            ofs = s2i(ofs ? ofs : "entry")
+            size = size ? s2i(size) : [0x20, @body.bytes.length-ofs].min
+            @body.dasm(ofs, size, how, self.class::MODE)
+        end
+
+
+        def valueof(str, type)
+            puts "value of " + str + " is:"
+            p getValue(str, type).unpack("H*")
+        end
+
+
+        def revert(what)
+            wid = @env.s2i_nt(what)
+            what = wid[1] ? wid[0] : what
+            res = @header.revert(what)
+            res |= @body.revert(what)
+            raise "Don't know how to revert: "+what if !res
+            log("Reverted")
+        end
+
+        def saveConfig()
+            cfg = {}
+            cfg['header'] = @header.saveChanges()
+            cfg['body'] = @body.saveChanges()
+            return {self.class.name => cfg}
+        end
+
+        def saveFile(f)
+            @header.saveData(f)
+            @body.saveData(f)
+        end
+
+        def save(filename)
+            raise "Filename expected." if !filename
+            open(filename, "wb:ascii-8bit"){|f|
+                saveFile(f)
+            }
+            open(filename+CFGEXT, "w"){|f|
+                f.write(JSON.pretty_generate(saveConfig()))
+            }
+        end
+    end
+
+end