contrast-agent 3.13.2 → 3.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0ae3e021f55160aef8f9a1c3beec72a68e4b6f2751284573a154251cc1f4483
-  data.tar.gz: 3e774fcb756fede7c319c38767354fc6cb7453bdf1d6c733983b1e5729ec5e2e
+  metadata.gz: c3ef67bfca5c3d772078af285e4b3fa1ab314b06af04355db1aa50cce0d284e8
+  data.tar.gz: 5eb0fe6b5dba8f64b5947c1c7cade90718b18224b62b5e02eed470613e6fbe6d
 SHA512:
-  metadata.gz: 4567fdb2323be1884bca5e0369fd135dfc6ffb0b87ecd5d4aac1ef808d0388c68e5c333f56134ee85230eeba587e56a0e692b8cbda0c447ef53f209cf7e67621
-  data.tar.gz: 784af7ef08e6e830525b2947270da6d1918fc2b924cd6f8efb7c2d2661b993929a6cb2aaf9db8806ac7411155b50ba4be24348005b1893d16e27a9edfdd56441
+  metadata.gz: caf748a141fe652cbb1cb3e658969820b22ca4e58a11cdc46ee9bc94932c00e031b186b96e8c44b884d6f658951e8936a75444aa4d52cb9d0d5e563ab29ef26b
+  data.tar.gz: b3235852bb77977f244beed747b032bfa6e80eb86ebdcfab622a8dba7acc7a939f87e08022a07e795d2c455ec3d3107771e5cdae0d5b893a4c6019f09945db43

data/exe/contrast_service

@@ -3,19 +3,13 @@
 # frozen_string_literal: true
 
 def mac?
-  RUBY_PLATFORM.match?(/darwin/)
-end
-
-def windows?
-  RUBY_PLATFORM.match?(/cygwin|mswin|mingw|bccwin|wince|emx/)
+  RUBY_PLATFORM.include?('darwin')
 end
 
 def path
   base_path = "#{ File.dirname(__FILE__) }/.."
   if mac?
     "#{ base_path }/service_executables/mac/contrast-service"
-  elsif windows?
-    "#{ base_path }/service_executables/windows/contrast-service.exe"
   else
     "#{ base_path }/service_executables/linux/contrast-service"
   end

data/ext/cs__assess_active_record_named/cs__active_record_named.c

@@ -2,8 +2,8 @@
  * https://www.contrastsecurity.com/enduser-terms-0317a for more details. */
 
 #include "cs__active_record_named.h"
-#include <ruby.h>
 #include "../cs__common/cs__common.h"
+#include <ruby.h>
 
 VALUE contrast_assess_active_record_scope(const int argc, const VALUE *argv,
                                           const VALUE self) {
@@ -19,7 +19,8 @@ VALUE contrast_assess_active_record_scope(const int argc, const VALUE *argv,
      */
     VALUE new_body, ret;
     VALUE new_args[3];
-    new_body = rb_funcall(active_record_named, rb_sym_assess_rewrite, 3, self, argv[0], argv[1]);
+    new_body = rb_funcall(active_record_named, rb_sym_assess_rewrite, 3, self,
+                          argv[0], argv[1]);
     new_args[0] = argv[0];
     if (NIL_P(new_body)) {
         new_args[1] = argv[1];
@@ -36,10 +37,10 @@ void Init_cs__assess_active_record_named(void) {
     framework = rb_define_module_under(contrast, "Framework");
     rails = rb_define_module_under(framework, "Rails");
     rewrite = rb_define_module_under(rails, "Rewrite");
-    active_record_named = rb_define_class_under(rewrite, "ActiveRecordNamed", rb_cObject);
+    active_record_named =
+        rb_define_class_under(rewrite, "ActiveRecordNamed", rb_cObject);
     rb_sym_assess_rewrite = rb_intern("rewrite");
-    rb_sym_assess_scope   = contrast_register_patch("ActiveRecord::Scoping::Named::ClassMethods",
-                                                    "scope",
-                                                    contrast_assess_active_record_scope);
+    rb_sym_assess_scope =
+        contrast_register_patch("ActiveRecord::Scoping::Named::ClassMethods",
+                                "scope", contrast_assess_active_record_scope);
 }
-

data/ext/cs__assess_array/cs__assess_array.c

@@ -23,15 +23,16 @@ static VALUE contrast_assess_array_join(const int argc, const VALUE *argv,
     /* Finally, default to empty String. Implicit since nil.to_s is ''*/
 
     result = rb_funcall2(ary, rb_sym_assess_array_join, argc, argv);
-    result = rb_funcall(array_propagator, rb_sym_assess_track_array_join, 3, ary, sep, result);
+    result = rb_funcall(array_propagator, rb_sym_assess_track_array_join, 3,
+                        ary, sep, result);
 
     return result;
 }
 
 void Init_cs__assess_array(void) {
-    array_propagator = rb_define_class_under(core_assess, "ArrayPropagator", rb_cObject);
+    array_propagator =
+        rb_define_class_under(core_assess, "ArrayPropagator", rb_cObject);
     rb_sym_assess_track_array_join = rb_intern("cs__track_join");
-    rb_sym_assess_array_join = contrast_register_patch("Array",
-                                                       "join",
-                                                       contrast_assess_array_join);
+    rb_sym_assess_array_join =
+        contrast_register_patch("Array", "join", contrast_assess_array_join);
 }

data/ext/cs__assess_basic_object/cs__assess_basic_object.c

@@ -7,7 +7,8 @@
 
 void contrast_assess_instance_eval_trigger_check(VALUE self, VALUE source,
                                                  VALUE ret) {
-    rb_funcall(basic_eval_trigger, instance_trigger_check_method, 3, self, source, ret);
+    rb_funcall(basic_eval_trigger, instance_trigger_check_method, 3, self,
+               source, ret);
 }
 
 VALUE
@@ -36,7 +37,8 @@ contrast_assess_basic_object_instance_eval(const int argc, const VALUE *argv,
 }
 
 void Init_cs__assess_basic_object(void) {
-    basic_eval_trigger = rb_define_class_under(core_assess, "EvalTrigger", rb_cObject);
+    basic_eval_trigger =
+        rb_define_class_under(core_assess, "EvalTrigger", rb_cObject);
     instance_trigger_check_method = rb_intern("instance_eval_trigger_check");
 
     /* We don't keep a reference to the underlying method.
@@ -45,8 +47,6 @@ void Init_cs__assess_basic_object(void) {
      * but if someone else patched BasicObject#instance_eval,
      * IDK if this is intentional... noting it.  -ajm
      */
-    contrast_register_patch("BasicObject",
-                            "instance_eval",
+    contrast_register_patch("BasicObject", "instance_eval",
                             contrast_assess_basic_object_instance_eval);
-
 }

data/ext/cs__assess_fiber_track/cs__assess_fiber_track.c

@@ -73,7 +73,8 @@ int install_fiber_hooks() {
 }
 
 void Init_cs__assess_fiber_track(void) {
-    fiber_propagator = rb_define_class_under(core_assess, "FiberPropagator", rb_cObject);
+    fiber_propagator =
+        rb_define_class_under(core_assess, "FiberPropagator", rb_cObject);
     track_rb_fiber_new = rb_intern("track_rb_fiber_new");
     track_rb_fiber_yield = rb_intern("track_rb_fiber_yield");
     rb_sym_next = rb_intern("next");

data/ext/cs__assess_hash/cs__assess_hash.c

@@ -12,23 +12,24 @@
  * This method instruments that unique bracket-construction style
  * of initializing a hash.
  */
-static VALUE contrast_assess_hash_bracket_constructor(const int argc, VALUE *argv,
-                                              const VALUE hash) {
+static VALUE contrast_assess_hash_bracket_constructor(const int argc,
+                                                      VALUE *argv,
+                                                      const VALUE hash) {
     VALUE result;
 
     /* Array of Arrays: Hash[ [ [key, value], ... ] ]   -> new_hash */
     if (RB_TYPE_P(argv[0], T_ARRAY)) {
         int i;
         for (i = 0; i < argc; i++) {
-            argv[i] =
-                rb_funcall(hash_propagator, rb_sym_assess_hash_dup_and_freeze, 1, argv[i]);
+            argv[i] = rb_funcall(hash_propagator,
+                                 rb_sym_assess_hash_dup_and_freeze, 1, argv[i]);
         }
         /* Hash[ key, value, ... ]         -> new_hash */
     } else if (argc > 1) {
         int i;
         for (i = 0; i < argc; i += 2) {
-            argv[i] =
-                rb_funcall(hash_propagator, rb_sym_assess_hash_dup_and_freeze, 1, argv[i]);
+            argv[i] = rb_funcall(hash_propagator,
+                                 rb_sym_assess_hash_dup_and_freeze, 1, argv[i]);
         }
     }
 
@@ -36,7 +37,8 @@ static VALUE contrast_assess_hash_bracket_constructor(const int argc, VALUE *arg
      * String keys
      * # Hash[ object ]                  -> new_hash
      */
-    result = rb_funcall2(hash, rb_sym_assess_hash_bracket_constructor, argc, argv);
+    result =
+        rb_funcall2(hash, rb_sym_assess_hash_bracket_constructor, argc, argv);
 
     return result;
 }
@@ -61,8 +63,9 @@ static VALUE contrast_assess_hash_bracket_set(const int argc, VALUE *argv,
      * We haven't revisited this approach since we started more extensively
      * hooking public C functions.)
      */
-    if(argc > 0) {
-        argv[0] = rb_funcall(hash_propagator, rb_sym_assess_hash_dup_and_freeze, 1, argv[0]);
+    if (argc > 0) {
+        argv[0] = rb_funcall(hash_propagator, rb_sym_assess_hash_dup_and_freeze,
+                             1, argv[0]);
     }
     /* This is the underlying assignment, w/ our instrumented key. */
     result = rb_funcall2(hash, rb_sym_assess_hash_bracket_equals, argc, argv);
@@ -71,17 +74,15 @@ static VALUE contrast_assess_hash_bracket_set(const int argc, VALUE *argv,
 }
 
 void Init_cs__assess_hash(void) {
-    hash_propagator = rb_define_class_under(core_assess, "HashPropagator", rb_cObject);
+    hash_propagator =
+        rb_define_class_under(core_assess, "HashPropagator", rb_cObject);
     rb_sym_assess_hash_dup_and_freeze = rb_intern("cs__duplicate_and_freeze");
 
     VALUE hash_class = rb_define_class("Hash", rb_cObject);
 
-    rb_sym_assess_hash_bracket_constructor = contrast_register_singleton_patch("Hash",
-                                                                               "[]",
-                                                                               contrast_assess_hash_bracket_constructor);
-
-    rb_sym_assess_hash_bracket_equals = contrast_register_patch("Hash",
-                                                                "[]=",
-                                                                contrast_assess_hash_bracket_set);
+    rb_sym_assess_hash_bracket_constructor = contrast_register_singleton_patch(
+        "Hash", "[]", contrast_assess_hash_bracket_constructor);
 
+    rb_sym_assess_hash_bracket_equals = contrast_register_patch(
+        "Hash", "[]=", contrast_assess_hash_bracket_set);
 }

data/ext/cs__assess_hash/cs__assess_hash.h

@@ -13,7 +13,8 @@ static VALUE hash_propagator;
  * ahead of time should avoid this, similar to the behavior of the -@ Strings
  * -HM
  */
-static VALUE contrast_assess_hash_bracket_constructor(const int argc, VALUE *argv,
+static VALUE contrast_assess_hash_bracket_constructor(const int argc,
+                                                      VALUE *argv,
                                                       const VALUE hash);
 
 static VALUE contrast_assess_hash_bracket_set(const int argc, VALUE *argv,

data/ext/cs__assess_kernel/cs__assess_kernel.c

@@ -18,8 +18,9 @@ contrast_patched_kernel_exec(const int argc, const VALUE *argv,
         rb_funcall(contrast_patcher(), rb_sym_exit_scope, 0);
     }
 
-    /* maybe this should be rb_funcall2.  this works right now because *argv == argv[0].
-     * exec shouldn't ever be called with != 1 argc, so not a huge problem */
+    /* maybe this should be rb_funcall2.  this works right now because *argv ==
+     * argv[0]. exec shouldn't ever be called with != 1 argc, so not a huge
+     * problem */
     return rb_funcall(self, rb_sym_assess_kernel_exec, argc, *argv);
 }
 
@@ -27,12 +28,10 @@ void Init_cs__assess_kernel(void) {
     kernel_propagator = rb_define_module_under(core_assess, "KernelPropagator");
     exec_apply_trigger = rb_intern("apply_trigger");
 
-    rb_sym_assess_kernel_exec = contrast_register_patch("Kernel",
-                                                        "exec",
-                                                        contrast_patched_kernel_exec);
+    rb_sym_assess_kernel_exec =
+        contrast_register_patch("Kernel", "exec", contrast_patched_kernel_exec);
 
     /* should return the same value as above */
-    rb_sym_assess_kernel_exec = contrast_register_singleton_patch("Kernel",
-                                                                  "exec",
-                                                                  contrast_patched_kernel_exec);
+    rb_sym_assess_kernel_exec = contrast_register_singleton_patch(
+        "Kernel", "exec", contrast_patched_kernel_exec);
 }

data/ext/cs__assess_marshal_module/cs__assess_marshal_module.c

@@ -9,7 +9,6 @@ static VALUE contrast_assess_marshal_module_load(const int argc,
                                                  const VALUE *argv) {
     VALUE result;
     VALUE source_string;
-
     result = rb_call_super(argc, argv);
 
     if (argc >= 1) {
@@ -27,7 +26,7 @@ static VALUE contrast_assess_marshal_module_load(const int argc,
                         rb_funcall(contrast_patcher(), rb_sym_enter_scope, 0);
                     rb_funcall(marshal_module, rb_sym_assess_load_trigger_check,
                                2, source_string, result);
-                    rb_funcall(contrast_patcher(), rb_sym_exit_scope, 1, scope);
+                    rb_funcall(contrast_patcher(), rb_sym_exit_scope, 0);
                 }
             }
         }
@@ -36,9 +35,9 @@ static VALUE contrast_assess_marshal_module_load(const int argc,
 }
 
 void Init_cs__assess_marshal_module(void) {
+    marshal_module = rb_define_class_under(core_assess, "MarshalPropagator", rb_cObject);
     rb_sym_assess_load_trigger_check = rb_intern("cs__load_trigger_check");
 
-    contrast_register_singleton_prepend_patch("Marshal",
-                                              "load",
-                                              &contrast_assess_marshal_module_load);
+    contrast_register_singleton_prepend_patch(
+        "Marshal", "load", &contrast_assess_marshal_module_load);
 }

data/ext/cs__assess_module/cs__assess_module.c

@@ -21,7 +21,8 @@ void contrast_assess_eval_trigger_check(VALUE module, VALUE source, VALUE ret) {
         /* If this method ever throws an exception, the scope-leave
          * needs to be moved within a rescue call.
          */
-        rb_funcall(module_eval_trigger, trigger_check_method, 4, module, source, ret, method);
+        rb_funcall(module_eval_trigger, trigger_check_method, 4, module, source,
+                   ret, method);
     }
 
     rb_funcall(contrast_patcher(), rb_sym_exit_scope, 0);
@@ -57,7 +58,8 @@ contrast_assess_module_module_eval(const int argc, const VALUE *argv,
 }
 
 void Init_cs__assess_module(void) {
-    module_eval_trigger = rb_define_class_under(core_assess, "EvalTrigger", rb_cObject);
+    module_eval_trigger =
+        rb_define_class_under(core_assess, "EvalTrigger", rb_cObject);
     trigger_check_method = rb_intern("eval_trigger_check");
 
     rb_sym_assess_patch_eval = rb_intern("patch_assess_on_eval");
@@ -69,11 +71,9 @@ void Init_cs__assess_module(void) {
      * See similar comments in basic_object C ext patch.
      */
 
-    contrast_register_patch("Module",
-                            "class_eval",
+    contrast_register_patch("Module", "class_eval",
                             contrast_assess_module_class_eval);
 
-    contrast_register_patch("Module",
-                            "module_eval",
+    contrast_register_patch("Module", "module_eval",
                             contrast_assess_module_module_eval);
 }

data/ext/cs__assess_regexp/cs__assess_regexp.c

@@ -29,7 +29,8 @@ static VALUE contrast_assess_regexp_equal_squiggle(const int argc,
 }
 
 void Init_cs__assess_regexp(void) {
-    regexp_propagator = rb_define_class_under(core_assess, "RegexpPropagator", rb_cObject);
+    regexp_propagator =
+        rb_define_class_under(core_assess, "RegexpPropagator", rb_cObject);
     rb_sym_assess_track_regexp = rb_intern("track_equal_squiggle");
 
     /* These are the keys we use to define our hash of
@@ -46,7 +47,6 @@ void Init_cs__assess_regexp(void) {
     rb_sym_back_ref = ID2SYM(rb_intern("back_ref"));
     rb_global_variable(&rb_sym_back_ref);
 
-    rb_sym_assess_regexp_equal_squiggle = contrast_register_patch("Regexp",
-                                                                  "=~",
-                                                                  contrast_assess_regexp_equal_squiggle);
+    rb_sym_assess_regexp_equal_squiggle = contrast_register_patch(
+        "Regexp", "=~", contrast_assess_regexp_equal_squiggle);
 }

data/ext/cs__assess_string/cs__assess_string.c

@@ -6,7 +6,7 @@
 #include <ruby.h>
 
 static VALUE contrast_assess_string_uminus(const int argc, VALUE *argv,
-                                              const VALUE obj) {
+                                           const VALUE obj) {
     VALUE dup, tracked;
     if (!OBJ_FROZEN(obj)) {
         tracked = rb_funcall(obj, rb_sym_cs_tracked, 0);
@@ -17,6 +17,7 @@ static VALUE contrast_assess_string_uminus(const int argc, VALUE *argv,
              * string.c, but we ignore any other monkey patches on String#-@
              */
             dup = rb_funcall(obj, rb_sym_dup, 0);
+            rb_funcall(obj, rb_intern("cs__transfer_properties"), 1, dup);
             rb_funcall(dup, rb_sym_freeze, 0);
             return dup;
         }
@@ -25,11 +26,26 @@ static VALUE contrast_assess_string_uminus(const int argc, VALUE *argv,
     return rb_funcall(obj, rb_sym_assess_string_uminus, 0);
 }
 
+static VALUE contrast_assess_string_freeze(const int argc, VALUE *argv,
+                                           const VALUE obj) {
+    if (!OBJ_FROZEN(obj)) {
+        // Contrast::Agent::Assess::Finalizers::Finalize::PROPERTIES_HASH.pre_freeze(self)
+        rb_funcall(properties_hash, rb_intern("pre_freeze"), 1, obj);
+    }
+    return rb_funcall(obj, rb_sym_assess_string_freeze, 0);
+}
+
 void Init_cs__assess_string(void) {
     rb_sym_dup = rb_intern("dup");
     rb_sym_freeze = rb_intern("freeze");
 
-    rb_sym_assess_string_uminus = contrast_register_patch("String",
-                                                          "-@",
-                                                          &contrast_assess_string_uminus);
+    // Contrast::Agent::Assess::Finalizers::Finalize::PROPERTIES_HASH
+    VALUE finalizers = rb_define_module_under(assess, "Finalizers");
+    VALUE finalize = rb_define_module_under(finalizers, "Finalize");
+    properties_hash = rb_const_get(finalize, rb_intern("PROPERTIES_HASH"));
+
+    rb_sym_assess_string_uminus =
+        contrast_register_patch("String", "-@", &contrast_assess_string_uminus);
+    rb_sym_assess_string_freeze = contrast_register_patch(
+        "String", "freeze", &contrast_assess_string_freeze);
 }

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

@@ -14,13 +14,15 @@ static VALUE rb_str_concat_literals_hook(size_t num, VALUE *strary) {
 
 static int install_hooks() {
     rb_str_concat_literals_original = rb_str_concat_literals;
-    patch_via_funchook(&rb_str_concat_literals_original, &rb_str_concat_literals_hook);
+    patch_via_funchook(&rb_str_concat_literals_original,
+                       &rb_str_concat_literals_hook);
 
     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

@@ -8,7 +8,7 @@
 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);
@@ -25,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__common/cs__common.c

@@ -2,8 +2,8 @@
  * https://www.contrastsecurity.com/enduser-terms-0317a for more details. */
 
 #include "cs__common.h"
-#include <ruby.h>
 #include <dlfcn.h>
+#include <ruby.h>
 
 /* Globals */
 /* These are defined w/ `extern` in the header */
@@ -27,19 +27,24 @@ void patch_via_funchook(void *original_function, void *hook_function) {
 
     void *funchook_lib_handle;
     void *funchook_reference, *(*funchook_create)(void);
-    int prepareResult, (*funchook_prepare)(void*, void**, void*);
-    int installResult, (*funchook_install)(void*, int);
+    int prepareResult, (*funchook_prepare)(void *, void **, void *);
+    int installResult, (*funchook_install)(void *, int);
 
-    funchook_lib_handle = dlopen(StringValueCStr(funchook_path), RTLD_NOW | RTLD_GLOBAL);
+    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_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)();
+    funchook_reference = (void *)(*funchook_create)();
 
-    prepareResult = (*funchook_prepare)(funchook_reference, (void**)original_function, hook_function);
+    prepareResult = (*funchook_prepare)(
+        funchook_reference, (void **)original_function, hook_function);
     installResult = (*funchook_install)(funchook_reference, 0);
 }
 
@@ -53,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);
@@ -105,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);
 }
 
@@ -141,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");