internal Hash(SerializationInfo info, StreamingContext context)
{
Dictionary<Type, byte[]> valueNoThrow = info.GetValueNoThrow("Hashes", typeof(Dictionary<Type, byte[]>)) as Dictionary<Type, byte[]>;
if (valueNoThrow != null)
{
this.m_hashes = valueNoThrow;
}
else
{
this.m_hashes = new Dictionary<Type, byte[]>();
byte[] buffer = info.GetValueNoThrow("Md5", typeof(byte[])) as byte[];
if (buffer != null)
{
this.m_hashes[typeof(System.Security.Cryptography.MD5)] = buffer;
}
byte[] buffer2 = info.GetValueNoThrow("Sha1", typeof(byte[])) as byte[];
if (buffer2 != null)
{
this.m_hashes[typeof(System.Security.Cryptography.SHA1)] = buffer2;
}
byte[] assemblyBytes = info.GetValueNoThrow("RawData", typeof(byte[])) as byte[];
if (assemblyBytes != null)
{
this.GenerateDefaultHashes(assemblyBytes);
}
}
}
protected Exception(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
this._className = info.GetString("ClassName");
this._message = info.GetString("Message");
this._data = (IDictionary) info.GetValueNoThrow("Data", typeof(IDictionary));
this._innerException = (Exception) info.GetValue("InnerException", typeof(Exception));
this._helpURL = info.GetString("HelpURL");
this._stackTraceString = info.GetString("StackTraceString");
this._remoteStackTraceString = info.GetString("RemoteStackTraceString");
this._remoteStackIndex = info.GetInt32("RemoteStackIndex");
this._exceptionMethodString = (string) info.GetValue("ExceptionMethod", typeof(string));
this.HResult = info.GetInt32("HResult");
this._source = info.GetString("Source");
if ((this._className == null) || (this.HResult == 0))
{
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
}
if (context.State == StreamingContextStates.CrossAppDomain)
{
this._remoteStackTraceString = this._remoteStackTraceString + this._stackTraceString;
this._stackTraceString = null;
}
}
internal Hash(SerializationInfo info, StreamingContext context)
{
//
// We have three serialization formats that we might be deserializing, the Whidbey format which
// contains hash values directly, the Whidbey format which contains a pointer to a PEImage, and
// the v4 format which contains a dictionary of calculated hashes.
//
// If we have the Whidbey version that has built in hash values, we can convert that, but we
// cannot do anything with the PEImage format since that is a serialized pointer into another
// runtime's VM.
//
Dictionary<Type, byte[]> hashes = info.GetValueNoThrow("Hashes", typeof(Dictionary<Type, byte[]>)) as Dictionary<Type, byte[]>;
if (hashes != null)
{
m_hashes = hashes;
}
else
{
// If there is no hash value dictionary, then check to see if we have the Whidbey multiple
// hashes version of the evidence.
m_hashes = new Dictionary<Type, byte[]>();
byte[] md5 = info.GetValueNoThrow("Md5", typeof(byte[])) as byte[];
if (md5 != null)
{
m_hashes[typeof(MD5)] = md5;
}
byte[] sha1 = info.GetValueNoThrow("Sha1", typeof(byte[])) as byte[];
if (sha1 != null)
{
m_hashes[typeof(SHA1)] = sha1;
}
byte[] rawData = info.GetValueNoThrow("RawData", typeof(byte[])) as byte[];
if (rawData != null)
{
GenerateDefaultHashes(rawData);
}
}
}
private SafeSerializationManager(SerializationInfo info, StreamingContext context)
{
RuntimeType runtimeType = info.GetValueNoThrow("CLR_SafeSerializationManager_RealType", typeof(RuntimeType)) as RuntimeType;
if (runtimeType == null)
{
this.m_serializedStates = (info.GetValue("m_serializedStates", typeof(List <object>)) as List <object>);
return;
}
this.m_realType = runtimeType;
this.m_savedSerializationInfo = info;
}
[System.Security.SecuritySafeCritical] // auto-generated
protected Exception(SerializationInfo info, StreamingContext context)
{
if (info==null)
throw new ArgumentNullException("info");
Contract.EndContractBlock();
_className = info.GetString("ClassName");
_message = info.GetString("Message");
_data = (IDictionary)(info.GetValueNoThrow("Data",typeof(IDictionary)));
_innerException = (Exception)(info.GetValue("InnerException",typeof(Exception)));
_helpURL = info.GetString("HelpURL");
_stackTraceString = info.GetString("StackTraceString");
_remoteStackTraceString = info.GetString("RemoteStackTraceString");
_remoteStackIndex = info.GetInt32("RemoteStackIndex");
_exceptionMethodString = (String)(info.GetValue("ExceptionMethod",typeof(String)));
HResult = info.GetInt32("HResult");
_source = info.GetString("Source");
// Get the WatsonBuckets that were serialized - this is particularly
// done to support exceptions going across AD transitions.
//
// We use the no throw version since we could be deserializing a pre-V4
// exception object that may not have this entry. In such a case, we would
// get null.
_watsonBuckets = (Object)info.GetValueNoThrow("WatsonBuckets", typeof(byte[]));
#if FEATURE_SERIALIZATION
_safeSerializationManager = info.GetValueNoThrow("SafeSerializationManager", typeof(SafeSerializationManager)) as SafeSerializationManager;
#endif // FEATURE_SERIALIZATION
if (_className == null || HResult==0)
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
// If we are constructing a new exception after a cross-appdomain call...
if (context.State == StreamingContextStates.CrossAppDomain)
{
// ...this new exception may get thrown. It is logically a re-throw, but
// physically a brand-new exception. Since the stack trace is cleared
// on a new exception, the "_remoteStackTraceString" is provided to
// effectively import a stack trace from a "remote" exception. So,
// move the _stackTraceString into the _remoteStackTraceString. Note
// that if there is an existing _remoteStackTraceString, it will be
// preserved at the head of the new string, so everything works as
// expected.
// Even if this exception is NOT thrown, things will still work as expected
// because the StackTrace property returns the concatenation of the
// _remoteStackTraceString and the _stackTraceString.
_remoteStackTraceString = _remoteStackTraceString + _stackTraceString;
_stackTraceString = null;
}
}
private SafeSerializationManager(SerializationInfo info, StreamingContext context)
{
RuntimeType valueNoThrow = info.GetValueNoThrow("CLR_SafeSerializationManager_RealType", typeof(RuntimeType)) as RuntimeType;
if (valueNoThrow == null)
{
this.m_serializedStates = info.GetValue("m_serializedStates", typeof(List<object>)) as List<object>;
}
else
{
this.m_realType = valueNoThrow;
this.m_savedSerializationInfo = info;
}
}
private DelegateSerializationHolder(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
bool flag = true;
try
{
this.m_delegateEntry = (DelegateEntry) info.GetValue("Delegate", typeof(DelegateEntry));
}
catch
{
this.m_delegateEntry = this.OldDelegateWireFormat(info, context);
flag = false;
}
if (flag)
{
DelegateEntry delegateEntry = this.m_delegateEntry;
int num = 0;
while (delegateEntry != null)
{
if (delegateEntry.target != null)
{
string target = delegateEntry.target as string;
if (target != null)
{
delegateEntry.target = info.GetValue(target, typeof(object));
}
}
num++;
delegateEntry = delegateEntry.delegateEntry;
}
MethodInfo[] infoArray = new MethodInfo[num];
int index = 0;
while (index < num)
{
string name = "method" + index;
infoArray[index] = (MethodInfo) info.GetValueNoThrow(name, typeof(MethodInfo));
if (infoArray[index] == null)
{
break;
}
index++;
}
if (index == num)
{
this.m_methods = infoArray;
}
}
}
private SafeSerializationManager(SerializationInfo info, StreamingContext context)
{
RuntimeType valueNoThrow = info.GetValueNoThrow("CLR_SafeSerializationManager_RealType", typeof(RuntimeType)) as RuntimeType;
if (valueNoThrow == null)
{
this.m_serializedStates = info.GetValue("m_serializedStates", typeof(List <object>)) as List <object>;
}
else
{
this.m_realType = valueNoThrow;
this.m_savedSerializationInfo = info;
}
}
protected SecurityException(SerializationInfo info, StreamingContext context) : base(info, context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
try
{
this.m_action = (SecurityAction) info.GetValue("Action", typeof(SecurityAction));
this.m_permissionThatFailed = (string) info.GetValueNoThrow("FirstPermissionThatFailed", typeof(string));
this.m_demanded = (string) info.GetValueNoThrow("Demanded", typeof(string));
this.m_granted = (string) info.GetValueNoThrow("GrantedSet", typeof(string));
this.m_refused = (string) info.GetValueNoThrow("RefusedSet", typeof(string));
this.m_denied = (string) info.GetValueNoThrow("Denied", typeof(string));
this.m_permitOnly = (string) info.GetValueNoThrow("PermitOnly", typeof(string));
this.m_assemblyName = (AssemblyName) info.GetValueNoThrow("Assembly", typeof(AssemblyName));
this.m_serializedMethodInfo = (byte[]) info.GetValueNoThrow("Method", typeof(byte[]));
this.m_strMethodInfo = (string) info.GetValueNoThrow("Method_String", typeof(string));
this.m_zone = (SecurityZone) info.GetValue("Zone", typeof(SecurityZone));
this.m_url = (string) info.GetValueNoThrow("Url", typeof(string));
}
catch
{
this.m_action = (SecurityAction) 0;
this.m_permissionThatFailed = "";
this.m_demanded = "";
this.m_granted = "";
this.m_refused = "";
this.m_denied = "";
this.m_permitOnly = "";
this.m_assemblyName = null;
this.m_serializedMethodInfo = null;
this.m_strMethodInfo = null;
this.m_zone = SecurityZone.NoZone;
this.m_url = "";
}
}
private SafeSerializationManager(SerializationInfo info, StreamingContext context)
{
// We need to determine if we're being called to really deserialize a SafeSerializationManager,
// or if we're being called because we've intercepted the deserialization callback for the real
// object being deserialized. We use the presence of the RealTypeSerializationName field in the
// serialization info to indicate that this is the interception callback and we just need to
// safe the info. If that field is not present, then we should be in a real deserialization
// construction.
RuntimeType realType = info.GetValueNoThrow(RealTypeSerializationName, typeof(RuntimeType)) as RuntimeType;
if (realType == null)
{
m_serializedStates = info.GetValue("m_serializedStates", typeof(List <object>)) as List <object>;
}
else
{
m_realType = realType;
m_savedSerializationInfo = info;
}
}
internal MemberInfoSerializationHolder(SerializationInfo info, StreamingContext context)
{
if (info == null)
throw new ArgumentNullException(nameof(info));
Contract.EndContractBlock();
String assemblyName = info.GetString("AssemblyName");
String typeName = info.GetString("ClassName");
if (assemblyName == null || typeName == null)
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
Assembly assem = FormatterServices.LoadAssemblyFromString(assemblyName);
m_reflectedType = assem.GetType(typeName, true, false) as RuntimeType;
m_memberName = info.GetString("Name");
m_signature = info.GetString("Signature");
// Only v4.0 and later generates and consumes Signature2
m_signature2 = (string)info.GetValueNoThrow("Signature2", typeof(string));
m_memberType = (MemberTypes)info.GetInt32("MemberType");
m_info = info;
}
public Delegate DeserializeDelegate (SerializationInfo info, int index)
{
object realTarget = null;
if (target != null)
realTarget = info.GetValue (target.ToString(), typeof(object));
var key = "method" + index;
var method = (MethodInfo)info.GetValueNoThrow (key, typeof(MethodInfo));
Assembly dasm = Assembly.Load (assembly);
Type dt = dasm.GetType (type);
if (realTarget != null) {
#if !DISABLE_REMOTING
if (RemotingServices.IsTransparentProxy (realTarget)) {
// The call to IsInstanceOfType will force the proxy
// to load the real type of the remote object. This is
// needed to make sure that subsequent calls to
// GetType() return the expected type.
Assembly tasm = Assembly.Load (targetTypeAssembly);
Type tt = tasm.GetType (targetTypeName);
if (!tt.IsInstanceOfType (realTarget))
throw new RemotingException ("Unexpected proxy type.");
}
#endif
return method == null ?
Delegate.CreateDelegate (dt, realTarget, methodName) :
Delegate.CreateDelegate (dt, realTarget, method);
}
if (method != null)
return Delegate.CreateDelegate (dt, realTarget, method);
Type tt2 = Assembly.Load (targetTypeAssembly).GetType (targetTypeName);
return Delegate.CreateDelegate (dt, tt2, methodName);
}
[System.Security.SecuritySafeCritical] // auto-generated
protected SecurityException(SerializationInfo info, StreamingContext context) : base (info, context)
{
if (info==null)
throw new ArgumentNullException("info");
Contract.EndContractBlock();
try
{
m_action = (SecurityAction)info.GetValue(ActionName, typeof(SecurityAction));
m_permissionThatFailed = (String)info.GetValueNoThrow(FirstPermissionThatFailedName, typeof(String));
m_demanded = (String)info.GetValueNoThrow(DemandedName, typeof(String));
m_granted = (String)info.GetValueNoThrow(GrantedSetName, typeof(String));
m_refused = (String)info.GetValueNoThrow(RefusedSetName, typeof(String));
m_denied = (String)info.GetValueNoThrow(DeniedName, typeof(String));
m_permitOnly = (String)info.GetValueNoThrow(PermitOnlyName, typeof(String));
m_assemblyName = (AssemblyName)info.GetValueNoThrow(Assembly_Name, typeof(AssemblyName));
m_serializedMethodInfo = (byte[])info.GetValueNoThrow(MethodName_Serialized, typeof(byte[]));
m_strMethodInfo = (String)info.GetValueNoThrow(MethodName_String, typeof(String));
m_zone = (SecurityZone)info.GetValue(ZoneName, typeof(SecurityZone));
m_url = (String)info.GetValueNoThrow(UrlName, typeof(String));
}
catch
{
m_action = 0;
m_permissionThatFailed = "";
m_demanded = "";
m_granted = "";
m_refused = "";
m_denied = "";
m_permitOnly = "";
m_assemblyName = null;
m_serializedMethodInfo = null;
m_strMethodInfo = null;
m_zone = SecurityZone.NoZone;
m_url = "";
}
}
[System.Security.SecurityCritical] // auto-generated
private DelegateSerializationHolder(SerializationInfo info, StreamingContext context)
{
if (info == null)
throw new ArgumentNullException("info");
Contract.EndContractBlock();
bool bNewWire = true;
try
{
m_delegateEntry = (DelegateEntry)info.GetValue("Delegate", typeof(DelegateEntry));
}
catch
{
// Old wire format
m_delegateEntry = OldDelegateWireFormat(info, context);
bNewWire = false;
}
if (bNewWire)
{
// retrieve the targets
DelegateEntry deiter = m_delegateEntry;
int count = 0;
while (deiter != null)
{
if (deiter.target != null)
{
string stringTarget = deiter.target as string; //need test to pass older wire format
if (stringTarget != null)
deiter.target = info.GetValue(stringTarget, typeof(Object));
}
count++;
deiter = deiter.delegateEntry;
}
// If the sender is as recent as us they'll have provided MethodInfos for each delegate. Look for these and pack
// them into an ordered array if present.
MethodInfo[] methods = new MethodInfo[count];
int i;
for (i = 0; i < count; i++)
{
String methodInfoName = "method" + i;
methods[i] = (MethodInfo)info.GetValueNoThrow(methodInfoName, typeof(MethodInfo));
if (methods[i] == null)
break;
}
// If we got the info then make the array available for deserialization.
if (i == count)
m_methods = methods;
}
}
private SafeSerializationManager(SerializationInfo info, StreamingContext context)
{
// We need to determine if we're being called to really deserialize a SafeSerializationManager,
// or if we're being called because we've intercepted the deserialization callback for the real
// object being deserialized. We use the presence of the RealTypeSerializationName field in the
// serialization info to indicate that this is the interception callback and we just need to
// safe the info. If that field is not present, then we should be in a real deserialization
// construction.
RuntimeType realType = info.GetValueNoThrow(RealTypeSerializationName, typeof(RuntimeType)) as RuntimeType;
if (realType == null)
{
m_serializedStates = info.GetValue("m_serializedStates", typeof(List<object>)) as List<object>;
}
else
{
m_realType = realType;
m_savedSerializationInfo = info;
}
}
protected Exception(SerializationInfo info, StreamingContext context)
{
if (info==null)
throw new ArgumentNullException("info");
_className = info.GetString("ClassName");
_message = info.GetString("Message");
_data = (IDictionary)(info.GetValueNoThrow("Data",typeof(IDictionary)));
_innerException = (Exception)(info.GetValue("InnerException",typeof(Exception)));
_helpURL = info.GetString("HelpURL");
_stackTraceString = info.GetString("StackTraceString");
_remoteStackTraceString = info.GetString("RemoteStackTraceString");
_remoteStackIndex = info.GetInt32("RemoteStackIndex");
_exceptionMethodString = (String)(info.GetValue("ExceptionMethod",typeof(String)));
HResult = info.GetInt32("HResult");
_source = info.GetString("Source");
if (_className == null || HResult==0)
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
// If we are constructing a new exception after a cross-appdomain call...
if (context.State == StreamingContextStates.CrossAppDomain)
{
// ...this new exception may get thrown. It is logically a re-throw, but
// physically a brand-new exception. Since the stack trace is cleared
// on a new exception, the "_remoteStackTraceString" is provided to
// effectively import a stack trace from a "remote" exception. So,
// move the _stackTraceString into the _remoteStackTraceString. Note
// that if there is an existing _remoteStackTraceString, it will be
// preserved at the head of the new string, so everything works as
// expected.
// Even if this exception is NOT thrown, things will still work as expected
// because the StackTrace property returns the concatenation of the
// _remoteStackTraceString and the _stackTraceString.
_remoteStackTraceString = _remoteStackTraceString + _stackTraceString;
_stackTraceString = null;
}
}
