furnace-avm2 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+.rbx/

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: ../furnace
+  specs:
+    furnace (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    trollop (1.16.2)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  furnace!
+  trollop

data/bin/furnace-avm2

@@ -0,0 +1,175 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "trollop"
+require "avm2"
+require "thread"
+require "benchmark"
+
+opts = Trollop::options do
+  version "furnace-as3 #{AVM2::VERSION}"
+  banner <<-EOS
+  furnace-avm2 is a processing tool which operates on ActionScript3 bytecode.
+
+  Usage: #{__FILE__} [options]
+EOS
+
+  opt :input,         "Input file",                                 :type => :string
+  opt :output,        "Output file",                                :type => :string
+  opt :verbose,       "Be verbose",                                 :default => false
+
+  opt :only,          "Only operate on methods <i+>",               :type => :ints,   :short => '-O'
+  opt :except,        "Operate on all methods except <i+>",         :type => :ints,   :short => '-E'
+  opt :grep,          "Search <s> in method names",                 :type => :string, :short => '-G'
+
+  opt :collect,       "Collect failed methods instead of exiting",  :default => false
+  opt :smallest,      "Find method with smallest body",             :default => false
+
+  opt :disasm_before, "Disassemble methods before transforming",    :default => false, :short => '-B'
+  opt :disasm_after,  "Disassemble methods after transforming",     :default => false, :short => '-A'
+  opt :cfg,           "Emit CFG in Graphviz format for methods",    :default => false, :short => '-C'
+
+  opt :dce,           "Eliminate dead code",                        :default => false
+  opt :ast,           "Build AST",                                  :default => false
+end
+
+Trollop::die "Input file is required" unless opts[:input]
+Trollop::die "Stray arguments: #{ARGV}" unless ARGV.empty?
+
+abc = nil
+File.open(opts[:input]) do |file|
+  abc = AVM2::ABC::File.new
+  abc.read(file)
+end
+
+disasm = lambda do |body, after|
+  puts
+  puts "Method #{body.method_idx}," <<
+       " max stack #{body.max_stack}, local count #{body.local_count}"
+  if after
+    puts "After transformation"
+  else
+    puts "Before transformation"
+  end
+  puts body.code.disassemble
+
+  if body.exceptions.any?
+    puts
+    puts "Exceptions"
+    body.exceptions.each do |exception|
+      puts "  #{exception.from_offset} -> #{exception.to_offset}: " <<
+           "catch(#{exception.exc_type} #{exception.var_name}) #{exception.target_offset}"
+    end
+  end
+end
+
+failed = []
+dced = []
+smallest = nil
+
+if opts[:grep]
+  regexp = Regexp.new(opts[:grep])
+
+  (abc.klasses + abc.instances).each do |scope|
+    if scope.is_a? AVM2::ABC::InstanceInfo
+      if scope.name.to_s =~ regexp
+        puts "Inst  Constructor  #{scope.name} #{scope.initializer_idx}"
+      end
+
+      type = "Inst "
+    else
+      type = "Class"
+    end
+
+    scope.traits.each do |trait|
+      if [:Function, :Method].include? trait.kind
+        if trait.name.to_s =~ regexp
+          puts "#{type} #{trait.kind.to_s.ljust 12} #{trait.name} #{trait.data.method_idx}"
+        end
+      end
+    end
+  end
+
+  exit
+end
+
+Thread.abort_on_exception = true
+
+threads = []
+bodies  = abc.method_bodies.dup
+mutex   = Mutex.new
+
+5.times do
+  threads << Thread.new do
+    loop do
+      body = mutex.synchronize { bodies.pop }
+      break if body.nil?
+
+      if (opts[:except] && opts[:except].include?(body.method_idx)) ||
+        (opts[:only]   && !opts[:only].include?(body.method_idx))
+        next
+      end
+
+      begin
+        disasm[body, false] if opts[:disasm_before]
+
+        if opts[:smallest]
+          if smallest.nil? || smallest.code_length > body.code_length
+            smallest = body
+          end
+        end
+
+        if opts[:dce]
+          dced << body.method_idx if body.code.eliminate_dead!
+        end
+
+        if opts[:ast]
+          ast, = body.build_ast
+          puts ast.to_sexp
+        end
+
+        if opts[:cfg]
+          cfg = body.code.build_cfg
+          File.open("method-#{body.method_idx}.dot", "w") do |dot|
+            dot.write cfg.to_graphviz
+          end
+        end
+
+        disasm[body, true] if opts[:disasm_after]
+      rescue Exception => e
+        if opts[:collect]
+          #puts "Failure at method body idx=#{body.method_idx}: #{e.class} (#{e.message}) at #{e.backtrace.first}."
+          failed << body.method_idx
+        else
+          raise e
+        end
+      end
+    end
+  end
+end
+
+threads.each &:join
+
+if opts[:verbose]
+  if opts[:dce]
+    puts "List of methods undergone DCE transform (#{dced.count}):"
+    puts "  #{dced.join " "}"
+  end
+end
+
+if opts[:smallest]
+  puts "Smallest method is #{smallest.method_idx} with #{smallest.code_length} bytes"
+end
+
+if opts[:collect] && failed.any?
+  puts "To skip #{failed.count} failed methods, append this command-line argument:"
+  puts "  --except #{failed.join " "}"
+elsif opts[:output]
+  File.open(opts[:output], "w") do |file|
+    abc.write(file)
+  end
+end

data/bin/furnace-avm2-benchmark

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "avm2"
+require "benchmark"
+
+puts "Working on #{RUBY_DESCRIPTION}"
+
+Benchmark.bm(7) do |x|
+  5.times do
+    abc = nil
+
+    GC.start
+
+    x.report("read   ") do
+      File.open(ARGV.first) do |file|
+        abc = AVM2::ABC::File.new
+        abc.read(file)
+      end
+    end
+
+    x.report("dce    ") do
+      abc.method_bodies.each do |body|
+        body.code.eliminate_dead!
+      end
+    end
+
+    x.report("write  ") do
+      File.open("/dev/null", "w") do |file|
+        abc.write(file)
+      end
+    end
+  end
+end

data/furnace-avm2.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "avm2/version"
+
+Gem::Specification.new do |s|
+  s.name        = "furnace-avm2"
+  s.version     = AVM2::VERSION
+  s.authors     = ["Peter Zotov"]
+  s.email       = ["whitequark@whitequark.org"]
+  s.homepage    = "http://github.com/whitequark/furnace-avm2"
+  s.summary     = %q{AVM2 analysis framework based on Furnace}
+  s.description = %q{furnace-avm2 allows one to load, modify and write back} <<
+                  %q{Flash ActionScript3 bytecode. It can also decompile it.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "furnace"
+  s.add_runtime_dependency "trollop"
+end

data/lib/avm2.rb

@@ -0,0 +1,13 @@
+require "furnace/cfg"
+require "furnace/ast"
+require "furnace/transform"
+
+require "furnace/graphviz"
+
+module AVM2
+end
+
+require "avm2/version"
+
+require "avm2/abc"
+require "avm2/transform"

data/lib/avm2/abc.rb

@@ -0,0 +1,65 @@
+module AVM2::ABC
+  AST = Furnace::AST
+  CFG = Furnace::CFG
+end
+
+require "avm2/binary/choice_definition"
+require "avm2/binary/record"
+
+require "avm2/abc/primitives/record"
+require "avm2/abc/primitives/opcode_sequence"
+
+require "avm2/abc/opcodes/opcode"
+require "avm2/abc/opcodes/contextual_opcode"
+
+require "avm2/abc/opcodes/load_store_opcode"
+require "avm2/abc/opcodes/arithmetic_opcode"
+require "avm2/abc/opcodes/bitwise_opcode"
+require "avm2/abc/opcodes/type_conversion_opcode"
+require "avm2/abc/opcodes/push_literal_opcode"
+require "avm2/abc/opcodes/control_transfer_opcode"
+require "avm2/abc/opcodes/function_invocation_opcode"
+require "avm2/abc/opcodes/function_return_opcode"
+require "avm2/abc/opcodes/exception_opcode"
+
+require "avm2/abc/opcodes/property_opcode"
+
+Dir[File.join(File.dirname(__FILE__), "abc", "opcodes", "*", "*.rb")].each do |file|
+  require file
+end
+
+AVM2::ABC::Opcode::MAP.freeze
+
+require "avm2/abc/metadata/namespace_info"
+require "avm2/abc/metadata/ns_set_info"
+require "avm2/abc/metadata/multiname_kind_multiname"
+require "avm2/abc/metadata/multiname_kind_multinamel"
+require "avm2/abc/metadata/multiname_kind_qname"
+require "avm2/abc/metadata/multiname_kind_rtqname"
+require "avm2/abc/metadata/multiname_kind_rtqnamel"
+require "avm2/abc/metadata/multiname_kind_genericname"
+require "avm2/abc/metadata/multiname_info"
+require "avm2/abc/metadata/const_pool_info"
+
+require "avm2/abc/metadata/option_detail"
+require "avm2/abc/metadata/option_info"
+require "avm2/abc/metadata/method_info"
+
+require "avm2/abc/metadata/metadata_info"
+
+require "avm2/abc/metadata/trait_slot"
+require "avm2/abc/metadata/trait_method"
+require "avm2/abc/metadata/trait_class"
+require "avm2/abc/metadata/trait_function"
+require "avm2/abc/metadata/trait_info"
+require "avm2/abc/metadata/instance_info"
+require "avm2/abc/metadata/klass_info"
+
+require "avm2/abc/metadata/script_info"
+
+require "avm2/abc/metadata/exception_info"
+require "avm2/abc/metadata/method_body_info"
+
+require "avm2/abc/metadata/file"
+
+AVM2::Binary::Record.codegen_each

data/lib/avm2/abc/metadata/const_pool_info.rb

@@ -0,0 +1,18 @@
+module AVM2::ABC
+  class ConstPoolInfo < Record
+    def self.cpool_array_of(name, type, options={})
+      field_size, field_array = :"#{name}_count", :"#{name}s"
+
+      vuint30 field_size, :value => lambda { send(field_array).count == 0 ? 0 : send(field_array).count + 1 }
+      array   field_array, :type => type, :initial_length => lambda { send(field_size) - 1 }, :options => options
+    end
+
+    cpool_array_of :int,       :vint32
+    cpool_array_of :uint,      :vuint32
+    cpool_array_of :double,    :double
+    cpool_array_of :string,    :vstring
+    cpool_array_of :namespace, :nested, :class => NamespaceInfo
+    cpool_array_of :ns_set,    :nested, :class => NsSetInfo
+    cpool_array_of :multiname, :nested, :class => MultinameInfo
+  end
+end

data/lib/avm2/abc/metadata/exception_info.rb

@@ -0,0 +1,29 @@
+module AVM2::ABC
+  class ExceptionInfo < Record
+    vuint30   :from_offset
+    vuint30   :to_offset
+    vuint30   :target_offset
+    const_ref :exc_type, :string
+    const_ref :var_name, :string
+
+    attr_reader :from, :to, :target
+
+    def initialize_record(options)
+      @parent = options[:parent]
+    end
+
+    def resolve!
+      sequence = @parent.code
+
+      @from   = sequence.opcode_at(@from_offset)
+      @to     = sequence.opcode_at(@to_offset)
+      @target = sequence.opcode_at(@target_offset)
+    end
+
+    def lookup!
+      @from_offset   = @from.offset
+      @to_offset     = @to.offset
+      @target_offset = @target.offset
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module AVM2::ABC
+  class File < Record
+    uint16          :minor_version
+    uint16          :major_version
+
+    nested          :constant_pool, :class => ConstPoolInfo
+
+    abc_array_of    :method,        :nested, :class => MethodInfo
+
+    abc_array_of    :metadata,      :nested, :class => MetadataInfo
+
+    vuint30         :klass_count,   :value => lambda { instances.count }
+    array           :instances,     :type => :nested, :initial_length => :klass_count,
+                                    :options => { :class => InstanceInfo }
+    array           :klasses,       :type => :nested, :initial_length => :klass_count,
+                                    :options => { :class => KlassInfo }
+    subset          :interfaces,    :instances, :interface?
+
+    abc_array_of    :script,        :nested, :class => ScriptInfo
+
+    abc_array_of    :method_body,   :nested, :class => MethodBodyInfo, :plural => :method_bodies
+
+    def root
+      self
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module AVM2::ABC
+  class InstanceInfo < Record
+    CLASS_SEALED       = 0x01
+    CLASS_FINAL        = 0x02
+    CLASS_INTERFACE    = 0x04
+    CLASS_PROTECTED_NS = 0x08
+
+    const_ref      :name,         :multiname
+    const_ref      :super_name,   :multiname
+
+    uint8          :flags
+    flag           :sealed,       :flags, CLASS_SEALED
+    flag           :final,        :flags, CLASS_FINAL
+    flag           :interface,    :flags, CLASS_INTERFACE
+    flag           :protected_ns, :flags, CLASS_PROTECTED_NS
+
+    const_ref      :protected_ns, :namespace, :if => :protected_ns?
+
+    const_array_of :interface,    :multiname
+
+    root_ref       :initializer,  :method
+
+    abc_array_of   :trait, :nested, :class => TraitInfo
+
+    def to_astlet
+      if interface?
+        root = AST::Node.new(:interface)
+      else
+        root = AST::Node.new(:instance)
+      end
+
+      root.children << name.to_astlet
+
+      unless interface?
+        if super_name
+          root.children << super_name.to_astlet
+        else
+          root.children << nil
+        end
+      end
+
+      if interfaces.any?
+        root.children << AST::Node.new(:interfaces, interfaces.map(&:to_astlet))
+      end
+
+      if traits.any?
+        root.children << AST::Node.new(:traits, traits.map(&:to_astlet))
+      end
+
+      root.normalize_hierarchy!
+    end
+  end
+end