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); }