ronin-code-asm 1.0.0.beta1

data/lib/ronin/code/asm/archs/amd64.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/asm/archs/x86'
+
+module Ronin
+  module Code
+    module ASM
+      module Archs
+        #
+        # Contains AMD64 Archtecture information.
+        #
+        module AMD64
+          include X86
+
+          # Default word size
+          WORD_SIZE = 8
+
+          # AMD64 registers
+          REGISTERS = X86::REGISTERS.merge(
+            rax: Register.new(:rax, 8, true),
+            rbx: Register.new(:rbx, 8, true),
+            rcx: Register.new(:rcx, 8, true),
+            rdx: Register.new(:rdx, 8, true),
+
+            rsi: Register.new(:rsi, 8, true),
+            rdi: Register.new(:rdi, 8, true),
+
+            rsp: Register.new(:rsp, 8, true),
+            rbp: Register.new(:rbp, 8, true),
+
+            r8b: Register.new(:r8b, 1, true),
+            r8w: Register.new(:r8w, 2, true),
+            r8d: Register.new(:r8d, 4, true),
+            r8:  Register.new(:r8, 8, true),
+
+            r9b: Register.new(:r9b, 1, true),
+            r9w: Register.new(:r9w, 2, true),
+            r9d: Register.new(:r9d, 4, true),
+            r9:  Register.new(:r9, 8, true),
+
+            r10b: Register.new(:r10b, 1, true),
+            r10w: Register.new(:r10w, 2, true),
+            r10d: Register.new(:r10d, 4, true),
+            r10:  Register.new(:r10, 8, true),
+
+            r11b: Register.new(:r11b, 1, true),
+            r11w: Register.new(:r11w, 2, true),
+            r11d: Register.new(:r11d, 4, true),
+            r11:  Register.new(:r11, 8, true),
+
+            r12b: Register.new(:r12b, 1, true),
+            r12w: Register.new(:r12w, 2, true),
+            r12d: Register.new(:r12d, 4, true),
+            r12:  Register.new(:r12, 8, true),
+
+            r13b: Register.new(:r13b, 1, true),
+            r13w: Register.new(:r13w, 2, true),
+            r13d: Register.new(:r13d, 4, true),
+            r13:  Register.new(:r13, 8, true),
+
+            r14b: Register.new(:r14b, 1, true),
+            r14w: Register.new(:r14w, 2, true),
+            r14d: Register.new(:r14d, 4, true),
+            r14:  Register.new(:r14, 8, true),
+
+            r15b: Register.new(:r15b, 1, true),
+            r15w: Register.new(:r15w, 2, true),
+            r15d: Register.new(:r15d, 4, true),
+            r15:  Register.new(:r15, 8, true),
+
+            rip: Register.new(:rip, 8, true)
+          )
+
+          #
+          # Generates the instruction to invoke a syscall.
+          #
+          def syscall; instruction(:syscall); end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/asm/register'
+
+module Ronin
+  module Code
+    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.
+          #
+          # @param [Integer] number
+          #   The interrupt number.
+          #
+          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, MemoryOperand, 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 [Symbol] name
+          #   The name of the register.
+          #
+          # @param [ImmediateOperand, MemoryOperand, Register, Integer, Symbol] value
+          #   The value to set.
+          #
+          def register_set(name,value)
+            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
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/asm/archs/x86'
+require 'ronin/code/asm/archs/amd64'

data/lib/ronin/code/asm/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+module Ronin
+  module Code
+    module ASM
+      #
+      # Handles configuration for ronin-code-asm.
+      #
+      module Config
+        # Data directory for ronin-code-asm
+        DATA_DIR = File.expand_path(File.join(__dir__,'..','..','..','..','data'))
+      end
+    end
+  end
+end

data/lib/ronin/code/asm/immediate_operand.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+module Ronin
+  module Code
+    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)
+          super(value.to_i,width)
+        end
+
+        #
+        # The width of the immediate operand.
+        #
+        # @return [8, 4, 2, 1]
+        #   The width.
+        #
+        def width
+          super || 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
+        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
+end

data/lib/ronin/code/asm/instruction.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/asm/immediate_operand'
+
+module Ronin
+  module Code
+    module ASM
+      #
+      # Represents an instruction.
+      #
+      class Instruction < Struct.new(:name, :operands)
+
+        #
+        # Initializes the instruction.
+        #
+        # @param [Symbol] name
+        #   The instruction name.
+        #
+        # @param [Array<MemoryOperand, Register, Symbol, Integer>] operands
+        #   Operands for the instruction.
+        #
+        def initialize(name,operands)
+          operands = operands.map do |value|
+            case value
+            when Integer, nil then ImmediateOperand.new(value)
+            else                   value
+            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
+end

data/lib/ronin/code/asm/memory_operand.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/asm/register'
+
+module Ronin
+  module Code
+    module ASM
+      #
+      # Represents a Memory Operand.
+      #
+      # @see http://asm.sourceforge.net/articles/linasm.html#Memory
+      #
+      class MemoryOperand < Struct.new(:base, :offset, :index, :scale, :width)
+
+        #
+        # 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.
+        #
+        # @param [Integer, nil] width
+        #   The optional width of the memory operand.
+        #
+        # @raise [TypeError]
+        #   `base` or `index` was not a {Register} or `nil`.
+        #
+        def initialize(base=nil,offset=0,index=nil,scale=1,width=nil)
+          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
+
+          if base
+            width ||= base.width
+          end
+
+          super(base,offset,index,scale,width)
+        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,
+            self.width
+          )
+        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,
+            self.width
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/code/asm/os/freebsd.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/asm/config'
+
+module Ronin
+  module Code
+    module ASM
+      module OS
+        #
+        # Contains FreeBSD specific helper methods.
+        #
+        module FreeBSD
+        end
+      end
+    end
+  end
+end

data/lib/ronin/code/asm/os/linux.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+#
+# ronin-code-asm - A Ruby DSL for crafting Assembly programs and shellcode.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-asm is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-asm.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/asm/config'
+
+module Ronin
+  module Code
+    module ASM
+      module OS
+        #
+        # Contains Linux specific helper methods.
+        #
+        module Linux
+        end
+      end
+    end
+  end
+end