ronin-asm 0.1.0

data/lib/ronin/asm/syntax/intel.rb

@@ -0,0 +1,150 @@
+#
+# Ronin ASM - A Ruby DSL for crafting Assembly programs and Shellcode.
+#
+# Copyright (c) 2007-2012 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin ASM.
+#
+# Ronin is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin.  If not, see <http://www.gnu.org/licenses/>
+#
+
+require 'ronin/asm/syntax/common'
+
+module Ronin
+  module ASM
+    module Syntax
+      class Intel < Common
+
+        # Data sizes and their identifiers
+        WIDTHS = {
+          1 => 'BYTE',
+          2 => 'WORD',
+          4 => 'DWORD',
+          8 => 'QWORD'
+        }
+
+        #
+        # Emits a register.
+        #
+        # @param [Register] reg
+        #   The register.
+        #
+        # @return [String]
+        #   The register name.
+        #
+        def self.emit_register(reg)
+          reg.name.to_s
+        end
+
+        #
+        # Emits an immediate operand.
+        #
+        # @param [ImmediateOperand] op
+        #   The operand.
+        #
+        # @return [String]
+        #   The formatted immediate operand.
+        #
+        def self.emit_immediate_operand(op)
+          "#{WIDTHS[op.width]} #{emit_integer(op.value)}"
+        end
+
+        #
+        # Emits a memory operand.
+        #
+        # @param [MemoryOperand] op
+        #   The operand.
+        #
+        # @return [String]
+        #   The formatted memory operand.
+        #
+        def self.emit_memory_operand(op)
+          asm = emit_register(op.base)
+
+          if op.index
+            asm << '+' << emit_register(op.index)
+            asm << '*' << emit_integer(op.scale) if op.scale > 1
+          end
+
+          if op.offset != 0
+            sign = if op.offset >= 0 then '+'
+                   else                   '-'
+                   end
+
+            asm << sign << emit_integer(op.offset)
+          end
+
+          return "[#{asm}]"
+        end
+
+        #
+        # Emits multiple operands.
+        #
+        # @param [Array<ImmediateOperand, MemoryOperand, Register, Symbol>] ops
+        #   The Array of operands.
+        #
+        # @return [String]
+        #   The formatted operands.
+        #
+        def self.emit_operands(ops)
+          if ops.length > 1
+            [ops[-1], *ops[0..-2]].map { |op| emit_operand(op) }.join(",\t")
+          else
+            super(ops)
+          end
+        end
+
+        #
+        # Emits an instruction.
+        #
+        # @param [Instruction] ins
+        #   The instruction.
+        #
+        # @return [String]
+        #   The formatted instruction.
+        #
+        def self.emit_instruction(ins)
+          line = emit_keyword(ins.name)
+
+          unless ins.operands.empty?
+            line << "\t" << emit_operands(ins.operands)
+          end
+
+          return line
+        end
+
+        #
+        # Emits a program.
+        #
+        # @param [Program] program
+        #   The program.
+        #
+        # @return [String]
+        #   The formatted program.
+        #
+        def self.emit_program(program)
+          asm = super(program)
+
+          # prepend the `BITS 64` directive for YASM
+          if program.arch == :amd64
+            asm = ["BITS 64", '', asm].join($/)
+          end
+
+          return asm
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/asm/version.rb

@@ -0,0 +1,27 @@
+#
+# Ronin ASM - A Ruby DSL for crafting Assembly programs and Shellcode.
+#
+# Copyright (c) 2007-2012 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin ASM.
+#
+# Ronin Asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin Asm is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin Asm.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+module Ronin
+  module ASM
+    # ronin-asm version
+    VERSION = '0.1.0'
+  end
+end

data/ronin-asm.gemspec

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'ronin/asm/version'
+                  Ronin::ASM::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files  = `git ls-files`.split($/)
+  gem.files  = glob[gemspec['files']] if gemspec['files']
+  gem.files += Array(gemspec['generated_files'])
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/spec/asm_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'ronin/asm/version'
+
+describe ASM do
+  it "should have a version" do
+    subject.const_defined?('VERSION').should == true
+  end
+end

data/spec/helpers/database.rb

@@ -0,0 +1,7 @@
+require 'ronin/database'
+
+require 'spec_helper'
+
+module Helpers
+  Database.setup(ENV['DATABASE'] || 'sqlite3::memory:')
+end

data/spec/immediate_operand_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+require 'ronin/asm/immediate_operand'
+
+describe ImmediateOperand do
+  let(:value) { 0xff }
+
+  describe "#initialize" do
+    context "with a width" do
+      let(:width) { 2 }
+
+      subject { described_class.new(value,width) }
+
+      it "should set the width" do
+        subject.width.should == width
+      end
+    end
+
+    describe "default width for" do
+      context "0x100000000 .. 0xffffffffffffffff" do
+        subject { described_class.new(0xffffffffffffffff).width }
+
+        it { should == 8 }
+      end
+
+      context "-0x800000000 .. -0x7fffffffffffffff" do
+        subject { described_class.new(-0x7fffffffffffffff).width }
+
+        it { should == 8 }
+      end
+
+      context "0x10000 .. 0xffffffff" do
+        subject { described_class.new(0xffffffff).width }
+
+        it { should == 4 }
+      end
+
+      context "-0x80000 .. -0x7fffffff" do
+        subject { described_class.new(-0x7fffffff).width }
+
+        it { should == 4 }
+      end
+
+      context "0x100 .. 0xffff" do
+        subject { described_class.new(0xffff).width }
+
+        it { should == 2 }
+      end
+
+      context "-0x80 .. -0x7fff" do
+        subject { described_class.new(-0x7fff).width }
+
+        it { should == 2 }
+      end
+
+      context "0x0 .. 0xff" do
+        subject { described_class.new(0xff).width }
+
+        it { should == 1 }
+      end
+
+      context "0x0 .. -0x7f" do
+        subject { described_class.new(-0x7f).width }
+
+        it { should == 1 }
+      end
+    end
+  end
+
+  describe "#to_i" do
+    subject { described_class.new(value) }
+
+    it "should return the value" do
+      subject.to_i.should == value
+    end
+  end
+end

data/spec/instruction_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+require 'ronin/asm/instruction'
+require 'ronin/asm/register'
+require 'ronin/asm/immediate_operand'
+require 'ronin/asm/memory_operand'
+
+describe Instruction do
+  let(:register) { Register.new(:eax, 4) }
+  let(:immediate)  { ImmediateOperand.new(0xff, 1)  }
+
+  describe "#initialize" do
+    let(:name)     { :mov }
+    let(:operands) { [immediate, register] }
+
+    subject { described_class.new(name,operands) }
+
+    it "should set the name" do
+      subject.name.should == :mov
+    end
+
+    it "should set the operands" do
+      subject.operands.should == operands
+    end
+
+    context "when given an Integer operand" do
+      let(:integer) { 0xff }
+
+      subject { described_class.new(name, [integer, register]) }
+
+      it "should wrap the operand to in a ImmediateOperand" do
+        subject.operands[0].should be_kind_of(ImmediateOperand)
+        subject.operands[0].value.should == integer
+      end
+    end
+
+    context "when given a nil operand" do
+      subject { described_class.new(name, [nil, register]) }
+
+      it "should wrap the operand to in a ImmediateOperand" do
+        subject.operands[0].should be_kind_of(ImmediateOperand)
+        subject.operands[0].value.should == 0
+      end
+    end
+  end
+
+  describe "#width" do
+    subject { described_class.new(:mov, [immediate, register]) }
+
+    it "should return the maximum width of the operands" do
+      subject.width.should == register.width
+    end
+
+    context "when one of the operands does not define #width" do
+      subject { described_class.new(:mov, [:label, register]) }
+
+      it "should ignore them" do
+        subject.width.should == register.width
+      end
+    end
+  end
+end

data/spec/memory_operand_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+require 'ronin/asm/memory_operand'
+require 'ronin/asm/register'
+
+describe MemoryOperand do
+  let(:register) { Register.new(:eax, 4) }
+
+  describe "#initialize" do
+    its(:base)   { should be_nil  }
+    its(:offset) { should == 0    }
+    its(:index)  { should be_nil  }
+    its(:scale)  { should == 1    }
+
+    it "should only accept nil and a Register for base" do
+      lambda {
+        described_class.new(Object.new)
+      }.should raise_error(TypeError)
+    end
+
+    it "should only accept Integers for offset" do
+      lambda {
+        described_class.new(register,2.0)
+      }.should raise_error(TypeError)
+    end
+
+    it "should only accept nil and a Register for index" do
+      lambda {
+        described_class.new(register,0,Object.new)
+      }.should raise_error(TypeError)
+    end
+
+    it "should only accept Integers for offset" do
+      lambda {
+        described_class.new(register,0,nil,2.0)
+      }.should raise_error(TypeError)
+    end
+
+  end
+
+  describe "#+" do
+    let(:operand) { described_class.new(register,4,register,2) }
+
+    subject { operand + 4 }
+
+    it "should add to offset" do
+      subject.offset.should == 8
+    end
+
+    it "should not change base, index or scale" do
+      subject.base.should  == operand.base
+      subject.index.should == operand.index
+      subject.scale.should == operand.scale
+    end
+  end
+
+  describe "#-" do
+    let(:operand) { described_class.new(register,4,register,2) }
+
+    subject { operand - 2 }
+
+    it "should subtract from offset" do
+      subject.offset.should == 2
+    end
+
+    it "should not change base, index or scale" do
+      subject.base.should  == operand.base
+      subject.index.should == operand.index
+      subject.scale.should == operand.scale
+    end
+  end
+
+  describe "#width" do
+    subject { described_class.new(register,10) }
+
+    it "should return the width of base" do
+      subject.width.should == register.width
+    end
+  end
+end