ronin-code-asm 1.0.0.beta1 → 1.0.0

data/spec/shellcode_spec.rb

@@ -1,58 +0,0 @@
-# encoding: US-ASCII
-
-require 'spec_helper'
-require 'ronin/code/asm/shellcode'
-
-describe Ronin::Code::ASM::Shellcode do
-  describe "#assemble", integration: true do
-    subject do
-      described_class.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
-    end
-
-    let(:shellcode) { "1\xC0Ph//shh/bin\x89\xE3PS\x89\xE11\xD2\xB0\v\xCD\x80" }
-
-    it "must assemble down to raw machine code" do
-      expect(subject.assemble).to eq(shellcode)
-    end
-
-    it "must return an ASCII-8bit encoded String" do
-      expect(subject.assemble.encoding).to eq(Encoding::ASCII_8BIT)
-    end
-
-    context "with :output" do
-      let(:output) do
-        Tempfile.new(['ronin-shellcode-custom-path', '.bin']).path
-      end
-
-      it "must write to the custom path" do
-        expect(subject.assemble(output: output)).to eq(shellcode)
-
-        File.binread(output)
-      end
-    end
-
-    context "with :syntax is :intel" do
-      it "assemble down to raw machine code" do
-        expect(subject.assemble(syntax: :intel)).to eq(shellcode)
-      end
-    end
-
-    context "with :syntax is :att" do
-      it "assemble down to raw machine code" do
-        expect(subject.assemble(syntax: :att)).to eq(shellcode)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,7 +0,0 @@
-require 'rspec'
-require 'simplecov'
-SimpleCov.start
-
-RSpec.configure do |specs|
-  specs.filter_run_excluding :yasm
-end

data/spec/syntax/att_spec.rb

@@ -1,181 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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