如何用非托管Shim解决托管WinForms进程COM+安全上下文设为None的问题

Great question—this is a common pain point when dealing with COM+ security contexts in .NET, since the CLR takes over COM initialization early on. Let's break this down step by step.

The core idea is to create a small unmanaged program that first configures CoInitializeSecurity with the None security context, then loads and executes your managed WinForms application. Here's a straightforward C++ implementation using the CLR Hosting API (this is reliable and avoids messy interop hacks):

Step 1: Basic Shim Structure #

#include <windows.h>
#include <metahost.h>
#pragma comment(lib, "mscoree.lib")

// Forward declaration of our managed entry point caller
HRESULT CallManagedMain(ICLRRuntimeHost* pRuntimeHost);

int main()
{
    HRESULT hr;

    // First, set up COM security with "None" context
    hr = CoInitializeSecurity(
        NULL,                          // Security descriptor (NULL = default)
        -1,                            // Number of authentication services (use default)
        NULL,                          // Authentication services array
        NULL,                          // Reserved
        RPC_C_AUTHN_LEVEL_NONE,        // Authentication level = None
        RPC_C_IMP_LEVEL_IMPERSONATE,   // Impersonation level
        NULL,                          // Authorization list
        EOAC_NONE,                     // Additional capabilities (none)
        NULL                           // Reserved
    );

    if (FAILED(hr))
    {
        MessageBox(NULL, L"Failed to initialize COM security", L"Error", MB_ICONERROR);
        return 1;
    }

    // Now load the CLR and execute the managed application
    ICLRMetaHost* pMetaHost = NULL;
    ICLRRuntimeInfo* pRuntimeInfo = NULL;
    ICLRRuntimeHost* pRuntimeHost = NULL;

    // Get the CLR meta host
    hr = CLRCreateInstance(CLSID_CLRMetaHost, IID_ICLRMetaHost, (LPVOID*)&pMetaHost);
    if (SUCCEEDED(hr))
    {
        // Get runtime info for .NET Framework 4.0 (adjust version as needed)
        hr = pMetaHost->GetRuntime(L"v4.0.30319", IID_ICLRRuntimeInfo, (LPVOID*)&pRuntimeInfo);
        if (SUCCEEDED(hr))
        {
            // Check if the runtime is loadable
            BOOL fLoadable = FALSE;
            hr = pRuntimeInfo->IsLoadable(&fLoadable);
            if (SUCCEEDED(hr) && fLoadable)
            {
                // Get the runtime host
                hr = pRuntimeInfo->GetInterface(CLSID_CLRRuntimeHost, IID_ICLRRuntimeHost, (LPVOID*)&pRuntimeHost);
                if (SUCCEEDED(hr))
                {
                    // Start the CLR
                    hr = pRuntimeHost->Start();
                    if (SUCCEEDED(hr))
                    {
                        // Call the managed application's Main method
                        hr = CallManagedMain(pRuntimeHost);
                        // Stop the CLR if needed
                        pRuntimeHost->Stop();
                    }
                    pRuntimeHost->Release();
                }
            }
            pRuntimeInfo->Release();
        }
        pMetaHost->Release();
    }

    CoUninitialize();
    return SUCCEEDED(hr) ? 0 : 1;
}

// Helper to call the managed Main method
HRESULT CallManagedMain(ICLRRuntimeHost* pRuntimeHost)
{
    // Replace with your managed assembly's fully qualified name and Main method details
    LPCWSTR szAssemblyPath = L"C:\\Path\\To\\YourWinFormsApp.exe";
    LPCWSTR szTypeName = L"YourWinFormsApp.Program";
    LPCWSTR szMethodName = L"Main";

    DWORD dwRetCode = 0;
    return pRuntimeHost->ExecuteInDefaultAppDomain(
        szAssemblyPath,
        szTypeName,
        szMethodName,
        NULL,  // No arguments (adjust if your Main takes args)
        &dwRetCode
    );
}

Key Notes on the Shim: #

• CoInitializeSecurity Parameters: We use RPC_C_AUTHN_LEVEL_NONE to disable COM authentication, which matches the "None" security context you need. Adjust other parameters if your scenario requires specific impersonation levels, but this is the minimal setup for your use case.
• CLR Version: The example targets .NET Framework 4.0—update the version string (v4.0.30319) to match your application's .NET version.
• Assembly Path: Replace the szAssemblyPath, szTypeName, and szMethodName with your actual WinForms application's details.

The critical reason here is timing of CoInitializeSecurity calls:

• The CLR automatically calls CoInitializeSecurity during its initialization process (before your managed Main method runs). Once this happens, you can't override the security context—Windows only allows CoInitializeSecurity to be called once per process.
• By using the unmanaged shim, you're setting the COM security context before the CLR is loaded or initialized. This means when your managed code runs, it inherits the pre-configured security context from the shim.
• The "activate and pass the interface" part (if you use a COM-registered managed component instead of the CLR host) is another approach: instead of loading the entire managed app via the CLR host, you could register your managed component as a COM object, create an instance of it from the shim (after setting security), and pass that instance to your managed code. This ensures the COM object is created under the correct security context, which your managed app can then use to interact with COM+ servers.

Either way, the core goal is to ensure the COM security context is set before the CLR takes over COM initialization.

内容的提问来源于stack exchange，提问作者John