using System;

using System.Collections.Generic;

using System.Net;

using System.Net.Sockets;

using System.Text;

using System.Linq;

using System.Reflection;

using Microsoft.VisualStudio.TestTools.UnitTesting;

​

public struct DNSHeader

{

    public ushort Id; // Identification number

    public ushort Flags; // Flags

    public ushort QuestionCount; // Number of questions

    public ushort AnswerCount; // Number of answer records

    public ushort AuthorityCount; // Number of authority records

    public ushort AdditionalCount; // Number of additional records

}

​

public struct DNSQuestion

{

    public string QNAME; // Domain name being queried

    public ushort QTYPE; // Type of the query (A = 1)

    public ushort QCLASS; // Class of the query (IN = 1)

}

​

public struct DNSAnswer

{

    public string NAME; // Domain name

    public ushort TYPE; // Type of the record (A = 1)

    public ushort CLASS; // Class of the record (IN = 1)

    public uint TTL; // Time to live

    public ushort RDLENGTH; // Length of the RDATA field

    public string RDATA; // The answer (IPv4 address)

}

​

public class DNSServer

{

    private static Dictionary<string, string> dnsRecords = new Dictionary<string, string>()

    {

        {"example.com", "127.0.0.1"},

        {"google.com", "142.250.184.142"}

    };

​

    public static string DNSFormatToString(byte[] data, ref int offset)

    {

        StringBuilder domainName = new StringBuilder();

        int length = data[offset];

        offset++;

​

        while (length != 0)

        {

            for (int i = 0; i < length; i++)

            {

                domainName.Append((char)data[offset]);

                offset++;

            }

            length = data[offset];

            if (length != 0)

            {

                domainName.Append('.');

            }

            offset++;

        }

​

        return domainName.ToString();

    }

​

    public static byte[] StringToDNSFormat(string domainName)

    {

        List<byte> result = new List<byte>();

        string[] labels = domainName.Split('.');

​

        foreach (string label in labels)

        {

            result.Add((byte)label.Length);

            foreach (char c in label)

            {

                result.Add((byte)c);

            }

        }

​

        result.Add(0); // Null terminator

​

        return result.ToArray();

    }

​

    public static string IPv4ToString(byte[] ipBytes)

    {

        return $"{ipBytes[0]}.{ipBytes[1]}.{ipBytes[2]}.{ipBytes[3]}";

    }

​

    public static byte[] StringToIPv4(string ipString)

    {

        string[] parts = ipString.Split('.');

        byte[] ipBytes = new byte[4];

​

        for (int i = 0; i < 4; i++)

        {

            ipBytes[i] = byte.Parse(parts[i]);

        }

​

        return ipBytes;

    }

​

    public static byte[] ConstructResponse(byte[] receivedData)

    {

        // Parse Header

        DNSHeader header = new DNSHeader();

        header.Id = (ushort)(receivedData[0] << 8 | receivedData[1]);

        header.Flags = (ushort)(receivedData[2] << 8 | receivedData[3]);

        header.QuestionCount = (ushort)(receivedData[4] << 8 | receivedData[5]);

        header.AnswerCount = (ushort)(receivedData[6] << 8 | receivedData[7]);

        header.AuthorityCount = (ushort)(receivedData[8] << 8 | receivedData[9]);

        header.AdditionalCount = (ushort)(receivedData[10] << 8 | receivedData[11]);

​

        // Parse Question

        int offset = 12;

        string domainName = DNSFormatToString(receivedData, ref offset);

        ushort queryType = (ushort)(receivedData[offset] << 8 | receivedData[offset + 1]);

        ushort queryClass = (ushort)(receivedData[offset + 2] << 8 | receivedData[offset + 3]);

​

        // Lookup IP Address

        string ipAddress = dnsRecords.ContainsKey(domainName) ? dnsRecords[domainName] : null;

​

        // Construct Response

        List<byte> response = new List<byte>();

​

        // Header

        header.Flags |= 0x8000; // Set response flag

        header.AnswerCount = (ushort)(ipAddress != null ? 1 : 0);

        response.AddRange(BitConverter.GetBytes(header.Id).Reverse());

        response.AddRange(BitConverter.GetBytes(header.Flags).Reverse());

        response.AddRange(BitConverter.GetBytes(header.QuestionCount).Reverse());

        response.AddRange(BitConverter.GetBytes(header.AnswerCount).Reverse());

        response.AddRange(BitConverter.GetBytes(header.AuthorityCount).Reverse());

        response.AddRange(BitConverter.GetBytes(header.AdditionalCount).Reverse());

​

        // Question (copied from request)

        byte[] domainNameBytes = StringToDNSFormat(domainName);

        response.AddRange(domainNameBytes);

        response.AddRange(BitConverter.GetBytes(queryType).Reverse());

        response.AddRange(BitConverter.GetBytes(queryClass).Reverse());

​

        // Answer

        if (ipAddress != null)

        {

            // Name

            response.AddRange(domainNameBytes);

​

            // Type

            ushort type = 1; // A record

            response.AddRange(BitConverter.GetBytes(type).Reverse());

​

            // Class

            ushort @class = 1; // IN class

            response.AddRange(BitConverter.GetBytes(@class).Reverse());

​

            // TTL

            uint ttl = 300;

            response.AddRange(BitConverter.GetBytes(ttl).Reverse());

​

            // RDLENGTH

            ushort rdLength = 4;

            response.AddRange(BitConverter.GetBytes(rdLength).Reverse());

​

            // RDATA (IP Address)

            byte[] ipBytes = StringToIPv4(ipAddress);

            response.AddRange(ipBytes);

        }

​

        return response.ToArray();

    }

​

    public static void StartServer()

    {

        UdpClient udpServer = new UdpClient(53);

        IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);

​

        Console.WriteLine("DNS Server started. Listening on port 53...");

​

        while (true)

        {

            try

            {

                byte[] receivedData = udpServer.Receive(ref remoteEP);

                Console.WriteLine($"Received request from {remoteEP.Address}:{remoteEP.Port}");

​

                byte[] responseData = ConstructResponse(receivedData);

                udpServer.Send(responseData, responseData.Length, remoteEP);

​

                Console.WriteLine($"Sent response to {remoteEP.Address}:{remoteEP.Port}");

            }

            catch (Exception e)

            {

                Console.WriteLine($"Exception: {e}");

            }

        }

    }

​

    public static void Main(string[] args)

    {

        Console.WriteLine("Running tests...\n");

​

        Type testClassType = typeof(DNSTests);

        object testInstance = Activator.CreateInstance(testClassType);

​

        // Get all methods with [TestMethod] attribute

        MethodInfo[] testMethods = testClassType.GetMethods()

            .Where(m => m.GetCustomAttributes(typeof(TestMethodAttribute), false).Length > 0)

            .ToArray();

​

        int passed = 0, failed = 0;

​

        foreach (var method in testMethods)

        {

            try

            {

                method.Invoke(testInstance, null);

                Console.WriteLine($"✅ {method.Name} PASSED");

                passed++;

            }

            catch (Exception ex)

            {

                Console.WriteLine($"❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");

                failed++;

            }

        }

        StartServer();

    }

}

​

[TestClass]

public class DNSTests

{

    [TestMethod]

    public void DNSFormatToString_ValidData_ReturnsDomainName()

    {

        byte[] data = { 7, (byte)'e', (byte)'x', (byte)'a', (byte)'m', (byte)'p', (byte)'l', (byte)'e', 3, (byte)'c', (byte)'o', (byte)'m', 0 };

        int offset = 0;

        string domainName = DNSServer.DNSFormatToString(data, ref offset);

        Assert.AreEqual("example.com", domainName);

    }

​

    [TestMethod]

    public void StringToDNSFormat_ValidDomainName_ReturnsDNSFormat()

    {

        string domainName = "example.com";

        byte[] expected = { 7, (byte)'e', (byte)'x', (byte)'a', (byte)'m', (byte)'p', (byte)'l', (byte)'e', 3, (byte)'c', (byte)'o', (byte)'m', 0 };

        byte[] actual = DNSServer.StringToDNSFormat(domainName);

​

        CollectionAssert.AreEqual(expected, actual);

    }

​

    [TestMethod]

    public void IPv4ToString_ValidBytes_ReturnsString()

    {

        byte[] ipBytes = { 127, 0, 0, 1 };

        string ipString = DNSServer.IPv4ToString(ipBytes);

        Assert.AreEqual("127.0.0.1", ipString);

    }

​

    [TestMethod]

    public void StringToIPv4_ValidString_ReturnsBytes()

    {

        string ipString = "127.0.0.1";

        byte[] expected = { 127, 0, 0, 1 };

        byte[] actual = DNSServer.StringToIPv4(ipString);

        CollectionAssert.AreEqual(expected, actual);

    }

​

    [TestMethod]

    public void ConstructResponse_ValidRequest_ReturnsResponse()

    {

        // Simulate a DNS query for "example.com"

        byte[] request = {

            0x12, 0x34, // ID

            0x01, 0x00, // Flags (Standard query)

            0x00, 0x01, // Question Count

            0x00, 0x00, // Answer Count

            0x00, 0x00, // Authority Count

            0x00, 0x00, // Additional Count

            0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // example.com

            0x00, 0x01, // Type (A record)

            0x00, 0x01  // Class (IN)

        };

​

        byte[] response = DNSServer.ConstructResponse(request);

​

        // Basic sanity checks (adjust as needed based on expected response structure)

        Assert.IsNotNull(response);

        Assert.IsTrue(response.Length > 12); // Minimum DNS header size

    }

}