MessageSecureChannel.cs

using System;
using System.Linq;
using Microsoft.Extensions.Logging;
 
namespace OSDP.Net.Messages.SecureChannel;

public abstract class MessageSecureChannel : IMessageSecureChannel
{
    protected MessageSecureChannel(SecurityContext context = null, ILoggerFactory loggerFactory = null)
    {
        Context = context ?? new();
        Logger = loggerFactory?.CreateLogger(GetType());
    }

    protected ILogger Logger { get; }

    protected SecurityContext Context { get; }

    public bool IsSecurityEstablished => Context.IsSecurityEstablished;

    public bool IsInitialized => Context.IsInitialized;

    public byte[] ServerRandomNumber => Context.ServerRandomNumber;
    
    public byte[] ServerCryptogram => Context.ServerCryptogram;

    public bool IsUsingDefaultKey => Context.IsUsingDefaultKey;

    public abstract byte[] DecodePayload(byte[] payload);

    public abstract void EncodePayload(byte[] payload, Span<byte> destination);

    public abstract ReadOnlySpan<byte> GenerateMac(ReadOnlySpan<byte> message, bool isIncoming);

    public void InitializeACU(byte[] clientRandomNumber, byte[] clientCryptogram)
    {
        Context.InitializeACU(clientRandomNumber, clientCryptogram);
    }

    public void ResetSecureChannelSession() => Context.Reset();

    public void Establish(byte[] rmac) => Context.Establish(rmac);

    protected byte[] GenerateCommandMac(ReadOnlySpan<byte> message) => Context.CMac = GenerateMac(message, Context.RMac);

    protected byte[] GenerateReplyMac(ReadOnlySpan<byte> message) => Context.RMac = GenerateMac(message, Context.CMac);
 
    private byte[] GenerateMac(ReadOnlySpan<byte> message, byte[] iv)
    {
        if (!IsSecurityEstablished)
        {
            throw new SecureChannelRequired();
        }
 
        using var crypto = Context.CreateCypher( false, Context.SMac1);
        crypto.IV = iv;
            
        var cursor = message;
        while (cursor.Length > 0)
        {
            byte[] block;
 
            if (cursor.Length < 16)
            {
                block = new byte[16];
                cursor.CopyTo(block);
                block[cursor.Length] = Message.FirstPaddingByte;
                cursor = cursor.Slice(cursor.Length);
                crypto.Key = Context.SMac2;
            }
            else
            {
                block = cursor.Slice(0, 16).ToArray();
                cursor = cursor.Slice(16);
                if (cursor.Length == 0) crypto.Key = Context.SMac2;
            }
 
            using var encryptor = crypto.CreateEncryptor();
            crypto.IV = encryptor.TransformFinalBlock(block, 0, block.Length);
        }
 
        return crypto.IV;
    }

    protected byte[] DecodePayload(byte[] payload, byte[] iv)
    {
        if (!IsSecurityEstablished)
        {
            throw new SecureChannelRequired();
        }
            
        if (payload.Length == 0)
        {
            return Array.Empty<byte>();
        }
        if (payload.Length % 16 != 0)
        {
            throw new Exception($"Unexpected payload length: {payload.Length}");
        }
 
        using var crypto = Context.CreateCypher( false, Context.Enc);
        crypto.IV = iv.Select(b => (byte)~b).ToArray();
 
        using var encryptor = crypto.CreateDecryptor();
        return encryptor.TransformFinalBlock(payload, 0, payload.Length);
    }

    protected void EncodePayload(byte[] payload, byte[] iv, Span<byte> destination)
    {
        if (!IsSecurityEstablished)
        {
            throw new SecureChannelRequired();
        }
        
        if (payload.Length > 0)
        {
            if (payload.Length % 16 != 0)
            {
                throw new Exception($"Unexpected payload length: {payload.Length}");
            }
 
            using var crypto = Context.CreateCypher( false, Context.Enc);
            crypto.IV = iv.Select(b => (byte)~b).ToArray();
 
            using var encryptor = crypto.CreateEncryptor();
            encryptor.TransformFinalBlock(payload, 0, payload.Length).CopyTo(destination);
        }
    }

    public ReadOnlySpan<byte> PadTheData(ReadOnlySpan<byte> data)
    {
        const byte cryptoLength = 16;
        const byte paddingStart = 0x80;
        
        int dataLength = data.Length + 1;
        int paddingLength = dataLength + (cryptoLength - dataLength % cryptoLength) % cryptoLength;
        
        Span<byte> buffer = stackalloc byte[paddingLength];
        buffer.Clear();
        
        var cursor = buffer.Slice(0);
 
        data.CopyTo(cursor);
        cursor = cursor.Slice(data.Length);
        
        cursor[0] = paddingStart;
        
        return buffer.ToArray();
    }
}