SecurityContext.cs

using System;
using System.Security.Cryptography;
 
namespace OSDP.Net.Messages.SecureChannel;

public class SecurityContext
{
    private byte[] _securityKey = DefaultKey;

    internal static readonly byte[] DefaultKey = "0123456789:;<=>?"u8.ToArray();

    public SecurityContext(byte[] securityKey = null) => Reset(securityKey);

    public void Reset(byte[] securityKey = null)
    {
        if (securityKey != null)
        {
            _securityKey = securityKey;
        }
 
        IsUsingDefaultKey = !(_securityKey != null && !_securityKey.SequenceEqual(DefaultKey));
        IsInitialized = false;
        IsSecurityEstablished = false;
        new Random().NextBytes(ServerRandomNumber);
    }

    internal void UpdateSecurityKey(byte[] securityKey)
    {
        if (securityKey == null)
        {
            return;
        }
 
        _securityKey = securityKey;
        IsUsingDefaultKey = _securityKey.SequenceEqual(DefaultKey);
    }

    internal bool IsSecurityEstablished { get; set; }

    internal byte[] Enc { get; set; } = Array.Empty<byte>();

    internal byte[] SMac1 { get; set; } = Array.Empty<byte>();

    internal byte[] SMac2 { get; set; } = Array.Empty<byte>();

    internal byte[] RMac { get; set; } = Array.Empty<byte>();

    internal byte[] CMac { get; set; } = Array.Empty<byte>();

    internal byte[] ServerCryptogram { get; private set; }

    internal byte[] ServerRandomNumber { get; } = new byte[8];

    public bool IsInitialized { get; private set; }

    public bool IsUsingDefaultKey { get; internal set; }

    internal Aes CreateCypher(bool isForSessionSetup, byte[] key = null)
    {
        var crypto = Aes.Create();
        if (crypto == null)
        {
            throw new Exception("Unable to create AES algorithm");
        }
 
        if (!isForSessionSetup)
        {
            crypto.Mode = CipherMode.CBC;
            crypto.Padding = PaddingMode.None;
        }
        else
        {
            crypto.Mode = CipherMode.ECB;
            crypto.Padding = PaddingMode.Zeros;
        }
        
        crypto.KeySize = 128;
        crypto.BlockSize = 128;
        crypto.Key = key ?? _securityKey;
 
        return crypto;
    }

    internal static byte[] GenerateKey(Aes aes, byte[] input)
    {
        var buffer = new byte[16];
        input.CopyTo(buffer, 0);
 
        using var encryptor = aes.CreateEncryptor();
        return encryptor.TransformFinalBlock(buffer, 0, buffer.Length);
    }

    internal static byte[] GenerateKey(Aes aes, byte[] input1, byte[] input2)
    {
        var buffer = new byte[16];
        input1.CopyTo(buffer, 0);
        input2.CopyTo(buffer, input1.Length);
 
        using var encryptor = aes.CreateEncryptor();
        return encryptor.TransformFinalBlock(buffer, 0, buffer.Length);
    }

    internal void InitializeACU(byte[] clientRandomNumber, byte[] clientCryptogram)
    {
        using var keyAlgorithm = CreateCypher(true);
        Enc = GenerateKey(keyAlgorithm, new byte[]
        {
            0x01, 0x82, ServerRandomNumber[0], ServerRandomNumber[1], ServerRandomNumber[2],
            ServerRandomNumber[3], ServerRandomNumber[4], ServerRandomNumber[5]
        });
 
        using var serverCypher  = CreateCypher(true, Enc);
        if (!clientCryptogram.SequenceEqual(GenerateKey(serverCypher, 
                ServerRandomNumber, clientRandomNumber)))
        {
            throw new Exception("Invalid client cryptogram");
        }
 
        SMac1 = GenerateKey(keyAlgorithm,
            new byte[]
            {
                0x01, 0x01, ServerRandomNumber[0], ServerRandomNumber[1], ServerRandomNumber[2],
                ServerRandomNumber[3], ServerRandomNumber[4], ServerRandomNumber[5]
            });
        SMac2 = GenerateKey(keyAlgorithm,
            new byte[]
            {
                0x01, 0x02, ServerRandomNumber[0], ServerRandomNumber[1], ServerRandomNumber[2],
                ServerRandomNumber[3], ServerRandomNumber[4], ServerRandomNumber[5]
            });
                
        ServerCryptogram = GenerateKey(serverCypher, clientRandomNumber, ServerRandomNumber);
        IsInitialized = true;
    }
 
    internal void Establish(byte[] rmac)
    {
        RMac = rmac;
        IsSecurityEstablished = true;
    }
}