public void Unrestricted()
{
VerifyInvariants(s_UnrestrictedPerm, isUnrestricted: true);
XamlAccessLevel assemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly);
Assert.IsTrue(s_UnrestrictedPerm.Includes(assemblyAccess));
}
public static void XamlAccessLevelTestsCallMethods()
{
Assembly execAssembly = Assembly.GetExecutingAssembly();
Type type = typeof(int);
XamlAccessLevel accessLevel = XamlAccessLevel.AssemblyAccessTo(execAssembly);
XamlAccessLevel accessLevel2 = XamlAccessLevel.AssemblyAccessTo(execAssembly.GetName());
XamlAccessLevel accessLevel3 = XamlAccessLevel.PrivateAccessTo(type);
XamlAccessLevel accessLevel4 = XamlAccessLevel.PrivateAccessTo(type.AssemblyQualifiedName);
AssemblyName an = accessLevel.AssemblyAccessToAssemblyName;
}
public void AccessLevelCtorsPositive()
{
XamlAccessLevel byRef = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly);
XamlAccessLevel byName = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly.GetName());
Assert.AreEqual(new XamlLoadPermission(byRef), new XamlLoadPermission(byName));
byRef = XamlAccessLevel.PrivateAccessTo(typeof(LoadPermissionTests));
byName = XamlAccessLevel.PrivateAccessTo(typeof(LoadPermissionTests).AssemblyQualifiedName);
Assert.AreEqual(new XamlLoadPermission(byRef), new XamlLoadPermission(byName));
}
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 static object LoadBaml(System.Xaml.XamlReader xamlReader, bool skipJournaledProperties,
Object rootObject, XamlAccessLevel accessLevel, Uri baseUri)
{
XamlObjectWriterSettings settings = XamlReader.CreateObjectWriterSettingsForBaml();
settings.RootObjectInstance = rootObject;
settings.AccessLevel = accessLevel;
object result = Load(xamlReader, null, skipJournaledProperties, rootObject, settings, baseUri);
EnsureXmlNamespaceMaps(result, xamlReader.SchemaContext);
return(result);
}
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;
_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();
}
public static void InitializeFromStream(Activity a, Assembly localAssembly, Stream xamlStream,
XamlSchemaContext schemaContext)
{
XmlReader xmlReader = null;
XamlReader reader = null;
XamlObjectWriter objectWriter = null;
try
{
xmlReader = XmlReader.Create(xamlStream);
XamlXmlReaderSettings readerSettings = new XamlXmlReaderSettings();
readerSettings.LocalAssembly = localAssembly;
readerSettings.AllowProtectedMembersOnRoot = true;
reader = new XamlXmlReader(xmlReader, schemaContext, readerSettings);
XamlObjectWriterSettings writerSettings = new XamlObjectWriterSettings();
writerSettings.RootObjectInstance = a;
writerSettings.AccessLevel = XamlAccessLevel.PrivateAccessTo(a.GetType());
objectWriter = new XamlObjectWriter(schemaContext, writerSettings);
XamlServices.Transform(reader, objectWriter);
}
finally
{
if (xmlReader != null)
{
((IDisposable)xmlReader).Dispose();
}
if (reader != null)
{
((IDisposable)reader).Dispose();
}
if (objectWriter != null)
{
((IDisposable)objectWriter).Dispose();
}
}
}
public PartialTrustTolerantRuntime(XamlRuntimeSettings runtimeSettings, XamlAccessLevel accessLevel, XamlSchemaContext schemaContext)
{
_transparentRuntime = new ClrObjectRuntime(runtimeSettings, true /*isWriter*/);
_accessLevel = accessLevel;
_schemaContext = schemaContext;
}
public void AccessLevelCtorUnqualifiedTypeName()
{
XamlAccessLevel.PrivateAccessTo(typeof(LoadPermissionTests).FullName);
}
public void AccessLevelCtorUnqualifiedAssemblyName()
{
XamlAccessLevel.AssemblyAccessTo(new AssemblyName("DRTXaml"));
}
public PartialTrustTolerantRuntime(XamlRuntimeSettings runtimeSettings, XamlAccessLevel accessLevel, XamlSchemaContext schemaContext)
{
this._transparentRuntime = new ClrObjectRuntime(runtimeSettings, true);
this._accessLevel = accessLevel;
this._schemaContext = schemaContext;
}
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);
}
}
//[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);
}
// Token: 0x06002268 RID: 8808 RVA: 0x000AAD94 File Offset: 0x000A8F94
public static object LoadBaml(XamlReader xamlReader, bool skipJournaledProperties, object rootObject, XamlAccessLevel accessLevel, Uri baseUri)
{
XamlObjectWriterSettings xamlObjectWriterSettings = XamlReader.CreateObjectWriterSettingsForBaml();
xamlObjectWriterSettings.RootObjectInstance = rootObject;
xamlObjectWriterSettings.AccessLevel = accessLevel;
object obj = WpfXamlLoader.Load(xamlReader, null, skipJournaledProperties, rootObject, xamlObjectWriterSettings, baseUri);
WpfXamlLoader.EnsureXmlNamespaceMaps(obj, xamlReader.SchemaContext);
return(obj);
}
