furnace-avm2 0.9.0 → 0.9.1

data/Gemfile.lock

@@ -2,13 +2,13 @@ PATH
   remote: .
   specs:
     furnace-avm2 (0.9.0)
-      furnace (>= 0.1.0)
+      furnace (>= 0.1.1)
       trollop
 
 GEM
   remote: http://rubygems.org/
   specs:
-    furnace (0.1.0)
+    furnace (0.1.1)
     trollop (1.16.2)
 
 PLATFORMS

data/bin/furnace-avm2

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
 require "rubygems"
-require "bundler/setup"
 
 $: << File.join(File.dirname(__FILE__), '..', 'lib')
 
@@ -38,6 +37,7 @@ EOS
   opt :cfg,           "Emit CFG in Graphviz format for methods",    :default => false, :short => '-C'
 
   opt :dce,           "Eliminate dead code",                        :default => false
+  opt :fix_names,     "Remove invalid characters from names",       :default => true,  :short => '-q'
   opt :ast,           "Build AST",                                  :default => false
   opt :nf,            "Build NF-AST",                               :default => false
   opt :decompile,     "Decompile methods",                          :default => false
@@ -77,6 +77,10 @@ failed = []
 dced = []
 smallest = nil
 
+if opts[:fix_names]
+  abc.fix_names!
+end
+
 if opts[:grep]
   regexp = Regexp.new(opts[:grep])
 

data/bin/furnace-avm2-decompiler

@@ -33,6 +33,8 @@ EOS
   opt :except,        "Operate on all classes except <s+>",         :type => :strings, :short => '-E'
   opt :grep,          "Search <s> (regexp) in class names",         :type => :string,  :short => '-G'
 
+  opt :no_output,     "Don't write out any code",                   :default => false
+
   opt :decompile,     "Write ActionScript 3 code",                  :type => :boolean, :short => '-d'
   opt :destructurize, "Write internal token structure",             :type => :boolean, :short => '-s'
 end
@@ -84,6 +86,19 @@ if opts[:grep]
   exit
 end
 
+global_slots = {}
+
+abc.scripts.each do |script|
+  (script.slot_traits + script.const_traits).each do |trait|
+    next if trait.idx == 0
+    global_slots[trait.idx] = trait
+  end
+end
+
+decompile_options[:global_slots] = global_slots
+
+start_time = Time.now
+
 mutex = Mutex.new
 
 roots      = {}
@@ -92,7 +107,32 @@ total_size = workqueue.size
 
 last_percentage = 0
 
-$stderr.puts "Decompiling #{total_size} classes and packages..."
+stat = {
+  total:   0,
+  success: 0,
+  partial: 0,
+  failed:  0,
+}
+
+$stderr.puts "Found #{total_size} classes and packages."
+
+stick       = %w(| / - \\)
+stick_state = 0
+stick_timer = 0
+
+progress_thread = Thread.new do
+  loop do
+    stick_timer += 1
+    if stick_timer % 10 == 0
+      $stderr.print "\e[KDecompiling... #{total_size - workqueue.size}/#{total_size} "
+      $stderr.print stick[stick_state]
+      $stderr.print "\e[0G"
+      stick_state = (stick_state + 1) % stick.count
+    end
+
+    sleep
+  end
+end
 
 opts[:threads].times.map do
   Thread.new do
@@ -100,12 +140,6 @@ opts[:threads].times.map do
       what = nil
       mutex.synchronize do
         what = workqueue.pop
-
-        percentage = (total_size - workqueue.size) * 100 / total_size
-        if percentage >= last_percentage
-          $stderr.print " #{percentage}% (#{total_size - workqueue.size}) "
-          last_percentage += 10
-        end
       end
 
       break if what.nil?
@@ -119,23 +153,56 @@ opts[:threads].times.map do
       end
       next if shound_skip.(name)
 
-      source = what.decompile(decompile_options)
+      options = decompile_options.merge(
+        stat: {
+          total:   0,
+          success: 0,
+          partial: 0,
+          failed:  0,
+        }
+      )
+
+      source = what.decompile(options)
       next unless source
 
       text = source.to_text
 
       mutex.synchronize do
-        $stderr.print "."
+        options[:stat].each do |facet, value|
+          stat[facet] += value
+        end
+
         roots[ns.to_s] ||= []
         roots[ns.to_s] << text
+
+        progress_thread.wakeup
       end
     end
   end
 end.each(&:join)
 
-$stderr.puts
+end_time = Time.now
+
+if stat[:total] > 0
+  $stderr.puts
 
-roots.values.flatten.each do |code|
-  puts code
-  puts
+  { "Decompiled"           => :success,
+    "Partially decompiled" => :partial,
+    "Failed"               => :failed,
+  }.each do |facet_name, facet|
+    $stderr.puts "#{facet_name.rjust(21)}: " \
+        "#{stat[facet]}/#{stat[:total]} " \
+        "(#{(stat[facet].to_f * 100 / stat[:total]).to_i}%)"
+  end
+else
+  $stderr.puts "No methods were processed."
 end
+
+$stderr.puts "Time taken: #{"%.2f" % (end_time - start_time)}s"
+
+unless opts[:no_output]
+  roots.values.flatten.each do |code|
+    puts code.gsub(/ +$/, '')
+    puts
+  end
+end

data/bin/furnace-avm2-shell

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "furnace-avm2"
+
+begin
+  gem "pry"
+  require "pry"
+rescue LoadError
+  puts "$ gem install pry"
+  exit 1
+end
+
+include Furnace
+
+def load_file(filename)
+  File.open(filename) do |file|
+    abc = AVM2::ABC::File.new
+    abc.read(file)
+    abc
+  end
+end
+
+# Interactive AVM2 console ready.
+# Begin with:
+# > abc = load_file("filename.abc")
+# Records can be examined via #to_hash.
+
+binding.pry

data/furnace-avm2.gemspec

@@ -17,6 +17,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency "furnace", '>= 0.1.0'
+  s.add_runtime_dependency "furnace", '>= 0.1.1'
   s.add_runtime_dependency "trollop"
 end

data/lib/furnace-avm2/abc.rb

@@ -10,18 +10,12 @@ require_relative "abc/primitives/record"
 require_relative "abc/primitives/opcode_sequence"
 
 require_relative "abc/opcodes/opcode"
-require_relative "abc/opcodes/contextual_opcode"
 
+require_relative "abc/opcodes/contextual_opcode"
 require_relative "abc/opcodes/load_store_opcode"
-require_relative "abc/opcodes/arithmetic_opcode"
-require_relative "abc/opcodes/bitwise_opcode"
-require_relative "abc/opcodes/type_conversion_opcode"
 require_relative "abc/opcodes/push_literal_opcode"
 require_relative "abc/opcodes/control_transfer_opcode"
 require_relative "abc/opcodes/function_invocation_opcode"
-require_relative "abc/opcodes/function_return_opcode"
-require_relative "abc/opcodes/exception_opcode"
-
 require_relative "abc/opcodes/property_opcode"
 
 Dir[File.join(File.dirname(__FILE__), "abc", "opcodes", "*", "*.rb")].each do |file|

data/lib/furnace-avm2/abc/metadata/file.rb

@@ -23,5 +23,70 @@ module Furnace::AVM2::ABC
     def root
       self
     end
+
+    def method_body_at(index)
+      @method_body_indexes[index]
+    end
+
+    def fix_names!
+      @name_set = Set.new(constant_pool.strings)
+
+      constant_pool.namespaces.each do |ns|
+        fix_name!(ns.name_idx, ns: true)
+      end
+
+      constant_pool.multinames.each do |multiname|
+        if [:QName, :QNameA,
+            :Multiname, :MultinameA,
+            :RTQName, :RTQMameA].include? multiname.kind
+          fix_name!(multiname.data.name_idx)
+        end
+      end
+    end
+
+    def fix_name!(name_idx, options={})
+      old_name = constant_pool.strings[name_idx - 1]
+      return if ["", "*"].include? old_name
+
+      fixed_name = sanitize_name(old_name, options)
+
+      if old_name != fixed_name
+        index = 0
+        indexed_name = fixed_name
+        while @name_set.include? indexed_name
+          indexed_name = "#{fixed_name}_i#{index}"
+          index += 1
+        end
+
+        @name_set.add indexed_name
+
+        constant_pool.strings[name_idx - 1] = indexed_name
+      end
+    end
+
+    def sanitize_name(name, options={})
+      if options[:ns]
+        return name if name.start_with? "http://"
+
+        name.split('.').map do |part|
+          part.gsub(/^[^a-zA-Z_$]+/, '').
+            gsub(/[^a-zA-Z_$0-9:]+/, '')
+        end.reject do |part|
+          part.empty?
+        end.join('.')
+      else
+        name.gsub(/^[^a-zA-Z_$]+/, '').
+          gsub(/[^a-zA-Z_$0-9:]+/, '')
+      end
+    end
+
+    protected
+
+    def after_read(io)
+      @method_body_indexes = {}
+      method_bodies.each do |body|
+        @method_body_indexes[body.method_idx] = body
+      end
+    end
   end
 end

data/lib/furnace-avm2/abc/metadata/instance_info.rb

@@ -63,21 +63,27 @@ module Furnace::AVM2::ABC
     end
 
     def collect_ns
-      ns = []
-      ns << super_name.ns if super_name
-      ns += initializer.collect_ns if initializer
-      interfaces.each   { |iface| ns << iface.ns_set.ns[0] } # stupid avm2
-      traits.each       { |trait| ns += trait.collect_ns }
-      klass.traits.each { |trait| ns += trait.collect_ns }
-      ns
+      options = {
+        ns:    Set.new([ name.ns ]),
+        names: { name.name => name.ns },
+        no_ns: Set.new,
+      }
+
+      super_name.collect_ns(options) if super_name
+      initializer.collect_ns(options) if initializer
+      interfaces.each   { |iface| iface.collect_ns(options) } # stupid avm2
+      traits.each       { |trait| trait.collect_ns(options) }
+      klass.traits.each { |trait| trait.collect_ns(options) }
+
+      options
     end
 
     def decompile(options={})
       Furnace::AVM2::Tokens::PackageToken.new(self,
-            options.merge(
-                ns: collect_ns,
-                package_type: (interface? ? :interface : :class),
-                package_name: name))
+            options.merge(collect_ns).merge(
+              package_type: (interface? ? :interface : :class),
+              package_name: name)
+            )
     end
   end
 end

data/lib/furnace-avm2/abc/metadata/metadata_info.rb

@@ -1,9 +1,19 @@
 module Furnace::AVM2::ABC
   class MetadataInfo < Record
-    vuint30      :name
+    const_ref   :name, :string
 
-    vuint30      :item_count,  :value => lambda { item_keys.count }
-    array        :item_keys,   :type => :vuint30, :initial_length => :item_count
-    array        :item_values, :type => :vuint30, :initial_length => :item_count
+    vuint30     :item_count,  :value => lambda { item_keys.count }
+    const_array :item_keys,   :string, :initial_length => :item_count
+    const_array :item_values, :string, :initial_length => :item_count
+
+    def to_hash
+      hash = {}
+
+      item_count.times do |n|
+        hash[item_keys[n]] = item_values[n]
+      end
+
+      hash
+    end
   end
 end

data/lib/furnace-avm2/abc/metadata/method_body_info.rb

@@ -1,5 +1,7 @@
 module Furnace::AVM2::ABC
   class MethodBodyInfo < Record
+    include RecordWithTraits
+
     root_ref     :method
     vuint30      :max_stack
     vuint30      :local_count
@@ -19,10 +21,10 @@ module Furnace::AVM2::ABC
       end
     end
 
-    def code_to_ast(options={})
+    def code_to_ast(options={ eliminate_nops: true })
       pipeline = Furnace::Transform::Pipeline.new([
         Furnace::AVM2::Transform::ASTBuild.new(options),
-        Furnace::AVM2::Transform::ASTNormalize.new
+        Furnace::AVM2::Transform::ASTNormalize.new(options)
       ])
 
       pipeline.run(code, self)
@@ -33,7 +35,7 @@ module Furnace::AVM2::ABC
         Furnace::AVM2::Transform::CFGBuild.new
       ])
 
-      pipeline.run(*code_to_ast)
+      pipeline.run(*code_to_ast({}))
     end
 
     def code_to_nf
@@ -48,5 +50,11 @@ module Furnace::AVM2::ABC
     def decompile(options={})
       Furnace::AVM2::Decompiler.new(self, options).decompile
     end
+
+    def collect_ns(options)
+      code.each do |opcode|
+        opcode.collect_ns(options) if opcode.respond_to? :collect_ns
+      end
+    end
   end
 end

data/lib/furnace-avm2/abc/metadata/method_info.rb

@@ -55,10 +55,9 @@ module Furnace::AVM2::ABC
       root.normalize_hierarchy!
     end
 
-    def collect_ns
-      ns = param_types.compact.map(&:collect_ns).reduce([], :+)
-      ns += return_type.collect_ns if return_type
-      ns
+    def collect_ns(options)
+      param_types.compact.each { |type| type.collect_ns(options) }
+      return_type.collect_ns(options) if return_type
     end
   end
 end

data/lib/furnace-avm2/abc/metadata/multiname_kind_genericname.rb

@@ -12,8 +12,9 @@ module Furnace::AVM2::ABC
       AST::Node.new(:generic, [ name.to_astlet, parameters.map(&:to_astlet) ])
     end
 
-    def collect_ns
-      [ *name.collect_ns, *parameters.map(&:collect_ns).reduce([], :+) ]
+    def collect_ns(options)
+      name.collect_ns(options)
+      parameters.each { |type| type.collect_ns(options) }
     end
   end
 end

data/lib/furnace-avm2/abc/metadata/multiname_kind_multiname.rb

@@ -11,8 +11,17 @@ module Furnace::AVM2::ABC
       AST::Node.new(:m, [ ns_set.to_astlet, name ])
     end
 
-    def collect_ns
-      ns_set.ns
+    def collect_ns(options)
+      ns = ns_set.ns[0]
+      return if options[:no_ns].include?(ns)
+
+      names = options[:names]
+      if names[name].nil?
+        options[:ns].add ns
+        names[name] = ns
+      elsif names[name] != ns
+        options[:no_ns].add ns
+      end
     end
 
     def context_size