IncomingMessage.cs

 
using System;
using System.Collections.Generic;
using System.Linq;
using OSDP.Net.Messages.SecureChannel;
 
namespace OSDP.Net.Messages
{
    public class IncomingMessage : Message
    {
        private const ushort MessageHeaderSize = 6;
        private readonly byte[] _originalMessage;

        public IncomingMessage(ReadOnlySpan<byte> data, IMessageSecureChannel channel)
        {
            IsUsingDefaultKey = channel.IsUsingDefaultKey;
            
            // TODO: way too much copying in this code, simplify it.
            _originalMessage = data.ToArray();
 
            Address = (byte)(data[1] & AddressMask);
            MessageType = data[1] < 0x80 ? MessageType.Command : MessageType.Reply;
            Sequence = (byte)(data[4] & 0x03);
            IsUsingCrc = Convert.ToBoolean(data[4] & 0x04);
            ushort replyMessageFooterSize = (ushort)(IsUsingCrc ? 2 : 1);
            bool isSecureControlBlockPresent = Convert.ToBoolean(data[4] & 0x08);
            byte secureBlockSize = (byte)(isSecureControlBlockPresent ? data[5] : 0);
            SecurityBlockType = (byte)(isSecureControlBlockPresent ? data[6] : 0);
            int messageLength = data.Length - (IsUsingCrc ? 6 : 5);
            if (isSecureControlBlockPresent)
            {
                SecureBlockData = data.Slice(MessageHeaderSize + 1, secureBlockSize - 2).ToArray();
                Mac = data.Slice(messageLength, MacSize).ToArray();
            }
 
            Type = data[MsgTypeIndex + secureBlockSize];
 
            Payload = data.Slice(MessageHeaderSize + secureBlockSize, data.Length -
                MessageHeaderSize - secureBlockSize - replyMessageFooterSize -
                (IsSecureMessage ? MacSize : 0)).ToArray();
            if (Payload.Length > 0 && HasSecureData)
            {
                if (channel.IsSecurityEstablished)
                {
                    var paddedPayload = channel.DecodePayload(Payload);
                    var lastByteIdx = Payload.Length;
                    while (lastByteIdx > 0 && paddedPayload[--lastByteIdx] != FirstPaddingByte)
                    {
                    }
 
                    // lastByteIdx now indexes the 0x80 pad marker. Index 0 is valid: it means the
                    // command carried an empty payload (e.g. an encrypted osdp_LSTAT), so the whole
                    // decrypted block is just the padding marker. Only a block with no 0x80 at all
                    // is genuinely malformed.
                    if (paddedPayload[lastByteIdx] != FirstPaddingByte)
                        throw new Exception("The encrypted payload is missing a padding byte");
 
                    Payload = paddedPayload.AsSpan().Slice(0, lastByteIdx).ToArray();
                }
                else
                {
                    IsPayloadDecrypted = false;
                }
            }
 
            IsDataCorrect = IsUsingCrc
                ? CalculateCrc(data.Slice(0, data.Length - 2)) ==
                  ConvertBytesToUnsignedShort(data.Slice(data.Length - 2, 2))
                : CalculateChecksum(data.Slice(0, data.Length - 1).ToArray()) == data[data.Length - 1];
 
            if (IsSecureMessage)
            {
                if (channel.IsSecurityEstablished)
                {
                    var mac = channel.GenerateMac(data.Slice(0, messageLength).ToArray(), true);
                    IsValidMac = !IsSecureMessage || mac.Slice(0, MacSize).SequenceEqual(Mac?.ToArray());
                }
                else
                {
                    IsValidMac = false;
                }
            }
            else
            {
                IsValidMac = true;
            }
        }

        public bool IsUsingCrc { get; }

        public byte Type { get; }

        public byte Sequence { get; }
 
        internal Control ControlBlock => new(Sequence, IsUsingCrc, IsSecureMessage);

        public bool IsSecureMessage => SecureSessionMessages.Contains(SecurityBlockType) && IsDataSecure;

        public bool IsValidMac { get; }

        public bool IsUsingDefaultKey { get; internal set; }

        public bool HasSecureData =>
            SecurityBlockType == (byte)SecureChannel.SecurityBlockType.CommandMessageWithDataSecurity ||
            SecurityBlockType == (byte)SecureChannel.SecurityBlockType.ReplyMessageWithDataSecurity;

        public bool IsPayloadDecrypted { get; private set; } = true;

        public byte[] Payload { get; }

        public ReadOnlySpan<byte> OriginalMessageData => _originalMessage;

        public byte SecurityBlockType { get; }

        public byte[] SecureBlockData { get; }

        protected override ReadOnlySpan<byte> Data() => Payload.ToArray();
 
        private bool IsDataSecure => Payload == null || Payload.Length == 0 || 
            SecurityBlockType == (byte)SecureChannel.SecurityBlockType.ReplyMessageWithDataSecurity || 
            SecurityBlockType == (byte)SecureChannel.SecurityBlockType.CommandMessageWithDataSecurity;
        
        private IEnumerable<byte> Mac { get; }

        public bool IsDataCorrect { get; }
 
        private static IEnumerable<byte> SecureSessionMessages => new[]
        {
            (byte)SecureChannel.SecurityBlockType.CommandMessageWithNoDataSecurity,
            (byte)SecureChannel.SecurityBlockType.ReplyMessageWithNoDataSecurity,
            (byte)SecureChannel.SecurityBlockType.CommandMessageWithDataSecurity,
            (byte)SecureChannel.SecurityBlockType.ReplyMessageWithDataSecurity,
        };

        public bool SecureCryptogramHasBeenAccepted() => SecureBlockData[0] == 0x01;
    }
}