internal DeferrableContent(Stream stream, Baml2006SchemaContext schemaContext, IXamlObjectWriterFactory objectWriterFactory, IServiceProvider serviceProvider, object rootObject) { ObjectWriterParentSettings = objectWriterFactory.GetParentSettings(); if (ObjectWriterParentSettings.AccessLevel != null) { XamlLoadPermission loadPermission = new XamlLoadPermission(ObjectWriterParentSettings.AccessLevel); loadPermission.Demand(); this.LoadPermission = loadPermission; } bool assemblyTargetsFramework2 = false; // The local assembly can be null if it is not specified in the XamlReaderSettings. if (schemaContext.LocalAssembly != null) { assemblyTargetsFramework2 = schemaContext.LocalAssembly.ImageRuntimeVersion.StartsWith("v2", StringComparison.Ordinal); } // There is an incompatibility between the framework versions 3 and 4 regarding MarkupExtension resources. // In version 3, MarkupExtension resources did not provide values when looked up. // In version 4, they do. if (assemblyTargetsFramework2) { ObjectWriterParentSettings.SkipProvideValueOnRoot = true; } this.Stream = stream; this.SchemaContext = schemaContext; this.ObjectWriterFactory = objectWriterFactory; this.ServiceProvider = serviceProvider; this.RootObject = rootObject; }
internal DeferrableContent(Stream stream, Baml2006SchemaContext schemaContext, IXamlObjectWriterFactory objectWriterFactory, IServiceProvider serviceProvider, object rootObject) { this.ObjectWriterParentSettings = objectWriterFactory.GetParentSettings(); if (this.ObjectWriterParentSettings.AccessLevel != null) { XamlLoadPermission xamlLoadPermission = new XamlLoadPermission(this.ObjectWriterParentSettings.AccessLevel); xamlLoadPermission.Demand(); this.LoadPermission = xamlLoadPermission; } bool flag = false; if (schemaContext.LocalAssembly != null) { flag = schemaContext.LocalAssembly.ImageRuntimeVersion.StartsWith("v2", StringComparison.Ordinal); } if (flag) { this.ObjectWriterParentSettings.SkipProvideValueOnRoot = true; } this.Stream = stream; this.SchemaContext = schemaContext; this.ObjectWriterFactory = objectWriterFactory; this.ServiceProvider = serviceProvider; this.RootObject = rootObject; }
private void VerifyInvariants(XamlLoadPermission original, bool isUnrestricted = false) { Assert.AreEqual(original, original); Assert.AreEqual(isUnrestricted, original.IsUnrestricted()); XamlLoadPermission copy = (XamlLoadPermission)original.Copy(); Assert.AreEqual(original, copy); Assert.AreEqual(original.IsUnrestricted(), copy.IsUnrestricted()); Assert.IsTrue(original.IsSubsetOf(copy)); Assert.IsTrue(copy.IsSubsetOf(original)); XamlLoadPermission xmlCopy = new XamlLoadPermission(PermissionState.None); xmlCopy.FromXml(original.ToXml()); Assert.AreEqual(original, xmlCopy); var intersect = (XamlLoadPermission)original.Intersect(copy); Assert.AreEqual(original, intersect); var union = (XamlLoadPermission)original.Union(copy); Assert.AreEqual(original, union); intersect = (XamlLoadPermission)original.Intersect(s_EmptyPerm); Assert.AreEqual(s_EmptyPerm, intersect); union = (XamlLoadPermission)original.Union(s_EmptyPerm); Assert.AreEqual(original, union); intersect = (XamlLoadPermission)original.Intersect(s_UnrestrictedPerm); Assert.AreEqual(original, intersect); union = (XamlLoadPermission)original.Union(s_UnrestrictedPerm); Assert.AreEqual(s_UnrestrictedPerm, union); }
internal DynamicMethodRuntime(XamlRuntimeSettings settings, XamlSchemaContext schemaContext, XamlAccessLevel accessLevel) : base(settings, true) { this._schemaContext = schemaContext; this._xamlLoadPermission = new XamlLoadPermission(accessLevel); this._localAssembly = Assembly.Load(accessLevel.AssemblyAccessToAssemblyName); if (accessLevel.PrivateAccessToTypeName != null) { this._localType = this._localAssembly.GetType(accessLevel.PrivateAccessToTypeName, true); } }
public void SingleAssembly() { XamlAccessLevel assemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly); XamlLoadPermission assemblyPerm = new XamlLoadPermission(assemblyAccess); VerifyInvariants(assemblyPerm); XamlLoadPermission testPerm, intersect, union; // Identical permission XamlAccessLevel sameAssemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly); testPerm = new XamlLoadPermission(sameAssemblyAccess); VerifyInvariants(testPerm); Assert.AreEqual(assemblyPerm, testPerm); Assert.IsTrue(testPerm.IsSubsetOf(assemblyPerm)); Assert.IsTrue(assemblyPerm.IsSubsetOf(testPerm)); intersect = (XamlLoadPermission)testPerm.Intersect(assemblyPerm); Assert.AreEqual(assemblyPerm, intersect); union = (XamlLoadPermission)testPerm.Union(assemblyPerm); Assert.AreEqual(assemblyPerm, union); Assert.IsTrue(testPerm.Includes(sameAssemblyAccess)); // Type permission to same assembly XamlAccessLevel typeAccess = XamlAccessLevel.PrivateAccessTo(typeof(LoadPermissionTests)); testPerm = new XamlLoadPermission(typeAccess); VerifyInvariants(testPerm); Assert.AreNotEqual(assemblyPerm, testPerm); Assert.IsFalse(testPerm.IsSubsetOf(assemblyPerm)); Assert.IsTrue(assemblyPerm.IsSubsetOf(testPerm)); intersect = (XamlLoadPermission)testPerm.Intersect(assemblyPerm); Assert.AreEqual(assemblyPerm, intersect); union = (XamlLoadPermission)testPerm.Union(assemblyPerm); Assert.AreEqual(testPerm, union); Assert.IsTrue(testPerm.Includes(sameAssemblyAccess)); Assert.IsTrue(testPerm.Includes(typeAccess)); // Assembly permission on different assembly XamlAccessLevel diffAssemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(string).Assembly); testPerm = new XamlLoadPermission(diffAssemblyAccess); VerifyInvariants(testPerm); Assert.AreNotEqual(assemblyPerm, testPerm); Assert.IsFalse(testPerm.IsSubsetOf(assemblyPerm)); Assert.IsFalse(assemblyPerm.IsSubsetOf(testPerm)); intersect = (XamlLoadPermission)testPerm.Intersect(assemblyPerm); Assert.AreEqual(s_EmptyPerm, intersect); union = (XamlLoadPermission)testPerm.Union(assemblyPerm); Assert.IsTrue(testPerm.IsSubsetOf(union)); Assert.IsTrue(assemblyPerm.IsSubsetOf(union)); Assert.IsFalse(testPerm.Includes(sameAssemblyAccess)); Assert.IsFalse(testPerm.Includes(typeAccess)); }
public void Empty() { VerifyInvariants(s_EmptyPerm); XamlLoadPermission emptyPerm = new XamlLoadPermission(new XamlAccessLevel[0]); VerifyInvariants(emptyPerm); Assert.AreEqual(s_EmptyPerm, emptyPerm); XamlAccessLevel assemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly); Assert.IsFalse(s_EmptyPerm.Includes(assemblyAccess)); }
internal DynamicMethodRuntime(XamlRuntimeSettings settings, XamlSchemaContext schemaContext, XamlAccessLevel accessLevel) : base(settings, true /*isWriter*/) { Debug.Assert(schemaContext != null); Debug.Assert(accessLevel != null); _schemaContext = schemaContext; _xamlLoadPermission = new XamlLoadPermission(accessLevel); _localAssembly = Assembly.Load(accessLevel.AssemblyAccessToAssemblyName); if (accessLevel.PrivateAccessToTypeName != null) { _localType = _localAssembly.GetType(accessLevel.PrivateAccessToTypeName, true /*throwOnError*/); } }
static void InitializeComponentFromXamlResource(Type componentType, string resource, object componentInstance, XamlSchemaContext schemaContext) { Stream initializeXaml = componentType.Assembly.GetManifestResourceStream(resource); XmlReader xmlReader = null; XamlReader reader = null; XamlObjectWriter objectWriter = null; try { xmlReader = XmlReader.Create(initializeXaml, new XmlReaderSettings { XmlResolver = null }); XamlXmlReaderSettings readerSettings = new XamlXmlReaderSettings(); readerSettings.LocalAssembly = componentType.Assembly; readerSettings.AllowProtectedMembersOnRoot = true; reader = new XamlXmlReader(xmlReader, schemaContext, readerSettings); XamlObjectWriterSettings writerSettings = new XamlObjectWriterSettings(); writerSettings.RootObjectInstance = componentInstance; writerSettings.AccessLevel = XamlAccessLevel.PrivateAccessTo(componentType); objectWriter = new XamlObjectWriter(schemaContext, writerSettings); // We need the XamlLoadPermission for the assembly we are dealing with. XamlLoadPermission perm = new XamlLoadPermission(XamlAccessLevel.PrivateAccessTo(componentType)); perm.Assert(); try { XamlServices.Transform(reader, objectWriter); } finally { CodeAccessPermission.RevertAssert(); } } finally { if ((xmlReader != null)) { ((IDisposable)(xmlReader)).Dispose(); } if ((reader != null)) { ((IDisposable)(reader)).Dispose(); } if ((objectWriter != null)) { ((IDisposable)(objectWriter)).Dispose(); } } }
public static void XamlLoadPermissionCallMethods() { XamlAccessLevel accessLevel = XamlAccessLevel.AssemblyAccessTo(Assembly.GetExecutingAssembly().GetName()); XamlLoadPermission xp = new XamlLoadPermission(accessLevel); XamlLoadPermission xp2 = new XamlLoadPermission(PermissionState.Unrestricted); XamlLoadPermission xp3 = new XamlLoadPermission(Array.Empty <XamlAccessLevel>()); bool testbool = xp.IsUnrestricted(); IPermission ip = xp.Copy(); IPermission ip2 = xp.Intersect(ip); IPermission ip3 = xp.Union(ip); testbool = xp.IsSubsetOf(ip); testbool = xp.Equals(new object()); testbool = xp.Includes(accessLevel); int hash = xp.GetHashCode(); SecurityElement se = new SecurityElement(""); xp.FromXml(se); se = xp.ToXml(); }
//[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 internal static object LoadBaml( Stream stream, ParserContext parserContext, object parent, bool closeStream) { object root = null; #if DEBUG_CLR_MEM bool clrTracingEnabled = false; // Use local pass variable to correctly log nested parses. int pass = 0; if (CLRProfilerControl.ProcessIsUnderCLRProfiler && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { clrTracingEnabled = true; pass = ++_CLRBamlPass; CLRProfilerControl.CLRLogWriteLine("Begin_BamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Event.WClientParseBamlBegin, parserContext.BaseUri); if (TraceMarkup.IsEnabled) { TraceMarkup.Trace(TraceEventType.Start, TraceMarkup.Load); } try { // // If the stream contains info about the Assembly that created it, // set StreamCreatedAssembly from the stream instance. // IStreamInfo streamInfo = stream as IStreamInfo; if (streamInfo != null) { parserContext.StreamCreatedAssembly = streamInfo.Assembly; } Baml2006ReaderSettings readerSettings = XamlReader.CreateBamlReaderSettings(); readerSettings.BaseUri = parserContext.BaseUri; readerSettings.LocalAssembly = streamInfo.Assembly; // We do not set OwnsStream = true so the Baml2006Reader will not close the stream. // Calling code is responsible for disposing the stream if (readerSettings.BaseUri == null || String.IsNullOrEmpty(readerSettings.BaseUri.ToString())) { readerSettings.BaseUri = BaseUriHelper.PackAppBaseUri; } var reader = new Baml2006ReaderInternal(stream, new Baml2006SchemaContext(readerSettings.LocalAssembly), readerSettings, parent); // We don't actually use the GeneratedInternalTypeHelper any more. // But for v3 compat, don't allow loading of internals in PT unless there is one. Type internalTypeHelper = null; if (streamInfo.Assembly != null) { try { internalTypeHelper = XamlTypeMapper.GetInternalTypeHelperTypeFromAssembly(parserContext); } // This can perform attribute reflection which will fail if the assembly has unresolvable // attributes. If that happens, just assume there is no helper. catch (Exception e) { if (MS.Internal.CriticalExceptions.IsCriticalException(e)) { throw; } } } if (internalTypeHelper != null) { XamlAccessLevel accessLevel = XamlAccessLevel.AssemblyAccessTo(streamInfo.Assembly); XamlLoadPermission loadPermission = new XamlLoadPermission(accessLevel); loadPermission.Assert(); try { root = WpfXamlLoader.LoadBaml(reader, parserContext.SkipJournaledProperties, parent, accessLevel, parserContext.BaseUri); } finally { CodeAccessPermission.RevertAssert(); } } else { root = WpfXamlLoader.LoadBaml(reader, parserContext.SkipJournaledProperties, parent, null, parserContext.BaseUri); } DependencyObject dObject = root as DependencyObject; if (dObject != null) { dObject.SetValue(BaseUriHelper.BaseUriProperty, readerSettings.BaseUri); } Application app = root as Application; if (app != null) { app.ApplicationMarkupBaseUri = GetBaseUri(readerSettings.BaseUri); } Debug.Assert(parent == null || root == parent); } finally { if (TraceMarkup.IsEnabled) { TraceMarkup.Trace(TraceEventType.Stop, TraceMarkup.Load, root); } EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Event.WClientParseBamlEnd, parserContext.BaseUri); if (closeStream && stream != null) { stream.Close(); } #if DEBUG_CLR_MEM if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { CLRProfilerControl.CLRLogWriteLine("End_BamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM } return(root); }