ronin-code-asm 1.0.0.beta1 → 1.0.0

data/spec/memory_operand_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/code/asm/memory_operand'
-require 'ronin/code/asm/register'
-
-describe Ronin::Code::ASM::MemoryOperand do
-  let(:register) { Ronin::Code::ASM::Register.new(:eax, 4) }
-
-  describe "#initialize" do
-    it { expect(subject.base).to   be_nil }
-    it { expect(subject.offset).to eq(0)  }
-    it { expect(subject.index).to  be_nil }
-    it { expect(subject.scale).to  eq(1)  }
-
-    it "must only accept nil and a Register for base" do
-      expect {
-        described_class.new(Object.new)
-      }.to raise_error(TypeError)
-    end
-
-    it "must only accept Integers for offset" do
-      expect {
-        described_class.new(register,2.0)
-      }.to raise_error(TypeError)
-    end
-
-    it "must only accept nil and a Register for index" do
-      expect {
-        described_class.new(register,0,Object.new)
-      }.to raise_error(TypeError)
-    end
-
-    it "must only accept Integers for offset" do
-      expect {
-        described_class.new(register,0,nil,2.0)
-      }.to raise_error(TypeError)
-    end
-
-  end
-
-  describe "#+" do
-    let(:operand) { described_class.new(register,4,register,2) }
-
-    subject { operand + 4 }
-
-    it "must add to offset" do
-      expect(subject.offset).to eq(8)
-    end
-
-    it "must not change base, index or scale" do
-      expect(subject.base).to  eq(operand.base)
-      expect(subject.index).to eq(operand.index)
-      expect(subject.scale).to eq(operand.scale)
-    end
-  end
-
-  describe "#-" do
-    let(:operand) { described_class.new(register,4,register,2) }
-
-    subject { operand - 2 }
-
-    it "must subtract from offset" do
-      expect(subject.offset).to eq(2)
-    end
-
-    it "must not change base, index or scale" do
-      expect(subject.base).to  eq(operand.base)
-      expect(subject.index).to eq(operand.index)
-      expect(subject.scale).to eq(operand.scale)
-    end
-  end
-
-  describe "#width" do
-    subject { described_class.new(register,10) }
-
-    it "must return the width of base" do
-      expect(subject.width).to eq(register.width)
-    end
-  end
-end

data/spec/os_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'ronin/code/asm/os'
-
-describe Ronin::Code::ASM::OS do
-  describe "SYSCALLS" do
-    subject { described_class::SYSCALLS }
-
-    let(:data_dir) { Ronin::Code::ASM::Config::DATA_DIR }
-
-    it { expect(subject).to be_kind_of(Hash) }
-
-    it "must load syscalls for :freebsd and :amd64" do
-      expect(subject[:freebsd][:amd64]).to eq(
-        YAML.load_file(
-          File.join(data_dir,'os','freebsd','amd64','syscalls.yml')
-        )
-      )
-    end
-
-    it "must load syscalls for :freebsd and :x86" do
-      expect(subject[:freebsd][:amd64]).to eq(
-        YAML.load_file(
-          File.join(data_dir,'os','freebsd','x86','syscalls.yml')
-        )
-      )
-    end
-
-    it "must load syscalls for :linux and :amd64" do
-      expect(subject[:linux][:amd64]).to eq(
-        YAML.load_file(
-          File.join(data_dir,'os','linux','amd64','syscalls.yml')
-        )
-      )
-    end
-
-    it "must load syscalls for :linux and :x86" do
-      expect(subject[:linux][:x86]).to eq(
-        YAML.load_file(
-          File.join(data_dir,'os','linux','x86','syscalls.yml')
-        )
-      )
-    end
-  end
-
-  describe ".[]" do
-    context "when given :linux" do
-      it "must return #{described_class}::Linux" do
-        expect(subject[:linux]).to be(described_class::Linux)
-      end
-    end
-
-    context "when given :freebsd" do
-      it "must return #{described_class}::FreeBSD" do
-        expect(subject[:freebsd]).to be(described_class::FreeBSD)
-      end
-    end
-
-    context "when given an unknown Symbol" do
-      let(:name) { :foo }
-
-      it do
-        expect {
-          subject[name]
-        }.to raise_error(ArgumentError,"unknown OS name: #{name.inspect}")
-      end
-    end
-  end
-end

data/spec/program_spec.rb

@@ -1,439 +0,0 @@
-require 'spec_helper'
-require 'ronin/code/asm/program'
-
-describe Ronin::Code::ASM::Program do
-  describe "#arch" do
-    it "must default to :x86" do
-      expect(subject.arch).to eq(:x86)
-    end
-  end
-
-  context "when :arch is :x86" do
-    subject { described_class.new(arch: :x86) }
-
-    it { expect(subject.word_size).to eq(4) }
-
-    describe "#stask_base" do
-      it "must be ebp" do
-        expect(subject.stack_base.name).to eq(:ebp)
-      end
-    end
-
-    describe "#stask_pointer" do
-      it "must be esp" do
-        expect(subject.stack_pointer.name).to eq(:esp)
-      end
-    end
-
-    describe "#stack_push" do
-      let(:value) { 0xff }
-
-      before { subject.stack_push(value) }
-
-      it "must add a 'push' instruction with a value" do
-        expect(subject.instructions[-1].name).to eq(:push)
-        expect(subject.instructions[-1].operands[0].value).to eq(value)
-      end
-    end
-
-    describe "#stack_pop" do
-      let(:register) { subject.register(:eax) }
-
-      before { subject.stack_pop(register) }
-
-      it "must add a 'pop' instruction with a register" do
-        expect(subject.instructions[-1].name).to eq(:pop)
-        expect(subject.instructions[-1].operands[0]).to eq(register)
-      end
-    end
-
-    describe "#register_clear" do
-      let(:name) { :eax }
-
-      before { subject.register_clear(name) }
-
-      it "must add a 'xor' instruction with a registers" do
-        expect(subject.instructions[-1].name).to eq(:xor)
-        expect(subject.instructions[-1].operands[0].name).to eq(name)
-        expect(subject.instructions[-1].operands[1].name).to eq(name)
-      end
-    end
-
-    describe "#register_set" do
-      let(:name)  { :eax }
-      let(:value) { 0xff }
-
-      before { subject.register_set(name,value) }
-
-      it "must add a 'xor' instruction with a registers" do
-        expect(subject.instructions[-1].name).to eq(:mov)
-        expect(subject.instructions[-1].operands[0].value).to eq(value)
-        expect(subject.instructions[-1].operands[1].name).to eq(name)
-      end
-    end
-
-    describe "#register_save" do
-      let(:name)  { :eax }
-
-      before { subject.register_save(name) }
-
-      it "must add a 'xor' instruction with a registers" do
-        expect(subject.instructions[-1].name).to eq(:push)
-        expect(subject.instructions[-1].operands[0].name).to eq(name)
-      end
-    end
-
-    describe "#register_save" do
-      let(:name)  { :eax }
-
-      before { subject.register_load(name) }
-
-      it "must add a 'xor' instruction with a registers" do
-        expect(subject.instructions[-1].name).to eq(:pop)
-        expect(subject.instructions[-1].operands[0].name).to eq(name)
-      end
-    end
-
-    describe "#interrupt" do
-      let(:number) { 0x0a }
-
-      before { subject.interrupt(number) }
-
-      it "must add an 'int' instruction with the interrupt number" do
-        expect(subject.instructions[-1].name).to eq(:int)
-        expect(subject.instructions[-1].operands[0].value).to eq(number)
-      end
-    end
-
-    describe "#syscall" do
-      before { subject.syscall }
-
-      it "must add an 'int 0x80' instruction" do
-        expect(subject.instructions[-1].name).to eq(:int)
-        expect(subject.instructions[-1].operands[0].value).to eq(0x80)
-      end
-    end
-
-    context "when :os is :linux" do
-      subject { described_class.new(arch: :x86, os: :linux) }
-
-      it { expect(subject.syscalls).to_not be_empty }
-    end
-
-    context "when :os is :freebsd" do
-      subject { described_class.new(arch: :x86, os: :freebsd) }
-
-      it { expect(subject.syscalls).to_not be_empty }
-    end
-  end
-
-  context "when :arch is :amd64" do
-    subject { described_class.new(arch: :amd64) }
-
-    it { expect(subject.word_size).to eq(8) }
-
-    describe "#syscall" do
-      before { subject.syscall }
-
-      it "must add a 'syscall' instruction" do
-        expect(subject.instructions[-1].name).to eq(:syscall)
-      end
-    end
-
-    context "when :os is :linux" do
-      subject { described_class.new(arch: :amd64, os: :linux) }
-
-      it { expect(subject.syscalls).to_not be_empty }
-    end
-
-    context "when :os is :freebsd" do
-      subject { described_class.new(arch: :amd64, os: :freebsd) }
-
-      it { expect(subject.syscalls).to_not be_empty }
-    end
-  end
-
-  describe "#register?" do
-    it "must return true for existing registers" do
-      expect(subject.register?(:eax)).to be(true)
-    end
-
-    it "must return false for unknown registers" do
-      expect(subject.register?(:foo)).to be(false)
-    end
-  end
-
-  describe "#register" do
-    it "must return a Register" do
-      expect(subject.register(:eax)).to be_kind_of(Ronin::Code::ASM::Register)
-    end
-
-    it "must allocate the register" do
-      subject.register(:ebx)
-
-      expect(subject.allocated_registers).to include(:ebx)
-    end
-
-    context "when given an unknown register name" do
-      it "must raise an ArgumentError" do
-        expect {
-          subject.register(:foo)
-        }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#instruction" do
-    it "must return an Instruction" do
-      expect(subject.instruction(:hlt)).to be_kind_of(Ronin::Code::ASM::Instruction)
-    end
-
-    it "must append the new Instruction" do
-      subject.instruction(:push, 1)
-
-      expect(subject.instructions.last.name).to eq(:push)
-    end
-  end
-
-  describe "#byte" do
-    it "must return a ImmedateOperand" do
-      expect(subject.byte(1)).to be_kind_of(Ronin::Code::ASM::ImmediateOperand)
-    end
-
-    it "must have width of 1" do
-      expect(subject.byte(1).width).to eq(1)
-    end
-
-    context "when given a MemoryOperand" do
-      let(:register)       { Ronin::Code::ASM::Register.new(:eax, 4)       }
-      let(:memory_operand) { Ronin::Code::ASM::MemoryOperand.new(register) }
-
-      it "must return a MemoryOperand" do
-        expect(subject.byte(memory_operand)).to be_kind_of(
-          Ronin::Code::ASM::MemoryOperand
-        )
-      end
-
-      it "must have a width of 1" do
-        expect(subject.byte(memory_operand).width).to eq(1)
-      end
-    end
-  end
-
-  describe "#word" do
-    it "must return a Ronin::Code::ASM::ImmediateOperand" do
-      expect(subject.word(1)).to be_kind_of(Ronin::Code::ASM::ImmediateOperand)
-    end
-
-    it "must have width of 2" do
-      expect(subject.word(1).width).to eq(2)
-    end
-
-    context "when given a MemoryOperand" do
-      let(:register)       { Ronin::Code::ASM::Register.new(:eax, 4)       }
-      let(:memory_operand) { Ronin::Code::ASM::MemoryOperand.new(register) }
-
-      it "must return a MemoryOperand" do
-        expect(subject.word(memory_operand)).to be_kind_of(
-          Ronin::Code::ASM::MemoryOperand
-        )
-      end
-
-      it "must have a width of 2" do
-        expect(subject.word(memory_operand).width).to eq(2)
-      end
-    end
-  end
-
-  describe "#dword" do
-    it "must return a Ronin::Code::ASM::ImmediateOperand" do
-      expect(subject.dword(1)).to be_kind_of(Ronin::Code::ASM::ImmediateOperand)
-    end
-
-    it "must have width of 4" do
-      expect(subject.dword(1).width).to eq(4)
-    end
-
-    context "when given a MemoryOperand" do
-      let(:register)       { Ronin::Code::ASM::Register.new(:eax, 4)       }
-      let(:memory_operand) { Ronin::Code::ASM::MemoryOperand.new(register) }
-
-      it "must return a MemoryOperand" do
-        expect(subject.dword(memory_operand)).to be_kind_of(
-          Ronin::Code::ASM::MemoryOperand
-        )
-      end
-
-      it "must have a width of 4" do
-        expect(subject.dword(memory_operand).width).to eq(4)
-      end
-    end
-  end
-
-  describe "#qword" do
-    it "must return a Ronin::Code::ASM::ImmediateOperand" do
-      expect(subject.qword(1)).to be_kind_of(Ronin::Code::ASM::ImmediateOperand)
-    end
-
-    it "must have width of 8" do
-      expect(subject.qword(1).width).to eq(8)
-    end
-
-    context "when given a MemoryOperand" do
-      let(:register)       { Ronin::Code::ASM::Register.new(:eax, 4)       }
-      let(:memory_operand) { Ronin::Code::ASM::MemoryOperand.new(register) }
-
-      it "must return a MemoryOperand" do
-        expect(subject.qword(memory_operand)).to be_kind_of(
-          Ronin::Code::ASM::MemoryOperand
-        )
-      end
-
-      it "must have a width of 8" do
-        expect(subject.qword(memory_operand).width).to eq(8)
-      end
-    end
-  end
-
-  describe "#label" do
-    let(:name) { :_start }
-
-    it "must return the label name" do
-      label = subject.label(name) { }
-      
-      expect(label).to eq(name)
-    end
-
-    it "must add the label to the instructions" do
-      subject.label(name) { }
-
-      expect(subject.instructions.last).to eq(name)
-    end
-
-    it "must accept a block" do
-      subject.label(name) { push 2 }
-
-      expect(subject.instructions[-1].name).to eq(:push)
-      expect(subject.instructions[-2]).to eq(name)
-    end
-  end
-
-  describe "#method_missing" do
-    context "when called without a block" do
-      it "must add a new instruction" do
-        subject.pop
-
-        expect(subject.instructions[-1].name).to eq(:pop)
-      end
-    end
-
-    context "when called with one argument and a block" do
-      it "must add a new label" do
-        subject._loop { mov eax, ebx }
-
-        expect(subject.instructions[-2]).to      eq(:_loop)
-        expect(subject.instructions[-1].name).to eq(:mov)
-      end
-    end
-  end
-
-  describe "#to_asm" do
-    subject do
-      described_class.new do
-        push eax
-        push ebx
-        push ecx
-
-        mov ebx, eax
-        mov ebx, eax+0
-        mov ebx, eax+4
-        mov ebx, eax+esi
-        mov ebx, eax+(esi*4)
-        mov ebx, eax+(esi*4)+10
-      end
-    end
-
-    it "must convert the program to Intel syntax" do
-      expect(subject.to_asm).to eq([
-        "BITS 32",
-        "section .text",
-        "_start:",
-        "\tpush\teax",
-        "\tpush\tebx",
-        "\tpush\tecx",
-        "\tmov\tebx,\teax",
-        "\tmov\tebx,\t[eax]",
-        "\tmov\tebx,\t[eax+0x4]",
-        "\tmov\tebx,\t[eax+esi]",
-        "\tmov\tebx,\t[eax+esi*0x4]",
-        "\tmov\tebx,\t[eax+esi*0x4+0xa]",
-        ""
-      ].join($/))
-    end
-
-    context "when given :att" do
-      it "must convert the program to ATT syntax" do
-        expect(subject.to_asm(:att)).to eq([
-          ".code32",
-          ".text",
-          "_start:",
-          "\tpushl\t%eax",
-          "\tpushl\t%ebx",
-          "\tpushl\t%ecx",
-          "\tmovl\t%eax,\t%ebx",
-          "\tmovl\t(%eax),\t%ebx",
-          "\tmovl\t0x4(%eax),\t%ebx",
-          "\tmovl\t(%eax,%esi),\t%ebx",
-          "\tmovl\t(%eax,%esi,4),\t%ebx",
-          "\tmovl\t0xa(%eax,%esi,4),\t%ebx",
-          ""
-        ].join($/))
-      end
-    end
-  end
-
-  describe "#assemble", integration: true do
-    subject do
-      described_class.new do
-        push eax
-        push ebx
-        push ecx
-
-        mov ebx, eax
-        mov ebx, eax+0
-        mov ebx, eax+4
-        mov ebx, eax+esi
-        mov ebx, eax+(esi*4)
-        mov ebx, eax+(esi*4)+10
-      end
-    end
-
-    let(:output) { Tempfile.new(['ronin-asm', '.o']).path }
-
-    before { subject.assemble(output) }
-
-    it "must write to the output file" do
-      expect(File.size(output)).to be > 0
-    end
-
-    context "when syntax: :intel is given" do
-      let(:output) { Tempfile.new(['ronin-asm', '.o']).path }
-
-      before { subject.assemble(output, syntax: :intel) }
-
-      it "must write to the output file" do
-        expect(File.size(output)).to be > 0
-      end
-    end
-
-    context "when syntax is unknown" do
-      let(:syntax) { :foo }
-
-      it do
-        expect {
-          subject.assemble(output, syntax: syntax)
-        }.to raise_error(ArgumentError,"unknown ASM syntax: #{syntax.inspect}")
-      end
-    end
-  end
-end

data/spec/register_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/code/asm/register'
-
-describe Ronin::Code::ASM::Register do
-  let(:register) { described_class.new(:eax, 4) }
-
-  subject { register }
-
-  describe "#+" do
-    context "when given an Ronin::Code::ASM::MemoryOperand" do
-      let(:operand) do
-        Ronin::Code::ASM::MemoryOperand.new(nil,10,register,2)
-      end
-
-      subject { register + operand }
-
-      it { expect(subject).to be_kind_of(Ronin::Code::ASM::MemoryOperand) }
-
-      it "must set the base" do
-        expect(subject.base).to eq(register)
-      end
-
-      it "must preserve the offset, index and scale" do
-        expect(subject.offset).to eq(operand.offset)
-        expect(subject.index).to  eq(operand.index)
-        expect(subject.scale).to  eq(operand.scale)
-      end
-    end
-
-    context "when given a Register" do
-      subject { register + register }
-
-      it { expect(subject).to be_kind_of(Ronin::Code::ASM::MemoryOperand) }
-
-      it "must set the base" do
-        expect(subject.base).to eq(register)
-      end
-
-      it { expect(subject.offset).to eq(0) }
-
-      it "must set the index" do
-        expect(subject.index).to eq(register)
-      end
-    end
-
-    context "when given an Integer" do
-      let(:offset) { 10 }
-
-      subject { register + offset }
-
-      it { expect(subject).to be_kind_of(Ronin::Code::ASM::MemoryOperand) }
-
-      it "must set the base" do
-        expect(subject.base).to eq(register)
-      end
-
-      it "must set the offset" do
-        expect(subject.offset).to eq(offset)
-      end
-    end
-
-    context "otherwise" do
-      it "must raise a TypeError" do
-        expect {
-          register + Object.new
-        }.to raise_error(TypeError)
-      end
-    end
-  end
-
-  describe "#-" do
-    let(:offset) { 10 }
-
-    subject { register - offset }
-
-    it { expect(subject).to be_kind_of(Ronin::Code::ASM::MemoryOperand) }
-
-    it "must set the base" do
-      expect(subject.base).to eq(register)
-    end
-
-    it "must set a negative offset" do
-      expect(subject.offset).to eq(-offset)
-    end
-  end
-
-  describe "#*" do
-    let(:scale) { 2 }
-
-    subject { register * scale }
-
-    it { expect(subject).to be_kind_of(Ronin::Code::ASM::MemoryOperand) }
-
-    it { expect(subject.base).to be_nil }
-    it { expect(subject.offset).to eq(0) }
-
-    it "must set the index" do
-      expect(subject.index).to eq(register)
-    end
-
-    it "must set the scale" do
-      expect(subject.scale).to eq(scale)
-    end
-  end
-
-  describe "#to_s" do
-    it "must return the register name" do
-      expect(subject.to_s).to eq(subject.name.to_s)
-    end
-  end
-end