ronin-code-asm 1.0.0.beta1

data/spec/syntax/att_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+require 'ronin/code/asm/syntax/att'
+require 'ronin/code/asm/register'
+require 'ronin/code/asm/immediate_operand'
+require 'ronin/code/asm/memory_operand'
+require 'ronin/code/asm/instruction'
+require 'ronin/code/asm/program'
+
+describe Ronin::Code::ASM::Syntax::ATT do
+  subject { described_class }
+
+  describe "emit_register" do
+    let(:register) { Ronin::Code::ASM::Register.new(:eax, 4) }
+
+    it "must prepend a '%' to the register name" do
+      expect(subject.emit_register(register)).to eq("%eax")
+    end
+  end
+
+  describe "emit_immediate_operand" do
+    let(:operand) { Ronin::Code::ASM::ImmediateOperand.new(255, 1) }
+
+    it "must prepend a '$' to the immediate" do
+      expect(subject.emit_immediate_operand(operand)).to eq("$0xff")
+    end
+  end
+
+  describe "emit_memory_operand" do
+    let(:register) { Ronin::Code::ASM::Register.new(:eax, 4)   }
+    let(:operand)  { Ronin::Code::ASM::MemoryOperand.new(register) }
+
+    it "must enclose the memory in parenthesis" do
+      expect(subject.emit_memory_operand(operand)).to eq("(%eax)")
+    end
+
+    context "with an offset" do
+      let(:offset)  { 255 }
+      let(:operand) { Ronin::Code::ASM::MemoryOperand.new(register,offset) }
+
+      it "must prepend the offset as an integer" do
+        expect(subject.emit_memory_operand(operand)).to eq("0xff(%eax)")
+      end
+
+      context "when 0" do
+        let(:operand) { Ronin::Code::ASM::MemoryOperand.new(register,0) }
+
+        it "must omit the offset" do
+          expect(subject.emit_memory_operand(operand)).to eq("(%eax)")
+        end
+      end
+    end
+
+    context "with an index" do
+      let(:index)   { Ronin::Code::ASM::Register.new(:esi, 4) }
+      let(:operand) { Ronin::Code::ASM::MemoryOperand.new(register,0,index) }
+
+      it "must include the index argument" do
+        expect(subject.emit_memory_operand(operand)).to eq("(%eax,%esi)")
+      end
+
+      context "with a scale" do
+        let(:scale)   { 4 }
+        let(:operand) { Ronin::Code::ASM::MemoryOperand.new(register,0,index,scale) }
+
+        it "must prepend the scale argument as a decimal" do
+          expect(subject.emit_memory_operand(operand)).to eq("(%eax,%esi,#{scale})")
+        end
+      end
+    end
+  end
+
+  describe "emit_instruction" do
+    context "with no operands" do
+      let(:instruction) { Ronin::Code::ASM::Instruction.new(:ret, []) }
+
+      it "must emit the instruction name" do
+        expect(subject.emit_instruction(instruction)).to eq('ret')
+      end
+    end
+
+    context "with one operand" do
+      context "with width of 1" do
+        let(:immediate)   { Ronin::Code::ASM::ImmediateOperand.new(0x80, 1) }
+        let(:instruction) { Ronin::Code::ASM::Instruction.new(:int, [immediate]) }
+
+        it "must not append a size specifier to the instruction name" do
+          expect(subject.emit_instruction(instruction)).to eq("int\t$0x80")
+        end
+      end
+    end
+
+    context "with multiple operands" do
+      let(:register)    { Ronin::Code::ASM::Register.new(:eax, 4) }
+      let(:immediate)   { Ronin::Code::ASM::ImmediateOperand.new(0xff, 1)  }
+      let(:instruction) { Ronin::Code::ASM::Instruction.new(:mov, [register, immediate]) }
+
+      it "must add a size specifier to the instruction name" do
+        expect(subject.emit_instruction(instruction)).to match(/^movl/)
+      end
+
+      it "must emit the operands" do
+        expect(subject.emit_instruction(instruction)).to eq("movl\t$0xff,\t%eax")
+      end
+    end
+  end
+
+  describe "emit_section" do
+    it "must emit the section name" do
+      expect(subject.emit_section(:text)).to eq(".text")
+    end
+  end
+
+  describe "emit_program" do
+    let(:program) do
+      Ronin::Code::ASM::Program.new do
+        mov eax, 0xff
+        ret
+      end
+    end
+
+    it "must output the _start label and the program" do
+      asm = subject.emit_program(program)
+
+      expect(asm).to eq([
+        ".code32",
+        ".text",
+        "_start:",
+        "\tmovl\t$0xff,\t%eax",
+        "\tret",
+        ""
+      ].join($/))
+    end
+
+    context "when emitting labels" do
+      let(:program) do
+        Ronin::Code::ASM::Program.new do
+          mov eax, 0
+
+          _loop do
+            inc eax
+            cmp eax, 10
+            jl  :_loop
+          end
+
+          ret
+        end
+      end
+
+      it "must emit both labels and instructions" do
+        expect(subject.emit_program(program)).to eq([
+          ".code32",
+          ".text",
+          "_start:",
+          "\tmovl\t$0x0,\t%eax",
+          "_loop:",
+          "\tincl\t%eax",
+          "\tcmpl\t$0xa,\t%eax",
+          "\tjl\t_loop",
+          "\tret",
+          ""
+        ].join($/))
+      end
+    end
+
+    context "when the program arch is :amd64" do
+      let(:program) do
+        Ronin::Code::ASM::Program.new(arch: :amd64) do
+          push rax
+          push rbx
+          mov 0xff, rax
+          ret
+        end
+      end
+
+      it "must include start with the '.code64' directive" do
+        expect(subject.emit_program(program)).to match(/^\.code64$/)
+      end
+    end
+  end
+end

data/spec/syntax/common_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'ronin/code/asm/syntax/common'
+
+describe Ronin::Code::ASM::Syntax::Common do
+  subject { described_class }
+
+  describe "emit_keyword" do
+    let(:name) { :_start }
+
+    it "must convert a keyword to a String" do
+      expect(subject.emit_keyword(name)).to eq(name.to_s)
+    end
+  end
+
+  describe "emit_integer" do
+    let(:integer)     { 255    }
+    let(:hexadecimal) { "0xff" }
+
+    it "must convert it into a hexadecimal value" do
+      expect(subject.emit_integer(integer)).to eq(hexadecimal)
+    end
+
+    context "when given a negative number" do
+      let(:negative)    { -255    }
+      let(:hexadecimal) { "-0xff" }
+
+      it "must convert it into a hexadecimal value" do
+        expect(subject.emit_integer(negative)).to eq(hexadecimal)
+      end
+    end
+  end
+
+  describe "emit_label" do
+    let(:name)  { :_start   }
+    let(:label) { '_start:' }
+
+    it "must append a ':' to the name" do
+      expect(subject.emit_label(name)).to eq(label)
+    end
+  end
+end

data/spec/syntax/intel_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+require 'ronin/code/asm/syntax/intel'
+require 'ronin/code/asm/register'
+require 'ronin/code/asm/immediate_operand'
+require 'ronin/code/asm/memory_operand'
+require 'ronin/code/asm/instruction'
+require 'ronin/code/asm/program'
+
+describe Ronin::Code::ASM::Syntax::Intel do
+  subject { described_class }
+
+  describe "emit_register" do
+    let(:register) { Ronin::Code::ASM::Register.new(:eax, 4) }
+
+    it "must return the register name" do
+      expect(subject.emit_register(register)).to eq("eax")
+    end
+  end
+
+  describe "emit_immediate_operand" do
+    let(:operand) { Ronin::Code::ASM::ImmediateOperand.new(255, 1) }
+
+    it "must prepend a size specifier" do
+      expect(subject.emit_immediate_operand(operand)).to eq("BYTE 0xff")
+    end
+  end
+
+  describe "emit_memory_operand" do
+    let(:register) { Ronin::Code::ASM::Register.new(:eax, 4)   }
+    let(:operand)  { Ronin::Code::ASM::MemoryOperand.new(register) }
+
+    it "must enclose the memory in brackets" do
+      expect(subject.emit_memory_operand(operand)).to eq("[eax]")
+    end
+
+    context "when operand width does not match the base width" do
+      before { operand.width = 2 }
+
+      it "must specify the width" do
+        expect(subject.emit_memory_operand(operand)).to eq("WORD [eax]")
+      end
+    end
+
+    context "with an offset" do
+      let(:offset)  { 255 }
+      let(:operand) { Ronin::Code::ASM::MemoryOperand.new(register,offset) }
+
+      it "must add the offset to the base" do
+        expect(subject.emit_memory_operand(operand)).to eq("[eax+0xff]")
+      end
+
+      context "when 0" do
+        let(:operand) { Ronin::Code::ASM::MemoryOperand.new(register,0) }
+
+        it "must omit the offset" do
+          expect(subject.emit_memory_operand(operand)).to eq("[eax]")
+        end
+      end
+    end
+
+    context "with an index" do
+      let(:index)   { Ronin::Code::ASM::Register.new(:esi, 4) }
+      let(:operand) { Ronin::Code::ASM::MemoryOperand.new(register,0,index) }
+
+      it "must add the index to the base" do
+        expect(subject.emit_memory_operand(operand)).to eq("[eax+esi]")
+      end
+
+      context "with a scale" do
+        let(:scale)   { 4 }
+        let(:operand) { Ronin::Code::ASM::MemoryOperand.new(register,0,index,scale) }
+
+        it "must multiple the index by the scale" do
+          expect(subject.emit_memory_operand(operand)).to eq("[eax+esi*0x4]")
+        end
+      end
+    end
+  end
+
+  describe "emit_instruction" do
+    context "with no operands" do
+      let(:instruction) { Ronin::Code::ASM::Instruction.new(:ret, []) }
+
+      it "must emit the instruction name" do
+        expect(subject.emit_instruction(instruction)).to eq('ret')
+      end
+    end
+
+    context "with multiple operands" do
+      let(:register)    { Ronin::Code::ASM::Register.new(:eax, 4) }
+      let(:immediate)   { Ronin::Code::ASM::ImmediateOperand.new(0xff, 1)  }
+      let(:instruction) { Ronin::Code::ASM::Instruction.new(:mov, [register, immediate]) }
+
+      it "must emit the operands" do
+        expect(subject.emit_instruction(instruction)).to eq("mov\teax,\tBYTE 0xff")
+      end
+    end
+  end
+
+  describe "emit_section" do
+    it "must emit the section name" do
+      expect(subject.emit_section(:text)).to eq("section .text")
+    end
+  end
+
+  describe "emit_program" do
+    let(:program) do
+      Ronin::Code::ASM::Program.new do
+        mov eax, 0xff
+        ret
+      end
+    end
+
+    it "must output the _start label and the program" do
+      asm = subject.emit_program(program)
+
+      expect(asm).to eq([
+        "BITS 32",
+        "section .text",
+        "_start:",
+        "\tmov\teax,\tBYTE 0xff",
+        "\tret",
+        ""
+      ].join($/))
+    end
+
+    context "when emitting labels" do
+      let(:program) do
+        Ronin::Code::ASM::Program.new do
+          mov eax, 0
+
+          _loop do
+            inc eax
+            cmp eax, 10
+            jl  :_loop
+          end
+
+          ret
+        end
+      end
+
+      it "must emit both labels and instructions" do
+        expect(subject.emit_program(program)).to eq([
+          "BITS 32",
+          "section .text",
+          "_start:",
+          "\tmov\teax,\tBYTE 0x0",
+          "_loop:",
+          "\tinc\teax",
+          "\tcmp\teax,\tBYTE 0xa",
+          "\tjl\t_loop",
+          "\tret",
+          ""
+        ].join($/))
+      end
+    end
+
+    context "when the program arch is :amd64" do
+      let(:program) do
+        Ronin::Code::ASM::Program.new(arch: :amd64) do
+          push rax
+          push rbx
+          mov  rax, 0xff
+          ret
+        end
+      end
+
+      it "must include start with the '.code64' directive" do
+        expect(subject.emit_program(program)).to match(/^BITS 64$/)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: ronin-code-asm
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta1
+platform: ruby
+authors:
+- Postmodern
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-yasm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: ronin-code-asm is a Ruby DSL for crafting Assembly programs and shellcode.
+email: postmodern.mod3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- COPYING.txt
+- ChangeLog.md
+- README.md
+files:
+- ".document"
+- ".editorconfig"
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".mailmap"
+- ".rspec"
+- ".ruby-version"
+- ".yardopts"
+- COPYING.txt
+- ChangeLog.md
+- Gemfile
+- README.md
+- Rakefile
+- data/os/freebsd/amd64/syscalls.yml
+- data/os/freebsd/x86/syscalls.yml
+- data/os/linux/amd64/syscalls.yml
+- data/os/linux/x86/syscalls.yml
+- gemspec.yml
+- lib/ronin/code/asm.rb
+- lib/ronin/code/asm/archs.rb
+- lib/ronin/code/asm/archs/amd64.rb
+- lib/ronin/code/asm/archs/x86.rb
+- lib/ronin/code/asm/config.rb
+- lib/ronin/code/asm/immediate_operand.rb
+- lib/ronin/code/asm/instruction.rb
+- lib/ronin/code/asm/memory_operand.rb
+- lib/ronin/code/asm/os.rb
+- lib/ronin/code/asm/os/freebsd.rb
+- lib/ronin/code/asm/os/linux.rb
+- lib/ronin/code/asm/os/os.rb
+- lib/ronin/code/asm/program.rb
+- lib/ronin/code/asm/register.rb
+- lib/ronin/code/asm/shellcode.rb
+- lib/ronin/code/asm/syntax.rb
+- lib/ronin/code/asm/syntax/att.rb
+- lib/ronin/code/asm/syntax/common.rb
+- lib/ronin/code/asm/syntax/intel.rb
+- lib/ronin/code/asm/version.rb
+- ronin-code-asm.gemspec
+- spec/asm_spec.rb
+- spec/config_spec.rb
+- spec/immediate_operand_spec.rb
+- spec/instruction_spec.rb
+- spec/memory_operand_spec.rb
+- spec/os_spec.rb
+- spec/program_spec.rb
+- spec/register_spec.rb
+- spec/shellcode_spec.rb
+- spec/spec_helper.rb
+- spec/syntax/att_spec.rb
+- spec/syntax/common_spec.rb
+- spec/syntax/intel_spec.rb
+homepage: https://github.com/ronin-rb/ronin-code-asm#readme
+licenses:
+- LGPL-3.0
+metadata:
+  documentation_uri: https://ronin-rb.dev/docs/ronin-code-asm/frames
+  source_code_uri: https://github.com/ronin-rb/ronin-code-asm
+  bug_tracker_uri: https://github.com/ronin-rb/ronin-code-asm/issues
+  changelog_uri: https://github.com/ronin-rb/ronin-code-asm/blob/master/ChangeLog.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- yasm >= 0.6.0
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: A Ruby DSL for crafting Assembly programs and Shellcode.
+test_files:
+- spec/asm_spec.rb
+- spec/config_spec.rb
+- spec/immediate_operand_spec.rb
+- spec/instruction_spec.rb
+- spec/memory_operand_spec.rb
+- spec/os_spec.rb
+- spec/program_spec.rb
+- spec/register_spec.rb
+- spec/shellcode_spec.rb
+- spec/syntax/att_spec.rb
+- spec/syntax/common_spec.rb
+- spec/syntax/intel_spec.rb