Functions.cs

#region Assembly DomainChecker, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// C:\Users\imalhas\Downloads\wwwroot\bin\DomainChecker.dll
// Decompiled with ICSharpCode.Decompiler 8.2.0.7535
#endregion

using DnsClient;
using DnsClient.Protocol;
using Nager.PublicSuffix;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Mail;
using System.Net.Sockets;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.Script.Serialization;


public class Functions
{
    private static readonly LookupClient dnsClient = new LookupClient(new IPAddress[1] { IPAddress.Parse("1.1.1.1") });

    public string[] getTXT(string domain)
    {
        //IL_005d: Expected O, but got Unknown
        List<string> list = new List<string>();
        try
        {
            IDnsQueryResponse val = dnsClient.Query(domain, (QueryType)16, (QueryClass)1);
            foreach (TxtRecord item in RecordCollectionExtension.TxtRecords((IEnumerable<DnsResourceRecord>)val.Answers))
            {
                list.Add(string.Join("\" ", item.Text));
            }
        }
        catch (DnsResponseException val2)
        {
            DnsResponseException val3 = val2;
            list.Add("ERROR: " + ((Exception)(object)val3).Message);
        }

        return list.ToArray();
    }

    public string[] getSPF(string domain)
    {
        //IL_00a6: Expected O, but got Unknown
        List<string> list = new List<string>();
        try
        {
            IDnsQueryResponse val = dnsClient.Query(domain, (QueryType)16, (QueryClass)1);
            IEnumerable<TxtRecord> enumerable = from r in RecordCollectionExtension.TxtRecords((IEnumerable<DnsResourceRecord>)val.Answers)
                                                where r.Text.Any((string t) => t.StartsWith("v=spf"))
                                                select r;
            foreach (TxtRecord item in enumerable)
            {
                foreach (string item2 in item.Text)
                {
                    list.Add(item2);
                }
            }
        }
        catch (DnsResponseException val2)
        {
            DnsResponseException val3 = val2;
            list.Add("An error occurred: " + ((Exception)(object)val3).Message);
        }

        return list.ToArray();
    }

    public string[] getMX(string domain)
    {
        //IL_00dc: Expected O, but got Unknown
        List<string> list = new List<string>();
        try
        {
            IDnsQueryResponse val = dnsClient.Query(domain, (QueryType)15, (QueryClass)1);
            foreach (MxRecord item in RecordCollectionExtension.MxRecords((IEnumerable<DnsResourceRecord>)val.Answers))
            {
                string value = item.Exchange.Value;
                IDnsQueryResponse val2 = dnsClient.Query(value, (QueryType)1, (QueryClass)1);
                IEnumerable<ARecord> enumerable = RecordCollectionExtension.ARecords((IEnumerable<DnsResourceRecord>)val2.Answers);
                if (enumerable.Any())
                {
                    foreach (ARecord item2 in enumerable)
                    {
                        list.Add($"Hostname: {value}, IP Address: {((AddressRecord)item2).Address}");
                    }
                }
                else
                {
                    list.Add("Hostname: " + value + ", IP Address: [Not found]");
                }
            }
        }
        catch (DnsResponseException val3)
        {
            DnsResponseException val4 = val3;
            list.Add("ERROR: " + ((Exception)(object)val4).Message);
        }

        return list.ToArray();
    }

    public string[] getDKIM1(string domain)
    {
        //IL_0077: Expected O, but got Unknown
        List<string> list = new List<string>();
        string text = "selector1-azurecomm-prod-net";
        try
        {
            string text2 = text + "._domainkey." + domain;
            IDnsQueryResponse val = dnsClient.Query(text2, (QueryType)16, (QueryClass)1);
            foreach (TxtRecord item in RecordCollectionExtension.TxtRecords((IEnumerable<DnsResourceRecord>)val.Answers))
            {
                list.Add(string.Join(", ", item.Text));
            }
        }
        catch (DnsResponseException val2)
        {
            DnsResponseException val3 = val2;
            list.Add("ERROR: " + ((Exception)(object)val3).Message);
        }

        return list.ToArray();
    }

    public string[] getDKIM2(string domain)
    {
        //IL_0077: Expected O, but got Unknown
        List<string> list = new List<string>();
        string text = "selector2-azurecomm-prod-net";
        try
        {
            string text2 = text + "._domainkey." + domain;
            IDnsQueryResponse val = dnsClient.Query(text2, (QueryType)16, (QueryClass)1);
            foreach (TxtRecord item in RecordCollectionExtension.TxtRecords((IEnumerable<DnsResourceRecord>)val.Answers))
            {
                list.Add(string.Join(", ", item.Text));
            }
        }
        catch (DnsResponseException val2)
        {
            DnsResponseException val3 = val2;
            list.Add("ERROR: " + ((Exception)(object)val3).Message);
        }

        return list.ToArray();
    }

    public string[] getCNAME(string domain)
    {
        //IL_006e: Expected O, but got Unknown
        List<string> list = new List<string>();
        try
        {
            IDnsQueryResponse val = dnsClient.Query(domain, (QueryType)5, (QueryClass)1);
            foreach (CNameRecord item in RecordCollectionExtension.CnameRecords((IEnumerable<DnsResourceRecord>)val.Answers))
            {
                list.Add(((object)item.CanonicalName).ToString().Remove(((object)item.CanonicalName).ToString().Length - 1));
            }
        }
        catch (DnsResponseException val2)
        {
            DnsResponseException val3 = val2;
            list.Add("ERROR: " + ((Exception)(object)val3).Message);
        }

        return list.ToArray();
    }

    public string[] getDMARC(string domain)
    {
        //IL_0067: Expected O, but got Unknown
        List<string> list = new List<string>();
        try
        {
            IDnsQueryResponse val = dnsClient.Query("_dmarc." + domain, (QueryType)16, (QueryClass)1);
            foreach (TxtRecord item in RecordCollectionExtension.TxtRecords((IEnumerable<DnsResourceRecord>)val.Answers))
            {
                list.Add(string.Join(", ", item.Text));
            }
        }
        catch (DnsResponseException val2)
        {
            DnsResponseException val3 = val2;
            list.Add("An error occurred: " + ((Exception)(object)val3).Message);
        }

        return list.ToArray();
    }
    //////////// RDAP /////////////
    private static readonly HttpClient httpClient = new HttpClient
    {
        Timeout = TimeSpan.FromSeconds(10)
    };

    private static Dictionary<string, string> rdapCache;
    private static readonly object rdapLock = new object();
    private static Dictionary<string, string> bootstrapCache = null;

    private string GetRDAPServer(string tld)
    {
        if (rdapCache == null)
        {
            lock (rdapLock)
            {
                if (rdapCache == null)
                {
                    var jsonText = httpClient.GetStringAsync("https://data.iana.org/rdap/dns.json").Result;

                    rdapCache = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                    var doc = JsonDocument.Parse(jsonText);

                    foreach (var service in doc.RootElement.GetProperty("services").EnumerateArray())
                    {
                        var tlds = service[0];
                        var servers = service[1];

                        if (servers.GetArrayLength() == 0)
                            continue;

                        string serverUrl = servers[0].GetString();

                        foreach (var t in tlds.EnumerateArray())
                        {
                            var name = t.GetString();
                            if (!string.IsNullOrEmpty(name))
                                rdapCache[name.ToLower()] = serverUrl;
                        }
                    }
                }
            }
        }

        return rdapCache.ContainsKey(tld) ? rdapCache[tld] : null;
    }
    ///////////// Domain Parser //////////


    private static readonly object _lock = new object();
    private static DomainParser _parser = null;

    /// <summary>
    /// Load PSL (Public Suffix List) from App_Data using FileTldRuleProvider.
    /// 100% stable on WebForms + .NET Framework.
    /// </summary>
    private static DomainParser GetParser()
    {
        if (_parser != null)
            return _parser;

        lock (_lock)
        {
            if (_parser != null)
                return _parser;

            // Set correct path for PSL file
            string pslPath;

            if (HttpContext.Current != null)
            {
                pslPath = HttpContext.Current.Server.MapPath("~/App_Data/public_suffix_list.dat");
            }
            else
            {
                pslPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data", "public_suffix_list.dat");
            }

            if (!File.Exists(pslPath))
                throw new FileNotFoundException("PSL file missing:", pslPath);

            // Use offline provider (BEST for WebForms)
            var provider = new FileTldRuleProvider(pslPath);
            _parser = new DomainParser(provider);

            return _parser;
        }
    }




    //////////// WHOIS /////////////
    private static Dictionary<string, string> whoisCache = null;

    private string GetWhoisServer(string tld)
    {
        if (whoisCache == null)
        {
            string url = "https://data.iana.org/whois-servers.json";
            string jsonText;

            using (var wc = new WebClient())
            {
                jsonText = wc.DownloadString(url);
            }

            whoisCache = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            var doc = JsonDocument.Parse(jsonText);

            if (doc.RootElement.TryGetProperty("services", out var services))
            {
                foreach (var service in services.EnumerateArray())
                {
                    if (service.ValueKind == JsonValueKind.Array && service.GetArrayLength() == 2)
                    {
                        var tlds = service[0];
                        var servers = service[1];

                        foreach (var t in tlds.EnumerateArray())
                        {
                            string tldName = t.GetString();
                            if (!string.IsNullOrEmpty(tldName) && servers.GetArrayLength() > 0)
                            {
                                string serverUrl = servers[0].GetString();
                                if (!string.IsNullOrEmpty(serverUrl))
                                    whoisCache[tldName.ToLower()] = serverUrl;
                            }
                        }
                    }
                }
            }
        }

        return whoisCache.ContainsKey(tld) ? whoisCache[tld] : "whois.iana.org";
    }

    public (string Expiry, string UpdatedOn, string Raw) QueryWhois(string domain)
    {
        string raw = string.Empty;
        string expiry = null;
        string updated = null;

        try
        {
            // Use your existing whois server logic or IANA lookup
            string whoisServer = GetWhoisServer(domain.Substring(domain.LastIndexOf('.') + 1));

            // Connect to WHOIS server via TCP
            using (var tcp = new System.Net.Sockets.TcpClient())
            {
                tcp.Connect(whoisServer, 43);
                using (var stream = tcp.GetStream())
                using (var writer = new StreamWriter(stream))
                using (var reader = new StreamReader(stream))
                {
                    writer.WriteLine(domain);
                    writer.Flush();

                    raw = reader.ReadToEnd();
                }
            }

            // Parse line by line
            foreach (var line in raw.Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries))
            {
                var l = line.Trim().ToLower();

                if (l.StartsWith("expires:") || l.StartsWith("expiry date:"))
                {
                    expiry = line.Substring(line.IndexOf(':') + 1).Trim();
                }
                else if (l.StartsWith("modified:") || l.StartsWith("updated date:"))
                {
                    updated = line.Substring(line.IndexOf(':') + 1).Trim();
                }
            }
        }
        catch (Exception ex)
        {
            raw += "\nError querying WHOIS: " + ex.Message;
        }

        return (expiry, updated, raw);
    }

    private string ParseDate(string rawDate)
    {
        string[] formats = { "yyyy-MM-dd", "dd.MM.yyyy", "dd-MMM-yyyy", "yyyy/MM/dd" };

        if (DateTimeOffset.TryParseExact(rawDate, formats,
            CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto))
            return dto.UtcDateTime.ToString("yyyy-MM-dd");

        if (DateTimeOffset.TryParse(rawDate, out var parsed))
            return parsed.UtcDateTime.ToString("yyyy-MM-dd");

        return null;
    }


    //////////// Domain Info /////////////
    public Dictionary<string, string> GetDomainInfoRDAP(string domain)
    {
        var result = new Dictionary<string, string>();

        try
        {
            string tld = domain.Substring(domain.LastIndexOf('.') + 1).ToLower();

            var serversToTry = new List<string>();

            var ianaServer = GetRDAPServer(tld);
            if (!string.IsNullOrEmpty(ianaServer))
                serversToTry.Add(ianaServer);

            // Universal fallback
            serversToTry.Add("https://rdap.org");

            string response = null;
            string usedServer = null;

            foreach (var server in serversToTry)
            {
                response = QueryRDAP(server, domain);
                if (!string.IsNullOrEmpty(response))
                {
                    usedServer = server;
                    break;
                }
            }

            // If RDAP failed → WHOIS
            if (response == null)
            {
                var whois = QueryWhois(domain);
                result["Domain"] = domain;
                result["Error"] = "RDAP failed";
                result["Expiry Date"] = whois.Expiry;
                result["Updated Date"] = whois.UpdatedOn;
                result["WhoisRaw"] = whois.Raw;
                return result;
            }

            var json = JsonDocument.Parse(response);

            result["Domain"] = domain;
            result["RDAP Server"] = usedServer;
            result["Registrar"] = ExtractRegistrar(json);
            result["Registration Date"] = ExtractEventDate(json, "registration", domain);
            result["Expiry Date"] = ExtractEventDate(json, "expiration", domain);
            result["Updated Date"] = ExtractEventDate(json, "last changed", domain);

            // Days to expiry
            if (DateTime.TryParse(result["Expiry Date"], out DateTime exp))
            {
                int days = (exp - DateTime.UtcNow.Date).Days;
                result["Days to Expiry"] = days.ToString();

                if (days < 30)
                    result["Warning"] = "⚠ Domain expiring soon";
            }

            // Fill missing from WHOIS
            var whois2 = QueryWhois(domain);

            if (string.IsNullOrEmpty(result["Expiry Date"]))
                result["Expiry Date"] = whois2.Expiry;

            if (string.IsNullOrEmpty(result["Updated Date"]))
                result["Updated Date"] = whois2.UpdatedOn;

            result["WhoisRaw"] = whois2.Raw;
        }
        catch (Exception ex)
        {
            var whois = QueryWhois(domain);
            result["Error"] = ex.Message;
            result["WhoisRaw"] = whois.Raw;
        }

        return result;
    }

    private string QueryRDAP(string server, string domain)
    {
        string url = server.TrimEnd('/') + "/domain/" + domain;

        for (int i = 0; i < 3; i++)
        {
            try
            {
                var response = httpClient.GetAsync(url).Result;
                if (!response.IsSuccessStatusCode)
                    return null;

                var json = response.Content.ReadAsStringAsync().Result;

                if (string.IsNullOrEmpty(json))
                    return null;

                // Valid domain response
                if (json.IndexOf("\"ldhName\"", StringComparison.OrdinalIgnoreCase) >= 0)
                    return json;

                // Check RDAP JSON redirect via links
                var doc = JsonDocument.Parse(json);
                if (doc.RootElement.TryGetProperty("links", out var links))
                {
                    foreach (var link in links.EnumerateArray())
                    {
                        if (link.TryGetProperty("rel", out var rel) &&
                            rel.GetString() == "related" &&
                            link.TryGetProperty("href", out var href))
                        {
                            url = href.GetString();
                            break;
                        }
                    }
                }
            }
            catch
            {
                return null;
            }
        }

        return null;
    }




    public string ExtractRegistrar(JsonDocument json)
    {
        if (json.RootElement.TryGetProperty("entities", out var entitiesProp))
        {
            foreach (var entity in entitiesProp.EnumerateArray())
            {
                if (entity.TryGetProperty("roles", out var rolesProp))
                {
                    foreach (var role in rolesProp.EnumerateArray())
                    {
                        if (role.GetString()?.Equals("registrar", StringComparison.OrdinalIgnoreCase) == true)
                        {
                            var registrar = ExtractVCardName(entity);
                            if (!string.IsNullOrEmpty(registrar))
                                return registrar;
                        }
                    }
                }

                var fallbackRegistrar = ExtractVCardName(entity);
                if (!string.IsNullOrEmpty(fallbackRegistrar))
                    return fallbackRegistrar;
            }
        }

        return "N/A";
    }

    private string ExtractVCardName(JsonElement entity)
    {
        if (entity.TryGetProperty("vcardArray", out var vcardArray) &&
            vcardArray.ValueKind == JsonValueKind.Array &&
            vcardArray.GetArrayLength() > 1)
        {
            var vcardInfo = vcardArray[1];
            if (vcardInfo.ValueKind == JsonValueKind.Array)
            {
                foreach (var item in vcardInfo.EnumerateArray())
                {
                    if (item.ValueKind == JsonValueKind.Array && item.GetArrayLength() >= 4)
                    {
                        var fieldName = item[0].GetString();
                        var fieldValue = item[3].GetString();
                        if (!string.IsNullOrEmpty(fieldValue) && (fieldName == "fn" || fieldName == "org"))
                            return fieldValue;
                    }
                }
            }
        }
        return null;
    }
    public string ExtractEventDate(JsonDocument json, string eventType, string domain)
    {
        if (json.RootElement.TryGetProperty("events", out var eventsProp))
        {
            foreach (var evt in eventsProp.EnumerateArray())
            {
                if (!evt.TryGetProperty("eventAction", out var actionProp) ||
                    !evt.TryGetProperty("eventDate", out var dateProp))
                    continue;

                string action = actionProp.GetString() ?? "";
                string date = dateProp.GetString() ?? "";

                if (!string.IsNullOrEmpty(action) &&
                    (action.IndexOf(eventType, StringComparison.OrdinalIgnoreCase) >= 0 ||
                     action.IndexOf("expire", StringComparison.OrdinalIgnoreCase) >= 0 ||
                     action.IndexOf("registration expires", StringComparison.OrdinalIgnoreCase) >= 0))
                {
                    return FormatDate(date);
                }
            }
        }

        // WHOIS fallback for expiration
        if (eventType.Equals("expiration", StringComparison.OrdinalIgnoreCase))
        {
            var whoisResult = QueryWhois(domain);
            if (!string.IsNullOrEmpty(whoisResult.Expiry))
                return whoisResult.Expiry;
        }

        // WHOIS fallback for updated
        if (eventType.Equals("last changed", StringComparison.OrdinalIgnoreCase))
        {
            var whoisResult = QueryWhois(domain);
            if (!string.IsNullOrEmpty(whoisResult.UpdatedOn))
                return whoisResult.UpdatedOn;
        }

        return "N/A";
    }


    private string FormatDate(string date)
    {
        if (DateTimeOffset.TryParse(date, out var dto))
            return dto.UtcDateTime.ToString("yyyy-MM-dd");

        return "N/A";
    }



    public static string ToRegistrableDomain(string domain)
    {
        if (string.IsNullOrWhiteSpace(domain))
            return domain;

        // Convert to ASCII label-by-label (Punycode)
        string ascii = ToAsciiIdn(domain.Trim().ToLower());

        // Get parser (PSL loaded from file)
        var parser = GetParser();

        // Parse using Public Suffix List rules
        var info = parser.Parse(ascii);

        // If parsing fails → fallback
        return string.IsNullOrEmpty(info?.RegistrableDomain)
            ? ascii
            : info.RegistrableDomain.ToLowerInvariant();
    }




    // Convert Unicode → ASCII for RDAP (IDN)
    public static string ToAsciiIdn(string host)
    {
        if (string.IsNullOrWhiteSpace(host))
            return host;

        var idn = new IdnMapping();

        try
        {
            var labels = host.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < labels.Length; i++)
            {
                labels[i] = idn.GetAscii(labels[i]);
            }
            return string.Join(".", labels).ToLowerInvariant();
        }
        catch
        {
            // Fallback—return as lowercase
            return host.ToLowerInvariant();
        }

    }
}