immunio 0.15.2

data/lib/immunio/rufus_lua_ext/utils.rb

@@ -0,0 +1,13 @@
+module Rufus::Lua
+  def self.to_lua_s_with_symbol(o)
+    case o
+    when Symbol then o.to_s.inspect
+    else
+      to_lua_s_without_symbol o
+    end
+  end
+  class << self
+    alias_method :to_lua_s_without_symbol, :to_lua_s
+    alias_method :to_lua_s, :to_lua_s_with_symbol
+  end
+end

data/lib/immunio/version.rb

@@ -0,0 +1,5 @@
+module Immunio
+  AGENT_TYPE = "agent-ruby"
+  VERSION = "0.15.2"
+  VM_VERSION = "2.2.0"
+end

data/lib/immunio/vm.rb

@@ -0,0 +1,291 @@
+require_relative "errors"
+
+# Use our custom Lua lib.
+ext = RbConfig::CONFIG['DLEXT']
+ENV['LUA_LIB'] = "#{Immunio::DIR}/immunio/lua-hooks.#{ext}"
+
+require 'rufus-lua'
+
+# Load rufus-lua extensions
+require_relative "rufus_lua_ext/ref"
+require_relative "rufus_lua_ext/state"
+require_relative "rufus_lua_ext/table"
+require_relative "rufus_lua_ext/utils"
+
+module Immunio
+  class VMError < Error; end
+
+  class VMFactory
+    attr_reader :code_version, :data_version
+
+    def initialize(key, secret, dev_mode = false, debug_mode = false)
+
+      # Code is lua functions plus utils generated by the __init__ function
+      @code_version = nil
+      @functions = {}
+      @utils = {}
+
+      # Data is to hold serverdata
+      @data_version = nil
+      @data = nil
+
+      @update_lock = Mutex.new
+
+      # Cached VM - reusable by multiple clients
+      @lua_vm = LuaVM.new(key, secret, dev_mode, debug_mode)
+      @dev_mode = dev_mode
+      @dev_checksum = ""
+    end
+
+    def update_code(version, code)
+      functions = {}
+      code.each { |fun_name, lua_code|
+        functions[fun_name] = @lua_vm.create_function lua_code, fun_name
+      }
+
+      init_hook = functions.delete("__init__")
+      if init_hook
+        utils = @lua_vm.call(init_hook)
+      else
+        utils = {}
+      end
+
+      @update_lock.synchronize {
+        @code_version = version
+        @functions = functions
+        @utils = utils
+      }
+      Immunio.logger.info "Lua code updated to version #{version}."
+    end
+
+    def update_data(version, data)
+      # Allow server data to be overridden in the Agent config file
+      data = data.deep_merge(Immunio.agent.config.vm_data)
+      new_data = @lua_vm.create_object(data)
+      @update_lock.synchronize {
+        @data_version = version
+        @data = new_data
+      }
+      Immunio.logger.debug "Lua data updated to version #{version}."
+    end
+
+    def current_state
+      {
+          vmcode_version: @code_version,
+          vmdata_version: @data_version
+      }
+    end
+
+    def new_vm
+      Immunio.logger.debug "Creating new Lua VM"
+      dev_mode_hook_update if @dev_mode
+
+      @update_lock.synchronize {
+        return VM.new(@lua_vm, @functions, @utils, @data, @code_version, @data_version)
+      }
+    end
+
+    def dev_mode_hook_update
+      # Load default hook handlers if present (they do not ship with the gem)
+      path = File.expand_path("#{Immunio::DIR}/../lua-hooks/hooks")
+      Immunio.logger.info "Checking hook handlers from #{path}"
+
+      unique_files = Dir[path + "/*.lua"].collect do |file|
+        name = File.basename(file, ".*")
+
+        fstat = File.stat(file)
+        mtime = fstat.mtime
+        size = fstat.size
+
+        "-#{name}:#{mtime}:#{size}-"
+      end
+      checksum = unique_files.join
+      if checksum == @dev_checksum
+        Immunio.logger.info "Reusing dev vm, files unchanged"
+        return
+      end
+
+      functions = Dir[path + "/*.lua"].inject({}) do |handlers, file|
+        name = File.basename(file, ".*")
+
+        # NB: because this code is part of the creation of a VM
+        # calling any code that fires off a plugin could result
+        # in an infinite loop.
+        if File.respond_to? :read_without_immunio
+          data = File.read_without_immunio file
+        else
+          data = File.read file
+        end
+        handlers[name] = data
+        handlers
+      end
+      Immunio.logger.info "Updating dev vm code, files changed"
+      update_code("DEV-#{Time.now.strftime("%H:%M:%S")}", functions)
+      @dev_checksum = checksum
+    end
+
+  end
+
+  class LuaVM
+    # An internal LuaVM. Should not be used outside of this module.
+
+    # One Monitor for the class, which means while we can have more than one VM,
+    # we can't allow more than one to be called at a time. Unfortunate necessity
+    # because we can't tell which VM every rufus-lua method is called on.
+    @@monitor = Monitor.new
+
+    # For each class listed below, wrap every public method in a Monitor lock.
+    # This ensures we can be reentrant into Rufus from the same thread, but not
+    # from other threads. Big hack, but desperate times call for desperate
+    # measures.
+    classes = [
+      Rufus::Lua::Ref,
+      Rufus::Lua::Function,
+      Rufus::Lua::Coroutine,
+      Rufus::Lua::Table,
+      Rufus::Lua::State
+    ]
+    classes.each do |klass|
+      klass.public_instance_methods(false).each do |method|
+        # This is a metaprogramming way of using alias_method_chain because we
+        # must generate the method symbols on the fly.
+        with_symbol = "#{method}_with_lock".to_sym
+        without_symbol = "#{method}_without_lock".to_sym
+
+        klass.send(:define_method, with_symbol) do |*args|
+          @@monitor.synchronize do
+            self.send(without_symbol, *args)
+          end
+        end
+
+        klass.send(:alias_method, without_symbol, method)
+        klass.send(:alias_method, method, with_symbol)
+      end
+    end
+
+    def initialize(key, secret, dev_mode = false, debug_mode = false)
+      @state = Rufus::Lua::State.new
+
+      # Bootstrap the VM ...
+
+      # Define load path for `require`.
+      lua_hooks = File.expand_path("#{Immunio::DIR}/../lua-hooks")
+      @state['package.path'] = lua_hooks + "/lib/?.lua;" + lua_hooks + "/lib/lexers/?.lua"
+      # Set the config key
+      @state['IMMUNIO_KEY'] = key
+      # Set the secret key
+      @state['IMMUNIO_SECRET'] = secret
+      # Pass dev mode option
+      @state['DEV_MODE'] = dev_mode
+      # Pass debug mode option
+      @state['DEBUG_MODE'] = debug_mode
+      # Pass platform to the vm.
+      # From: http://stackoverflow.com/questions/170956/how-can-i-find-which-operating-system-my-ruby-program-is-running-on
+      if (/cygwin|mswin|mingw|bccwin|wince|emx|windows/ =~ RUBY_PLATFORM) != nil then
+        @state['LUA_PLATFORM'] = 'windows'
+      elsif (/darwin/ =~ RUBY_PLATFORM) != nil
+        @state['LUA_PLATFORM'] = 'darwin'
+      else
+        @state['LUA_PLATFORM'] = 'unix'
+      end
+      # Boot it. Yeaaaaah!
+      @state.eval "require 'boot'"
+
+      @error_handler = @state["debug.traceback"]
+      @call_function = @state['sandboxed_call']
+
+      self.class.check_rufus_stack @state, "Stack not empty after bootstrap"
+    end
+
+    # Create a function wrapping some Lua code or base64-encoded bytecode.
+    def create_function(code, name=nil)
+      lua_call do
+        @state.load code, name
+      end
+    end
+
+    def create_object(object)
+      return object if object.is_a?(Rufus::Lua::Ref)
+
+      lua_call do
+        @state.eval "return #{Rufus::Lua.to_lua_s(object)}"
+      end
+    end
+
+    def self.check_rufus_stack(state, message)
+      top = state.send(:stack_top)
+      if top != 0
+        raise VMError, "#{message} (#{top})"
+      end
+    end
+
+    # Wrap calls to Lua VM.
+    def lua_call
+      @@monitor.synchronize { yield }
+    rescue Rufus::Lua::LuaError => e
+      raise VMError, e.message, e.backtrace
+    end
+
+    def call(code, vars = nil)
+      lua_call do
+        # Setup the error handler
+        @error_handler.load_onto_stack
+        @call_function.error_handler = @call_function.send :stack_top
+
+        # For the VM heavy thread test, we need to cause out-of-order execution
+        # in methods modifying the Lua stack. Here we tell Ruby to swap out
+        # threads if we are in the thread test.
+        Thread.pass if $IMMUNIO_IN_THREAD_TEST
+
+        ret = @call_function.call code, vars
+        @state.send :stack_pop # Pop the error handler
+        Array === ret ? ret.first : ret
+      end
+    end
+
+    # Call a Lua function by name, outside of the sandbox.
+    def unsafe_call_by_name(name, *args)
+      lua_call do
+        @state[name].call(*args)
+      end
+    end
+  end
+
+  class VM
+    attr_reader :code_version, :data_version
+
+    def initialize(lua_vm, functions, utils, data, code_version, data_version)
+      @lua_vm = lua_vm
+      @functions = functions
+      @utils = utils
+      @data = data
+      @code_version = code_version
+      @data_version = data_version
+    end
+
+    def call(function_name, vars=nil)
+      if has_function? function_name
+        vars ||= {}
+        expanded_vars = vars.merge(
+            {
+                "serverdata" => @data,
+                "utils" => @utils
+            })
+
+        @lua_vm.call @functions[function_name], expanded_vars
+      end
+    end
+
+    def unsafe_call_by_name(name, *args)
+      @lua_vm.unsafe_call_by_name name, *args
+    end
+
+    def has_function?(function_name)
+      @functions.has_key? function_name
+    end
+
+    def create_object(object)
+      @lua_vm.create_object(object)
+    end
+  end
+end

data/lua-hooks/ext/all.c

@@ -0,0 +1,78 @@
+/*
+* Based on Lua's all.c -- Lua core & libraries in a single file.
+*/
+
+#define luaall_c
+
+#define LUA_USE_POSIX
+
+#include "lua/lapi.c"
+#include "lua/lcode.c"
+#include "lua/ldebug.c"
+#include "lua/ldo.c"
+#include "lua/ldump.c"
+#include "lua/lfunc.c"
+#include "lua/lgc.c"
+#include "lua/llex.c"
+#include "lua/lmem.c"
+#include "lua/lobject.c"
+#include "lua/lopcodes.c"
+#include "lua/lparser.c"
+#include "lua/lstate.c"
+#include "lua/lstring.c"
+#include "lua/ltable.c"
+#include "lua/ltm.c"
+#include "lua/lundump.c"
+#include "lua/lvm.c"
+#include "lua/lzio.c"
+
+#include "lua/lauxlib.c"
+#include "lua/lbaselib.c"
+#include "lua/ldblib.c"
+#include "lua/liolib.c"
+#include "lua/lmathlib.c"
+#include "lua/loadlib.c"
+#include "lua/loslib.c"
+#include "lua/lstrlib.c"
+#include "lua/ltablib.c"
+
+// Include our custom modules
+#include "bitop/bit.c"
+#include "libinjection/lualib.c"
+#include "luautf8/lutf8lib.c"
+#include "lpeg/lptree.c"
+#include "lua-cmsgpack/lua_cmsgpack.c"
+#include "lua-snapshot/snapshot.c"
+
+// Activate the Lua modules we need and our custom ones.
+static const luaL_Reg lualibs[] = {
+  {"", luaopen_base},
+  {LUA_TABLIBNAME, luaopen_table},
+  {LUA_STRLIBNAME, luaopen_string},
+  {LUA_MATHLIBNAME, luaopen_math},
+
+  // Include unsafe libs in tests
+#if defined(LUA_UNSAFE_MODE)
+  {LUA_IOLIBNAME, luaopen_io},
+  {LUA_OSLIBNAME, luaopen_os},
+#endif
+
+  // SECURITY NOTE:
+  // The following modules are unsafe according to http://lua-users.org/wiki/SandBoxes.
+  // They are loaded, but never exposed to the sandbox used to run the hook handlers.
+  // See lib/boot.lua for more details.
+  {LUA_LOADLIBNAME, luaopen_package},
+  {LUA_DBLIBNAME, luaopen_debug},  
+
+  // Our custom modules
+  {"libinjection", luaopen_libinjection},
+  {"utf8", luaopen_utf8},
+  {"bit", luaopen_bit},
+  {"lpeg", luaopen_lpeg},
+  {LUACMSGPACK_NAME, luaopen_cmsgpack},
+  {"snapshot", luaopen_snapshot},
+  {NULL, NULL}
+};
+// The previous array replaces the one in linit.c.
+// If you update Lua, make sure to comment the lualibs declaration in the following file.
+#include "lua/linit.c"

data/lua-hooks/ext/bitop/README

@@ -0,0 +1,22 @@
+README for Lua BitOp 1.0.2
+--------------------------
+
+Lua BitOp is a C extension module for Lua 5.1/5.2 which adds
+bitwise operations on numbers.
+
+Homepage: http://bitop.luajit.org/
+
+Lua BitOp is Copyright (C) 2008-2012 Mike Pall.
+Lua BitOp is free software, released under the MIT license.
+
+--------------------------
+
+Full documentation for Lua BitOp is available in HTML format.
+Please point your favourite browser to:
+
+ doc/index.html
+
+Detailed installation instructions are here:
+
+ doc/install.html
+

data/lua-hooks/ext/bitop/bit.c

@@ -0,0 +1,189 @@
+/*
+** Lua BitOp -- a bit operations library for Lua 5.1/5.2.
+** http://bitop.luajit.org/
+**
+** Copyright (C) 2008-2012 Mike Pall. All rights reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
+*/
+
+#define LUA_BITOP_VERSION	"1.0.2"
+
+#define LUA_LIB
+#include "lua/lua.h"
+#include "lua/lauxlib.h"
+
+#ifdef _MSC_VER
+/* MSVC is stuck in the last century and doesn't have C99's stdint.h. */
+typedef __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+#else
+#include <stdint.h>
+#endif
+
+typedef int32_t SBits;
+typedef uint32_t UBits;
+
+typedef union {
+  lua_Number n;
+#ifdef LUA_NUMBER_DOUBLE
+  uint64_t b;
+#else
+  UBits b;
+#endif
+} BitNum;
+
+/* Convert argument to bit type. */
+static UBits barg(lua_State *L, int idx)
+{
+  BitNum bn;
+  UBits b;
+#if LUA_VERSION_NUM < 502
+  bn.n = lua_tonumber(L, idx);
+#else
+  bn.n = luaL_checknumber(L, idx);
+#endif
+#if defined(LUA_NUMBER_DOUBLE)
+  bn.n += 6755399441055744.0;  /* 2^52+2^51 */
+#ifdef SWAPPED_DOUBLE
+  b = (UBits)(bn.b >> 32);
+#else
+  b = (UBits)bn.b;
+#endif
+#elif defined(LUA_NUMBER_INT) || defined(LUA_NUMBER_LONG) || \
+      defined(LUA_NUMBER_LONGLONG) || defined(LUA_NUMBER_LONG_LONG) || \
+      defined(LUA_NUMBER_LLONG)
+  if (sizeof(UBits) == sizeof(lua_Number))
+    b = bn.b;
+  else
+    b = (UBits)(SBits)bn.n;
+#elif defined(LUA_NUMBER_FLOAT)
+#error "A 'float' lua_Number type is incompatible with this library"
+#else
+#error "Unknown number type, check LUA_NUMBER_* in luaconf.h"
+#endif
+#if LUA_VERSION_NUM < 502
+  if (b == 0 && !lua_isnumber(L, idx)) {
+    luaL_typerror(L, idx, "number");
+  }
+#endif
+  return b;
+}
+
+/* Return bit type. */
+#define BRET(b)  lua_pushnumber(L, (lua_Number)(SBits)(b)); return 1;
+
+static int bit_tobit(lua_State *L) { BRET(barg(L, 1)) }
+static int bit_bnot(lua_State *L) { BRET(~barg(L, 1)) }
+
+#define BIT_OP(func, opr) \
+  static int func(lua_State *L) { int i; UBits b = barg(L, 1); \
+    for (i = lua_gettop(L); i > 1; i--) b opr barg(L, i); BRET(b) }
+BIT_OP(bit_band, &=)
+BIT_OP(bit_bor, |=)
+BIT_OP(bit_bxor, ^=)
+
+#define bshl(b, n)  (b << n)
+#define bshr(b, n)  (b >> n)
+#define bsar(b, n)  ((SBits)b >> n)
+#define brol(b, n)  ((b << n) | (b >> (32-n)))
+#define bror(b, n)  ((b << (32-n)) | (b >> n))
+#define BIT_SH(func, fn) \
+  static int func(lua_State *L) { \
+    UBits b = barg(L, 1); UBits n = barg(L, 2) & 31; BRET(fn(b, n)) }
+BIT_SH(bit_lshift, bshl)
+BIT_SH(bit_rshift, bshr)
+BIT_SH(bit_arshift, bsar)
+BIT_SH(bit_rol, brol)
+BIT_SH(bit_ror, bror)
+
+static int bit_bswap(lua_State *L)
+{
+  UBits b = barg(L, 1);
+  b = (b >> 24) | ((b >> 8) & 0xff00) | ((b & 0xff00) << 8) | (b << 24);
+  BRET(b)
+}
+
+static int bit_tohex(lua_State *L)
+{
+  UBits b = barg(L, 1);
+  SBits n = lua_isnone(L, 2) ? 8 : (SBits)barg(L, 2);
+  const char *hexdigits = "0123456789abcdef";
+  char buf[8];
+  int i;
+  if (n < 0) { n = -n; hexdigits = "0123456789ABCDEF"; }
+  if (n > 8) n = 8;
+  for (i = (int)n; --i >= 0; ) { buf[i] = hexdigits[b & 15]; b >>= 4; }
+  lua_pushlstring(L, buf, (size_t)n);
+  return 1;
+}
+
+static const struct luaL_Reg bit_funcs[] = {
+  { "tobit",	bit_tobit },
+  { "bnot",	bit_bnot },
+  { "band",	bit_band },
+  { "bor",	bit_bor },
+  { "bxor",	bit_bxor },
+  { "lshift",	bit_lshift },
+  { "rshift",	bit_rshift },
+  { "arshift",	bit_arshift },
+  { "rol",	bit_rol },
+  { "ror",	bit_ror },
+  { "bswap",	bit_bswap },
+  { "tohex",	bit_tohex },
+  { NULL, NULL }
+};
+
+/* Signed right-shifts are implementation-defined per C89/C99.
+** But the de facto standard are arithmetic right-shifts on two's
+** complement CPUs. This behaviour is required here, so test for it.
+*/
+#define BAD_SAR		(bsar(-8, 2) != (SBits)-2)
+
+LUALIB_API int luaopen_bit(lua_State *L)
+{
+  UBits b;
+  lua_pushnumber(L, (lua_Number)1437217655L);
+  b = barg(L, -1);
+  if (b != (UBits)1437217655L || BAD_SAR) {  /* Perform a simple self-test. */
+    const char *msg = "compiled with incompatible luaconf.h";
+#ifdef LUA_NUMBER_DOUBLE
+#ifdef _WIN32
+    if (b == (UBits)1610612736L)
+      msg = "use D3DCREATE_FPU_PRESERVE with DirectX";
+#endif
+    if (b == (UBits)1127743488L)
+      msg = "not compiled with SWAPPED_DOUBLE";
+#endif
+    if (BAD_SAR)
+      msg = "arithmetic right-shift broken";
+    luaL_error(L, "bit library self-test failed (%s)", msg);
+  }
+#if LUA_VERSION_NUM < 502
+  luaL_register(L, "bit", bit_funcs);
+#else
+  luaL_newlib(L, bit_funcs);
+#endif
+  return 1;
+}
+