ronin-asm 0.1.0

data/lib/ronin/asm/register.rb

@@ -0,0 +1,110 @@
+#
+# 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/memory_operand'
+
+module Ronin
+  module ASM
+    #
+    # Represents a Register.
+    #
+    class Register < Struct.new(:name, :width, :general)
+
+      #
+      # Initializes a register.
+      #
+      # @param [Symbol] name
+      #   The register name.
+      #
+      # @param [Integer] width
+      #   The width of the register.
+      #
+      # @param [Boolean] general
+      #   Specifies whether the register is a General Purpose Register (GPR).
+      #
+      def initialize(name,width,general=false)
+        super(name,width,general)
+      end
+
+      #
+      # Adds an offset to the value within the register and dereferences the
+      # address.
+      #
+      # @param [MemoryOperand, Register, Integer] offset
+      #   The offset to add to the value of the register.
+      #
+      # @return [MemoryOperand]
+      #   The new Memory Operand.
+      #
+      # @raise [TypeError]
+      #   the `offset` was not an {MemoryOperand}, {Register} or Integer.
+      #
+      def +(offset)
+        case offset
+        when MemoryOperand
+          MemoryOperand.new(self,offset.offset,offset.index,offset.scale)
+        when Register
+          MemoryOperand.new(self,0,offset)
+        when Integer
+          MemoryOperand.new(self,offset)
+        else
+          raise(TypeError,"offset was not an MemoryOperand, Register or Integer")
+        end
+      end
+
+      #
+      # Substracts from the value within the register and dereferences the
+      # address.
+      #
+      # @param [Integer] offset
+      #   The value to subtract from the value of the register.
+      #
+      # @return [MemoryOperand]
+      #   The new Memory Operand.
+      #
+      def -(offset)
+        MemoryOperand.new(self,-offset)
+      end
+
+      #
+      # Multiples the value within the register.
+      #
+      # @param [Integer] scale
+      #   The scale to multiply the value within register by.
+      #
+      # @return [MemoryOperand]
+      #   The new Memory Operand.
+      #
+      def *(scale)
+        MemoryOperand.new(nil,0,self,scale)
+      end
+
+      #
+      # @return [String]
+      #   The register's name.
+      #
+      def to_s
+        self.name.to_s
+      end
+
+    end
+  end
+end

data/lib/ronin/asm/shellcode.rb

@@ -0,0 +1,70 @@
+#
+# 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/>.
+#
+
+require 'ronin/asm/program'
+
+require 'tempfile'
+
+module Ronin
+  module ASM
+    #
+    # Represents Shellcode. Shellcode is like an Assembly {Program}, but
+    # assembles into raw machine code which can be injected into a process.
+    #
+    #     ASM::Shellcode.new do
+    #       xor   eax,  eax
+    #       push  eax
+    #       push  0x68732f2f
+    #       push  0x6e69622f
+    #       mov   esp,  ebx
+    #       push  eax
+    #       push  ebx
+    #       mov   esp,  ecx
+    #       xor   edx,  edx
+    #       mov   0xb,  al
+    #       int   0x80
+    #     end
+    # 
+    #
+    class Shellcode < Program
+
+      #
+      # Assembles the Shellcode.
+      #
+      # @param [Hash] options
+      #   Additional options.
+      #
+      # @return [String]
+      #   The raw object-code of the Shellcode.
+      #
+      # @see Program#assemble
+      #
+      def assemble(options={})
+        output = Tempfile.new(['ronin-shellcode', '.bin']).path
+
+        super(output,options.merge(:format => :bin))
+
+        return File.new(output,'rb').read
+      end
+
+    end
+  end
+end

data/lib/ronin/asm/syntax.rb

@@ -0,0 +1,23 @@
+#
+# 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/att'
+require 'ronin/asm/syntax/intel'

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

@@ -0,0 +1,136 @@
+#
+# 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
+      #
+      # Handles emitting Assembly source code in ATT syntax.
+      #
+      class ATT < Common
+
+        # Data sizes and their instruction mnemonics
+        WIDTHS = {
+          8 => 'q',
+          4 => 'l',
+          2 => 'w',
+          1 => 'b',
+          nil => ''
+        }
+
+        #
+        # Emits a register.
+        #
+        # @param [Register] reg
+        #   The register.
+        #
+        # @return [String]
+        #   The register name.
+        #
+        def self.emit_register(reg)
+          "%#{reg.name}"
+        end
+
+        #
+        # Emits an immediate operand.
+        #
+        # @param [ImmediateOperand] op
+        #   The operand.
+        #
+        # @return [String]
+        #   The formatted immediate operand.
+        #
+        def self.emit_immediate_operand(op)
+          "$#{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 << ',' << op.scale.to_s if op.scale > 1
+          end
+
+          asm = "(#{asm})"
+          asm = emit_integer(op.offset) + asm if op.offset != 0
+
+          return asm
+        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?
+            unless (ins.operands.length == 1 && ins.width == 1)
+              line << WIDTHS[ins.width]
+            end
+
+            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 `.code64` directive for YASM
+          if program.arch == :amd64
+            asm = [".code64", '', asm].join($/)
+          end
+
+          return asm
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,202 @@
+#
+# 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/register'
+require 'ronin/asm/immediate_operand'
+require 'ronin/asm/memory_operand'
+
+module Ronin
+  module ASM
+    module Syntax
+      #
+      # Abstract base-class for all Assembly Syntax classes.
+      #
+      class Common
+
+        #
+        # Emits a keyword.
+        #
+        # @param [Symbol] name
+        #   Name of the keyword.
+        #
+        # @return [String]
+        #   The formatted keyword.
+        #
+        def self.emit_keyword(name)
+          name.to_s
+        end
+
+        #
+        # Emits a register.
+        #
+        # @param [Register] reg
+        #
+        # @return [String]
+        #   The formatted register.
+        #
+        # @abstract
+        #
+        def self.emit_register(reg)
+        end
+
+        #
+        # Emits an integer.
+        #
+        # @param [Integer] value
+        #   The integer.
+        #
+        # @return [String]
+        #   The formatted integer.
+        #
+        def self.emit_integer(value)
+          if value >= 0 then "0x%x" % value
+          else               "-0x%x" % value.abs
+          end
+        end
+
+        #
+        # Emits a floating point number.
+        #
+        # @param [Float] value
+        #   The number.
+        #
+        # @return [String]
+        #   The formatted float.
+        #
+        # @abstract
+        #
+        def self.emit_float(value)
+        end
+
+        #
+        # Emits an immediate operand.
+        #
+        # @param [ImmediateOperand] op
+        #   The immediate operand.
+        #
+        # @return [String]
+        #   The formatted immediate operand.
+        #
+        # @abstract
+        #
+        def self.emit_immediate_operand(op)
+        end
+
+        #
+        # Emits an memory operand.
+        #
+        # @param [MemoryOperand] op
+        #   The memory operand.
+        #
+        # @return [String]
+        #   The formatted memory operand.
+        #
+        # @abstract
+        #
+        def self.emit_memory_operand(op)
+        end
+
+        #
+        # Emits an operand.
+        #
+        # @param [ImmediateOperand, MemoryOperand, Register, Symbol] op
+        #   The operand.
+        #
+        # @return [String]
+        #   The formatted operand.
+        #
+        def self.emit_operand(op)
+          case op
+          when ImmediateOperand then emit_immediate_operand(op)
+          when MemoryOperand    then emit_memory_operand(op)
+          when Register         then emit_register(op)
+          when Symbol           then emit_keyword(op)
+          end
+        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)
+          ops.map { |op| emit_operand(op) }.join(",\t")
+        end
+
+        #
+        # Emits a label.
+        #
+        # @param [Symbol] name
+        #   The name of the label.
+        #
+        # @return [String]
+        #   The formatted label.
+        #
+        def self.emit_label(name)
+          "#{name}:"
+        end
+
+        #
+        # Emits an instruction.
+        #
+        # @param [Instruction] ins
+        #   The instruction.
+        #
+        # @return [String]
+        #   The formatted instruction.
+        #
+        # @abstract
+        #
+        def self.emit_instruction(ins)
+        end
+
+        #
+        # Emits a program.
+        #
+        # @param [Program] program
+        #   The program.
+        #
+        # @return [String]
+        #   The formatted program.
+        #
+        def self.emit_program(program)
+          lines = [emit_label(:_start)]
+
+          program.instructions.each do |ins|
+            case ins
+            when Symbol      then lines << emit_label(ins)
+            when Instruction then lines << "\t#{emit_instruction(ins)}"
+            end
+          end
+
+          lines << ''
+
+          return lines.join($/)
+        end
+
+      end
+    end
+  end
+end