Archive. Posts from 2004 to 2016, kept as they were written. My current blog is at dariuszparys.com.

Ich experimentiere momentan ein wenig mit dem Hosting der Common Language Runtime. Dazu habe ich mir Steven Pratschner's Buch besorgt

Amazon.de: Customizing the Microsoft Visual Studio Common Language Runtime.: English Books: Steven Pratschner ISBN: 0735619883 ISBN-13: 9780735619883

(Witzigerweise ist der Titel bei Amazon.de falsch eingestellt, nebenbei, dieser Link ist ohne Empfehlungs-ID, ich verdiene also nichts daran)

Das Buch gibt einen guten Überblick über die Möglichkeiten zur Anpassung der CLR. Da mein Kollege Dirk vor kurzem eine Frage zur Code Access Security hatte versuchte ich die CLR zu hosten und dabei eine eigene Domain Policy zu verwenden.

Hierzu benötigt man zuerst ein HostControl COM Objekt welches der CLR mitteilt welche eigenen Anpassungen zu verwenden sind. In meinem Beispiel soll nur der AppDomainManager ersetzt werden. Hier die entsprechenden C++ Source Dateien:

#pragma once
class HostControl : public IHostControl
{
public:
    // IHostControl
    HRESULT STDMETHODCALLTYPE GetHostManager(
                                REFIID riid,
                                void **ppObject);

    HRESULT STDMETHODCALLTYPE SetAppDomainManager(
                                DWORD dwAppDomainID,
                                IUnknown *pUnkAppDomainManager);

    HRESULT STDMETHODCALLTYPE GetDomainNeutralAssemblies(
                                   ICLRAssemblyReferenceList **ppReferenceList);

    // IUnknown
    virtual HRESULT STDMETHODCALLTYPE    QueryInterface(const IID &iid, void **ppv);
    virtual ULONG STDMETHODCALLTYPE        AddRef();
    virtual ULONG STDMETHODCALLTYPE        Release();

    HostControl();
    virtual ~HostControl();

    IMyDomainManager *GetDomainManagerForDefaultDomain();

private:
    long refCount;
    IMyDomainManager                *defaultDomainManager;
};

MyHostControl.h

#include "stdafx.h"
#include "MyHostControl.h"

HostControl::HostControl()
{
    refCount=0;
    defaultDomainManager   = NULL;
}

HostControl::~HostControl()
{
    if (defaultDomainManager)
    {
        defaultDomainManager->Release();
    }
}

IMyDomainManager* HostControl::GetDomainManagerForDefaultDomain()
{
    if (defaultDomainManager)
    {
        defaultDomainManager->AddRef();
    }
    return defaultDomainManager;
}

//
// IHostControl
//
HRESULT STDMETHODCALLTYPE HostControl::GetHostManager(REFIID riid,void **ppv)
{
    return E_NOINTERFACE;
}

HRESULT STDMETHODCALLTYPE HostControl::GetDomainNeutralAssemblies(
                                   ICLRAssemblyReferenceList **ppReferenceList)
{
    return E_NOTIMPL;
}

HRESULT STDMETHODCALLTYPE HostControl::SetAppDomainManager(
                                            DWORD dwAppDomainID,
                                            IUnknown *pUnkAppDomainManager)
{
    HRESULT hr = S_OK;
    hr = pUnkAppDomainManager->QueryInterface(__uuidof(IMyDomainManager),
                                 (PVOID*) &defaultDomainManager);
    return hr;
}

//
// IUnknown
//
HRESULT STDMETHODCALLTYPE HostControl::QueryInterface(const IID &iid,void **ppv)
{
    if (!ppv) return E_POINTER;
    *ppv=this;
    AddRef();
    return S_OK;
}

ULONG STDMETHODCALLTYPE HostControl::AddRef()
{
    return InterlockedIncrement(&refCount);
}

ULONG STDMETHODCALLTYPE HostControl::Release()
{
    if(InterlockedDecrement(&refCount) == 0){
        delete this;
        return 0;
    }
    return refCount;
}

MyHostControl.cpp

Das HostControl Objekt kann die CLR beeinflussen indem es verschiedene eigene Manager Objekte injiziert um zum Beispiel den Assembly Lade-Mechanismus zu verändern oder ein eigenes Threading Konzept zu realisieren. Im obigen Code Beispiel wurden diese Anpassungsmöglichkeiten komplett weggelassen damit der Code überschaubar bleibt.

Das HostControl gibt nur einen Default AppDomain Manager zurück (Zeile 42 - 50), mehr nicht.

Der Hosting Code sieht folgendermaßen aus:

#include "stdafx.h"
#include "MyHostControl.h"

int _tmain(int argc, _TCHAR* argv[])
{
    HRESULT hr = S_OK;

    hr = CoInitialize( NULL );
    assert( SUCCEEDED( hr ) );

    ICLRRuntimeHost *clr = NULL;
    hr = CorBindToRuntimeEx(
        L"v2.0.50727",
        L"wks",
        NULL,
        CLSID_CLRRuntimeHost,
        IID_ICLRRuntimeHost,
        ( void** ) &clr );
    assert( SUCCEEDED( hr ) );

    HostControl* hostControl = new HostControl();
    hr = clr->SetHostControl( ( IHostControl* ) hostControl );
    assert( SUCCEEDED( hr ) );

    ICLRControl* clrControl = NULL;
    hr = clr->GetCLRControl( &clrControl );
    assert( SUCCEEDED( hr ) );

    hr = clrControl->SetAppDomainManagerType( L"MyRuntimeHost,
                        Version=2.0.0.0,
                        Culture=neutral,
                        PublicKeyToken=9a273431606e9be3",
                        L"MyRuntimeHost.MyDomainManager" );
    assert( SUCCEEDED( hr ) );

    hr = clr->Start();
    assert( SUCCEEDED( hr ) );

    IMyDomainManager* myDomainManager = hostControl->GetDomainManagerForDefaultDomain();
    assert( myDomainManager );

    hr = myDomainManager->Run( L"ConsoleApplication1", "ConsoleApplication1.Program" );
    assert( SUCCEEDED( hr ) );

    myDomainManager->Release();
    clrControl->Release();
    hostControl->Release();

    CoUninitialize();

    return 0;
}

Es wird die .NET 2.0 Runtime geladen, das Host Control gesetzt und danach die entsprechende Runtime gestartet. Ab Zeile 39 beginnt der eigentliche Teil der den Code in der Runtime ausführt. Der Lademechanismus befindet sich im eigenen Default Domain Manager welcher über das Interface IMyDomainManager angesprochen wird. Dort wird die Methode Run aufgerufen die eine Datei namens "ConsoleApplication1" durch Path-Probing sucht und dort den Typen "ConsoleApplication1.Program" instanziert. Die Instanzierungsmethode sieht man noch im folgenden MyDomainManager Source Code. Zur Vereinfachung wurden asserts() verwendet damit die Fehlerbehandlungsroutinen nicht zuviel Platz wegnehmen.

Das Domain Manager COM Objekt ist in C# implementiert. Neben der Basisklasse AppDomainManager die notwendig ist wird noch ein Custom Interface IMyDomainManager implementiert welches das eigentliche Starten eines Assemblies in dem eigenen CLR Host durchführt.

using System;
using System.Reflection;

namespace MyRuntimeHost
{
    public class MyDomainManager : AppDomainManager, IMyDomainManager
    {
        public override void InitializeNewDomain( AppDomainSetup appDomainInfo )
        {
            this.InitializationFlags =
                 AppDomainManagerInitializationOptions.RegisterWithHost;
        }

        public override System.Security.HostSecurityManager HostSecurityManager
        {
            get
            {
                return new MySecurityManager();
            }
        }

        #region IMyDomainManager Members
        public void Run( string assemblyName, string typeName )
        {
            try
            {
                Assembly asm = Assembly.Load( assemblyName );
                MethodInfo m = asm.EntryPoint;
                m.Invoke( null, new string[] { null } );
            }
            catch( Exception e )
            {
                Console.WriteLine( "Exception executing entry point: " + e.ToString() );
            }

        }
        #endregion
    }
}

Die Zeilen 27-29 versuchen im übergebenen Assembly die EntryPoint Methode aufzurufen.

MyDomainManager liefert dem eigenen Runtime Host einen selbstgeschriebenen HostSecurityManager namens MySecurityManager zurück. Dieser enthält die Domain Policy, sprich die eigentlichen Code Access Security Anweisungen für die verschiedenen Assemblies die in dem eigenen Host geladen und ausgeführt werden. Hier die Definition von MySecurityManager

using System;
using System.Security;
using System.Security.Permissions;
using System.Security.Policy;

namespace MyRuntimeHost
{
    public class MySecurityManager : HostSecurityManager
    {
        private static byte[] MicrosoftPublicKey =
        {
            0,  36,   0,   0,   4, 128,   0,   0, 148,   0,   0,   0,   6,   2,   0,
            0,   0,  36,   0,   0,  82,  83,  65,  49,   0,   4,   0,   0,   1,   0,
            1,   0,   7, 209, 250,  87, 196, 174, 217, 240, 163,  46, 132, 170,  15,
            174, 253,  13, 233, 232, 253, 106, 236, 143, 135, 251,   3, 118, 108,
            131,  76, 153, 146,  30, 178,  59, 231, 154, 217, 213, 220, 193, 221,
            154, 210,  54,  19,  33,   2, 144,  11, 114,  60, 249, 128, 149, 127,
            196, 225, 119,  16, 143, 198,   7, 119,  79,  41, 232,  50,  14, 146,
            234,   5, 236, 228, 232,  33, 192, 165, 239, 232, 241, 100,  92,  76,
            12, 147, 193, 171, 153,  40,  93,  98,  44, 170, 101,  44,  29, 250, 214,
            61, 116,  93, 111,  45, 229, 241, 126,  94, 175,  15, 196, 150,  61,  38,
            28, 138,  18,  67, 101,  24,  32, 109, 192, 147,  52,  77,  90, 210, 147
        };

        private static byte[] ECMAPublicKey =
        {
            0,   0,   0,   0,   0,   0,   0,   0,   4,
            0,   0,   0,   0,   0,   0,   0
        };

        private static byte[] MyHostPublicKey =
        {
            0,  36,   0,   0,   4, 128,   0,   0, 148,   0,   0,   0,   6,   2,   0,
            0,   0,  36,   0,   0,  82,  83,  65,  49,   0,   4,   0,   0,   1,   0,
            1,   0,  87, 176, 125, 174, 147, 128, 206, 155, 234, 177, 235,  82, 189,
            90, 240, 123, 136,  87, 197, 175,  77, 218,  82,  87,  30, 171,  71,  64,
            181, 240, 205,  50,  27,   0, 241, 210, 232, 233,  79, 137, 189, 218,
            128,  16, 124,  57,  74, 241,  86, 187, 189, 136,  35, 162, 166,   0,
            176, 234, 178,  86, 146, 209, 183, 136, 179, 240,  92, 165, 150, 117,
            78, 216, 180, 153, 222, 179, 192, 106, 133, 255,  68, 106,   5, 119,  98,
            185, 201, 184, 208, 223, 180, 133, 224,  52,  74, 254, 128, 115, 234,
            208,  79, 152,  10, 255,  39, 241, 106,  72, 212, 234, 167, 137, 214,
            213, 243, 203, 177,  50,  47, 101, 213, 100, 218, 151, 189, 248,  25, 191
        };

        public override HostSecurityManagerOptions Flags
        {
            get
            {
                return HostSecurityManagerOptions.HostPolicyLevel;
            }
        }

        public override PolicyLevel DomainPolicy
        {
            get
            {
                PolicyLevel policy = PolicyLevel.CreateAppDomainLevel();

                policy.RootCodeGroup.PolicyStatement = new PolicyStatement(
                        new PermissionSet( PermissionState.None ) );

                UnionCodeGroup microsoftKeyCodeGroup =
                    new UnionCodeGroup(
                         new StrongNameMembershipCondition( new
                                StrongNamePublicKeyBlob( MicrosoftPublicKey ),
                                null,
                                null ),
                    new PolicyStatement( new PermissionSet(
                                            PermissionState.Unrestricted ) ) );

                policy.RootCodeGroup.AddChild( microsoftKeyCodeGroup );

                UnionCodeGroup ecmaKeyCodeGroup =
                    new UnionCodeGroup(
                        new StrongNameMembershipCondition( new
                            StrongNamePublicKeyBlob( ECMAPublicKey ), null, null ),
                          new PolicyStatement(
                            new PermissionSet( PermissionState.Unrestricted ) ) );

                policy.RootCodeGroup.AddChild( ecmaKeyCodeGroup );

                UnionCodeGroup hostKeyCG =
                    new UnionCodeGroup(
                    new StrongNameMembershipCondition( new
                    StrongNamePublicKeyBlob( MyHostPublicKey ), null, null ),
                    new PolicyStatement( new PermissionSet( PermissionState.Unrestricted ) ) );

                policy.RootCodeGroup.AddChild( hostKeyCG );

                PermissionSet pSet = new PermissionSet( PermissionState.None );
                pSet.AddPermission( new SecurityPermission( SecurityPermissionFlag.Execution ) );
                pSet.AddPermission( new UIPermission( PermissionState.Unrestricted ) );

                UnionCodeGroup anythingElseCodeGroup =
                    new UnionCodeGroup(
                        new ZoneMembershipCondition( SecurityZone.MyComputer ),
                        new PolicyStatement( pSet ) );

                policy.RootCodeGroup.AddChild( anythingElseCodeGroup );

                return policy;
            }
        }
    }
}

Im Property DomainPolicy werden zuerst alle Rechte genommen. Danach werden die Rechte für Microsoft und ECMA Key Assemblies wieder zur Verfügung gestellt. Zum Schluß in der Zeile 95 allen restlichen Assemblies nur Ausführungs- und UI-Rechte gegeben. Damit ist der eigene Host fertig konfiguriert und Betriebsbereit.

Die Anwendung die im Host geladen wird ist einfach nur eine Konsolenanwendung die ein Hello World rausschreibt. Versucht man zum Beispiel aus dieser Anwendung heraus eine Datei zu schreiben so bekommt man eine entsprechende Security Exception.

shot1

Selbst der Versuch den Stackwalk zu umgehen hilft in diesem Fall nicht um sich das Recht zum Beispiel naträglich geben zu wollen.

Wer Interesse hat sich mit dem Thema näher zu beschäftigen dem kann ich nur oben genanntes Buch empfehlen. Es geht in die entsprechende Detailtiefe die benötigt wird um die CLR selbst zu hosten.

Technorati Tags: C++/CLI, Common Language Runtime, C#