ronin-asm 0.1.0 → 0.2.0

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

@@ -1,7 +1,7 @@
 #
 # Ronin ASM - A Ruby DSL for crafting Assembly programs and Shellcode.
 #
-# Copyright (c) 2007-2012 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2013 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This file is part of Ronin ASM.
 #
@@ -31,6 +31,12 @@ module Ronin
       #
       class Common
 
+        # Bit sizes for various architectures
+        BITS = {
+          x86:   32,
+          amd64: 64,
+        }
+
         #
         # Emits a keyword.
         #
@@ -172,6 +178,34 @@ module Ronin
         def self.emit_instruction(ins)
         end
 
+        #
+        # Emits a section name.
+        #
+        # @param [Symbol] name
+        #   The section name.
+        #
+        # @return [String]
+        #   The formatted section name.
+        #
+        # @since 0.2.0
+        #
+        def self.emit_section(name)
+        end
+
+        #
+        # Emits the program's prologue.
+        #
+        # @param [Program] program
+        #   The program.
+        #
+        # @return [String]
+        #   The formatted prologue.
+        #
+        # @since 0.2.0
+        #
+        def self.emit_prologue(program)
+        end
+
         #
         # Emits a program.
         #
@@ -182,7 +216,11 @@ module Ronin
         #   The formatted program.
         #
         def self.emit_program(program)
-          lines = [emit_label(:_start)]
+          lines = [
+            emit_prologue(program),
+            emit_section(:text),
+            emit_label(:_start)
+          ].compact
 
           program.instructions.each do |ins|
             case ins

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

@@ -1,7 +1,7 @@
 #
 # Ronin ASM - A Ruby DSL for crafting Assembly programs and Shellcode.
 #
-# Copyright (c) 2007-2012 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2013 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This file is part of Ronin ASM.
 #
@@ -85,24 +85,13 @@ module Ronin
             asm << sign << emit_integer(op.offset)
           end
 
-          return "[#{asm}]"
-        end
+          asm = "[#{asm}]"
 
-        #
-        # 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)
+          unless op.width == op.base.width
+            asm = "#{WIDTHS[op.width]} #{asm}"
           end
+
+          return asm
         end
 
         #
@@ -125,23 +114,33 @@ module Ronin
         end
 
         #
-        # Emits a program.
+        # Emits a section name.
+        #
+        # @param [Symbol] name
+        #   The section name.
+        #
+        # @return [String]
+        #   The formatted section name.
+        #
+        # @since 0.2.0
+        #
+        def self.emit_section(name)
+          "section .#{name}"
+        end
+
+        #
+        # Emits the program's prologue.
         #
         # @param [Program] program
         #   The program.
         #
         # @return [String]
-        #   The formatted program.
+        #   The formatted prologue.
         #
-        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
+        # @since 0.2.0
+        #
+        def self.emit_prologue(program)
+          "BITS #{BITS[program.arch]}"
         end
 
       end

data/lib/ronin/asm/version.rb

@@ -1,7 +1,7 @@
 #
 # Ronin ASM - A Ruby DSL for crafting Assembly programs and Shellcode.
 #
-# Copyright (c) 2007-2012 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2013 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This file is part of Ronin ASM.
 #
@@ -22,6 +22,6 @@
 module Ronin
   module ASM
     # ronin-asm version
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/spec/{immediate_operand_spec.rb → asm/immediate_operand_spec.rb}

@@ -15,7 +15,9 @@ describe ImmediateOperand do
         subject.width.should == width
       end
     end
+  end
 
+  describe "#width" do
     describe "default width for" do
       context "0x100000000 .. 0xffffffffffffffff" do
         subject { described_class.new(0xffffffffffffffff).width }

data/spec/{program_spec.rb → asm/program_spec.rb}

@@ -8,8 +8,8 @@ describe ASM::Program do
     end
   end
 
-  context "when :arch => :x86" do
-    subject { described_class.new(:arch => :x86) }
+  context "when :arch is :x86" do
+    subject { described_class.new(arch: :x86) }
 
     its(:word_size) { should == 4 }
 
@@ -63,7 +63,7 @@ describe ASM::Program do
       let(:name)  { :eax }
       let(:value) { 0xff }
 
-      before { subject.register_set(value,name) }
+      before { subject.register_set(name,value) }
 
       it "should add a 'xor' instruction with a registers" do
         subject.instructions[-1].name.should == :mov
@@ -114,21 +114,21 @@ describe ASM::Program do
       end
     end
 
-    context "when :os => 'Linux'" do
-      subject { described_class.new(:arch => :x86, :os => 'Linux') }
+    context "when :os is 'Linux'" do
+      subject { described_class.new(arch: :x86, os: 'Linux') }
 
       its(:syscalls) { should_not be_empty }
     end
 
-    context "when :os => 'FreeBSD'" do
-      subject { described_class.new(:arch => :x86, :os => 'FreeBSD') }
+    context "when :os is 'FreeBSD'" do
+      subject { described_class.new(arch: :x86, os: 'FreeBSD') }
 
       its(:syscalls) { should_not be_empty }
     end
   end
 
-  context "when :arch => :amd64" do
-    subject { described_class.new(:arch => :amd64) }
+  context "when :arch is :amd64" do
+    subject { described_class.new(arch: :amd64) }
 
     its(:word_size) { should == 8 }
 
@@ -140,14 +140,14 @@ describe ASM::Program do
       end
     end
 
-    context "when :os => 'Linux'" do
-      subject { described_class.new(:arch => :amd64, :os => 'Linux') }
+    context "when :os is 'Linux'" do
+      subject { described_class.new(arch: :amd64, os: 'Linux') }
 
       its(:syscalls) { should_not be_empty }
     end
 
-    context "when :os => 'FreeBSD'" do
-      subject { described_class.new(:arch => :amd64, :os => 'FreeBSD') }
+    context "when :os is 'FreeBSD'" do
+      subject { described_class.new(arch: :amd64, os: 'FreeBSD') }
 
       its(:syscalls) { should_not be_empty }
     end
@@ -203,6 +203,19 @@ describe ASM::Program do
     it "should have width of 1" do
       subject.byte(1).width.should == 1
     end
+
+    context "when given a MemoryOperand" do
+      let(:register)       { Register.new(:eax, 4)       }
+      let(:memory_operand) { MemoryOperand.new(register) }
+
+      it "should return a MemoryOperand" do
+        subject.byte(memory_operand).should be_kind_of(MemoryOperand)
+      end
+
+      it "should have a width of 1" do
+        subject.byte(memory_operand).width.should == 1
+      end
+    end
   end
 
   describe "#word" do
@@ -213,6 +226,19 @@ describe ASM::Program do
     it "should have width of 2" do
       subject.word(1).width.should == 2
     end
+
+    context "when given a MemoryOperand" do
+      let(:register)       { Register.new(:eax, 4)       }
+      let(:memory_operand) { MemoryOperand.new(register) }
+
+      it "should return a MemoryOperand" do
+        subject.word(memory_operand).should be_kind_of(MemoryOperand)
+      end
+
+      it "should have a width of 2" do
+        subject.word(memory_operand).width.should == 2
+      end
+    end
   end
 
   describe "#dword" do
@@ -223,6 +249,19 @@ describe ASM::Program do
     it "should have width of 4" do
       subject.dword(1).width.should == 4
     end
+
+    context "when given a MemoryOperand" do
+      let(:register)       { Register.new(:eax, 4)       }
+      let(:memory_operand) { MemoryOperand.new(register) }
+
+      it "should return a MemoryOperand" do
+        subject.dword(memory_operand).should be_kind_of(MemoryOperand)
+      end
+
+      it "should have a width of 4" do
+        subject.dword(memory_operand).width.should == 4
+      end
+    end
   end
 
   describe "#qword" do
@@ -233,6 +272,19 @@ describe ASM::Program do
     it "should have width of 8" do
       subject.qword(1).width.should == 8
     end
+
+    context "when given a MemoryOperand" do
+      let(:register)       { Register.new(:eax, 4)       }
+      let(:memory_operand) { MemoryOperand.new(register) }
+
+      it "should return a MemoryOperand" do
+        subject.qword(memory_operand).should be_kind_of(MemoryOperand)
+      end
+
+      it "should have a width of 8" do
+        subject.qword(memory_operand).width.should == 8
+      end
+    end
   end
 
   describe "#label" do
@@ -284,63 +336,67 @@ describe ASM::Program do
         push ebx
         push ecx
 
-        mov eax, ebx
-        mov eax+0, ebx
-        mov eax+4, ebx
-        mov eax+esi, ebx
-        mov eax+(esi*4), ebx
-        mov eax+(esi*4)+10, ebx
+        mov ebx, eax
+        mov ebx, eax+0
+        mov ebx, eax+4
+        mov ebx, eax+esi
+        mov ebx, eax+(esi*4)
+        mov ebx, eax+(esi*4)+10
       end
     end
 
-    it "should convert the program to ATT syntax" do
+    it "should convert the program to Intel syntax" do
       subject.to_asm.should == [
+        "BITS 32",
+        "section .text",
         "_start:",
-        "\tpushl\t%eax",
-        "\tpushl\t%ebx",
-        "\tpushl\t%ecx",
-        "\tmovl\t%eax,\t%ebx",
-        "\tmovl\t(%eax),\t%ebx",
-        "\tmovl\t0x4(%eax),\t%ebx",
-        "\tmovl\t(%eax,%esi),\t%ebx",
-        "\tmovl\t(%eax,%esi,4),\t%ebx",
-        "\tmovl\t0xa(%eax,%esi,4),\t%ebx",
+        "\tpush\teax",
+        "\tpush\tebx",
+        "\tpush\tecx",
+        "\tmov\tebx,\teax",
+        "\tmov\tebx,\t[eax]",
+        "\tmov\tebx,\t[eax+0x4]",
+        "\tmov\tebx,\t[eax+esi]",
+        "\tmov\tebx,\t[eax+esi*0x4]",
+        "\tmov\tebx,\t[eax+esi*0x4+0xa]",
         ""
       ].join($/)
     end
 
-    context "when given :intel" do
-      it "should convert the program to Intel syntax" do
-        subject.to_asm(:intel).should == [
+    context "when given :att" do
+      it "should convert the program to ATT syntax" do
+        subject.to_asm(:att).should == [
+          ".code32",
+          ".text",
           "_start:",
-          "\tpush\teax",
-          "\tpush\tebx",
-          "\tpush\tecx",
-          "\tmov\tebx,\teax",
-          "\tmov\tebx,\t[eax]",
-          "\tmov\tebx,\t[eax+0x4]",
-          "\tmov\tebx,\t[eax+esi]",
-          "\tmov\tebx,\t[eax+esi*0x4]",
-          "\tmov\tebx,\t[eax+esi*0x4+0xa]",
+          "\tpushl\t%eax",
+          "\tpushl\t%ebx",
+          "\tpushl\t%ecx",
+          "\tmovl\t%eax,\t%ebx",
+          "\tmovl\t(%eax),\t%ebx",
+          "\tmovl\t0x4(%eax),\t%ebx",
+          "\tmovl\t(%eax,%esi),\t%ebx",
+          "\tmovl\t(%eax,%esi,4),\t%ebx",
+          "\tmovl\t0xa(%eax,%esi,4),\t%ebx",
           ""
         ].join($/)
       end
     end
   end
 
-  describe "#assemble", :yasm => true do
+  describe "#assemble", integration: true do
     subject do
       described_class.new do
         push eax
         push ebx
         push ecx
 
-        mov eax, ebx
-        mov eax+0, ebx
-        mov eax+4, ebx
-        mov eax+esi, ebx
-        mov eax+(esi*4), ebx
-        mov eax+(esi*4)+10, ebx
+        mov ebx, eax
+        mov ebx, eax+0
+        mov ebx, eax+4
+        mov ebx, eax+esi
+        mov ebx, eax+(esi*4)
+        mov ebx, eax+(esi*4)+10
       end
     end
 
@@ -352,10 +408,10 @@ describe ASM::Program do
       File.size(output).should > 0
     end
 
-    context "with :syntax => :intel" do
+    context "with :syntax is :intel" do
       let(:output) { Tempfile.new(['ronin-asm', '.o']).path }
 
-      before { subject.assemble(output, :syntax => :intel) }
+      before { subject.assemble(output, syntax: :intel) }
 
       it "should write to the output file" do
         File.size(output).should > 0

data/spec/{shellcode_spec.rb → asm/shellcode_spec.rb}

@@ -1,33 +1,41 @@
+# encoding: US-ASCII
+
 require 'spec_helper'
 require 'ronin/asm/shellcode'
 
 describe ASM::Shellcode do
-  describe "#assemble", :yasm => true do
+  describe "#assemble", integration: true do
     subject do
       described_class.new do
         xor   eax,  eax
         push  eax
         push  0x68732f2f
         push  0x6e69622f
-        mov   esp,  ebx
+        mov   ebx, esp
         push  eax
         push  ebx
-        mov   esp,  ecx
+        mov   ecx,  esp
         xor   edx,  edx
-        mov   0xb,  al
+        mov   al,   0xb
         int   0x80
       end
     end
 
-    let(:shellcode) { "f1\xC0fPfh//shfh/binf\x89\xE3fPfSf\x89\xE1f1\xD2\xB0\v\xCD\x80" }
+    let(:shellcode) { "1\xC0Ph//shh/bin\x89\xE3PS\x89\xE11\xD2\xB0\v\xCD\x80" }
 
     it "assemble down to raw machine code" do
       subject.assemble.should == shellcode
     end
 
-    context "with :syntax => :intel" do
+    context "with :syntax is :intel" do
+      it "assemble down to raw machine code" do
+        subject.assemble(syntax: :intel).should == shellcode
+      end
+    end
+
+    context "with :syntax is :att" do
       it "assemble down to raw machine code" do
-        subject.assemble(:syntax => :intel).should == shellcode
+        subject.assemble(syntax: :att).should == shellcode
       end
     end
   end