ronin-asm 0.1.0

data/lib/ronin/asm/archs/x86.rb

@@ -0,0 +1,166 @@
+#
+# 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'
+
+module Ronin
+  module ASM
+    module Archs
+      #
+      # Contains X86 Archtecture information.
+      #
+      module X86
+        # Default word size
+        WORD_SIZE = 4
+
+        # X86 registers
+        REGISTERS = {
+          :al  => Register.new(:al, 1),
+          :ah  => Register.new(:ah, 1),
+          :ax  => Register.new(:ax, 2),
+          :eax => Register.new(:eax, 4, true),
+
+          :bl  => Register.new(:bl, 1),
+          :bh  => Register.new(:bh, 1),
+          :bx  => Register.new(:bx, 2),
+          :ebx => Register.new(:ebx, 4, true),
+
+          :cl  => Register.new(:cl, 1),
+          :ch  => Register.new(:ch, 1),
+          :cx  => Register.new(:cx, 2),
+          :ecx => Register.new(:ecx, 4, true),
+
+          :dl  => Register.new(:dl, 1),
+          :dh  => Register.new(:dh, 1),
+          :dx  => Register.new(:dx, 2),
+          :edx => Register.new(:edx, 4, true),
+
+          :bp  => Register.new(:bp, 2),
+          :ebp => Register.new(:ebp, 4),
+
+          :sp  => Register.new(:sp, 2),
+          :esp => Register.new(:esp, 4),
+
+          :ip  => Register.new(:ip, 2),
+          :eip => Register.new(:eip, 4),
+
+          :sil => Register.new(:sil, 1),
+          :si  => Register.new(:si, 2),
+          :esi => Register.new(:esi, 4, true),
+
+          :dil => Register.new(:dil, 1),
+          :di  => Register.new(:di, 2),
+          :edi => Register.new(:edi, 4, true),
+
+          :cs => Register.new(:cs, 2),
+          :ds => Register.new(:ds, 2),
+          :es => Register.new(:es, 2),
+          :fs => Register.new(:fs, 2),
+          :gs => Register.new(:gs, 2),
+          :ss => Register.new(:ss, 2)
+        }
+
+        #
+        # Generates the instruction to trigger an interrupt.
+        #
+        def interrupt(number); instruction(:int,number); end
+
+        #
+        # Generates the instruction to invoke a syscall.
+        #
+        def syscall; interrupt(0x80); end
+
+        #
+        # The Stack Base Pointer register.
+        #
+        # @see ebp
+        #
+        def stack_base; ebp; end
+
+        #
+        # The Stack Pointer register.
+        #
+        # @see esp
+        #
+        def stack_pointer; esp; end
+
+        #
+        # Generates the instruction to push a value onto the Stack.
+        #
+        # @param [ImmediateOperand, MemoryOperate, Register, Integer, Symbol] op
+        #   The value.
+        #
+        def stack_push(op); instruction(:push,op); end
+
+        #
+        # Generates the instruction to pop a value off of the Stack.
+        #
+        # @param [Register] op
+        #   The register operand to store the value.
+        #
+        def stack_pop(op); instruction(:pop,op); end
+
+        #
+        # Generates the instruction to clear a register.
+        #
+        # @param [Symbol] name
+        #   The name of the register.
+        #
+        def register_clear(name)
+          instruction(:xor,register(name),register(name))
+        end
+
+        #
+        # Generates the instruction to set a register.
+        # 
+        # @param [ImmediateOperand, MemoryOperate, Register, Integer, Symbol] value
+        #   The value to set.
+        #
+        # @param [Symbol] name
+        #   The name of the register.
+        #
+        def register_set(value,name)
+          instruction(:mov,value,register(name))
+        end
+
+        #
+        # Generates the instruction to save a register.
+        # 
+        # @param [Symbol] name
+        #   The name of the register.
+        #
+        def register_save(name)
+          stack_push(register(name))
+        end
+
+        #
+        # Generates the instruction to restore a register.
+        # 
+        # @param [Symbol] name
+        #   The name of the register.
+        #
+        def register_load(name)
+          stack_pop(register(name))
+        end
+      end
+    end
+  end
+end

data/lib/ronin/asm/asm.rb

@@ -0,0 +1,66 @@
+#
+# 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/program'
+require 'ronin/asm/shellcode'
+
+module Ronin
+  module ASM
+    #
+    # Creates a new Assembly Program.
+    #
+    # @param [Hash{Symbol => Object}] options
+    #   Additional options.
+    #
+    # @option options [String, Symbol] :arch (:x86)
+    #   The architecture of the Program.
+    #
+    # @option options [Hash{Symbol => Object}] :variables
+    #   Variables to set in the program.
+    #
+    # @yield []
+    #   The given block will be evaluated within the program.
+    #
+    # @return [Program]
+    #   The new Assembly Program.
+    #
+    # @example
+    #   ASM.new do
+    #     mov  1, eax
+    #     mov  1, ebx
+    #     mov  2, ecx
+    #
+    #     _loop do
+    #       push  ecx
+    #       imul  ebx, ecx
+    #       pop   ebx
+    #
+    #       inc eax
+    #       cmp ebx, 10
+    #       jl  :_loop
+    #     end
+    #   end
+    #
+    def ASM.new(options={},&block)
+      Program.new(options,&block)
+    end
+  end
+end

data/lib/ronin/asm/config.rb

@@ -0,0 +1,39 @@
+#
+# 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 'data_paths'
+
+module Ronin
+  module ASM
+    #
+    # Handles configuration for ronin-asm.
+    #
+    module Config
+      include DataPaths
+      extend DataPaths::Finders
+
+      register_data_path File.join(File.dirname(__FILE__),'..','..','..','data')
+
+      # Data directory for ronin-asm
+      DATA_DIR = File.join('ronin','asm')
+    end
+  end
+end

data/lib/ronin/asm/immediate_operand.rb

@@ -0,0 +1,76 @@
+#
+# 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/>
+#
+
+module Ronin
+  module ASM
+    #
+    # Represents an Immediate Data Operand.
+    #
+    # @see http://asm.sourceforge.net/articles/linasm.html#Prefixes
+    #
+    class ImmediateOperand < Struct.new(:value, :width)
+
+      #
+      # Initializes a new Immediate Operand.
+      #
+      # @param [Integer, nil] value
+      #   The value.
+      #
+      # @param [nil, 1, 2, 4, 8] width
+      #   The size in bytes of the value.
+      #
+      def initialize(value,width=nil)
+        value   = value.to_i
+        width ||= case value
+                  when (0x100000000..0xffffffffffffffff),
+                       (-0x7fffffffffffffff..-0x800000000) then 8
+                  when (0x10000..0xffffffff),
+                       (-0x7fffffff..-0x80000)             then 4
+                  when (0x100..0xffff), (-0x7fff..-0x80)   then 2
+                  when (0..0xff), (-0x7f..0)               then 1
+                  end
+
+        super(value,width)
+      end
+
+      #
+      # Converts the operand to an Integer.
+      #
+      # @return [Integer]
+      #   The value.
+      #
+      def to_i
+        self.value
+      end
+
+      #
+      # Converts the operand to a String.
+      #
+      # @return [String]
+      #   The value in String form.
+      #
+      def to_s
+        self.value.to_s
+      end
+
+    end
+  end
+end

data/lib/ronin/asm/instruction.rb

@@ -0,0 +1,65 @@
+#
+# 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/immediate_operand'
+
+module Ronin
+  module ASM
+    #
+    # Represents an instruction.
+    #
+    class Instruction < Struct.new(:name, :operands)
+
+      #
+      # Initializes the instruction.
+      #
+      # @param [Symbol] name
+      #   The instruction name.
+      #
+      # @param [Array<MemoryOperand, Register, Symbo, Integer>] operands
+      #   Operands for the instruction.
+      #
+      def initialize(name,operands)
+        operands = operands.map do |op|
+          case op
+          when Integer, nil then ImmediateOperand.new(op)
+          else                   op
+          end
+        end
+
+        super(name,operands)
+      end
+
+      #
+      # The word size of the instruction.
+      #
+      # @return [Integer, nil]
+      #   The word size in bytes.
+      #
+      def width
+        self.operands.map { |op|
+          op.width if op.respond_to?(:width)
+        }.compact.max
+      end
+
+    end
+  end
+end

data/lib/ronin/asm/memory_operand.rb

@@ -0,0 +1,109 @@
+#
+# 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'
+
+module Ronin
+  module ASM
+    #
+    # Represents a Memory Operand.
+    #
+    # @see http://asm.sourceforge.net/articles/linasm.html#Memory
+    #
+    class MemoryOperand < Struct.new(:base, :offset, :index, :scale)
+
+      #
+      # Creates a new Memory Operand.
+      #
+      # @param [Register, nil] base
+      #   The base of the value.
+      #
+      # @param [Integer] offset
+      #   The fixed offset to add to the `base`.
+      #
+      # @param [Register, nil] index
+      #   The variable index to multiple by `scale`, then add to `base.
+      #
+      # @param [Integer] scale
+      #   The scale to multiple `index` by.
+      #
+      # @raise [TypeError]
+      #   `base` or `index` was not a {Register} or `nil`.
+      #
+      def initialize(base=nil,offset=0,index=nil,scale=1)
+        unless (base.nil? || base.kind_of?(Register))
+          raise(TypeError,"base must be a Register or nil")
+        end
+
+        unless offset.kind_of?(Integer)
+          raise(TypeError,"offset must be an Integer")
+        end
+
+        unless (index.nil? || index.kind_of?(Register))
+          raise(TypeError,"index must be a Register or nil")
+        end
+
+        unless scale.kind_of?(Integer)
+          raise(TypeError,"scale must be an Integer")
+        end
+
+        super(base,offset,index,scale)
+      end
+
+      #
+      # Adds to the offset of the Memory Operand.
+      #
+      # @param [Integer] offset
+      #   The offset to add to the Memory Operand.
+      #
+      # @return [MemoryOperand]
+      #   The new Memory Operand.
+      #
+      def +(offset)
+        MemoryOperand.new(self.base,self.offset+offset,self.index,self.scale)
+      end
+
+      #
+      # Subtracts from the offset of the Memory Operand.
+      #
+      # @param [Integer] offset
+      #   The offset to subject from the Memory Operand.
+      #
+      # @return [Memoryoperand]
+      #   The new Memory Operand.
+      #
+      def -(offset)
+        MemoryOperand.new(self.base,self.offset-offset,self.index,self.scale)
+      end
+
+      #
+      # The width of the Memory Operand.
+      #
+      # @return [Integer]
+      #   The width taken from the base {Register}.
+      #
+      def width
+        base.width
+      end
+
+    end
+  end
+end