asmrepl 1.0.0

data/lib/asmrepl/macos.rb

@@ -0,0 +1,205 @@
+require "fisk/helpers"
+
+module ASMREPL
+  module MacOS
+    include Fiddle
+
+    def self.make_function name, args, ret
+      ptr = Handle::DEFAULT[name]
+      func = Function.new ptr, args, ret, name: name
+      define_singleton_method name, &func.to_proc
+    end
+
+    # from sys/mman.h on macOS
+    PROT_READ   = 0x01
+    PROT_WRITE  = 0x02
+    PROT_EXEC   = 0x04
+    MAP_PRIVATE = 0x0002
+    MAP_SHARED  = 0x0001
+    MAP_ANON    = 0x1000
+
+    make_function "ptrace", [TYPE_INT, TYPE_INT, TYPE_VOIDP, TYPE_INT], TYPE_INT
+    make_function "memset", [TYPE_VOIDP, TYPE_INT, TYPE_SIZE_T], TYPE_VOID
+    make_function "strerror", [TYPE_INT], TYPE_CONST_STRING
+    make_function "mach_task_self", [], TYPE_VOIDP
+    make_function "task_threads", [TYPE_VOIDP, TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP
+    make_function "task_for_pid", [TYPE_VOIDP, TYPE_INT, TYPE_VOIDP], TYPE_INT
+    make_function "task_threads", [TYPE_VOIDP, TYPE_VOIDP, TYPE_VOIDP], TYPE_INT
+    make_function "thread_get_state", [TYPE_VOIDP, TYPE_INT, TYPE_VOIDP, TYPE_VOIDP], TYPE_INT
+    make_function "mmap", [TYPE_VOIDP,
+                           TYPE_SIZE_T,
+                           TYPE_INT,
+                           TYPE_INT,
+                           TYPE_INT,
+                           TYPE_INT], TYPE_VOIDP
+
+    def self.mmap_jit size
+      ptr = mmap 0, size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_SHARED | MAP_ANON, -1, 0
+      ptr.size = size
+      ptr
+    end
+
+    def self.jitbuffer size
+      Fisk::Helpers::JITBuffer.new mmap_jit(size), size
+    end
+
+    def self.traceme
+      raise unless ptrace(PT_TRACE_ME, 0, 0, 0).zero?
+    end
+
+    class ThreadState
+      fields = (<<-eostruct).scan(/uint64_t ([^;]*);/).flatten
+struct x86_thread_state64_t {
+  uint64_t rax;
+  uint64_t rbx;
+  uint64_t rcx;
+  uint64_t rdx;
+  uint64_t rdi;
+  uint64_t rsi;
+  uint64_t rbp;
+  uint64_t rsp;
+  uint64_t r8;
+  uint64_t r9;
+  uint64_t r10;
+  uint64_t r11;
+  uint64_t r12;
+  uint64_t r13;
+  uint64_t r14;
+  uint64_t r15;
+  uint64_t rip;
+  uint64_t rflags;
+  uint64_t cs;
+  uint64_t fs;
+  uint64_t gs;
+}
+      eostruct
+      fields.each_with_index do |field, i|
+        define_method(field) do
+          to_ptr[Fiddle::SIZEOF_INT64_T * i, Fiddle::SIZEOF_INT64_T].unpack1("l!")
+        end
+      end
+
+      define_singleton_method(:sizeof) do
+        fields.length * Fiddle::SIZEOF_INT64_T
+      end
+
+      def [] name
+        idx = fields.index(name)
+        return unless idx
+        to_ptr[Fiddle::SIZEOF_INT64_T * idx, Fiddle::SIZEOF_INT64_T].unpack1("l!")
+      end
+
+      def self.malloc
+        new Fiddle::Pointer.malloc sizeof
+      end
+
+      attr_reader :to_ptr
+
+      def initialize buffer
+        @to_ptr = buffer
+      end
+
+      define_method(:fields) do
+        fields
+      end
+
+      def to_s
+        buf = ""
+        fields.first(8).zip(fields.drop(8).first(8)).each do |l, r|
+          buf << "#{l.ljust(3)}  #{sprintf("%#018x", send(l))}"
+          buf << "  "
+          buf << "#{r.ljust(3)}  #{sprintf("%#018x", send(r))}\n"
+        end
+
+        buf << "\n"
+
+        fields.drop(16).each do |reg|
+          buf << "#{reg.ljust(6)}  #{sprintf("%#018x", send(reg))}\n"
+        end
+        buf
+      end
+
+      FLAGS = [
+        ['CF', 'Carry Flag'],
+        [nil, 'Reserved'],
+        ['PF', 'Parity Flag'],
+        [nil, 'Reserved'],
+        ['AF', 'Adjust Flag'],
+        [nil, 'Reserved'],
+        ['ZF', 'Zero Flag'],
+        ['SF', 'Sign Flag'],
+        ['TF', 'Trap Flag'],
+        ['IF', 'Interrupt Enable Flag'],
+        ['DF', 'Direction Flag'],
+        ['OF', 'Overflow Flag'],
+        ['IOPL_H', 'I/O privilege level High bit'],
+        ['IOPL_L', 'I/O privilege level Low bit'],
+        ['NT', 'Nested Task Flag'],
+        [nil, 'Reserved'],
+      ]
+
+      def flags
+        flags = rflags
+        f = []
+        FLAGS.each do |abbrv, _|
+          if abbrv && flags & 1 == 1
+            f << abbrv
+          end
+          flags >>= 1
+        end
+        f
+      end
+    end
+
+    PT_TRACE_ME    = 0
+    PT_CONTINUE    = 7
+
+    class Tracer
+      def initialize pid
+        @pid = pid
+        @target = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+
+        unless MacOS.task_for_pid(MacOS.mach_task_self, pid, @target.ref).zero?
+          raise "Couldn't get task pid. Did you run with sudo?"
+        end
+
+        @thread_list = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        thread_count = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+
+        raise unless MacOS.task_threads(@target, @thread_list.ref, thread_count).zero?
+
+        @thread = Fiddle::Pointer.new(@thread_list[0, Fiddle::SIZEOF_VOIDP].unpack1("l!"))
+      end
+
+      def wait
+        Process.waitpid @pid
+      end
+
+      def state
+        # Probably should use this for something
+        # count = thread_count[0]
+
+        # I can't remember what header I found this in, but it's from a macOS header
+        # :sweat-smile:
+        x86_THREAD_STATE64_COUNT = ThreadState.sizeof / Fiddle::SIZEOF_INT
+
+        # Same here
+        x86_THREAD_STATE64 = 4
+
+        state_count = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT64_T)
+        state_count[0, Fiddle::SIZEOF_INT64_T] = [x86_THREAD_STATE64_COUNT].pack("l!")
+
+        state = ThreadState.malloc
+        raise unless MacOS.thread_get_state(@thread, x86_THREAD_STATE64, state, state_count).zero?
+
+        state
+      end
+
+      def continue
+        unless MacOS.ptrace(MacOS::PT_CONTINUE, @pid, 1, 0).zero?
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/asmrepl/parser.rb

@@ -0,0 +1,101 @@
+require "racc/parser"
+require "ripper"
+require "fisk"
+require "set"
+require "strscan"
+
+module ASMREPL
+  class Lexer
+    INTEGER = /(?:[-+]?0b[0-1_,]+               (?# base 2)
+                 |[-+]?(?:0(?!x)|[1-9][0-9_,]*) (?# base 10)
+                 |[-+]?0x[0-9a-fA-F_,]+         (?# base 16))/x
+
+    def initialize input
+      @input = input
+      @scanner = StringScanner.new input
+    end
+
+    REGISTERS = Set.new Fisk::Registers.constants.map(&:to_s)
+    INSTRUCTIONS = Set.new Fisk::Instructions.constants.map(&:to_s)
+
+    def next_token
+      return if @scanner.eos?
+
+      if @scanner.scan(INTEGER)
+        [:on_int, @scanner.matched]
+      elsif @scanner.scan(/\[/)
+        [:on_lbracket, @scanner.matched]
+      elsif @scanner.scan(/\]/)
+        [:on_rbracket, @scanner.matched]
+      elsif @scanner.scan(/,/)
+        [:on_comma, @scanner.matched]
+      elsif @scanner.scan(/qword/)
+        [:qword, @scanner.matched]
+      elsif @scanner.scan(/dword/)
+        [:dword, @scanner.matched]
+      elsif @scanner.scan(/word/)
+        [:word, @scanner.matched]
+      elsif @scanner.scan(/byte/)
+        [:byte, @scanner.matched]
+      elsif @scanner.scan(/ptr/)
+        [:ptr, @scanner.matched]
+      elsif @scanner.scan(/rip/i)
+        [:on_rip, @scanner.matched]
+      elsif @scanner.scan(/int/i)
+        [:on_instruction, Fisk::Instructions::INT]
+      elsif @scanner.scan(/movabs/i)
+        [:on_instruction, Fisk::Instructions::MOV]
+      elsif @scanner.scan(/\w+/)
+        ident = @scanner.matched
+        if INSTRUCTIONS.include?(ident.upcase)
+          [:on_instruction, Fisk::Instructions.const_get(ident.upcase)]
+        elsif REGISTERS.include?(ident.upcase)
+          [:on_register, Fisk::Registers.const_get(ident.upcase)]
+        else
+          [:on_ident, @scanner.matched]
+        end
+      elsif @scanner.scan(/\s+/)
+        [:on_sp, @scanner.matched]
+      elsif @scanner.scan(/\+/)
+        [:plus, @scanner.matched]
+      elsif @scanner.scan(/-/)
+        [:minus, @scanner.matched]
+      else
+        raise
+      end
+    end
+  end
+
+  class Parser < Racc::Parser
+    def initialize
+      @registers = Set.new Fisk::Registers.constants.map(&:to_s)
+      @instructions = Set.new Fisk::Instructions.constants.map(&:to_s)
+    end
+
+    def parse input
+      @lexer = Lexer.new input
+      do_parse
+    end
+
+    def new_command mnemonic, arg1, arg2
+      [:command, mnemonic, arg1, arg2]
+    end
+
+    def new_tuple mnemonic, arg1
+      [:command, mnemonic, arg1]
+    end
+
+    def new_single mnemonic
+      [:command, mnemonic]
+    end
+
+    def next_token
+      while tok = @lexer.next_token
+        next if tok.first == :on_sp
+        return tok
+      end
+    end
+  end
+end
+
+require "asmrepl/parser.tab"

data/lib/asmrepl/parser.tab.rb

@@ -0,0 +1,297 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.5.1
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+module ASMREPL
+  class Parser < Racc::Parser
+##### State transition tables begin ###
+
+racc_action_table = [
+    12,     3,     9,     4,    14,    18,    16,    15,    17,    10,
+    11,    12,     8,     9,    19,    14,    20,    16,    15,    17,
+    10,    11,     9,     8,    21,    35,     9,    37,     9,    10,
+    11,    22,     8,    10,    11,    10,    11,    43,     9,    45,
+     9,     8,    24,     8,    39,    10,    11,    10,    11,    25,
+    26,    27,    28,    29,    41,    42,    47,    48 ]
+
+racc_action_check = [
+     2,     0,     2,     1,     2,     4,     2,     2,     2,     2,
+     2,    19,     2,    19,     5,    19,     6,    19,    19,    19,
+    19,    19,    20,    19,    10,    23,    23,    24,    24,    20,
+    20,    11,    20,    23,    23,    24,    24,    39,    39,    40,
+    40,    12,    12,    25,    25,    39,    39,    40,    40,    13,
+    14,    15,    16,    17,    36,    38,    44,    46 ]
+
+racc_action_pointer = [
+   -12,     3,    -2,   nil,     5,     9,    11,   nil,   nil,   nil,
+    20,    27,    27,    47,    43,    44,    45,    46,   nil,     9,
+    18,   nil,   nil,    22,    24,    29,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    51,   nil,    52,    34,
+    36,   nil,   nil,   nil,    53,   nil,    54,   nil,   nil ]
+
+racc_action_default = [
+   -27,   -27,    -9,   -10,   -27,    -6,    -7,    -8,   -11,   -12,
+   -27,   -27,   -27,   -27,   -27,   -27,   -27,   -27,    49,   -27,
+   -27,   -13,   -14,   -27,   -27,   -27,   -23,   -24,   -25,   -26,
+    -1,    -2,    -3,    -4,    -5,   -15,   -27,   -16,   -27,   -27,
+   -27,   -20,   -17,   -18,   -27,   -21,   -27,   -19,   -22 ]
+
+racc_goto_table = [
+     7,     1,     5,     2,   nil,   nil,     6,   nil,   nil,   nil,
+   nil,   nil,    23,   nil,   nil,   nil,   nil,    30,    34,    31,
+    33,    36,    38,    32,   nil,    40,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    44,    46 ]
+
+racc_goto_check = [
+     4,     1,     3,     2,   nil,   nil,     5,   nil,   nil,   nil,
+   nil,   nil,     3,   nil,   nil,   nil,   nil,     4,     4,     3,
+     3,     4,     4,     5,   nil,     3,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,     4,     4 ]
+
+racc_goto_pointer = [
+   nil,     1,     3,     0,    -2,     4,   nil ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,   nil,    13 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  4, 17, :_reduce_1,
+  4, 17, :_reduce_2,
+  4, 17, :_reduce_3,
+  4, 17, :_reduce_4,
+  4, 17, :_reduce_5,
+  2, 17, :_reduce_6,
+  2, 17, :_reduce_7,
+  2, 17, :_reduce_8,
+  1, 17, :_reduce_9,
+  1, 18, :_reduce_10,
+  1, 19, :_reduce_11,
+  1, 20, :_reduce_12,
+  2, 20, :_reduce_13,
+  2, 20, :_reduce_14,
+  3, 21, :_reduce_15,
+  3, 21, :_reduce_16,
+  4, 21, :_reduce_17,
+  4, 21, :_reduce_18,
+  5, 21, :_reduce_19,
+  4, 21, :_reduce_20,
+  4, 21, :_reduce_21,
+  5, 21, :_reduce_22,
+  2, 22, :_reduce_23,
+  2, 22, :_reduce_24,
+  2, 22, :_reduce_25,
+  2, 22, :_reduce_26 ]
+
+racc_reduce_n = 27
+
+racc_shift_n = 49
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :on_lbracket => 2,
+  :on_rbracket => 3,
+  :on_int => 4,
+  :on_comma => 5,
+  :qword => 6,
+  :ptr => 7,
+  :word => 8,
+  :dword => 9,
+  :byte => 10,
+  :plus => 11,
+  :minus => 12,
+  :on_instruction => 13,
+  :on_register => 14,
+  :on_rip => 15 }
+
+racc_nt_base = 16
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "on_lbracket",
+  "on_rbracket",
+  "on_int",
+  "on_comma",
+  "qword",
+  "ptr",
+  "word",
+  "dword",
+  "byte",
+  "plus",
+  "minus",
+  "on_instruction",
+  "on_register",
+  "on_rip",
+  "$start",
+  "command",
+  "instruction",
+  "register",
+  "int",
+  "memory",
+  "memsize" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+ result = new_command(val[0], val[1], val[3])
+    result
+end
+
+def _reduce_2(val, _values, result)
+ result = new_command(val[0], val[1], val[3])
+    result
+end
+
+def _reduce_3(val, _values, result)
+ result = new_command(val[0], val[1], val[3])
+    result
+end
+
+def _reduce_4(val, _values, result)
+ result = new_command(val[0], val[1], val[3])
+    result
+end
+
+def _reduce_5(val, _values, result)
+ result = new_command(val[0], val[1], val[3])
+    result
+end
+
+def _reduce_6(val, _values, result)
+ result = new_tuple(val[0], val[1])
+    result
+end
+
+def _reduce_7(val, _values, result)
+ result = new_tuple(val[0], val[1])
+    result
+end
+
+def _reduce_8(val, _values, result)
+ result = new_tuple(val[0], val[1])
+    result
+end
+
+def _reduce_9(val, _values, result)
+ result = new_single(val[0])
+    result
+end
+
+def _reduce_10(val, _values, result)
+ result = [:instruction, val[0]]
+    result
+end
+
+def _reduce_11(val, _values, result)
+ result = [:register, val[0]]
+    result
+end
+
+def _reduce_12(val, _values, result)
+ result = [:int, Integer(val[0])]
+    result
+end
+
+def _reduce_13(val, _values, result)
+ result = [:int, Integer(val[1])]
+    result
+end
+
+def _reduce_14(val, _values, result)
+ result = [:int, -Integer(val[1])]
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = [:memory, Fisk::M64.new(val[1].last, 0)]
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = [:memory, Fisk::Registers::Rip.new(0)]
+    result
+end
+
+def _reduce_17(val, _values, result)
+ result = [:memory, Fisk::Registers::Rip.new(val[2].last)]
+    result
+end
+
+def _reduce_18(val, _values, result)
+ result = [:memory, Fisk::Registers::Rip.new(0)]
+    result
+end
+
+def _reduce_19(val, _values, result)
+ result = [:memory, Fisk::Registers::Rip.new(val[3].last)]
+    result
+end
+
+def _reduce_20(val, _values, result)
+ result = [:memory, Fisk::M64.new(val[1].last, val[2].last)]
+    result
+end
+
+def _reduce_21(val, _values, result)
+ result = [:memory, val[0].new(val[2].last, 0)]
+    result
+end
+
+def _reduce_22(val, _values, result)
+ result = [:memory, val[0].new(val[2].last, val[3].last)]
+    result
+end
+
+def _reduce_23(val, _values, result)
+ result = Fisk::M64
+    result
+end
+
+def _reduce_24(val, _values, result)
+ result = Fisk::M32
+    result
+end
+
+def _reduce_25(val, _values, result)
+ result = Fisk::M16
+    result
+end
+
+def _reduce_26(val, _values, result)
+ result = Fisk::M8
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+  end   # class Parser
+end   # module ASMREPL

data/lib/asmrepl/parser.y

@@ -0,0 +1,44 @@
+class ASMREPL::Parser
+  token on_lbracket on_rbracket on_int on_comma qword ptr word dword byte
+  token plus minus on_instruction on_register on_rip
+
+rule
+
+  command: instruction register on_comma int { result = new_command(val[0], val[1], val[3]) }
+         | instruction register on_comma register { result = new_command(val[0], val[1], val[3]) }
+         | instruction register on_comma memory { result = new_command(val[0], val[1], val[3]) }
+         | instruction memory on_comma register { result = new_command(val[0], val[1], val[3]) }
+         | instruction memory on_comma int { result = new_command(val[0], val[1], val[3]) }
+         | instruction register { result = new_tuple(val[0], val[1]) }
+         | instruction memory { result = new_tuple(val[0], val[1]) }
+         | instruction int { result = new_tuple(val[0], val[1]) }
+         | instruction { result = new_single(val[0]) }
+         ;
+
+  instruction: on_instruction { result = [:instruction, val[0]] }
+             ;
+
+  register: on_register { result = [:register, val[0]] }
+          ;
+
+  int: on_int     { result = [:int, Integer(val[0])] }
+     | plus on_int { result = [:int, Integer(val[1])] }
+     | minus on_int { result = [:int, -Integer(val[1])] }
+     ;
+
+  memory: on_lbracket register on_rbracket { result = [:memory, Fisk::M64.new(val[1].last, 0)] }
+        | on_lbracket on_rip on_rbracket { result = [:memory, Fisk::Registers::Rip.new(0)] }
+        | on_lbracket on_rip int on_rbracket { result = [:memory, Fisk::Registers::Rip.new(val[2].last)] }
+        | memsize on_lbracket on_rip on_rbracket { result = [:memory, Fisk::Registers::Rip.new(0)] }
+        | memsize on_lbracket on_rip int on_rbracket { result = [:memory, Fisk::Registers::Rip.new(val[3].last)] }
+        | on_lbracket register int on_rbracket { result = [:memory, Fisk::M64.new(val[1].last, val[2].last)] }
+        | memsize on_lbracket register on_rbracket { result = [:memory, val[0].new(val[2].last, 0)] }
+        | memsize on_lbracket register int on_rbracket { result = [:memory, val[0].new(val[2].last, val[3].last)] }
+        ;
+
+  memsize: qword ptr { result = Fisk::M64 }
+         | dword ptr { result = Fisk::M32 }
+         | word ptr { result = Fisk::M16 }
+         | byte ptr { result = Fisk::M8 }
+         ;
+end