ronin-code-asm 1.0.0.beta1

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

@@ -0,0 +1,75 @@
+# 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/program'
+
+require 'tempfile'
+
+module Ronin
+  module Code
+    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   ebx, esp
+      #       push  eax
+      #       push  ebx
+      #       mov   ecx,  esp
+      #       xor   edx,  edx
+      #       mov   al,   0xb
+      #       int   0x80
+      #     end
+      # 
+      #
+      class Shellcode < Program
+
+        #
+        # Assembles the Shellcode.
+        #
+        # @param [String] output
+        #   The optional output to write the shellcode to. If no `:output` is
+        #   given a tempfile will be used.
+        #
+        # @param [Hash{Symbol => Object}] kwargs
+        #   Additional keyword arguments for {Program#assemble}.
+        #
+        # @return [String]
+        #   The raw object-code of the Shellcode.
+        #
+        # @see Program#assemble
+        #
+        def assemble(output: nil, **kwargs)
+          output ||= Tempfile.new(['ronin-shellcode', '.bin']).path
+
+          super(output, format: :bin, **kwargs)
+
+          return File.binread(output)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# 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/syntax/common'
+
+module Ronin
+  module Code
+    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 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..-1], ops[0]].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?
+              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 section name.
+          #
+          # @param [Symbol] name
+          #   The section name.
+          #
+          # @return [String]
+          #   The formatted section name.
+          #
+          # @since 0.2.0
+          #
+          def self.emit_section(name)
+            ".#{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)
+            ".code#{BITS[program.arch]}"
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,241 @@
+# 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'
+require 'ronin/code/asm/immediate_operand'
+require 'ronin/code/asm/memory_operand'
+
+module Ronin
+  module Code
+    module ASM
+      module Syntax
+        #
+        # Abstract base-class for all Assembly Syntax classes.
+        #
+        class Common
+
+          # Bit sizes for various architectures
+          BITS = {
+            x86:   32,
+            amd64: 64,
+          }
+
+          #
+          # 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 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.
+          #
+          # @param [Program] program
+          #   The program.
+          #
+          # @return [String]
+          #   The formatted program.
+          #
+          def self.emit_program(program)
+            lines = [
+              emit_prologue(program),
+              emit_section(:text),
+              emit_label(:_start)
+            ].compact
+
+            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
+end

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

@@ -0,0 +1,150 @@
+# 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/syntax/common'
+
+module Ronin
+  module Code
+    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
+
+            asm = "[#{asm}]"
+
+            unless op.width == op.base.width
+              asm = "#{WIDTHS[op.width]} #{asm}"
+            end
+
+            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?
+              line << "\t" << emit_operands(ins.operands)
+            end
+
+            return line
+          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)
+            "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)
+            "BITS #{BITS[program.arch]}"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ronin/code/asm/syntax.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/syntax/att'
+require 'ronin/code/asm/syntax/intel'

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

@@ -0,0 +1,28 @@
+# 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
+      # ronin-code-asm version
+      VERSION = '1.0.0.beta1'
+    end
+  end
+end