public ClaimsSetMetadata(byte[] data)
{
var pacStream = new NdrBinaryReader(data);
Header = new RpcHeader(pacStream);
ClaimSetSize = pacStream.ReadInt();
pacStream.Seek(4);
CompressionFormat = (CompressionFormat)pacStream.ReadInt();
UncompressedClaimSetSize = pacStream.ReadInt();
ReservedType = pacStream.ReadShort();
ReservedFieldSize = pacStream.ReadInt();
pacStream.Align(8);
var size = pacStream.ReadInt();
if (size != ClaimSetSize)
{
throw new InvalidDataException($"Data length {size} doesn't match expected ClaimSetSize {ClaimSetSize}");
}
var claimSet = pacStream.Read(ClaimSetSize);
if (CompressionFormat != CompressionFormat.COMPRESSION_FORMAT_NONE)
{
claimSet = Compressions.Decompress(claimSet, UncompressedClaimSetSize, CompressionFormat);
}
ClaimsSet = new ClaimsSet(claimSet);
ReservedField = pacStream.Read(ReservedFieldSize);
}
protected NdrMessage(byte[] data) : base(data)
{
if ((data?.Length ?? 0) <= 0)
{
return;
}
Header = Stream.ReadNdrHeader();
}
public void Response(Action body, RpcHeader header)
{
var before = m.Position;
m.Seek(RpcHeader.HeaderLength, SeekOrigin.Current);
body();
var after = m.Position;
m.Seek(before, SeekOrigin.Begin);
Write(header.Response((uint)(after - before - RpcHeader.HeaderLength)));
m.Seek(after, SeekOrigin.Begin);
}
public Action <Writer> Dispatch(RpcHeader header)
{
#if DEBUG
assert(header.Length, "RpcBody " + (MethodId)header.MethodId);
#endif
switch ((MethodId)header.MethodId)
{
case MethodId.Add:
return(_ => OnAdd(r.ReadInt32()));
case MethodId.Echo:
return(_ => OnEcho(r.ReadFullType()));
case MethodId.Exchange:
return(_ => OnExchange(r.ReadItemArray()));
case MethodId.Get:
return(_ => OnGet(r.ReadItem()));
case MethodId.Change:
Item[] consume = r.ReadItemArray();
return(w => w.ResponseChange(OnChange(consume), header));
case MethodId.Ping:
FullType type = r.ReadFullType();
return(w => w.ResponsePing(OnPing(type), header));
default:
return(null);
}
}
public IEnumerator <uint> Parse(Func <MemoryStream> get, BinaryPackerWriterEx w)
{
while (true)
{
yield return(RpcHeader.HeaderLength);
var r = new BinaryPackerReaderEx(get());
var header = new RpcHeader(r.ReadUInt32());
yield return(header.Length);
switch ((MethodId)header.MethodId)
{
case MethodId.Add:
OnAdd(r.ReadInt32());
break;
case MethodId.Echo:
OnEcho(r.ReadFullType());
break;
case MethodId.Exchange:
OnExchange(r.ReadItemArray());
break;
case MethodId.Get:
OnGet(r.ReadItem());
break;
case MethodId.Change:
Item[] consume = r.ReadItemArray();
w.Write(OnChange(consume));
break;
case MethodId.Ping:
FullType type = r.ReadFullType();
w.Write(OnPing(type));
break;
// invalid case
default:
throw new InvalidDataException("Invalid methodId = " + header.MethodId);
}
}
}
public static RpcHeader FromStream(BinaryReader reader)
{
RpcHeader header = new RpcHeader();
header.MajorVersion = reader.ReadByte();
header.MinorVersion = reader.ReadByte();
header.PacketType = reader.ReadByte();
header.PacketFlags = reader.ReadByte();
header.DataRepresentation = reader.ReadUInt32();
header.FragLength = reader.ReadUInt16();
header.AuthLength = reader.ReadUInt16();
header.CallId = reader.ReadUInt32();
header.Data = reader.ReadBytes(header.FragLength - header.AuthLength - 16);
header.AuthData = reader.ReadBytes(header.AuthLength);
return(header);
}
static void WriterThread(object o)
{
RpcContextSplit ctx = (RpcContextSplit)o;
try
{
while (true)
{
RpcHeader header = RpcHeader.FromStream(ctx.serverReader);
//Console.WriteLine("<= Packet: {0} Data: {1} Auth: {2}", header.PacketType, header.FragLength, header.AuthLength);
header.ToStream(ctx.clientWriter);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine("Stopping Writer Thread");
ctx.client.Client.Shutdown(SocketShutdown.Send);
ctx.server.Client.Shutdown(SocketShutdown.Receive);
}
public Action<Writer> Dispatch(RpcHeader header)
{
#if DEBUG
assert(header.Length, "RpcBody " + (MethodId)header.MethodId);
#endif
switch((MethodId)header.MethodId)
{
case MethodId.Change:
return _ => OnChange(r.ReadItemArray());
case MethodId.Ping:
return _ => OnPing(r.ReadFullType());
case MethodId.Add:
Int32 a = r.ReadInt32();
Int32 b = r.ReadInt32();
return w => w.ResponseAdd(OnAdd(a, b), header);
case MethodId.Echo:
FullType type = r.ReadFullType();
return w => w.ResponseEcho(OnEcho(type), header);
case MethodId.Empty:
return _ => OnEmpty();
case MethodId.Exchange:
Item[] consume = r.ReadItemArray();
return w => w.ResponseExchange(OnExchange(consume), header);
case MethodId.Get:
return w => w.ResponseGet(OnGet(), header);
case MethodId.Put:
Item item = r.ReadItem();
return _ => OnPut(item);
default:
return null;
}
}
/// <summary>
/// Read from the client socket and send to server
/// </summary>
/// <param name="o"></param>
static void ReaderThread(object o)
{
RpcContextSplit ctx = (RpcContextSplit)o;
bool isauth = false;
bool replacediid = false;
try
{
while (true)
{
RpcHeader header = RpcHeader.FromStream(ctx.clientReader);
if (!isauth && header.AuthLength > 0)
{
isauth = true;
}
if (isauth)
{
if (!replacediid)
{
byte[] b = ReplaceBytes(header.Data, oxidResolveIID, systemActivatorIID);
if (b != null)
{
header.Data = b;
replacediid = true;
}
}
else
{
// Is a RPC request
if (header.PacketType == 0)
{
//Console.WriteLine("Changing activation at localsystem");
byte[] actData = Trebuchet.Properties.Resources.request;
for (int i = 0; i < ctx.objref.Length; ++i)
{
// Replace the marshalled IStorage object
actData[i + 0x368] = ctx.objref[i];
}
RpcHeader newHeader = RpcHeader.FromStream(new BinaryReader(new MemoryStream(actData)));
// Fixup callid
newHeader.CallId = header.CallId;
header = newHeader;
}
}
}
//Console.WriteLine("=> Packet: {0} Data: {1} Auth: {2} {3}", header.PacketType, header.FragLength, header.AuthLength, isauth);
header.ToStream(ctx.serverWriter);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine("Stopping Reader Thread");
ctx.client.Client.Shutdown(SocketShutdown.Receive);
ctx.server.Client.Shutdown(SocketShutdown.Send);
}
public void ResponseExchange(Item[] x, RpcHeader header)
{
w.Response(() => w.Write(x), header);
}
public void ResponseGet(Item x, RpcHeader header)
{
w.Response(() => w.Write(x), header);
}
public void ResponseAdd(Int32 x, RpcHeader header)
{
w.Response(() => w.Write(x), header);
}
public void ResponseEcho(FullType x, RpcHeader header)
{
w.Response(() => w.Write(x), header);
}
public static RpcHeader FromStream(BinaryReader reader)
{
RpcHeader header = new RpcHeader();
header.MajorVersion = reader.ReadByte();
header.MinorVersion = reader.ReadByte();
header.PacketType = reader.ReadByte();
header.PacketFlags = reader.ReadByte();
header.DataRepresentation = reader.ReadUInt32();
header.FragLength = reader.ReadUInt16();
header.AuthLength = reader.ReadUInt16();
header.CallId = reader.ReadUInt32();
header.Data = reader.ReadBytes(header.FragLength - header.AuthLength - 16);
header.AuthData = reader.ReadBytes(header.AuthLength);
return header;
}
public void ResponseGet(Item x, RpcHeader header)
{
w.Response(() => w.Write(x), header);
}
public void ResponseAdd(Int32 x, RpcHeader header)
{
w.Response(() => w.Write(x), header);
}
public void Response(Action body, RpcHeader header)
{
var before = m.Position;
m.Seek(RpcHeader.HeaderLength, SeekOrigin.Current);
body();
var after = m.Position;
m.Seek(before, SeekOrigin.Begin);
Write(header.Response((uint)(after - before)));
m.Seek(after, SeekOrigin.Begin);
}
public IEnumerator<uint> Parse(Func<MemoryStream> get, BinaryPackerWriterEx w)
{
while(true)
{
yield return RpcHeader.HeaderLength;
var r = new BinaryPackerReaderEx(get());
var header = new RpcHeader(r.ReadUInt32());
yield return header.Length;
switch((MethodId)header.MethodId)
{
case MethodId.Add:
OnAdd(r.ReadInt32());
break;
case MethodId.Echo:
OnEcho(r.ReadFullType());
break;
case MethodId.Exchange:
OnExchange(r.ReadItemArray());
break;
case MethodId.Get:
OnGet(r.ReadItem());
break;
case MethodId.Change:
Item[] consume = r.ReadItemArray();
w.Write(OnChange(consume));
break;
case MethodId.Ping:
FullType type = r.ReadFullType();
w.Write(OnPing(type));
break;
// invalid case
default:
throw new InvalidDataException("Invalid methodId = " + header.MethodId);
}
}
}
public void ResponsePing(FullType x, RpcHeader header)
{
w.Response(() => w.Write(x), header);
}
public void ResponseChange(Item[] x, RpcHeader header)
{
w.Response(() => w.Write(x), header);
}
