MessageSpy.cs

#nullable enable
 
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Text.Json;
using OSDP.Net.Messages;
using OSDP.Net.Messages.SecureChannel;
using OSDP.Net.Model;
using OSDP.Net.Model.CommandData;
using OSDP.Net.Utilities;
 
namespace OSDP.Net.Tracing;

public class MessageSpy
{
    private const byte MarkByte = 0xFF;
 
    private readonly SecurityContext _context;
    private readonly MessageSecureChannel _commandSpyChannel;
    private readonly MessageSecureChannel _replySpyChannel;

    public MessageSpy(byte[]? securityKey = null)
    {
        _context = new SecurityContext(securityKey);
        _commandSpyChannel = new PdMessageSecureChannelBase(_context);
        _replySpyChannel = new ACUMessageSecureChannel(_context);
    }

    public byte PeekAddressByte(ReadOnlySpan<byte> data)
    {
        return SkipMarkBytes(data)[1];
    }

    private static ReadOnlySpan<byte> SkipMarkBytes(ReadOnlySpan<byte> data)
    {
        int index = 0;
        while (index < data.Length && data[index] == MarkByte)
        {
            index++;
        }
 
        return data.Slice(index);
    }

    public IncomingMessage ParseCommand(byte[] data)
    {
        var command = new IncomingMessage(SkipMarkBytes(data), _commandSpyChannel);
 
        return (CommandType)command.Type switch
        {
            CommandType.SessionChallenge => HandleSessionChallenge(command),
            CommandType.ServerCryptogram => HandleSCrypt(command),
            CommandType.KeySet => HandleKeySet(command),
            _ => command
        };
    }
 
    private IncomingMessage HandleKeySet(IncomingMessage command)
    {
        // osdp_KEYSET installs a new Secure Channel Base Key. The command is delivered over the
        // current secure channel, so once its payload has been decrypted we capture the new key and
        // apply it to the shared security context. The ACU then tears down and re-establishes the
        // secure channel, and that handshake must derive its session keys (S-ENC/S-MAC) from this
        // new key rather than the one originally supplied to the parser. Without this, every
        // encrypted payload after the re-key decodes to garbage (e.g. "missing a padding byte").
        if (command.IsPayloadDecrypted)
        {
            var keyConfiguration = EncryptionKeyConfiguration.ParseData(command.Payload);
            _context.UpdateSecurityKey(keyConfiguration.KeyData);
        }
 
        return command;
    }

    public IncomingMessage ParseReply(byte[] data)
    {
        var reply = new IncomingMessage(SkipMarkBytes(data), _replySpyChannel);
 
        return (ReplyType)reply.Type switch
        {
            ReplyType.InitialRMac => HandleInitialRMac(reply),
            _ => reply
        };
    }
 
    private IncomingMessage HandleSessionChallenge(IncomingMessage command)
    {
        // The osdp_CHLNG security block data byte is the authoritative indicator of which key the
        // session uses: 0x00 = well-known default key (SCBK-D), anything else = per-installation key
        // (SCBK). Record it so every subsequent secure message in this session reports the actual
        // wire key type rather than the key that happened to be supplied to the parser.
        if (command.SecureBlockData is { Length: > 0 })
        {
            bool isUsingDefaultKey = command.SecureBlockData[0] == 0x00;
            _context.IsUsingDefaultKey = isUsingDefaultKey;
            // The command message was constructed before the context was updated above, so re-stamp
            // it too, keeping the osdp_CHLNG packet consistent with the rest of the session.
            command.IsUsingDefaultKey = isUsingDefaultKey;
        }
 
        byte[] rndA = command.Payload;
        var crypto = _context.CreateCypher(true);
        _context.Enc = SecurityContext.GenerateKey(crypto,
            [0x01, 0x82, rndA[0], rndA[1], rndA[2], rndA[3], rndA[4], rndA[5]]);
        _context.SMac1 = SecurityContext.GenerateKey(crypto,
            [0x01, 0x01, rndA[0], rndA[1], rndA[2], rndA[3], rndA[4], rndA[5]]);
        _context.SMac2 = SecurityContext.GenerateKey(crypto,
            [0x01, 0x02, rndA[0], rndA[1], rndA[2], rndA[3], rndA[4], rndA[5]]);
        return command;
    }
 
    private IncomingMessage HandleSCrypt(IncomingMessage command)
    {
        var serverCryptogram = command.Payload;
        using var crypto = _context.CreateCypher(true, _context.SMac1);
        var intermediate = SecurityContext.GenerateKey(crypto, serverCryptogram);
        crypto.Key = _context.SMac2;
        _context.RMac = SecurityContext.GenerateKey(crypto, intermediate);
        return command;
    }
 
    private IncomingMessage HandleInitialRMac(IncomingMessage reply)
    {
        _context.IsSecurityEstablished = true;
        return reply;
    }

    public Packet ParsePacket(byte[] data)
    {
        const byte replyAddress = 0x80;
        var message = PeekAddressByte(data) < replyAddress
            ? ParseCommand(data)
            : ParseReply(data);
        return new Packet(message);
    }

    public bool TryParsePacket(byte[] data, out Packet? packet)
    {
        try
        {
            packet = ParsePacket(data);
            return true;
        }
        catch
        {
            packet = null;
            return false;
        }
    }

    public IEnumerable<OSDPCaptureEntry> ParseCaptureFile(string json)
    {
        var lines = json.Split('\n');
        foreach (var line in lines)
        {
            if (string.IsNullOrWhiteSpace(line)) continue;
 
            dynamic? entry = JsonSerializer.Deserialize<ExpandoObject>(line);
            if (entry == null) continue;
 
            DateTime dateTime = new DateTime(1970, 1, 1).AddSeconds(double.Parse(entry.timeSec.ToString()))
                .AddTicks(long.Parse(entry.timeNano.ToString()) / 100L);
            Enum.TryParse(entry.io.ToString(), true, out TraceDirection io);
            string data = entry.data.ToString();
 
            var rawData = BinaryUtils.HexToBytes(data).ToArray();
            var packet = ParsePacket(rawData);
 
            yield return new OSDPCaptureEntry(
                dateTime,
                io,
                packet,
                entry.osdpTraceVersion.ToString(),
                entry.osdpSource.ToString());
        }
    }
}