public bool MoveNext()
{
IEnumerator currentEnumerator = this.CurrentEnumerator;
if (currentEnumerator == null)
{
this.m_currentEvidence = null;
return(false);
}
if (currentEnumerator.MoveNext())
{
LegacyEvidenceWrapper current = currentEnumerator.Current as LegacyEvidenceWrapper;
LegacyEvidenceList list = currentEnumerator.Current as LegacyEvidenceList;
if (current != null)
{
this.m_currentEvidence = current.EvidenceObject;
}
else if (list != null)
{
IEnumerator enumerator = list.GetEnumerator();
this.m_enumerators.Push(enumerator);
this.MoveNext();
}
else
{
this.m_currentEvidence = currentEnumerator.Current;
}
return(true);
}
this.m_enumerators.Pop();
return(this.MoveNext());
}
public IEnumerable <EvidenceBase> GetFactorySuppliedEvidence()
{
if (m_assemblyProvidedEvidence == null)
{
byte[] serializedEvidence = null;
GetAssemblySuppliedEvidence(m_peFile, JitHelpers.GetObjectHandleOnStack(ref serializedEvidence));
m_assemblyProvidedEvidence = new List <EvidenceBase>();
if (serializedEvidence != null)
{
Evidence deserializedEvidence = new Evidence();
// Partial trust assemblies can provide their own evidence, so make sure that we have
// permission to deserialize it
new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
try
{
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream(serializedEvidence))
{
deserializedEvidence = (Evidence)formatter.Deserialize(ms);
}
}
catch { /* Ignore any errors deserializing */ }
CodeAccessPermission.RevertAssert();
// Enumerate the assembly evidence, ignoring any host evidence supplied. Since we
// could be loading a Whidbey assembly, we need to use the old GetAssemblyEnumerator
// API and deal with objects instead of EvidenceBases.
if (deserializedEvidence != null)
{
IEnumerator enumerator = deserializedEvidence.GetAssemblyEnumerator();
while (enumerator.MoveNext())
{
if (enumerator.Current != null)
{
// If this is a legacy evidence object, we need to wrap it before
// returning it.
EvidenceBase currentEvidence = enumerator.Current as EvidenceBase;
if (currentEvidence == null)
{
currentEvidence = new LegacyEvidenceWrapper(enumerator.Current);
}
m_assemblyProvidedEvidence.Add(currentEvidence);
}
}
}
}
}
return(m_assemblyProvidedEvidence);
}
private static EvidenceBase WrapLegacyEvidence(object evidence)
{
EvidenceBase base2 = evidence as EvidenceBase;
if (base2 == null)
{
base2 = new LegacyEvidenceWrapper(evidence);
}
return(base2);
}
public IEnumerable <EvidenceBase> GetFactorySuppliedEvidence()
{
if (this.m_assemblyProvidedEvidence == null)
{
byte[] array = null;
PEFileEvidenceFactory.GetAssemblySuppliedEvidence(this.m_peFile, JitHelpers.GetObjectHandleOnStack <byte[]>(ref array));
this.m_assemblyProvidedEvidence = new List <EvidenceBase>();
if (array != null)
{
Evidence evidence = new Evidence();
new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
try
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
using (MemoryStream memoryStream = new MemoryStream(array))
{
evidence = (Evidence)binaryFormatter.Deserialize(memoryStream);
}
}
catch
{
}
CodeAccessPermission.RevertAssert();
if (evidence != null)
{
IEnumerator assemblyEnumerator = evidence.GetAssemblyEnumerator();
while (assemblyEnumerator.MoveNext())
{
if (assemblyEnumerator.Current != null)
{
EvidenceBase evidenceBase = assemblyEnumerator.Current as EvidenceBase;
if (evidenceBase == null)
{
evidenceBase = new LegacyEvidenceWrapper(assemblyEnumerator.Current);
}
this.m_assemblyProvidedEvidence.Add(evidenceBase);
}
}
}
}
}
return(this.m_assemblyProvidedEvidence);
}
public IEnumerable<EvidenceBase> GetFactorySuppliedEvidence()
{
if (this.m_assemblyProvidedEvidence == null)
{
byte[] o = null;
GetAssemblySuppliedEvidence(this.m_peFile, JitHelpers.GetObjectHandleOnStack<byte[]>(ref o));
this.m_assemblyProvidedEvidence = new List<EvidenceBase>();
if (o != null)
{
Evidence evidence = new Evidence();
new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
try
{
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream(o))
{
evidence = (Evidence) formatter.Deserialize(stream);
}
}
catch
{
}
CodeAccessPermission.RevertAssert();
if (evidence != null)
{
IEnumerator assemblyEnumerator = evidence.GetAssemblyEnumerator();
while (assemblyEnumerator.MoveNext())
{
if (assemblyEnumerator.Current != null)
{
EvidenceBase current = assemblyEnumerator.Current as EvidenceBase;
if (current == null)
{
current = new LegacyEvidenceWrapper(assemblyEnumerator.Current);
}
this.m_assemblyProvidedEvidence.Add(current);
}
}
}
}
}
return this.m_assemblyProvidedEvidence;
}
public IEnumerable<EvidenceBase> GetFactorySuppliedEvidence()
{
if (m_assemblyProvidedEvidence == null)
{
byte[] serializedEvidence = null;
GetAssemblySuppliedEvidence(m_peFile, JitHelpers.GetObjectHandleOnStack(ref serializedEvidence));
m_assemblyProvidedEvidence = new List<EvidenceBase>();
if (serializedEvidence != null)
{
Evidence deserializedEvidence = new Evidence();
// Partial trust assemblies can provide their own evidence, so make sure that we have
// permission to deserialize it
new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
try
{
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream(serializedEvidence))
{
deserializedEvidence = (Evidence)formatter.Deserialize(ms);
}
}
catch { /* Ignore any errors deserializing */ }
CodeAccessPermission.RevertAssert();
// Enumerate the assembly evidence, ignoring any host evidence supplied. Since we
// could be loading a Whidbey assembly, we need to use the old GetAssemblyEnumerator
// API and deal with objects instead of EvidenceBases.
if (deserializedEvidence != null)
{
IEnumerator enumerator = deserializedEvidence.GetAssemblyEnumerator();
while (enumerator.MoveNext())
{
if (enumerator.Current != null)
{
// If this is a legacy evidence object, we need to wrap it before
// returning it.
EvidenceBase currentEvidence = enumerator.Current as EvidenceBase;
if (currentEvidence == null)
{
currentEvidence = new LegacyEvidenceWrapper(enumerator.Current);
}
m_assemblyProvidedEvidence.Add(currentEvidence);
}
}
}
}
}
return m_assemblyProvidedEvidence;
}
internal void InitStore(IsolatedStorageScope scope, object domain, object assem, object app)
{
PermissionSet newGrant = null;
PermissionSet newDenied = null;
Evidence domainEv = null;
Evidence assemEv = null;
Evidence appEv = null;
if (IsApp(scope))
{
EvidenceBase evidence = app as EvidenceBase;
if (evidence == null)
{
evidence = new LegacyEvidenceWrapper(app);
}
appEv = new Evidence();
appEv.AddHostEvidence<EvidenceBase>(evidence);
}
else
{
EvidenceBase base3 = assem as EvidenceBase;
if (base3 == null)
{
base3 = new LegacyEvidenceWrapper(assem);
}
assemEv = new Evidence();
assemEv.AddHostEvidence<EvidenceBase>(base3);
if (IsDomain(scope))
{
EvidenceBase base4 = domain as EvidenceBase;
if (base4 == null)
{
base4 = new LegacyEvidenceWrapper(domain);
}
domainEv = new Evidence();
domainEv.AddHostEvidence<EvidenceBase>(base4);
}
}
this._InitStore(scope, domainEv, null, assemEv, null, appEv, null);
if (!IsRoaming(scope))
{
RuntimeAssembly caller = GetCaller();
GetControlEvidencePermission().Assert();
caller.GetGrantSet(out newGrant, out newDenied);
if (newGrant == null)
{
throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_AssemblyGrantSet"));
}
}
this.SetQuota(newGrant, newDenied);
}
