contrast-agent 3.12.1 → 3.14.0

data/ext/cs__assess_string/cs__assess_string.h

@@ -1,6 +1,9 @@
 #include <ruby.h>
 
 static VALUE rb_sym_assess_string_uminus;
+static VALUE rb_sym_assess_string_freeze;
+// Contrast::Agent::Assess::Finalizers::Finalize::PROPERTIES_HASH
+static VALUE properties_hash;
 static VALUE rb_sym_dup;
 static VALUE rb_sym_freeze;
 
@@ -15,6 +18,6 @@ static VALUE rb_sym_freeze;
  * -HM
  */
 static VALUE contrast_assess_string_uminus(const int argc, VALUE *argv,
-                                              const VALUE obj);
+                                           const VALUE obj);
 
 void Init_cs__assess_string(void);

data/ext/cs__assess_string_interpolation26/cs__assess_string_interpolation26.c

@@ -3,7 +3,6 @@
 
 #include "cs__assess_string_interpolation26.h"
 #include "../cs__common/cs__common.h"
-#include <funchook.h>
 #include <ruby.h>
 
 static VALUE rb_str_concat_literals_hook(size_t num, VALUE *strary) {
@@ -14,18 +13,16 @@ static VALUE rb_str_concat_literals_hook(size_t num, VALUE *strary) {
 }
 
 static int install_hooks() {
-    funchook_t *funchook = funchook_create();
-
     rb_str_concat_literals_original = rb_str_concat_literals;
-    funchook_prepare(funchook, (void **)&rb_str_concat_literals_original,
-                     rb_str_concat_literals_hook);
+    patch_via_funchook(&rb_str_concat_literals_original,
+                       &rb_str_concat_literals_hook);
 
-    funchook_install(funchook, 0);
     return 0;
 }
 
 void Init_cs__assess_string_interpolation26(void) {
-    string_propagator = rb_define_class_under(core_assess, "StringPropagator", rb_cObject);
+    string_propagator =
+        rb_define_class_under(core_assess, "StringPropagator", rb_cObject);
     track_interpolation = rb_intern("track_interpolation");
     install_hooks();
 }

data/ext/cs__assess_yield_track/cs__assess_yield_track.c

@@ -3,13 +3,12 @@
 
 #include "cs__assess_yield_track.h"
 #include "../cs__common/cs__common.h"
-#include <funchook.h>
 #include <ruby.h>
 
 static VALUE rb_yield_hook(VALUE val, const VALUE self) {
     VALUE method = rb_funcall(rb_mKernel, rb_sym_method, 0);
 
-    if(method == split_method && RB_TYPE_P(val, T_STRING)) {
+    if (method == split_method && RB_TYPE_P(val, T_STRING)) {
         rb_funcall(split_class, propagate_yield, 1, val);
     }
     VALUE result = rb_yield_original(val);
@@ -17,11 +16,8 @@ static VALUE rb_yield_hook(VALUE val, const VALUE self) {
 }
 
 static int install_yield_hooks() {
-    funchook_t *funchook = funchook_create();
     rb_yield_original = rb_yield;
-    funchook_prepare(funchook, (void **)&rb_yield_original,
-                     rb_yield_hook);
-    funchook_install(funchook, 0);
+    patch_via_funchook(&rb_yield_original, &rb_yield_hook);
     return 0;
 }
 
@@ -29,6 +25,6 @@ void Init_cs__assess_yield_track(void) {
     VALUE base = rb_define_class_under(assess_propagator, "Base", rb_cObject);
     split_class = rb_define_class_under(assess_propagator, "Split", base);
     propagate_yield = rb_intern("propagate_yield");
-    split_method =  ID2SYM(rb_intern("split"));
+    split_method = ID2SYM(rb_intern("split"));
     install_yield_hooks();
 }

data/ext/cs__assess_yield_track/cs__assess_yield_track.h

@@ -1,4 +1,3 @@
-#include <funchook.h>
 #include <ruby.h>
 
 static VALUE split_class;

data/ext/cs__common/cs__common.c

@@ -2,6 +2,7 @@
  * https://www.contrastsecurity.com/enduser-terms-0317a for more details. */
 
 #include "cs__common.h"
+#include <dlfcn.h>
 #include <ruby.h>
 
 /* Globals */
@@ -9,6 +10,7 @@
 VALUE contrast, agent, patching, policy, assess;
 VALUE core_extensions, core_assess;
 VALUE assess_policy, assess_propagator;
+VALUE funchook_path;
 
 VALUE rb_sym_enter_scope;
 VALUE rb_sym_exit_scope;
@@ -19,6 +21,33 @@ VALUE rb_sym_method;
 VALUE rb_sym_cs_tracked;
 /* end globals */
 
+void patch_via_funchook(void *original_function, void *hook_function) {
+    VALUE funchook_module_wrapper = rb_define_module("Funchook");
+    funchook_path = rb_iv_get(funchook_module_wrapper, "@path");
+
+    void *funchook_lib_handle;
+    void *funchook_reference, *(*funchook_create)(void);
+    int prepareResult, (*funchook_prepare)(void *, void **, void *);
+    int installResult, (*funchook_install)(void *, int);
+
+    funchook_lib_handle =
+        dlopen(StringValueCStr(funchook_path), RTLD_NOW | RTLD_GLOBAL);
+
+    /* Load the funchook methods we need */
+    funchook_create =
+        (void *(*)(void))dlsym(funchook_lib_handle, "funchook_create");
+    funchook_prepare = (int (*)(void *, void **, void *))dlsym(
+        funchook_lib_handle, "funchook_prepare");
+    funchook_install =
+        (int (*)(void *, int))dlsym(funchook_lib_handle, "funchook_install");
+
+    funchook_reference = (void *)(*funchook_create)();
+
+    prepareResult = (*funchook_prepare)(
+        funchook_reference, (void **)original_function, hook_function);
+    installResult = (*funchook_install)(funchook_reference, 0);
+}
+
 void contrast_alias_method(const VALUE target, const char *to,
                            const char *from) {
     rb_funcall(target, cs__send_method, 3, cs__alias_method_sym,
@@ -29,33 +58,32 @@ VALUE contrast_patcher() {
     return patcher;
 }
 
-VALUE contrast_register_patch(const char *module_name,
-                               const char *method_name,
-                               VALUE(c_fn)(const int, const VALUE*, const VALUE)
-                               ) {
-  return _contrast_register_patch(module_name, method_name, c_fn, IMPL_ALIAS_INSTANCE);
+VALUE contrast_register_patch(const char *module_name, const char *method_name,
+                              VALUE(c_fn)(const int, const VALUE *,
+                                          const VALUE)) {
+    return _contrast_register_patch(module_name, method_name, c_fn,
+                                    IMPL_ALIAS_INSTANCE);
 }
 
-
 VALUE contrast_register_singleton_patch(const char *module_name,
                                         const char *method_name,
-                                        VALUE(c_fn)(const int, const VALUE*, const VALUE)
-                                        ) {
-  return _contrast_register_patch(module_name, method_name, c_fn, IMPL_ALIAS_SINGLETON);
+                                        VALUE(c_fn)(const int, const VALUE *,
+                                                    const VALUE)) {
+    return _contrast_register_patch(module_name, method_name, c_fn,
+                                    IMPL_ALIAS_SINGLETON);
 }
 
-VALUE contrast_register_singleton_prepend_patch(const char *module_name,
-                                                const char *method_name,
-                                                VALUE(c_fn)(const int, const VALUE*, const VALUE)
-                                                ) {
-  return _contrast_register_patch(module_name, method_name, c_fn, IMPL_PREPEND);
+VALUE contrast_register_singleton_prepend_patch(
+    const char *module_name, const char *method_name,
+    VALUE(c_fn)(const int, const VALUE *, const VALUE)) {
+    return _contrast_register_patch(module_name, method_name, c_fn,
+                                    IMPL_PREPEND);
 }
 
-static VALUE _contrast_register_patch(const char *module_name,
-                                      const char *method_name,
-                                      VALUE(c_fn)(const int, const VALUE*, const VALUE),
-                                      patch_impl patch
-                                      ) {
+static VALUE
+_contrast_register_patch(const char *module_name, const char *method_name,
+                         VALUE(c_fn)(const int, const VALUE *, const VALUE),
+                         patch_impl patch) {
     VALUE contrast_bind_module = rb_funcall(rb_cModule, rb_intern("new"), 0);
     VALUE unbound_method = Qnil;
     VALUE rb_str_module_name = rb_str_new_cstr(module_name);
@@ -81,24 +109,27 @@ static VALUE _contrast_register_patch(const char *module_name,
      */
     rb_define_method(contrast_bind_module, method_name, (VALUE(*)())c_fn, -1);
     VALUE rb_sym_instance_method = rb_intern("instance_method");
-    unbound_method = rb_funcall(contrast_bind_module, rb_sym_instance_method, 1, rb_str_method_name);
+    unbound_method = rb_funcall(contrast_bind_module, rb_sym_instance_method, 1,
+                                rb_str_method_name);
     rb_undef_method(contrast_bind_module, method_name);
 
     /* map impl enum -> ruby symbol */
     VALUE impl = Qnil;
-    switch(patch) {
-      case IMPL_ALIAS_INSTANCE:
+    switch (patch) {
+    case IMPL_ALIAS_INSTANCE:
         impl = ID2SYM(rb_sym_alias_instance);
         break;
-      case IMPL_ALIAS_SINGLETON:
+    case IMPL_ALIAS_SINGLETON:
         impl = ID2SYM(rb_sym_alias_singleton);
         break;
-      case IMPL_PREPEND:
+    case IMPL_PREPEND:
         impl = ID2SYM(rb_sym_prepend);
         break;
     }
 
-    VALUE underlying_method_name = rb_funcall(contrast_patcher(), rb_sym_register_c_patch, 3, rb_str_module_name, unbound_method, impl);
+    VALUE underlying_method_name =
+        rb_funcall(contrast_patcher(), rb_sym_register_c_patch, 3,
+                   rb_str_module_name, unbound_method, impl);
     return SYM2ID(underlying_method_name);
 }
 
@@ -117,9 +148,9 @@ void Init_cs__common(void) {
 
     /* Used for returning unbound C functions */
     rb_sym_register_c_patch = rb_intern("register_c_patch");
-    rb_sym_alias_instance   = rb_intern("alias_instance");
-    rb_sym_alias_singleton  = rb_intern("alias_singleton");
-    rb_sym_prepend          = rb_intern("prepend");
+    rb_sym_alias_instance = rb_intern("alias_instance");
+    rb_sym_alias_singleton = rb_intern("alias_singleton");
+    rb_sym_prepend = rb_intern("prepend");
 
     /* Ensure definition of core Contrast instrumentation modules */
     contrast = rb_define_module("Contrast");

data/ext/cs__common/cs__common.h

@@ -4,18 +4,18 @@
 #include <ruby.h>
 
 typedef enum {
-  IMPL_ALIAS_INSTANCE,
-  IMPL_ALIAS_SINGLETON,
-  IMPL_PREPEND
+    IMPL_ALIAS_INSTANCE,
+    IMPL_ALIAS_SINGLETON,
+    IMPL_PREPEND
 } patch_impl;
 
-
 static VALUE cs__send_method;
 static VALUE cs__alias_method_sym;
 
 extern VALUE contrast, agent, patching, policy, assess;
 extern VALUE core_extensions, core_assess;
 extern VALUE assess_policy, assess_propagator;
+extern VALUE funchook_path;
 
 extern VALUE rb_sym_enter_scope;
 extern VALUE rb_sym_exit_scope;
@@ -32,30 +32,28 @@ static VALUE rb_sym_alias_instance;
 static VALUE rb_sym_alias_singleton;
 static VALUE rb_sym_prepend;
 
+void patch_via_funchook(void *original_function, void *hook_function);
+
 void contrast_alias_method(const VALUE target, const char *to,
                            const char *from);
 
-VALUE contrast_register_patch(const char *module_name,
-                              const char *method_name,
-                              VALUE(c_fn)(const int, const VALUE*, const VALUE)
-                              );
+VALUE contrast_register_patch(const char *module_name, const char *method_name,
+                              VALUE(c_fn)(const int, const VALUE *,
+                                          const VALUE));
 
 VALUE contrast_register_singleton_patch(const char *module_name,
                                         const char *method_name,
-                                        VALUE(c_fn)(const int, const VALUE*, const VALUE)
-                                        );
-
-VALUE contrast_register_singleton_prepend_patch(const char *module_name,
-                                                const char *method_name,
-                                                VALUE(c_fn)(const int, const VALUE*, const VALUE)
-                                                );
+                                        VALUE(c_fn)(const int, const VALUE *,
+                                                    const VALUE));
 
-static VALUE _contrast_register_patch(const char *module_name,
-                                      const char *method_name,
-                                      VALUE(c_fn)(const int, const VALUE*, const VALUE),
-                                      patch_impl patch_impl
-                                      );
+VALUE contrast_register_singleton_prepend_patch(
+    const char *module_name, const char *method_name,
+    VALUE(c_fn)(const int, const VALUE *, const VALUE));
 
+static VALUE
+_contrast_register_patch(const char *module_name, const char *method_name,
+                         VALUE(c_fn)(const int, const VALUE *, const VALUE),
+                         patch_impl patch_impl);
 
 VALUE contrast_patcher();
 

data/ext/cs__common/extconf.rb

@@ -4,18 +4,4 @@
 require 'mkmf'
 require_relative '../../lib/contrast/agent/version'
 
-installed_path = __dir__
-
-origin =  if !(/darwin/ =~ RUBY_PLATFORM).nil?
-            '@loader_path'
-          else
-            '\$${ORIGIN}'
-          end
-
-options = " -Wl,-rpath,#{ origin }/../../shared_libraries"
-
-$LDFLAGS << options if try_link('int main() {return 0;}', options)
-
-$LIBPATH << installed_path
-
 create_makefile 'cs__common/cs__common'

data/ext/cs__contrast_patch/cs__contrast_patch.c

@@ -34,7 +34,6 @@ VALUE contrast_patch_call_original(const VALUE *args) {
     method = args[3];
     method_id = SYM2ID(method);
 
-
     /* It looks like we can find the last Ruby block given so long as we don't
      * change Ruby method scope (always call this function from C, not Ruby),
      * which is the point of this C call.
@@ -111,7 +110,8 @@ VALUE contrast_call_super(const VALUE *args) {
 }
 
 VALUE contrast_run_patches(const VALUE *wrapped_args) {
-    VALUE impl, method, method_policy, object, original_args, original_ret, preshift, transformed_ret;
+    VALUE impl, method, method_policy, object, original_args, original_ret,
+        preshift, transformed_ret;
     int argc;
     VALUE *argv;
     VALUE rescue_args[6];
@@ -168,17 +168,17 @@ VALUE contrast_run_patches(const VALUE *wrapped_args) {
      */
 
     switch (impl) {
-        case IMPL_ALIAS_INSTANCE:
-        case IMPL_ALIAS_SINGLETON:
-            original_ret = rb_rescue2(
-                contrast_patch_call_original, original_args,
-                contrast_patch_call_rescue, (VALUE)rescue_args, rb_eException, 0);
-            break;
-        case IMPL_PREPEND:
-            original_ret = rb_rescue2(contrast_call_super, original_args,
-                                      contrast_patch_call_rescue,
-                                      (VALUE)rescue_args, rb_eException, 0);
-            break;
+    case IMPL_ALIAS_INSTANCE:
+    case IMPL_ALIAS_SINGLETON:
+        original_ret = rb_rescue2(contrast_patch_call_original, original_args,
+                                  contrast_patch_call_rescue,
+                                  (VALUE)rescue_args, rb_eException, 0);
+        break;
+    case IMPL_PREPEND:
+        original_ret = rb_rescue2(contrast_call_super, original_args,
+                                  contrast_patch_call_rescue,
+                                  (VALUE)rescue_args, rb_eException, 0);
+        break;
     };
 
     /* If you're here, the original method did not throw an exception
@@ -302,16 +302,17 @@ VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
     }
 
     /* Otherwise, invoke Contrast analysis. */
-     VALUE wrapped_args[7];
-     wrapped_args[0] = impl;
-     wrapped_args[1] = (VALUE)original_args;
-     wrapped_args[2] = method;
-     wrapped_args[3] = method_policy;
-     wrapped_args[4] = object;
-     wrapped_args[5] = INT2NUM(argc);
-     wrapped_args[6] = (VALUE)argv;
-
-    return rb_ensure(contrast_run_patches, (VALUE)wrapped_args, contrast_ensure_function, method_policy);
+    VALUE wrapped_args[7];
+    wrapped_args[0] = impl;
+    wrapped_args[1] = (VALUE)original_args;
+    wrapped_args[2] = method;
+    wrapped_args[3] = method_policy;
+    wrapped_args[4] = object;
+    wrapped_args[5] = INT2NUM(argc);
+    wrapped_args[6] = (VALUE)argv;
+
+    return rb_ensure(contrast_run_patches, (VALUE)wrapped_args,
+                     contrast_ensure_function, method_policy);
 
 call_original:
 
@@ -351,8 +352,9 @@ VALUE contrast_patch_define_method(const VALUE self, const VALUE clazz,
         rb_funcall(method_policy, rb_sym_instance_method, 0);
     char *cStr;
     VALUE str;
-    rb_funcall(patch_status, rb_sym_set_info_for, 5, clazz, original_method_name,
-               method_policy, is_instance_method, cs_method);
+    rb_funcall(patch_status, rb_sym_set_info_for, 5, clazz,
+               original_method_name, method_policy, is_instance_method,
+               cs_method);
 
     /* Some methods we patch rely on a specific C level patch,
      * in those cases we should still add the method to the info_for hash

data/ext/cs__contrast_patch/cs__contrast_patch.h

@@ -1,5 +1,5 @@
-#include <ruby.h>
 #include "../cs__common/cs__common.h"
+#include <ruby.h>
 
 /* Calls to Contrast modules */
 /* Contrast::Agent::Patching::Policy::PatchStatus */
@@ -140,8 +140,7 @@ VALUE contrast_call_super(const VALUE *args);
  *          instance (specifically for frozen sources)
  */
 VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
-                              const patch_impl impl,
-                              const VALUE object);
+                              const patch_impl impl, const VALUE object);
 
 VALUE contrast_alias_instance_patch(const int argc, const VALUE *argv,
                                     const VALUE object);
@@ -149,7 +148,6 @@ VALUE contrast_alias_instance_patch(const int argc, const VALUE *argv,
 VALUE contrast_alias_singleton_patch(const int argc, const VALUE *argv,
                                      const VALUE object);
 
-
 VALUE contrast_prepend_patch(const int argc, const VALUE *argv,
                              const VALUE object);
 
@@ -169,12 +167,12 @@ VALUE contrast_prepend_patch(const int argc, const VALUE *argv,
  *   - prepending Foo with Foo::ContrastPrepend
  *
  * originalModule - Module; the actual Module being prepended
- * methodPolicy - :MethodPolicy; the method policy that apply to the method being redefined
+ * methodPolicy - :MethodPolicy; the method policy that apply to the method
+ * being redefined
  *
  * return - Boolean; if the prepend occurred or not
  */
-VALUE contrast_patch_prepend(const VALUE self,
-                             const VALUE originalModule,
+VALUE contrast_patch_prepend(const VALUE self, const VALUE originalModule,
                              const VALUE methodPolicy);
 
 /*