Changeset 2865

Timestamp:

Sep 3, 2016, 12:17:13 AM (9 years ago)

Author:

bird

Message:

fixed exception in c1xx.dll/msvcrt/memcpy.

Location:

trunk/src/kWorker

Files:

• kWorker.c (modified) (14 diffs)
• tst-1-c1xx-xcpt.cpp (added)

trunk/src/kWorker/kWorker.c

@@ -164 +164 @@
             /** The state. */
             KWMODSTATE          enmState;
+#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
+            /** The number of entries in the table. */
+            KU32                cFunctions;
+            /** The function table address (in the copy). */
+            PRUNTIME_FUNCTION   paFunctions;
+            /** Set if we've already registered a function table already. */
+            KBOOL               fRegisteredFunctionTable;
+#endif
+            /** Set if we share memory with other executables. */
+            KBOOL               fUseLdBuf;
             /** Number of imported modules. */
             KSIZE               cImpMods;
@@ -431 +441 @@
 static KWSANDBOX    g_Sandbox;
 
+/** The module currently occupying g_abDefLdBuf. */
+static PKWMODULE    g_pModInLdBuf = NULL;
+
 /** Module hash table. */
 static PKWMODULE    g_apModules[127];
@@ -1219 +1232 @@
                     pMod->pLdrMod       = pLdrMod;
                     pMod->u.Manual.cImpMods = (KU32)cImports;
+                    pMod->u.Manual.fUseLdBuf = K_FALSE;
+#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
+                    pMod->u.Manual.fRegisteredFunctionTable = K_FALSE;
+#endif
                     pMod->pszPath       = (char *)kHlpMemCopy(&pMod->u.Manual.apImpMods[cImports + 1], pszPath, cbPath);
                     pMod->pwszPath      = (wchar_t *)(pMod->pszPath + cbPath + (cbPath & 1));
@@ -1231 +1248 @@
                     pMod->u.Manual.cbImage = kLdrModSize(pLdrMod);
                     if (   !fFixed
+                        || pLdrMod->enmType != KLDRTYPE_EXECUTABLE_FIXED /* only allow fixed executables */
                         || (KUPTR)pMod->u.Manual.pvLoad - (KUPTR)g_abDefLdBuf >= sizeof(g_abDefLdBuf)
                         || sizeof(g_abDefLdBuf) - (KUPTR)pMod->u.Manual.pvLoad - (KUPTR)g_abDefLdBuf < pMod->u.Manual.cbImage)
                         rc = kHlpPageAlloc(&pMod->u.Manual.pvLoad, pMod->u.Manual.cbImage, KPROT_EXECUTE_READWRITE, fFixed);
+                    else
+                        pMod->u.Manual.fUseLdBuf = K_TRUE;
                     if (rc == 0)
                     {
@@ -1271 +1291 @@
                                 if (rc == 0)
                                 {
+#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
+                                    /*
+                                     * Find the function table.  No validation here because the
+                                     * loader did that already, right...
+                                     */
+                                    KU8                        *pbImg = (KU8 *)pMod->u.Manual.pvCopy;
+                                    IMAGE_NT_HEADERS const     *pNtHdrs;
+                                    IMAGE_DATA_DIRECTORY const *pXcptDir;
+                                    if (((PIMAGE_DOS_HEADER)pbImg)->e_magic == IMAGE_DOS_SIGNATURE)
+                                        pNtHdrs = (PIMAGE_NT_HEADERS)&pbImg[((PIMAGE_DOS_HEADER)pbImg)->e_lfanew];
+                                    else
+                                        pNtHdrs = (PIMAGE_NT_HEADERS)pbImg;
+                                    pXcptDir = &pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION];
+                                    kHlpAssert(pNtHdrs->Signature == IMAGE_NT_SIGNATURE);
+                                    if (pXcptDir->Size > 0)
+                                    {
+                                        pMod->u.Manual.cFunctions  = pXcptDir->Size / sizeof(pMod->u.Manual.paFunctions[0]);
+                                        kHlpAssert(   pMod->u.Manual.cFunctions * sizeof(pMod->u.Manual.paFunctions[0])
+                                                   == pXcptDir->Size);
+                                        pMod->u.Manual.paFunctions = (PRUNTIME_FUNCTION)&pbImg[pXcptDir->VirtualAddress];
+                                    }
+                                    else
+                                    {
+                                        pMod->u.Manual.cFunctions  = 0;
+                                        pMod->u.Manual.paFunctions = NULL;
+                                    }
+#endif
+
+                                    /*
+                                     * Final finish.
+                                     */
                                     pMod->u.Manual.pvBits = pMod->u.Manual.pvCopy;
                                     pMod->u.Manual.enmState = KWMODSTATE_NEEDS_BITS;
@@ -1577 +1628 @@
         if (pMod->u.Manual.enmState == KWMODSTATE_NEEDS_BITS)
         {
+            if (pMod->u.Manual.fUseLdBuf)
+            {
+#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
+                if (g_pModInLdBuf != NULL && g_pModInLdBuf != pMod && pMod->u.Manual.fRegisteredFunctionTable)
+                {
+                    BOOLEAN fRc = RtlDeleteFunctionTable(pMod->u.Manual.paFunctions);
+                    kHlpAssert(fRc); K_NOREF(fRc);
+                }
+#endif
+                g_pModInLdBuf = pMod;
+            }
+
             kHlpMemCopy(pMod->u.Manual.pvLoad, pMod->u.Manual.pvCopy, pMod->u.Manual.cbImage);
             pMod->u.Manual.enmState = KWMODSTATE_NEEDS_INIT;
         }
+
+#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
+        /* Need to register function table? */
+        if (   !pMod->u.Manual.fRegisteredFunctionTable
+            && pMod->u.Manual.cFunctions > 0)
+        {
+            pMod->u.Manual.fRegisteredFunctionTable = RtlAddFunctionTable(pMod->u.Manual.paFunctions,
+                                                                          pMod->u.Manual.cFunctions,
+                                                                          (KUPTR)pMod->u.Manual.pvLoad) != FALSE;
+            kHlpAssert(pMod->u.Manual.fRegisteredFunctionTable);
+        }
+#endif
 
         if (pMod->u.Manual.enmState == KWMODSTATE_NEEDS_INIT)
@@ -4066 +4141 @@
 
 
+/*
+ *
+ * Misc function only intercepted while debugging.
+ * Misc function only intercepted while debugging.
+ * Misc function only intercepted while debugging.
+ *
+ */
+
+#ifndef NDEBUG
+
+/** CRT - memcpy   */
+static void * __cdecl kwSandbox_msvcrt_memcpy(void *pvDst, void const *pvSrc, size_t cb)
+{
+    KU8 const *pbSrc = (KU8 const *)pvSrc;
+    KU8       *pbDst = (KU8 *)pvDst;
+    KSIZE      cbLeft = cb;
+    while (cbLeft-- > 0)
+        *pbDst++ = *pbSrc++;
+    return pvDst;
+}
+
+#endif /* NDEBUG */
+
+
+
 /**
  * Functions that needs replacing for sandboxed execution.
@@ -4172 +4272 @@
     { TUPLE("__p__environ"),                NULL,       (KUPTR)kwSandbox_msvcrt___p__environ },
     { TUPLE("__p__wenviron"),               NULL,       (KUPTR)kwSandbox_msvcrt___p__wenviron },
+
+#ifndef NDEBUG
+    { TUPLE("memcpy"),                      NULL,       (KUPTR)kwSandbox_msvcrt_memcpy },
+#endif
 };
 /** Number of entries in g_aReplacements. */
@@ -4455 +4559 @@
 
 
-static int kwSandboxExec(PKWTOOL pTool, KU32 cArgs, const char **papszArgs, KBOOL fWatcomBrainDamange,
+static int kwSandboxExec(PKWSANDBOX pSandbox, PKWTOOL pTool, KU32 cArgs, const char **papszArgs, KBOOL fWatcomBrainDamange,
                          KU32 cEnvVars, const char **papszEnvVars)
 {
@@ -4521 +4625 @@
     return rcExit;
 }
-
-
-#if 0
-static int kwExecCmdLine(const char *pszExe, const char *pszCmdLine)
-{
-    int rc;
-    PKWTOOL pTool = kwToolLookup(pszExe);
-    if (pTool)
-    {
-        int rc;
-        int rcExitCode;
-        switch (pTool->enmType)
-        {
-            case KWTOOLTYPE_SANDBOXED:
-                KW_LOG(("Sandboxing tool %s\n", pTool->pszPath));
-                rc = kwSandboxExec(pTool, pszCmdLine, &rcExitCode);
-                break;
-
-            case KWTOOLTYPE_WATCOM:
-                KW_LOG(("TODO: Watcom style tool %s\n", pTool->pszPath));
-                rc = rcExitCode = 2;
-                break;
-
-            case KWTOOLTYPE_EXEC:
-                KW_LOG(("TODO: Direct exec tool %s\n", pTool->pszPath));
-                rc = rcExitCode = 2;
-                break;
-
-            default:
-                kHlpAssertFailed();
-                rc = rcExitCode = 2;
-                break;
-        }
-        KW_LOG(("rcExitCode=%d (rc=%d)\n", rcExitCode, rc));
-    }
-    else
-        rc = 1;
-    return rc;
-}
-#endif
 
 
@@ -4620 +4684 @@
                 {
                     KW_LOG(("Sandboxing tool %s\n", pTool->pszPath));
-                    rcExit = kwSandboxExec(pTool, cArgs, papszArgs, fWatcomBrainDamange, cEnvVars, papszEnvVars);
+                    rcExit = kwSandboxExec(&g_Sandbox, pTool, cArgs, papszArgs, fWatcomBrainDamange, cEnvVars, papszEnvVars);
                 }
                 else
@@ -4950 +5014 @@
 }
 
-
+#if 1
 
 int main(int argc, char **argv)
 {
-#if 1
     KSIZE   cbMsgBuf = 0;
     KU8    *pbMsgBuf = NULL;
@@ -5081 +5144 @@
         return rc > 0 ? 0 : 1;
     }
+}
 
 #else
+
+static int kwExecCmdLine(const char *pszExe, const char *pszCmdLine)
+{
+    int rc;
+    PKWTOOL pTool = kwToolLookup(pszExe);
+    if (pTool)
+    {
+        int rcExitCode;
+        switch (pTool->enmType)
+        {
+            case KWTOOLTYPE_SANDBOXED:
+                KW_LOG(("Sandboxing tool %s\n", pTool->pszPath));
+                rc = kwSandboxExec(&g_Sandbox, pTool, pszCmdLine, &rcExitCode);
+                break;
+            default:
+                kHlpAssertFailed();
+                KW_LOG(("TODO: Direct exec tool %s\n", pTool->pszPath));
+                rc = rcExitCode = 2;
+                break;
+        }
+        KW_LOG(("rcExitCode=%d (rc=%d)\n", rcExitCode, rc));
+    }
+    else
+        rc = 1;
+    return rc;
+}
+
+int main(int argc, char **argv)
+{
     int rc = 0;
     int i;
@@ -5108 +5201 @@
 # endif
     return rc;
+}
 
 #endif
-}
-
+