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 GMDataFile(GMAssets _a, Stream _stream)
{
int num = _stream.ReadInteger();
FileName = _stream.ReadString();
OrigName = _stream.ReadString();
Exists = _stream.ReadBoolean();
Size = _stream.ReadInteger();
Store = _stream.ReadBoolean();
if (Exists && Store)
{
switch (num)
{
case 620:
Data = _stream.ReadCompressedStream();
break;
case 800:
Data = _stream.ReadStream();
break;
}
}
ExportAction = _stream.ReadInteger();
ExportDir = _stream.ReadString();
Overwrite = _stream.ReadBoolean();
FreeData = _stream.ReadBoolean();
RemoveEnd = _stream.ReadBoolean();
}
public GMSound(GMAssets _a, Stream _s)
{
int num = _s.ReadInteger();
Kind = _s.ReadInteger();
Extension = _s.ReadString();
OrigName = _s.ReadString();
if (OrigName == "")
{
OrigName = "Dummy" + Extension;
}
bool flag = _s.ReadBoolean();
Data = null;
if (flag)
{
switch (num)
{
case 600:
Data = _s.ReadCompressedStream();
break;
case 800:
Data = _s.ReadStream();
break;
}
}
Effects = _s.ReadInteger();
Volume = _s.ReadDouble();
Pan = _s.ReadDouble();
Preload = _s.ReadBoolean();
}
public GMBackground(GMAssets _a, Stream _s)
{
switch (_s.ReadInteger())
{
case 543:
Width = _s.ReadInteger();
Height = _s.ReadInteger();
Transparent = _s.ReadBoolean();
Smooth = _s.ReadBoolean();
Preload = _s.ReadBoolean();
Tileset = false;
if (_s.ReadBoolean())
{
Bitmap = new GMBitmap32(_s);
}
break;
case 710:
Bitmap = new GMBitmap32(_s);
Width = _s.ReadInteger();
Height = _s.ReadInteger();
Width = Bitmap.Width;
Height = Bitmap.Height;
break;
}
}
public GMAction(GMAssets _a, Stream _stream)
{
_stream.ReadInteger();
LibID = _stream.ReadInteger();
ID = _stream.ReadInteger();
Kind = (eAction)_stream.ReadInteger();
UseRelative = _stream.ReadBoolean();
IsQuestion = _stream.ReadBoolean();
UseApplyTo = _stream.ReadBoolean();
ExeType = (eExecuteTypes)_stream.ReadInteger();
Name = _stream.ReadString();
Code = _stream.ReadString();
ArgumentCount = _stream.ReadInteger();
int num = _stream.ReadInteger();
ArgTypes = new List <eArgTypes>(num);
for (int i = 0; i < num; i++)
{
ArgTypes.Add((eArgTypes)_stream.ReadInteger());
}
Who = _stream.ReadInteger();
Relative = _stream.ReadBoolean();
num = _stream.ReadInteger();
Args = new List <string>(num);
for (int j = 0; j < num; j++)
{
Args.Add(_stream.ReadString());
}
IsNot = _stream.ReadBoolean();
}
public override void ReadFromStream(Stream aStream)
{
A = aStream.ReadFloat();
B = aStream.ReadFloat();
C = aStream.ReadBoolean();
D = aStream.ReadBoolean();
E = aStream.ReadFloat();
F = aStream.ReadFloat();
}
public GMFont(GMAssets _a, Stream _s)
{
int num = _s.ReadInteger();
Name = _s.ReadString();
Size = _s.ReadInteger();
Bold = _s.ReadBoolean();
Italic = _s.ReadBoolean();
First = _s.ReadInteger();
Last = _s.ReadInteger();
CharSet = ((First >> 16) & 0xFF);
AntiAlias = ((First >> 24) & 0xFF);
First &= 65535;
Glyphs = new List <GMGlyph>();
for (int i = 0; i < 256; i++)
{
int x = _s.ReadInteger();
int y = _s.ReadInteger();
int w = _s.ReadInteger();
int h = _s.ReadInteger();
int shift = _s.ReadInteger();
int offset = _s.ReadInteger();
Glyphs.Add(new GMGlyph(x, y, w, h, shift, offset));
}
int num2 = _s.ReadInteger();
int num3 = _s.ReadInteger();
byte[] array = null;
array = ((num != 540) ? _s.ReadStream() : _s.ReadCompressedStream());
Bitmap = new Bitmap(num2, num3, PixelFormat.Format32bppArgb);
Rectangle rect = new Rectangle(0, 0, Bitmap.Width, Bitmap.Height);
BitmapData bitmapData = Bitmap.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
IntPtr intPtr = new IntPtr(bitmapData.Scan0.ToInt64());
int num4 = 0;
int num5 = 0;
while (num5 < num3)
{
int num6 = num4;
IntPtr ptr = intPtr;
int num7 = 0;
while (num7 < num2)
{
int val = 16777215 + (array[num6] << 24);
Marshal.WriteInt32(ptr, val);
num7++;
num6++;
ptr = new IntPtr(ptr.ToInt64() + 4);
}
num5++;
intPtr = new IntPtr(intPtr.ToInt64() + bitmapData.Stride);
num4 += num2;
}
Bitmap.UnlockBits(bitmapData);
}
public GMBack(Stream _stream)
{
Visible = _stream.ReadBoolean();
Foreground = _stream.ReadBoolean();
Index = _stream.ReadInteger();
X = _stream.ReadInteger();
Y = _stream.ReadInteger();
HTiled = _stream.ReadBoolean();
VTiled = _stream.ReadBoolean();
HSpeed = _stream.ReadInteger();
VSpeed = _stream.ReadInteger();
Blend = 16777215;
Alpha = 1.0;
Stretch = _stream.ReadBoolean();
}
public static NotificationRequest ReadBody(Stream stream)
{
var feed = stream.ReadString();
var isAdd = stream.ReadBoolean();
return(new NotificationRequest(feed, isAdd));
}
public void Unpack(Stream stream)
{
var flags = (TileFlags)stream.ReadInt8();
Active = flags.HasFlag(TileFlags.Active);
if (Active)
{
Type = stream.ReadInt8();
if (FrameImportant)
{
FrameX = stream.ReadInt16();
FrameY = stream.ReadInt16();
}
}
if (flags.HasFlag(TileFlags.Wall))
{
Wall = stream.ReadInt8();
}
if (flags.HasFlag(TileFlags.Liquid))
{
Liquid = stream.ReadInt8();
Lava = stream.ReadBoolean();
}
if (flags.HasFlag(TileFlags.Wire))
{
Wire = true;
}
}
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);
}
}
IJsonValue ParseAMF(Stream stream)
{
int type = (int)stream.ReadUInt8(); //1
switch (type)
{
case 0: return(JsonValue.CreateNumberValue(stream.ReadDouble(true))); //8
case 1: return(JsonValue.CreateBooleanValue(stream.ReadBoolean()));; //1
case 3:
var data = new JsonObject();
while (true)
{
var l3 = (int)stream.ReadUInt16();
if (l3 == 0)
{
if (stream.ReadUInt8() == 9)
{
break;
}
}
var s3 = stream.ReadString(l3);
var d3 = ParseAMF(stream);
data.Add(s3, d3); //n
}
return(data);
case 2:
var len = stream.ReadUInt16();
return(JsonValue.CreateStringValue(stream.ReadString((int)len))); //n
case 8:
var l8 = stream.ReadUInt32();
var obj = new JsonObject();
for (int i = 0; i < l8; i++)
{
var key = stream.ReadString((int)stream.ReadUInt16()); //2+n
var val = ParseAMF(stream); //n
obj.Add(key, val);
}
return(obj);
case 9:
return(null); //END
case 10:
var l10 = stream.ReadUInt32();
var arr = new JsonArray();
for (int i = 0; i < l10; i++)
{
var val = ParseAMF(stream); //n
arr.Add(val);
}
return(arr);
default:
throw new Exception("JsonValue:" + type);
}
}
public void Room_Load(Stream _s)
{
int num = _s.ReadInteger();
int num2 = _s.ReadInteger();
for (int i = 0; i < num2; i++)
{
Stream stream = _s;
if (num == 800)
{
stream = _s.ReadStreamC();
}
bool flag = stream.ReadBoolean();
KeyValuePair <string, GMRoom> item = default(KeyValuePair <string, GMRoom>);
if (flag)
{
string key = stream.ReadString();
GMRoom value = new GMRoom(this, stream);
item = new KeyValuePair <string, GMRoom>(key, value);
}
Rooms.Add(item);
}
RoomMaxId = _s.ReadInteger();
RoomMaxTileId = _s.ReadInteger();
}
public static Object ReadFromStream(Stream stream, ZoneType zoneType)
{
Object obj = new Object();
obj.ActorDefinition = stream.ReadString(StringCoding.ZeroTerminated);
obj.RenderDistance = stream.ReadSingle();
obj.Instances = new List <Instance>();
uint instancesLength = stream.ReadUInt32();
for (uint i = 0; i < instancesLength; i++)
{
Instance instance = new Instance();
instance.Position = stream.ReadVector4();
instance.Rotation = stream.ReadVector4();
instance.Scale = stream.ReadVector4();
instance.ID = stream.ReadUInt32();
instance.DontCastShadows = stream.ReadBoolean();
instance.LODMultiplier = stream.ReadSingle();
if (zoneType == ZoneType.H1Z1)
{
instance.UnknownDword1 = stream.ReadUInt32();
instance.UnknownDword2 = stream.ReadUInt32();
instance.UnknownDword3 = stream.ReadUInt32();
instance.UnknownDword4 = stream.ReadUInt32();
instance.UnknownDword5 = stream.ReadUInt32();
}
obj.Instances.Add(instance);
}
return(obj);
}
private void ReadConstants()
{
int Count = Stream.ReadInt32();
List <LuaConstant> Consts = new List <LuaConstant>(Count);
for (int Idx = 0; Idx < Count; Idx++)
{
LuaConstantType Type = (LuaConstantType)Stream.ReadByte();
LuaConstant Const = LuaNil;
if (Type == LuaConstantType.BOOL)
{
Const = Stream.ReadBoolean();
}
else if (Type == LuaConstantType.NUMBER)
{
Const = Stream.ReadDouble();
}
else if (Type == LuaConstantType.STRING)
{
Const = Stream.ReadCString();
}
Consts.Add(Const);
}
Proto.Consts = Consts;
}
public static MonitorRequest ReadBody(Stream stream)
{
var feed = stream.ReadString();
var isAdd = stream.ReadBoolean();
return(new MonitorRequest(feed, isAdd));
}
/// <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 static ForwardedSubscriptionRequest ReadBody(Stream stream)
{
var clientId = stream.ReadInt32();
var topic = stream.ReadString();
var isAdd = stream.ReadBoolean();
return new ForwardedSubscriptionRequest(clientId, topic, isAdd);
}
internal void Read(Stream reader)
{
AddinId = new AddinId();
AddinId.Read(reader);
FriendName = reader.ReadString();
Description = reader.ReadString();
Version = reader.ReadVersion();
CompatVersion = reader.ReadVersion();
Url = reader.ReadString();
Enabled = reader.ReadBoolean();
AddinCategory = (AddinCategory)reader.ReadSByte();
var count = reader.ReadInt32();
if (count <= 0)
{
return;
}
var result = new Dictionary <string, string>(count);
for (int i = 0; i < count; i++)
{
var key = reader.ReadString();
var value = reader.ReadString();
result.Add(key, value);
}
Properties = result;
}
internal void Read(Stream reader, string parentPath)
{
Head = new ExtensionHeadRecord();
Head.Read(reader);
Head.ParentPath = parentPath; // assign the parent path first!!!!
var hasData = reader.ReadBoolean();
if (hasData)
{
Data = new ExtensionDataRecord();
Data.Read(reader);
}
var childCount = reader.ReadInt32();
if (childCount > 0)
{
_children = new List <ExtensionRecord>(childCount);
for (int i = 0; i < childCount; i++)
{
var child = new ExtensionRecord();
child.Read(reader, Head.Path);
_children.Add(child);
}
}
}
public override void Load(Stream stream)
{
TestForEditable();
byte version = stream.ReadNextByte();
switch (version)
{
case 1:
m_directoryMethod = (ArchiveDirectoryMethod)stream.ReadInt32();
m_isMemoryArchive = stream.ReadBoolean();
m_prefix = stream.ReadString();
m_fileExtension = 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 static SubscriptionRequest ReadBody(Stream stream)
{
var feed = stream.ReadString();
var topic = stream.ReadString();
var isAdd = stream.ReadBoolean();
return(new SubscriptionRequest(feed, topic, isAdd));
}
public override void ReadFromStream(Stream aStream)
{
X = aStream.ReadDouble();
Y = aStream.ReadDouble();
Stance = aStream.ReadDouble();
Z = aStream.ReadDouble();
OnGround = aStream.ReadBoolean();
}
public static InteractorAdvertisement ReadBody(Stream stream)
{
var user = stream.ReadString();
var address = stream.ReadIPAddress();
var isJoining = stream.ReadBoolean();
return(new InteractorAdvertisement(user, address, isJoining));
}
/// <summary>
/// Reads a string from a <see cref="Stream"/> that was encoded in UTF8.
/// Value can be null and is prefixed with a boolean.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static string ReadNullableString(this Stream stream)
{
if (stream.ReadBoolean())
{
return(stream.ReadString());
}
return(null);
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
protected override void LoadData(Stream stream)
{
FrameTime = stream.ReadUInt32();
WhiteBackground = stream.ReadBoolean();
uint bitmapDataSize = stream.ReadUInt32();
Data = new FrameBitmapData(stream.ReadBytes((int)bitmapDataSize));
}
public GMRoom(GMAssets _a, Stream _stream)
{
int num = _stream.ReadInteger();
Caption = _stream.ReadString();
Width = _stream.ReadInteger();
Height = _stream.ReadInteger();
Speed = _stream.ReadInteger();
Persistent = _stream.ReadBoolean();
Colour = _stream.ReadInteger();
int num2 = _stream.ReadInteger();
ShowColour = ((num2 & 1) != 0);
ViewClearScreen = ((num2 & 2) == 0);
Code = _stream.ReadString();
int num3 = _stream.ReadInteger();
Backgrounds = new List <GMBack>(num3);
for (int i = 0; i < num3; i++)
{
GMBack item = new GMBack(_stream);
Backgrounds.Add(item);
}
EnableViews = _stream.ReadBoolean();
num3 = _stream.ReadInteger();
Views = new List <GMView>(num3);
for (int j = 0; j < num3; j++)
{
GMView item2 = new GMView(_stream);
Views.Add(item2);
}
num3 = _stream.ReadInteger();
Instances = new List <GMInstance>(num3);
for (int k = 0; k < num3; k++)
{
GMInstance item3 = new GMInstance(_stream, num);
Instances.Add(item3);
}
num3 = _stream.ReadInteger();
Tiles = new List <GMTile>(num3);
for (int l = 0; l < num3; l++)
{
GMTile item4 = new GMTile(_stream, num);
Tiles.Add(item4);
}
}
} // 插件二进制数据的长度
internal void Read(Stream stream)
{
//Status = (AddinStatus)stream.ReadSByte();
Enabled = stream.ReadBoolean();
AddinUid = stream.ReadInt32();
Position = stream.ReadInt64();
Length = stream.ReadInt64();
}
/// <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();
}
public static ForwardedSubscriptionRequest ReadBody(Stream stream)
{
var clientId = stream.ReadGuid();
var feed = stream.ReadString();
var topic = stream.ReadString();
var isAdd = stream.ReadBoolean();
return(new ForwardedSubscriptionRequest(clientId, feed, topic, isAdd));
}
public void Read(Stream source)
{
this.Error = source.ReadErrorCode();
this.Name = source.ReadCompactString();
this.IsInternal = source.ReadBoolean();
this.Partitions = source.ReadCompactArray <Partition>();
this.TopicAuthorizedOperations = source.ReadInt32();
this.TaggedFields = source.ReadTaggedFields();
}
public static MulticastData ReadBody(Stream stream)
{
var topic = stream.ReadString();
var isImage = stream.ReadBoolean();
var nbytes = stream.ReadInt32();
var data = new byte[nbytes];
var offset = 0;
while (nbytes > 0)
{
var bytesRead = stream.Read(data, offset, nbytes);
if (bytesRead == 0)
throw new EndOfStreamException();
nbytes -= bytesRead;
offset += bytesRead;
}
return new MulticastData(topic, isImage, data);
}
public static SetupMessage FromStream(DateTime timestamp, Stream stream)
{
bool? ex = stream.ReadNullBoolean();
bool? low = stream.ReadNullBoolean();
int count = stream.ReadInt32();
var contributors = new Models.GameSettings.Contributor[count];
for (int i = 0; i < count; i++)
{
var name = stream.ReadString();
var active = stream.ReadBoolean();
contributors[i] = new Models.GameSettings.Contributor() { Name = name, Active = active };
}
var settings = new Models.GameSettings()
{
ExcludeMerges = ex,
LowerCase = low,
Contributors = contributors
};
return new SetupMessage(timestamp, settings);
}
public override void ReadFromStream(Stream aStream)
{
A = aStream.ReadFloat ();
B = aStream.ReadFloat ();
C = aStream.ReadBoolean ();
D = aStream.ReadBoolean ();
E = aStream.ReadFloat ();
F = aStream.ReadFloat ();
}
public static SubscriptionRequest ReadBody(Stream stream)
{
var topic = stream.ReadString();
var isAdd = stream.ReadBoolean();
return new SubscriptionRequest(topic, isAdd);
}
public void Unpack(Stream stream)
{
var flags = (TileFlags) stream.ReadInt8();
Active = flags.HasFlag(TileFlags.Active);
if (Active)
{
Type = stream.ReadInt8();
if (FrameImportant)
{
FrameX = stream.ReadInt16();
FrameY = stream.ReadInt16();
}
}
if (flags.HasFlag(TileFlags.Wall))
{
Wall = stream.ReadInt8();
}
if (flags.HasFlag(TileFlags.Liquid))
{
Liquid = stream.ReadInt8();
Lava = stream.ReadBoolean();
}
if (flags.HasFlag(TileFlags.Wire))
Wire = true;
}
public static NotificationRequest ReadBody(Stream stream)
{
var topicPattern = stream.ReadString();
var isAdd = stream.ReadBoolean();
return new NotificationRequest(topicPattern, isAdd);
}
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);
}
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 override void ReadFromStream(Stream aStream)
{
X = aStream.ReadInt ();
Z = aStream.ReadInt ();
Mode = aStream.ReadBoolean ();
}
public override void ReadFromStream(Stream aStream)
{
X = aStream.ReadDouble ();
Stance = aStream.ReadDouble ();
Y = aStream.ReadDouble ();
Z = aStream.ReadDouble ();
Yaw = aStream.ReadFloat ();
Pitch = aStream.ReadFloat ();
OnGround = aStream.ReadBoolean ();
}
public override void ReadFromStream(Stream aStream)
{
Yaw = aStream.ReadFloat ();
Pitch = aStream.ReadFloat ();
OnGround = aStream.ReadBoolean ();
}
public override void ReadFromStream(Stream aStream)
{
OnGround = aStream.ReadBoolean ();
}
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
}
public static object Read(Stream stream)
{
return stream.ReadBoolean();
}
public override void ReadFromStream(Stream aStream)
{
UserID = aStream.ReadInt ();
TargetID = aStream.ReadInt ();
LeftClick = aStream.ReadBoolean ();
}
