/// <summary>
/// Reads an object from a stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <returns>Decoded object.</returns>
public static object?ReadObject(this Stream stream)
{
ObjectType type = (ObjectType)stream.ReadNextByte();
return(type switch
{
ObjectType.Null => null,
ObjectType.DbNull => DBNull.Value,
ObjectType.BooleanTrue => true,
ObjectType.BooleanFalse => false,
ObjectType.Char => stream.ReadChar(),
ObjectType.SByte => stream.ReadSByte(),
ObjectType.Byte => stream.ReadNextByte(),
ObjectType.Int16 => stream.ReadInt16(),
ObjectType.UInt16 => stream.ReadUInt16(),
ObjectType.Int32 => stream.ReadInt32(),
ObjectType.UInt32 => stream.ReadUInt32(),
ObjectType.Int64 => stream.ReadInt64(),
ObjectType.UInt64 => stream.ReadUInt64(),
ObjectType.Single => stream.ReadSingle(),
ObjectType.Double => stream.ReadDouble(),
ObjectType.Decimal => stream.ReadDecimal(),
ObjectType.DateTime => stream.ReadDateTime(),
ObjectType.String => stream.ReadString(),
ObjectType.ByteArray => stream.ReadBytes(),
ObjectType.CharArray => stream.ReadString().ToCharArray(),
ObjectType.Guid => stream.ReadGuid(),
_ => throw new ArgumentOutOfRangeException()
});
/// <summary>
/// Reads a 7-bit encoded uint.
/// </summary>
/// <param name="stream">A stream to read from.</param>
/// <returns>the value</returns>
/// <remarks>
/// This method will check for the end of the stream
/// </remarks>
/// <exception cref="EndOfStreamException">Occurs if the end of the stream was reached.</exception>
public static uint ReadUInt32(Stream stream)
{
uint value11;
value11 = stream.ReadNextByte();
if (value11 < 128)
{
return(value11);
}
value11 ^= ((uint)stream.ReadNextByte() << 7);
if (value11 < 128 * 128)
{
return(value11 ^ 0x80);
}
value11 ^= ((uint)stream.ReadNextByte() << 14);
if (value11 < 128 * 128 * 128)
{
return(value11 ^ 0x4080);
}
value11 ^= ((uint)stream.ReadNextByte() << 21);
if (value11 < 128 * 128 * 128 * 128)
{
return(value11 ^ 0x204080);
}
value11 ^= ((uint)stream.ReadNextByte() << 28) ^ 0x10204080;
return(value11);
}
private bool ResumeSession(Stream stream, byte[] additionalChallenge)
{
stream.Write((byte)16);
byte[] aChallenge = SaltGenerator.Create(16);
stream.Write(aChallenge);
stream.Write((short)m_resumeTicket.Length);
stream.Write(m_resumeTicket);
stream.Flush();
if (stream.ReadBoolean())
{
SetHashMethod((HashMethod)stream.ReadNextByte());
byte[] bChallenge = stream.ReadBytes(stream.ReadNextByte());
byte[] clientProof = m_hash.ComputeHash(aChallenge, bChallenge, m_sessionSecret, additionalChallenge);
stream.Write(clientProof);
stream.Flush();
if (stream.ReadBoolean())
{
byte[] serverProof = m_hash.ComputeHash(bChallenge, aChallenge, m_sessionSecret, additionalChallenge);
byte[] serverProofCheck = stream.ReadBytes(m_hash.GetDigestSize());
return(serverProof.SecureEquals(serverProofCheck));
}
}
m_sessionSecret = null;
m_resumeTicket = null;
return(Authenticate(stream, additionalChallenge));
}
public SKColor ReadPixel(Stream stream)
{
var r = ScaleTone(stream.ReadNextByte());
var g = ScaleTone(stream.ReadNextByte());
var b = ScaleTone(stream.ReadNextByte());
return(new SKColor(r, g, b));
}
/// <summary>
/// Reads a 7-bit encoded uint.
/// </summary>
/// <param name="stream">A stream to read from.</param>
/// <returns>the value</returns>
/// <remarks>
/// This method will check for the end of the stream
/// </remarks>
/// <exception cref="EndOfStreamException">Occurs if the end of the stream was reached.</exception>
public static short ReadInt15(Stream stream)
{
short value11;
value11 = stream.ReadNextByte();
if (value11 < 128)
{
return(value11);
}
value11 ^= (short)(stream.ReadNextByte() << 7);
return((short)(value11 ^ 0x80));
}
private bool Authenticate(Stream stream, byte[] additionalChallenge)
{
HashMethod passwordHashMethod = (HashMethod)stream.ReadNextByte();
byte[] salt = stream.ReadBytes(stream.ReadNextByte());
int iterations = stream.ReadInt32();
SetHashMethod((HashMethod)stream.ReadNextByte());
SetSrpStrength((SrpStrength)stream.ReadInt32());
m_credentials.TryUpdate(passwordHashMethod, salt, iterations);
BigInteger pubA = m_client.GenerateClientCredentials(m_hash, salt, m_credentials.UsernameBytes, m_credentials.SaltedPassword);
byte[] pubABytes = pubA.ToPaddedArray(m_srpByteLength);
stream.Write(pubABytes);
stream.Flush();
//Read from Server: B
byte[] pubBBytes = stream.ReadBytes(m_srpByteLength);
BigInteger pubB = new BigInteger(1, pubBBytes);
//Calculate Session Key
BigInteger S = m_client.CalculateSecret(m_hash, pubB);
byte[] SBytes = S.ToPaddedArray(m_srpByteLength);
byte[] clientProof = m_hash.ComputeHash(pubABytes, pubBBytes, SBytes, additionalChallenge);
stream.Write(clientProof);
stream.Flush();
byte[] serverProof = m_hash.ComputeHash(pubBBytes, pubABytes, SBytes, additionalChallenge);
if (stream.ReadBoolean())
{
byte[] serverProofCheck = stream.ReadBytes(m_hash.GetDigestSize());
int ticketLength = stream.ReadInt16();
if (ticketLength < 0 || ticketLength > 10000)
{
return(false);
}
if (serverProofCheck.SecureEquals(serverProof))
{
m_resumeTicket = stream.ReadBytes(ticketLength);
m_sessionSecret = m_hash.ComputeHash(pubABytes, SBytes, pubBBytes).Combine(m_hash.ComputeHash(pubBBytes, SBytes, pubABytes));
return(true);
}
return(false);
}
return(false);
}
public EnumMatchingFlags(Stream stream)
{
switch (stream.ReadNextByte())
{
case 1:
m_matchMode = (EnumMatchingFlagsMode)stream.ReadNextByte();
m_value = stream.ReadInt32();
m_description = stream.ReadString();
break;
default:
throw new VersionNotFoundException();
}
}
public TimestampMatching(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_mode = (TimestampMatchingMode)stream.ReadNextByte();
m_first = stream.ReadDateTime();
m_second = stream.ReadDateTime();
break;
default:
throw new VersionNotFoundException();
}
}
public StringMatching(Stream stream)
{
switch (stream.ReadNextByte())
{
case 1:
MatchMode = (StringMatchingMode)stream.ReadNextByte();
MatchText = stream.ReadString();
if (MatchMode == StringMatchingMode.Regex)
m_matchRegex = new Regex(MatchText);
break;
default:
throw new VersionNotFoundException();
}
}
public EnumMatchingFlags(Stream stream)
{
switch (stream.ReadNextByte())
{
case 1:
m_matchMode = (EnumMatchingFlagsMode)stream.ReadNextByte();
m_value = stream.ReadInt32();
m_description = stream.ReadString();
break;
default:
throw new VersionNotFoundException();
}
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_isEnabled = stream.ReadBoolean();
m_prebufferWriter.Load(stream);
m_firstStageWriter.Load(stream);
int cnt = stream.ReadInt32();
m_stagingRollovers.Clear();
while (cnt > 0)
{
cnt--;
var cfs = new CombineFilesSettings();
cfs.Load(stream);
m_stagingRollovers.Add(cfs);
}
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_directoryMethod = (ArchiveDirectoryMethod)stream.ReadInt32();
m_prefix = stream.ReadString();
m_pendingExtension = stream.ReadString();
m_finalExtension = stream.ReadString();
m_desiredRemainingSpace = stream.ReadInt64();
m_encodingMethod = new EncodingDefinition(stream);
int cnt = stream.ReadInt32();
m_writePath.Clear();
while (cnt > 0)
{
cnt--;
m_writePath.Add(stream.ReadString());
}
cnt = stream.ReadInt32();
m_flags.Clear();
while (cnt > 0)
{
cnt--;
m_flags.Add(stream.ReadGuid());
}
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
public SKColor ReadPixel(Stream stream)
{
var rawTone = stream.ReadNextByte();
var tone = ScaleTone(rawTone);
return(new SKColor(tone, tone, tone));
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
int cnt = stream.ReadInt32();
m_importPaths.Clear();
while (cnt > 0)
{
cnt--;
m_importPaths.Add(stream.ReadString());
}
cnt = stream.ReadInt32();
m_importPaths.Clear();
while (cnt > 0)
{
cnt--;
m_importPaths.Add(stream.ReadString());
}
m_logSettings.Load(stream);
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
public TimestampMatching(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_mode = (TimestampMatchingMode)stream.ReadNextByte();
m_first = stream.ReadDateTime();
m_second = stream.ReadDateTime();
break;
default:
throw new VersionNotFoundException();
}
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
int cnt = stream.ReadInt32();
m_databases.Clear();
while (cnt > 0)
{
cnt--;
var database = new ServerDatabaseSettings();
database.Load(stream);
m_databases.Add(database);
}
cnt = stream.ReadInt32();
m_listeners.Clear();
while (cnt > 0)
{
cnt--;
var listener = new SnapSocketListenerSettings();
listener.Load(stream);
m_listeners.Add(listener);
}
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_keyType = stream.ReadGuid();
m_valueType = stream.ReadGuid();
m_databaseName = stream.ReadString();
int cnt = stream.ReadInt32();
m_streamingEncodingMethods.Clear();
while (cnt > 0)
{
cnt--;
m_streamingEncodingMethods.Add(new EncodingDefinition(stream));
}
m_archiveList.Load(stream);
m_writeProcessor.Load(stream);
m_rolloverLog.Load(stream);
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
public StringMatching(Stream stream)
{
switch (stream.ReadNextByte())
{
case 1:
MatchMode = (StringMatchingMode)stream.ReadNextByte();
MatchText = stream.ReadString();
if (MatchMode == StringMatchingMode.Regex)
{
m_matchRegex = new Regex(MatchText);
}
break;
default:
throw new VersionNotFoundException();
}
}
/// <summary>
/// Creates a <see cref="SnapStreamingClient"/>
/// </summary>
/// <param name="stream">The config to use for the client</param>
/// <param name="credentials">Authenticates using the supplied user credentials.</param>
/// <param name="useSsl">specifies if a ssl connection is desired.</param>
protected void Initialize(Stream stream, SecureStreamClientBase credentials, bool useSsl)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (credentials == null)
{
throw new ArgumentNullException("credentials");
}
m_credentials = credentials;
m_rawStream = stream;
m_rawStream.Write(0x2BA517361121L);
m_rawStream.Write(useSsl); //UseSSL
var command = (ServerResponse)m_rawStream.ReadNextByte();
switch (command)
{
case ServerResponse.UnknownProtocol:
throw new Exception("Client and server cannot agree on a protocol, this is commonly because they are running incompatible versions.");
case ServerResponse.KnownProtocol:
break;
default:
throw new Exception("Unknown server response: " + command.ToString());
}
useSsl = m_rawStream.ReadBoolean();
if (!m_credentials.TryAuthenticate(m_rawStream, useSsl, out m_secureStream))
{
throw new Exception("Authentication Failed");
}
m_stream = new RemoteBinaryStream(m_secureStream);
command = (ServerResponse)m_stream.ReadUInt8();
switch (command)
{
case ServerResponse.UnhandledException:
string exception = m_stream.ReadString();
throw new Exception("Server UnhandledExcetion: \n" + exception);
case ServerResponse.UnknownProtocol:
throw new Exception("Client and server cannot agree on a protocol, this is commonly because they are running incompatible versions.");
case ServerResponse.ConnectedToRoot:
break;
default:
throw new Exception("Unknown server response: " + command.ToString());
}
RefreshDatabaseInfo();
}
/// <summary>
/// Reads a 7-bit encoded ulong.
/// </summary>
/// <param name="stream">A stream to read from.</param>
/// <returns>the value</returns>
/// <remarks>
/// This method will check for the end of the stream
/// </remarks>
/// <exception cref="EndOfStreamException">Occurs if the end of the stream was reached.</exception>
public static ulong ReadUInt64(Stream stream)
{
ulong value11;
value11 = stream.ReadNextByte();
if (value11 < 128)
{
return(value11);
}
value11 ^= ((ulong)stream.ReadNextByte() << (7));
if (value11 < 128 * 128)
{
return(value11 ^ 0x80);
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7));
if (value11 < 128 * 128 * 128)
{
return(value11 ^ 0x4080);
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7));
if (value11 < 128 * 128 * 128 * 128)
{
return(value11 ^ 0x204080);
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7));
if (value11 < 128L * 128 * 128 * 128 * 128)
{
return(value11 ^ 0x10204080L);
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7 + 7));
if (value11 < 128L * 128 * 128 * 128 * 128 * 128)
{
return(value11 ^ 0x810204080L);
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7 + 7 + 7));
if (value11 < 128L * 128 * 128 * 128 * 128 * 128 * 128)
{
return(value11 ^ 0x40810204080L);
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7 + 7 + 7 + 7));
if (value11 < 128L * 128 * 128 * 128 * 128 * 128 * 128 * 128)
{
return(value11 ^ 0x2040810204080L);
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7 + 7 + 7 + 7 + 7));
return(value11 ^ 0x102040810204080L);
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
if (version != 1)
{
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
private bool TryResumeSession(Stream stream, byte[] certSignatures, out Guid userToken)
{
#if SQLCLR
userToken = Guid.Empty;
return(false);
#else
//Resume Session:
// C => S
// byte ResumeSession
// byte TicketLength
// byte[] Ticket
// byte ClientChallengeLength
// byte[] ClientChallenge
// S <= C
// byte HashMethod
// byte ServerChallengeLength
// byte[] ServerChallenge
IDigest hash = new Sha384Digest();
byte[] serverChallenge = SaltGenerator.Create(16);
stream.WriteByte((byte)HashMethod.Sha384);
stream.WriteByte((byte)serverChallenge.Length);
stream.Write(serverChallenge);
stream.Flush();
// C => S
// byte ClientResponseLength
// byte[] ClientChallenge
byte[] ticket = stream.ReadBytes(stream.ReadNextByte());
byte[] clientChallenge = stream.ReadBytes(stream.ReadNextByte());
byte[] clientResponse = stream.ReadBytes(stream.ReadByte());
// S => C
// bool IsSuccessful
// byte ServerResponseLength
// byte[] ServerResponse
if (TryLoadTicket(ticket, out byte[] secret, out userToken))
/// <summary>
/// Looks in the contents of a file for the block size of the file.
/// </summary>
/// <param name="stream">the stream to look</param>
/// <returns>the number of bytes in a block. Always a power of 2.</returns>
public static int SearchForBlockSize(Stream stream)
{
long oldPosition = stream.Position;
stream.Position = 0;
if (!stream.ReadBytes(26).SequenceEqual(FileAllocationTableHeaderBytes))
{
throw new Exception("This file is not an archive file system, or the file is corrupt, or this file system major version is not recgonized by this version of the historian");
}
char endian = (char)stream.ReadNextByte();
if (BitConverter.IsLittleEndian)
{
if (endian != 'L')
{
throw new Exception("This archive file was not writen with a little endian processor");
}
}
else
{
if (endian != 'B')
{
throw new Exception("This archive file was not writen with a big endian processor");
}
}
byte blockSizePower = stream.ReadNextByte();
if (blockSizePower > 30 || blockSizePower < 5) //Stored as 2^n power.
{
throw new Exception("Block size of this file is not supported");
}
int blockSize = 1 << blockSizePower;
stream.Position = oldPosition;
return(blockSize);
}
public string LoadString(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 0:
return(stream.ReadString());
case 1:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
int id = stream.ReadInt32();
return(m_stringLoadLookup[id]);
}
case 2:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
int id = stream.ReadInt32();
var value = stream.ReadString();
m_stringLoadLookup.Add(value);
return(value);
}
case 3:
{
return(string.Empty);
}
case 4:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
var value = stream.ReadString();
m_stringLoadLookup.Add(value);
return(value);
}
default:
throw new VersionNotFoundException();
}
}
/// <summary>
/// Loads from the supplied stream.
/// </summary>
/// <param name="stream"></param>
public void Load(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
Users.Load(stream);
return;
default:
throw new VersionNotFoundException("Unknown encoding method");
}
}
public LogStackTrace LoadStackTrace(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 0:
return(LogStackTrace.Empty);
case 1:
return(new LogStackTrace(stream));
case 2:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
int id = stream.ReadInt32();
return(m_stackTraceLoadLookup[id]);
}
case 3:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
int id = stream.ReadInt32();
var trace = new LogStackTrace(stream);
m_stackTraceLoadLookup.Add(trace);
return(trace);
}
case 4:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
var trace = new LogStackTrace(stream);
m_stackTraceLoadLookup.Add(trace);
return(trace);
}
default:
throw new VersionNotFoundException();
}
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
/// <summary>
/// Loads from the supplied stream.
/// </summary>
/// <param name="stream"></param>
public void Load(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
Username = stream.ReadString();
UserID = stream.ReadString();
UserToken = stream.ReadGuid();
return;
default:
throw new VersionNotFoundException("Unknown encoding method");
}
}
/// <summary>
/// Loads the token from a stream
/// </summary>
/// <param name="stream">the stream to load from</param>
public void Load(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
CanWrite = stream.ReadBoolean();
CanRead = stream.ReadBoolean();
IsAdmin = stream.ReadBoolean();
break;
default:
throw new VersionNotFoundException("Could not interpret version");
}
}
public PublisherTypeDefinition LoadPublisherTypeDefinition(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 0:
return(new PublisherTypeDefinition(stream));
case 1:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
int id = stream.ReadInt32();
return(m_publisherTypeDefinitionLoadLookup[id]);
}
case 2:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
int id = stream.ReadInt32();
var details = new PublisherTypeDefinition(stream);
m_publisherTypeDefinitionLoadLookup.Add(details);
return(details);
}
case 3:
{
if (m_isSimple)
{
throw new Exception("Cannot load without a LogMessageSaveHelper");
}
var details = new PublisherTypeDefinition(stream);
m_publisherTypeDefinitionLoadLookup.Add(details);
return(details);
}
default:
throw new VersionNotFoundException();
}
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_rolloverInterval = stream.ReadInt32();
m_maximumPointCount = stream.ReadInt32();
m_rolloverPointCount = stream.ReadInt32();
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_logPath = stream.ReadString();
m_logFilePrefix = stream.ReadString();
m_logFileExtension = stream.ReadString();
break;
default:
throw new VersionNotFoundException("Unknown Version Code: " + version);
}
}
/// <summary>
/// Attempts to authenticate the provided stream.
/// </summary>
/// <param name="stream">the stream to authenticate</param>
/// <returns>True if successful, false otherwise</returns>
public bool TryAuthenticate(Stream stream, byte[] additionalChallenge)
{
// Header
// C => S
// byte Mode = (1: New, 2: Resume)
byte mode = stream.ReadNextByte();
Sha512Digest hash = new Sha512Digest();
switch (mode)
{
case 1:
return StandardAuthentication(hash, stream, additionalChallenge);
case 2: //resume ticket
return ResumeTicket(hash, stream, additionalChallenge);
default:
return false;
}
}
/// <summary>
/// Creates a <see cref="LogStackFrame"/> from a <see cref="Stream"/>.
/// </summary>
/// <param name="stream">the stream to load from</param>
public LogStackFrame(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
ClassName = stream.ReadString();
MethodName = stream.ReadString();
FileName = stream.ReadString();
NativeOffset = stream.ReadInt32();
LineNumber = stream.ReadInt32();
ColumnNumber = stream.ReadInt32();
break;
default:
throw new VersionNotFoundException("Unknown StackTraceDetails Version");
}
}
private bool Authenticate(Stream stream, byte[] additionalChallenge)
{
HashMethod passwordHashMethod = (HashMethod)stream.ReadNextByte();
byte[] salt = stream.ReadBytes(stream.ReadNextByte());
int iterations = stream.ReadInt32();
SetHashMethod((HashMethod)stream.ReadNextByte());
SetSrpStrength((SrpStrength)stream.ReadInt32());
m_credentials.TryUpdate(passwordHashMethod, salt, iterations);
BigInteger pubA = m_client.GenerateClientCredentials(m_hash, salt, m_credentials.UsernameBytes, m_credentials.SaltedPassword);
byte[] pubABytes = pubA.ToPaddedArray(m_srpByteLength);
stream.Write(pubABytes);
stream.Flush();
//Read from Server: B
byte[] pubBBytes = stream.ReadBytes(m_srpByteLength);
BigInteger pubB = new BigInteger(1, pubBBytes);
//Calculate Session Key
BigInteger S = m_client.CalculateSecret(m_hash, pubB);
byte[] SBytes = S.ToPaddedArray(m_srpByteLength);
byte[] clientProof = m_hash.ComputeHash(pubABytes, pubBBytes, SBytes, additionalChallenge);
stream.Write(clientProof);
stream.Flush();
byte[] serverProof = m_hash.ComputeHash(pubBBytes, pubABytes, SBytes, additionalChallenge);
if (stream.ReadBoolean())
{
byte[] serverProofCheck = stream.ReadBytes(m_hash.GetDigestSize());
int ticketLength = stream.ReadInt16();
if (ticketLength < 0 || ticketLength > 10000)
return false;
if (serverProofCheck.SecureEquals(serverProof))
{
m_resumeTicket = stream.ReadBytes(ticketLength);
m_sessionSecret = m_hash.ComputeHash(pubABytes, SBytes, pubBBytes).Combine(m_hash.ComputeHash(pubBBytes, SBytes, pubABytes));
return true;
}
return false;
}
return false;
}
public PublisherTypeDefinition LoadPublisherTypeDefinition(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 0:
return new PublisherTypeDefinition(stream);
case 1:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
int id = stream.ReadInt32();
return m_publisherTypeDefinitionLoadLookup[id];
}
case 2:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
int id = stream.ReadInt32();
var details = new PublisherTypeDefinition(stream);
m_publisherTypeDefinitionLoadLookup.Add(details);
return details;
}
case 3:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
var details = new PublisherTypeDefinition(stream);
m_publisherTypeDefinitionLoadLookup.Add(details);
return details;
}
default:
throw new VersionNotFoundException();
}
}
public LogStackTrace LoadStackTrace(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 0:
return LogStackTrace.Empty;
case 1:
return new LogStackTrace(stream);
case 2:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
int id = stream.ReadInt32();
return m_stackTraceLoadLookup[id];
}
case 3:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
int id = stream.ReadInt32();
var trace = new LogStackTrace(stream);
m_stackTraceLoadLookup.Add(trace);
return trace;
}
case 4:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
var trace = new LogStackTrace(stream);
m_stackTraceLoadLookup.Add(trace);
return trace;
}
default:
throw new VersionNotFoundException();
}
}
public string LoadString(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 0:
return stream.ReadString();
case 1:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
int id = stream.ReadInt32();
return m_stringLoadLookup[id];
}
case 2:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
int id = stream.ReadInt32();
var value = stream.ReadString();
m_stringLoadLookup.Add(value);
return value;
}
case 3:
{
return string.Empty;
}
case 4:
{
if (m_isSimple)
throw new Exception("Cannot load without a LogMessageSaveHelper");
var value = stream.ReadString();
m_stringLoadLookup.Add(value);
return value;
}
default:
throw new VersionNotFoundException();
}
}
private bool TryResumeSession(ref Stream secureStream, Stream stream2, byte[] certSignatures)
{
#if SQLCLR
return false;
#else
if (m_resumeTicket != null && m_sessionSecret != null)
{
//Resume Session:
// C => S
// byte ResumeSession
// byte TicketLength
// byte[] Ticket
// byte ClientChallengeLength
// byte[] ClientChallenge
byte[] clientChallenge = SaltGenerator.Create(16);
stream2.WriteByte((byte)AuthenticationMode.ResumeSession);
stream2.WriteByte((byte)m_resumeTicket.Length);
stream2.Write(m_resumeTicket);
stream2.WriteByte((byte)clientChallenge.Length);
stream2.Write(clientChallenge);
stream2.Flush();
// S <= C
// byte HashMethod
// byte ServerChallengeLength
// byte[] ServerChallenge
HashMethod hashMethod = (HashMethod)stream2.ReadNextByte();
IDigest hash = Scram.CreateDigest(hashMethod);
byte[] serverChallenge = stream2.ReadBytes(stream2.ReadNextByte());
// C => S
// byte ClientResponseLength
// byte[] ClientChallenge
byte[] clientResponse = hash.ComputeHash(serverChallenge, clientChallenge, m_sessionSecret, certSignatures);
byte[] serverResponse = hash.ComputeHash(clientChallenge, serverChallenge, m_sessionSecret, certSignatures);
stream2.WriteByte((byte)clientResponse.Length);
stream2.Write(clientResponse);
stream2.Flush();
// S => C
// bool IsSuccessful
// byte ServerResponseLength
// byte[] ServerResponse
if (stream2.ReadBoolean())
{
byte[] serverResponseCheck = stream2.ReadBytes(stream2.ReadNextByte());
// C => S
// bool IsSuccessful
if (serverResponse.SecureEquals(serverResponseCheck))
{
stream2.Write(true);
stream2.Flush();
secureStream = stream2;
return true;
}
stream2.Write(false);
stream2.Flush();
}
m_resumeTicket = null;
m_sessionSecret = null;
}
return false;
#endif
}
/// <summary>
/// Loads from the supplied stream.
/// </summary>
/// <param name="stream"></param>
public void Load(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
Users.Load(stream);
return;
default:
throw new VersionNotFoundException("Unknown encoding method");
}
}
/// <summary>
/// Reads a 7-bit encoded uint.
/// </summary>
/// <param name="stream">A stream to read from.</param>
/// <returns>the value</returns>
/// <remarks>
/// This method will check for the end of the stream
/// </remarks>
/// <exception cref="EndOfStreamException">Occurs if the end of the stream was reached.</exception>
public static short ReadInt15(Stream stream)
{
short value11;
value11 = stream.ReadNextByte();
if (value11 < 128)
{
return value11;
}
value11 ^= (short)(stream.ReadNextByte() << 7);
return (short)(value11 ^ 0x80);
}
/// <summary>
/// Loads from the supplied stream.
/// </summary>
/// <param name="stream"></param>
public void Load(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
lock (m_users)
{
int count = stream.ReadInt32();
m_users.Clear();
while (count > 0)
{
count--;
var user = new IntegratedSecurityUserCredential(stream);
m_users.Add(user.UserID, user);
}
}
return;
default:
throw new VersionNotFoundException("Unknown encoding method");
}
}
private bool ResumeTicket(IDigest hash, Stream stream, byte[] additionalChallenge)
{
// Successful Resume Session (If mode = 1)
// C => S
// byte ChallengeLength
// byte[] A = Challenge
// int16 TicketLength
// byte[] Ticket
// C <= S
// bool IsSuccess = true
// byte HashMethod
// byte ChallengeLength
// byte[] B = Challenge
// C => S
// byte[] M1 = H(A | B | SessionKey)
// Bool Success (if false, done)
// C <= S
// byte[] M2 = H(B | A | SessionKey)
// Failed Resume Session
// C => S
// byte ChallengeLength
// byte[] A = Challenge
// int16 TicketLength
// byte[] Ticket
// C <= S
// bool IsSuccess = false
// Goto Authenticate Code
byte[] a = stream.ReadBytes(stream.ReadNextByte());
int ticketLength = stream.ReadInt16();
if (ticketLength < 0 || ticketLength > 10000)
return false;
byte[] ticket = stream.ReadBytes(ticketLength);
if (TryLoadTicket(ticket, m_user, out SessionSecret))
{
stream.Write(true);
stream.WriteByte((byte)SrpHashMethod);
byte[] b = SaltGenerator.Create(16);
stream.WriteByte(16);
stream.Write(b);
stream.Flush();
byte[] clientProofCheck = hash.ComputeHash(a, b, SessionSecret, additionalChallenge);
byte[] serverProof = hash.ComputeHash(b, a, SessionSecret, additionalChallenge);
byte[] clientProof = stream.ReadBytes(hash.GetDigestSize());
if (clientProof.SecureEquals(clientProofCheck))
{
stream.Write(true);
stream.Write(serverProof);
stream.Flush();
return true;
}
stream.Write(false);
return false;
}
stream.Write(false);
return StandardAuthentication(hash, stream, additionalChallenge);
}
private bool ResumeSession(Stream stream, byte[] additionalChallenge)
{
stream.Write((byte)16);
byte[] aChallenge = SaltGenerator.Create(16);
stream.Write(aChallenge);
stream.Write((short)m_resumeTicket.Length);
stream.Write(m_resumeTicket);
stream.Flush();
if (stream.ReadBoolean())
{
SetHashMethod((HashMethod)stream.ReadNextByte());
byte[] bChallenge = stream.ReadBytes(stream.ReadNextByte());
byte[] clientProof = m_hash.ComputeHash(aChallenge, bChallenge, m_sessionSecret, additionalChallenge);
stream.Write(clientProof);
stream.Flush();
if (stream.ReadBoolean())
{
byte[] serverProof = m_hash.ComputeHash(bChallenge, aChallenge, m_sessionSecret, additionalChallenge);
byte[] serverProofCheck = stream.ReadBytes(m_hash.GetDigestSize());
return serverProof.SecureEquals(serverProofCheck);
}
}
m_sessionSecret = null;
m_resumeTicket = null;
return Authenticate(stream, additionalChallenge);
}
/// <summary>
/// Reads a 7-bit encoded ulong.
/// </summary>
/// <param name="stream">A stream to read from.</param>
/// <returns>the value</returns>
/// <remarks>
/// This method will check for the end of the stream
/// </remarks>
/// <exception cref="EndOfStreamException">Occurs if the end of the stream was reached.</exception>
public static ulong ReadUInt64(Stream stream)
{
ulong value11;
value11 = stream.ReadNextByte();
if (value11 < 128)
{
return value11;
}
value11 ^= ((ulong)stream.ReadNextByte() << (7));
if (value11 < 128 * 128)
{
return value11 ^ 0x80;
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7));
if (value11 < 128 * 128 * 128)
{
return value11 ^ 0x4080;
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7));
if (value11 < 128 * 128 * 128 * 128)
{
return value11 ^ 0x204080;
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7));
if (value11 < 128L * 128 * 128 * 128 * 128)
{
return value11 ^ 0x10204080L;
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7 + 7));
if (value11 < 128L * 128 * 128 * 128 * 128 * 128)
{
return value11 ^ 0x810204080L;
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7 + 7 + 7));
if (value11 < 128L * 128 * 128 * 128 * 128 * 128 * 128)
{
return value11 ^ 0x40810204080L;
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7 + 7 + 7 + 7));
if (value11 < 128L * 128 * 128 * 128 * 128 * 128 * 128 * 128)
{
return value11 ^ 0x2040810204080L;
}
value11 ^= ((ulong)stream.ReadNextByte() << (7 + 7 + 7 + 7 + 7 + 7 + 7 + 7));
return value11 ^ 0x102040810204080L;
}
/// <summary>
/// Loads from the supplied stream.
/// </summary>
/// <param name="stream"></param>
public void Load(Stream stream)
{
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
Username = stream.ReadString();
UserID = stream.ReadString();
UserToken = stream.ReadGuid();
return;
default:
throw new VersionNotFoundException("Unknown encoding method");
}
}
/// <summary>
/// Reads a 7-bit encoded uint.
/// </summary>
/// <param name="stream">A stream to read from.</param>
/// <returns>the value</returns>
/// <remarks>
/// This method will check for the end of the stream
/// </remarks>
/// <exception cref="EndOfStreamException">Occurs if the end of the stream was reached.</exception>
public static uint ReadUInt32(Stream stream)
{
uint value11;
value11 = stream.ReadNextByte();
if (value11 < 128)
{
return value11;
}
value11 ^= ((uint)stream.ReadNextByte() << 7);
if (value11 < 128 * 128)
{
return value11 ^ 0x80;
}
value11 ^= ((uint)stream.ReadNextByte() << 14);
if (value11 < 128 * 128 * 128)
{
return value11 ^ 0x4080;
}
value11 ^= ((uint)stream.ReadNextByte() << 21);
if (value11 < 128 * 128 * 128 * 128)
{
return value11 ^ 0x204080;
}
value11 ^= ((uint)stream.ReadNextByte() << 28) ^ 0x10204080;
return value11;
}
/// <summary>
/// Loads a log messages from the supplied stream
/// </summary>
/// <param name="stream">the stream to load the log message from.</param>
/// <param name="saveHelper">A save helper that will condense objects</param>
internal LogMessage(Stream stream, LogMessageSaveHelper saveHelper = null)
{
if (saveHelper == null)
saveHelper = LogMessageSaveHelper.Create(true);
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
EventPublisherDetails = saveHelper.LoadEventPublisherDetails(stream);
InitialStackMessages = saveHelper.LoadStackMessages(stream);
InitialStackTrace = saveHelper.LoadStackTrace(stream);
CurrentStackMessages = saveHelper.LoadStackMessages(stream);
CurrentStackTrace = saveHelper.LoadStackTrace(stream);
UtcTime = stream.ReadDateTime();
LogMessageAttributes = new LogMessageAttributes(stream);
Message = stream.ReadString();
Details = stream.ReadString();
Exception = null;
ExceptionString = stream.ReadString();
ManagedThreadID = -1;
PreviousFirstChanceExceptionSequenceNumber = -1;
break;
case 2:
EventPublisherDetails = saveHelper.LoadEventPublisherDetails(stream);
InitialStackMessages = saveHelper.LoadStackMessages(stream);
InitialStackTrace = saveHelper.LoadStackTrace(stream);
CurrentStackMessages = saveHelper.LoadStackMessages(stream);
CurrentStackTrace = saveHelper.LoadStackTrace(stream);
UtcTime = stream.ReadDateTime();
LogMessageAttributes = new LogMessageAttributes(stream);
Message = stream.ReadString();
Details = stream.ReadString();
Exception = null;
ExceptionString = stream.ReadString();
ManagedThreadID = stream.ReadInt32();
PreviousFirstChanceExceptionSequenceNumber = -1;
break;
case 3:
EventPublisherDetails = saveHelper.LoadEventPublisherDetails(stream);
InitialStackMessages = saveHelper.LoadStackMessages(stream);
InitialStackTrace = saveHelper.LoadStackTrace(stream);
CurrentStackMessages = saveHelper.LoadStackMessages(stream);
CurrentStackTrace = saveHelper.LoadStackTrace(stream);
UtcTime = stream.ReadDateTime();
LogMessageAttributes = new LogMessageAttributes(stream);
Message = saveHelper.LoadString(stream);
Details = saveHelper.LoadString(stream);
Exception = null;
ExceptionString = saveHelper.LoadString(stream);
ManagedThreadID = stream.ReadInt32();
PreviousFirstChanceExceptionSequenceNumber = -1;
break;
case 4:
EventPublisherDetails = saveHelper.LoadEventPublisherDetails(stream);
InitialStackMessages = saveHelper.LoadStackMessages(stream);
InitialStackTrace = saveHelper.LoadStackTrace(stream);
CurrentStackMessages = saveHelper.LoadStackMessages(stream);
CurrentStackTrace = saveHelper.LoadStackTrace(stream);
UtcTime = stream.ReadDateTime();
LogMessageAttributes = new LogMessageAttributes(stream);
Message = saveHelper.LoadString(stream);
Details = saveHelper.LoadString(stream);
Exception = null;
ExceptionString = saveHelper.LoadString(stream);
ManagedThreadID = stream.ReadInt32();
PreviousFirstChanceExceptionSequenceNumber = stream.ReadInt32();
break;
default:
throw new VersionNotFoundException();
}
}
