public void TestByte()
{
_writer.Write((byte)0xFE);
_writer.Write((byte)0xFA);
Assert.Equal <byte[]>(new byte[] { 0xFE, 0xFA }, _writer.ToBytes());
}
public async Task SendAsync(byte[] bytes)
{
logger.LogTrace($"Sending auxiliary stream buffer: {bytes.Length} bytes");
var writer = new BEWriter();
writer.Write(new byte[] { 0xde, 0xad });
writer.Write((ushort)bytes.Length);
writer.Write(_cryptoContext.Encrypt(bytes));
writer.Write(_cryptoContext.CalculateMessageSignature(writer.ToBytes()));
var buffer = writer.ToBytes();
await _client.GetStream().WriteAsync(buffer, 0, buffer.Length);
}
public async Task SendAsync(IMessage message)
{
var cryptoMessage = message as ICryptoMessage;
if (cryptoMessage != null)
{
cryptoMessage.Crypto = _crypto;
}
var writer = new BEWriter();
message.Serialize(writer);
var serialized = writer.ToBytes();
if (_addressOrHostname == null)
{
await _client.SendAsync(serialized, serialized.Length, new IPEndPoint(IPAddress.Broadcast, 5050));
await _client.SendAsync(serialized, serialized.Length, new IPEndPoint(MULTICAST_ADDR, 5050));
}
else
{
await _client.SendAsync(serialized, serialized.Length);
}
}
public override void Serialize(BEWriter writer)
{
var messageWriter = new BEWriter();
base.Serialize(messageWriter);
var message = messageWriter.ToBytes();
var initVectorSource = message.Take(16).ToArray();
var initVector = Crypto.CreateDerivedInitVector(initVectorSource);
var fragmentWriter = new BEWriter();
byte[] padding = Padding.CreatePaddingData(
PaddingType.PKCS7,
Fragment,
alignment: payloadSizeAlignment
);
fragmentWriter.Write(Fragment);
fragmentWriter.Write(padding);
var encryptedFragment = Crypto.EncryptWithoutPadding(fragmentWriter.ToBytes(), initVector);
Header.Serialize(writer);
writer.Write(encryptedFragment);
var signature = Crypto.CalculateMessageSignature(writer.ToBytes());
writer.Write(signature);
}
private byte[] AssembleMessage(IMessage message)
{
var writer = new BEWriter();
message.Serialize(writer);
return(writer.ToBytes());
}
private byte[] AssembleSessionMessage(SessionMessageBase message,
uint sequenceNumber,
uint sourceParticipantId,
uint targetParticipantId = 0)
{
var fragment = new SessionFragmentMessage();
fragment.Header.IsFragment = message.Header.IsFragment;
fragment.Header.ChannelId = message.Header.ChannelId;
fragment.Header.RequestAcknowledge = message.Header.RequestAcknowledge;
fragment.Header.SessionMessageType = message.Header.SessionMessageType;
fragment.Header.Version = message.Header.Version;
fragment.Header.SequenceNumber = sequenceNumber;
fragment.Header.SourceParticipantId = sourceParticipantId;
fragment.Header.TargetParticipantId = targetParticipantId;
var writer = new BEWriter();
message.Serialize(writer);
fragment.Fragment = writer.ToBytes();
((ICryptoMessage)fragment).Crypto = _crypto;
var finalWriter = new BEWriter();
fragment.Serialize(finalWriter);
return(finalWriter.ToBytes());
}
public static byte[] AssemblePacket(INanoPacket packet, NanoChannelContext context)
{
if (packet.Channel == NanoChannel.Unknown)
{
throw new NanoPackingException("AssemblePacket: INanoPacket.Channel is UNKNOWN");
}
BEWriter packetWriter = new BEWriter();
BinaryWriter payloadWriter = new BinaryWriter(new MemoryStream());
packet.Serialize(payloadWriter);
byte[] padding = Padding.CreatePaddingData(
PaddingType.ANSI_X923,
payloadWriter.ToBytes(),
alignment: 4);
payloadWriter.Write(padding);
if (padding.Length > 0)
{
packet.Header.Padding = true;
}
packet.Header.ChannelId = context.GetChannelId(packet.Channel);
packet.Header.Serialize(packetWriter);
packetWriter.Write(payloadWriter.ToBytes());
return(packetWriter.ToBytes());
}
public Task SendAsyncControl(RtpPacket message)
{
var writer = new BEWriter();
message.Serialize(writer);
byte[] serialized = writer.ToBytes();
return(_controlProtoClient.SendAsyncPrefixed(serialized));
}
#pragma warning restore 1998
public Task SendAsyncStreaming(RtpPacket message)
{
var writer = new BEWriter();
message.Serialize(writer);
var serialized = writer.ToBytes();
return(_streamingProtoClient.SendAsync(serialized, serialized.Length));
}
public virtual void Serialize(BEWriter writer)
{
var payloadWriter = new BEWriter();
SerializePayload(payloadWriter);
var payload = payloadWriter.ToBytes();
Header.PayloadLength = (ushort)payload.Length;
Header.Serialize(writer);
writer.Write(payload);
}
public override void Serialize(BEWriter writer)
{
var protectedPayloadWriter = new BEWriter();
SerializeProtectedPayload(protectedPayloadWriter);
var protectedPayload = protectedPayloadWriter.ToBytes();
Header.ProtectedPayloadLength = (ushort)protectedPayload.Length;
var encryptedPayload = protectedPayload.Length > 0 ?
Crypto.Encrypt(protectedPayload, InitVector) : new byte[] { };
base.Serialize(writer);
writer.Write(encryptedPayload);
var signature = Crypto.CalculateMessageSignature(writer.ToBytes());
writer.Write(signature);
}
private Task SendFragmentAsync(SessionMessageBase message, uint sequenceNumber)
{
logger.LogTrace($"Sending {message.GetType().Name} message");
var fragment = new SessionFragmentMessage();
fragment.Header.ChannelId = message.Header.ChannelId;
fragment.Header.RequestAcknowledge = message.Header.RequestAcknowledge;
fragment.Header.SessionMessageType = message.Header.SessionMessageType;
fragment.Header.Version = message.Header.Version;
fragment.Header.SequenceNumber = sequenceNumber;
fragment.Header.SourceParticipantId = _participantId;
var writer = new BEWriter();
message.Serialize(writer);
fragment.Fragment = writer.ToBytes();
return(_transport.SendAsync(fragment));
}
private byte[] ReadAndDecryptChunk(Stream stream)
{
var reader = new BEReader(stream);
// 0xde, 0xad
reader.ReadBytes(2);
var length = reader.ReadUInt16();
var encryptedPayloadLength = length + Padding.CalculatePaddingSize(length, 16);
var encryptedPayloadBytes = new byte[encryptedPayloadLength];
var encryptedPayloadPosition = 0;
while (encryptedPayloadPosition < encryptedPayloadLength - 1)
{
var received = reader.ReadBytes(encryptedPayloadLength - encryptedPayloadPosition);
received.CopyTo(encryptedPayloadBytes, encryptedPayloadPosition);
encryptedPayloadPosition += received.Length;
}
var signature = reader.ReadBytes(32);
var bodyWriter = new BEWriter();
bodyWriter.Write(new byte[] { 0xde, 0xad });
bodyWriter.Write(length);
bodyWriter.Write(encryptedPayloadBytes);
var messageSignature = _cryptoContext.CalculateMessageSignature(bodyWriter.ToBytes());
if (!signature.SequenceEqual(messageSignature))
{
throw new InvalidDataException("Invalid message signature.");
}
var decryptedPayload = _cryptoContext.Decrypt(encryptedPayloadBytes);
return(decryptedPayload.Take(length).ToArray());
}
public SessionMessageBase AssembleFragment(SessionMessageBase message, uint sequenceNumber)
{
FragmentMessage fragment = message as FragmentMessage;
SessionMessageType messageType = fragment.Header.SessionMessageType;
int sequenceBegin = (int)fragment.SequenceBegin;
int sequenceEnd = (int)fragment.SequenceEnd;
_fragmentQueue[(int)sequenceNumber] = fragment.Data;
IEnumerable <int> neededSequences = Enumerable.Range(sequenceBegin, sequenceEnd - sequenceBegin);
BEWriter writer = new BEWriter();
foreach (int seq in neededSequences)
{
try
{
byte[] data = _fragmentQueue[seq];
writer.Write(data);
}
catch (KeyNotFoundException)
{
return(null);
}
}
// Pop obsolete fragment data
foreach (int seq in neededSequences)
{
_fragmentQueue.Remove(seq);
}
SessionMessageBase assembled = SessionMessageTransport.CreateFromMessageType(messageType);
assembled.Deserialize(new BEReader(writer.ToBytes()));
return(assembled);
}
public byte[] Encrypt(byte[] data)
{
var writer = new BEWriter();
byte[] padding = Padding.CreatePaddingData(
PaddingType.PKCS7,
data,
alignment: 16);
writer.Write(data);
writer.Write(padding);
var paddedData = writer.ToBytes();
var output = new byte[paddedData.Length];
for (var i = 0; i < paddedData.Length; i += 16)
{
_clientCipher.ProcessBlock(paddedData, i, output, i);
}
return(output);
}
