Extensions.cs

using System.Text;

namespace DnsMessageParser;

public static class Extensions
{
    public static int QuestionSectionSkippedPosition(this byte[] udpPacket, int initialPositionOffset = 12)
    {
        if (initialPositionOffset >= udpPacket.Length)
        {
            return initialPositionOffset;
        }

        // Skip the domain name (variable length)
        while (udpPacket[initialPositionOffset] != 0)
        {
            // Check if the domain name is compressed
            if ((udpPacket[initialPositionOffset] & 0xC0) == 0xC0)
            {
                // Skip the pointer (2 bytes total) and break
                initialPositionOffset += 2;
                break;
            }

            initialPositionOffset += udpPacket[initialPositionOffset] + 1;

            if (initialPositionOffset >= udpPacket.Length)
            {
                throw new IndexOutOfRangeException("Domain name parsing went out of bounds.");
            }
        }

        // Skip the null terminator of the domain name (0x00)
        initialPositionOffset++;
        if (initialPositionOffset + 4 > udpPacket.Length)
        {
            throw new IndexOutOfRangeException("Not enough data for type and class in the DNS question.");
        }

        // Skip DNS Type (2 bytes) and DNS Class (2 bytes)
        return initialPositionOffset + 4;
    }
    
    public static string ReadDomainName(this byte[] udpPacket, ref int position)
    {
        var domainName = new StringBuilder();

        while (udpPacket[position] != 0)
        {
            int labelLength = udpPacket[position];
            position++;
        
            if ((labelLength & 0xC0) == 0xC0)
            {
                var offset = ((labelLength & 0x3F) << 8) | udpPacket[position];
                position++;
                
                return ReadDomainName(udpPacket, ref offset);
            }

            domainName.Append(Encoding.UTF8.GetString(udpPacket, position, labelLength));
            position += labelLength;

            if (udpPacket[position] != 0)
            {
                domainName.Append('.');
            }
        }

        position++;
        return domainName.ToString();
    }
    
    public static byte[] GetDnsQuestionBytes(this List<DnsQuestionItem> dnsQuestions)
    {
        using var stream = new MemoryStream();

        foreach (var dnsQuestionItem in dnsQuestions)
        {
            var domainNameBytes = dnsQuestionItem.DomainName.GetDomainNameBytes();

            var dnsTypeBytes = BitConverter.GetBytes((ushort)dnsQuestionItem.DnsType);
            var dnsClassBytes = BitConverter.GetBytes((ushort)dnsQuestionItem.DnsClass);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(dnsTypeBytes);
                Array.Reverse(dnsClassBytes);
            }

            stream.Write(domainNameBytes, 0, domainNameBytes.Length);
            stream.Write(dnsTypeBytes, 0, dnsTypeBytes.Length);
            stream.Write(dnsClassBytes, 0, dnsClassBytes.Length);
        }

        return stream.ToArray();
    }
    
    public static byte[] GetDnsAnswerBytes(this List<DnsAnswerItem> dnsAnswers)
    {
        using var stream = new MemoryStream();

        foreach (var dnsAnswerItem in dnsAnswers)
        {
            var domainNameBytes = dnsAnswerItem.DomainName.GetDomainNameBytes();

            var dnsTypeBytes = BitConverter.GetBytes((ushort)dnsAnswerItem.DnsType);
            var dnsClassBytes = BitConverter.GetBytes((ushort)dnsAnswerItem.DnsClass);
            var ttlBytes = BitConverter.GetBytes(dnsAnswerItem.TimeToLive);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(dnsTypeBytes);
                Array.Reverse(dnsClassBytes);
                Array.Reverse(ttlBytes);
            }

            stream.Write(domainNameBytes, 0, domainNameBytes.Length);
            stream.Write(dnsTypeBytes, 0, dnsTypeBytes.Length);
            stream.Write(dnsClassBytes, 0, dnsClassBytes.Length);
            stream.Write(ttlBytes, 0, ttlBytes.Length);

            var ipAddressParts = dnsAnswerItem.Data.Split('.');
            var rdataBytes = new byte[4];
            for (var i = 0; i < 4; i++)
            {
                rdataBytes[i] = byte.Parse(ipAddressParts[i]);
            }

            var rdLengthBytes = BitConverter.GetBytes((ushort)rdataBytes.Length);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(rdLengthBytes);
            }

            stream.Write(rdLengthBytes, 0, rdLengthBytes.Length);
            stream.Write(rdataBytes, 0, rdataBytes.Length);
        }

        return stream.ToArray();
    }

    private static byte[] GetDomainNameBytes(this string domainName)
    {
        var parts = domainName.Split('.');

        using var stream = new MemoryStream();
        foreach (var part in parts)
        {
            stream.WriteByte((byte)part.Length);
            var partBytes = Encoding.ASCII.GetBytes(part);
            stream.Write(partBytes, 0, partBytes.Length);
        }

        stream.WriteByte(0);
        return stream.ToArray();
    }
}