[WRAPPER] Improved bridge with a secondary function (inplace of the name)

Author: ptitSeb

src/emu/x64int3.c

@@ -81,7 +81,12 @@ void print_wrapper_name(int level, x64emu_t* emu)
 {
     onebridge_t* bridge = (onebridge_t*)(R_RIP&~(sizeof(onebridge_t)-1));
     if (IsBridgeSignature(bridge->S, bridge->C)) {
-        printf_log(level, "calling %s\n", bridge->name?bridge->name:"????");
+        const char* name = NULL;
+        if(bridge->func)
+            name = GetNativeName(bridge->name_or_func);
+        else
+            name = bridge->name_or_func;
+        printf_log(level, "calling %s\n", name?name:"????");
     } else {
         printf_log(level, "Could found the function name for fnc=%p\n", bridge->f);
     }
@@ -149,7 +154,7 @@ void x64Int3(x64emu_t* emu, uintptr_t* addr)
                 uint64_t *pu64 = NULL;
                 uint32_t *pu32 = NULL;
                 uint8_t *pu8 = NULL;
-                const char *s = bridge->name;
+                const char *s = (bridge->func)?GetNativeName(bridge->name_or_func):bridge->name_or_func;
                 if(!s)
                     s = GetNativeName((void*)a);
                 if(a==(uintptr_t)PltResolver64) {

src/emu/x86int3.c

@@ -83,7 +83,7 @@ void x86Int3(x64emu_t* emu, uintptr_t* addr)
                 uint64_t *pu64 = NULL;
                 uint32_t *pu32 = NULL;
                 uint8_t *pu8 = NULL;
-                const char *s = bridge->name;
+                const char *s = (bridge->func)?GetNativeName(bridge->name_or_func):bridge->name_or_func;
                 if(!s)
                     s = GetNativeName((void*)a);
                 if(a==(uintptr_t)PltResolver32) {

src/include/bridge.h

@@ -12,7 +12,10 @@ void FreeBridge(bridge_t** bridge);
 
 uintptr_t AddBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char* name);
 uintptr_t CheckBridged(bridge_t* bridge, void* fnc);
+uintptr_t CheckBridged2(bridge_t* bridge, void* fnc, void* fnc2);
+uintptr_t AddBridge2(bridge_t* bridge, wrapper_t w, void* fnc, void* fnc2, int N, const char* name);
 uintptr_t AddCheckBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char* name);
+uintptr_t AddCheckBridge2(bridge_t* bridge, wrapper_t w, void* fnc, void* fnc2, int N, const char* name);
 uintptr_t AddAutomaticBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char* name);
 uintptr_t AddAutomaticBridgeAlt(bridge_t* bridge, wrapper_t w, void* fnc, void* alt, int N, const char* name);
 void* GetNativeFnc(uintptr_t fnc);
@@ -22,6 +25,7 @@ void* GetNativeOrAlt(void* fnc, void* alt);
 uintptr_t AddVSyscall(bridge_t* bridge, int num);
 
 const char* getBridgeName(void* addr);
+void* getBridgeFnc2(void* addr);
 
 void init_bridge_helper(void);
 void fini_bridge_helper(void);

src/include/khash.h

@@ -142,6 +142,7 @@ typedef unsigned long khint64_t;
 #else
 typedef unsigned long long khint64_t;
 #endif
+typedef __uint128_t khint128_t;
 
 #ifdef _MSC_VER
 #define kh_inline __inline
@@ -393,6 +394,16 @@ static const double __ac_HASH_UPPER = 0.77;
   @abstract     64-bit integer comparison function
  */
 #define kh_int64_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     128-bit integer hash function
+  @param  key   The integer [khint128_t]
+  @return       The hash value [khint_t]
+ */
+#define kh_int128_hash_func(key) (khint32_t)((key)>>100^(key)>>66^(key)>>33^(key)^(key)<<11)
+/*! @function
+  @abstract     128-bit integer comparison function
+ */
+#define kh_int128_hash_equal(a, b) ((a) == (b))
 /*! @function
   @abstract     const char* hash function
   @param  s     Pointer to a null terminated string
@@ -696,7 +707,34 @@ static kh_inline khint_t __ac_Wang_hash(khint_t key)
 #define KHASH_MAP_IMPL_INT64(name, khval_t)								\
 	__KHASH_IMPL(name, , khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal)
 
-typedef const char *kh_cstr_t;
+/*! @function
+  @abstract     Instantiate a hash map containing 128-bit integer keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_INT128(name)										\
+	KHASH_INIT(name, khint128_t, char, 0, kh_int128_hash_func, kh_int128_hash_equal)
+
+#define KHASH_SET_DECLARE_INT128(name)										\
+	KHASH_DECLARE(name, khint128_t, char)
+
+#define KHASH_SET_IMPL_INT128(name)										\
+	__KHASH_IMPL(name, , khint128_t, char, 0, kh_int128_hash_func, kh_int128_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing 128-bit integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_INT128(name, khval_t)								\
+	KHASH_INIT(name, khint128_t, khval_t, 1, kh_int128_hash_func, kh_int128_hash_equal)
+
+#define KHASH_MAP_DECLARE_INT128(name, khval_t)								\
+	KHASH_DECLARE(name, khint128_t, khval_t)
+
+#define KHASH_MAP_IMPL_INT128(name, khval_t)								\
+	__KHASH_IMPL(name, , khint128_t, khval_t, 1, kh_int128_hash_func, kh_int128_hash_equal)
+
+	typedef const char *kh_cstr_t;
 /*! @function
   @abstract     Instantiate a hash map containing const char* keys
   @param  name  Name of the hash table [symbol]

src/tools/bridge.c

@@ -25,7 +25,7 @@
 #include "box32context.h"
 #endif
 
-KHASH_MAP_INIT_INT64(bridgemap, uintptr_t)
+KHASH_MAP_INIT_INT128(bridgemap, uintptr_t)
 
 typedef struct brick_s brick_t;
 typedef struct brick_s {
@@ -99,12 +99,8 @@ void FreeBridge(bridge_t** bridge)
     *bridge = NULL;
 }
 
-#ifdef HAVE_TRACE
-void addBridgeName(void* addr, const char* name);
-#endif
-
 //static const char* default_bridge = "bridge???";
-uintptr_t AddBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char* name)
+uintptr_t AddBridge2(bridge_t* bridge, wrapper_t w, void* fnc, void* fnc2, int N, const char* name)
 {
     brick_t *b = NULL;
     int sz = -1;
@@ -120,7 +116,8 @@ uintptr_t AddBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char*
     sz = b->sz;
     b->sz++;
     // add bridge to map, for fast recovery
-    khint_t k = kh_put(bridgemap, bridge->bridgemap, (uintptr_t)fnc, &ret);
+    khint128_t key = (uintptr_t)fnc | (khint128_t)((uintptr_t)fnc2)<<64;
+    khint_t k = kh_put(bridgemap, bridge->bridgemap, key, &ret);
     kh_value(bridge->bridgemap, k) = (uintptr_t)&b->b[sz].CC;
     mutex_unlock(&my_context->mutex_bridge);
 
@@ -130,11 +127,17 @@ uintptr_t AddBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char*
     b->b[sz].f = (uintptr_t)fnc;
     b->b[sz].C3 = N?0xC2:0xC3;
     b->b[sz].N = N;
-    b->b[sz].name = name/*?name:default_bridge*/;
+    b->b[sz].func = fnc2?1:0;
+    b->b[sz].name_or_func = fnc2?(void*)name:fnc2;
 
     return (uintptr_t)&b->b[sz].CC;
 }
 
+uintptr_t AddBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char* name)
+{
+    return AddBridge2(bridge, w, fnc, NULL, N, name);
+}
+
 uintptr_t CheckBridged(bridge_t* bridge, void* fnc)
 {
     // check if function alread have a bridge (the function wrapper will not be tested)
@@ -144,6 +147,16 @@ uintptr_t CheckBridged(bridge_t* bridge, void* fnc)
     return kh_value(bridge->bridgemap, k);
 }
 
+uintptr_t CheckBridged2(bridge_t* bridge, void* fnc, void* fnc2)
+{
+    // check if function alread have a bridge (the function wrapper will not be tested)
+    khint128_t key = (uintptr_t)fnc | (khint128_t)((uintptr_t)fnc2)<<64;
+    khint_t k = kh_get(bridgemap, bridge->bridgemap, key);
+    if(k==kh_end(bridge->bridgemap))
+        return 0;
+    return kh_value(bridge->bridgemap, k);
+}
+
 uintptr_t AddCheckBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char* name)
 {
     if(!fnc && w)
@@ -154,6 +167,16 @@ uintptr_t AddCheckBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const
     return ret;
 }
 
+uintptr_t AddCheckBridge2(bridge_t* bridge, wrapper_t w, void* fnc, void* fnc2, int N, const char* name)
+{
+    if(!fnc && w)
+        return 0;
+    uintptr_t ret = CheckBridged2(bridge, fnc, fnc2);
+    if(!ret)
+        ret = AddBridge2(bridge, w, fnc, fnc2, N, name);
+    return ret;
+}
+
 uintptr_t AddAutomaticBridge(bridge_t* bridge, wrapper_t w, void* fnc, int N, const char* name)
 {
     if(!fnc)
@@ -260,8 +283,32 @@ const char* getBridgeName(void* addr)
     if (one->C3 == 0xC3 && IsBridgeSignature(one->S, one->C)) {
         if(one->w==NULL)
             return "ExitEmulation";
-        else
-            return one->name;
+        else {
+            if(one->func)
+                return GetNativeName(one->name_or_func);
+            else
+                return one->name_or_func;
+        }
+    }
+    return NULL;
+}
+
+const char* getBridgeFunc2(void* addr)
+{
+    if(!memExist((uintptr_t)addr))
+        return NULL;
+    if(!(getProtection((uintptr_t)addr)&PROT_READ))
+        return NULL;
+    onebridge_t* one = (onebridge_t*)(((uintptr_t)addr&~(sizeof(onebridge_t)-1)));   // align to start of bridge
+    if (one->C3 == 0xC3 && IsBridgeSignature(one->S, one->C)) {
+        if(one->w==NULL)
+            return NULL;
+        else {
+            if(one->func)
+                return one->name_or_func;
+            else
+                return NULL;
+        }
     }
     return NULL;
 }

src/tools/bridge_private.h

@@ -14,7 +14,8 @@ typedef union onebridge_s {
     uintptr_t f;    // the function for the wrapper
     uint8_t C3;     // C2 or C3 ret
     uint16_t N;     // N in case of C2 ret
-    const char* name;   // name of the function bridged
+    uint8_t func;   // 1 if name_or_func is actualy a function (so no name in that case)
+    void* name_or_func;   // name of the function bridged
     };
     struct {
     uint8_t B8;     // B8 00 11 22 33 mov eax, num