공교육 학내망과 군 인트라넷의 도메인 위조·전파 지연 0초 진단: ZeliDNS의 5대 글로벌 DNS 병렬 쿼리, nslookup 파이프 데드락 방어, 및 실시간 역방향 해석 아키텍처

private async Task MultiDnsLookup(string domain)
{
    var sb = new StringBuilder();
    sb.AppendLine($"═══ {Loc.Get("DNS_MultiDnsCompare")}: {domain} ═══\n");

    var tasks = new List<Task<string>>();

    // 1) 시스템 기본 DNS (Dns.GetHostEntryAsync + 3초 타임아웃 가드)
    tasks.Add(Task.Run(async () =>
    {
        try
        {
            var sw = Stopwatch.StartNew();
            var entryTask = Dns.GetHostEntryAsync(domain);
            var completed = await Task.WhenAny(entryTask, Task.Delay(3000));
            sw.Stop();

            if (completed != entryTask) 
                return $"  🖥️ {Loc.Get("DNS_SystemDefault")}:  ⏱ {Loc.Get("DNS_TimeoutBrief3s")}";

            var entry = await entryTask;
            string ips = string.Join(", ", entry.AddressList.Select(a => a.ToString()));
            return $"  🖥️ {Loc.Get("DNS_SystemDefault")}:  {ips} ({sw.ElapsedMilliseconds}ms)";
        }
        catch (Exception ex) 
        { 
            return $"  🖥️ {Loc.Get("DNS_SystemDefault")}:  ❌ {ex.Message}"; 
        }
    }));

    // 2) 외부 공용 DNS 리졸버들 (Google, Cloudflare, Quad9, OpenDNS 병렬 쿼리)
    foreach (var (name, server) in DnsServers.Skip(1))
    {
        var n = name; 
        var s = server;
        tasks.Add(Task.Run(async () =>
        {
            try
            {
                return await RunNslookupCompact(domain, s, n);
            }
            catch (Exception ex) 
            { 
                return $"  {n}:  ❌ {ex.Message}"; 
            }
        }));
    }

    // 3) 모든 리졸버의 질의 완료를 동시 대기 (최장 응답 시간 = 전체 지연시간)
    var results = await Task.WhenAll(tasks);
    foreach (var r in results) 
        sb.AppendLine(r);

    TxtResult.Text = sb.ToString();
    TxtStatus.Text = string.Format("✅ " + Loc.Get("DNS_MultiDnsComplete"), DnsServers.Length);
}

private async Task<string> RunNslookupCompact(string domain, string server, string name)
{
    var psi = new ProcessStartInfo("nslookup", $"{domain} {server}")
    {
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        UseShellExecute = false,
        CreateNoWindow = true
    };

    var sw = Stopwatch.StartNew();
    using var proc = Process.Start(psi);

    // 5초 타임아웃 캔슬레이션 토큰
    using var cts = new CancellationTokenSource(5000);
    try
    {
        // ★ 파이프 데드락 방어: stdout과 stderr를 동시에 비동기로 읽어낸다
        var outTask = proc.StandardOutput.ReadToEndAsync(cts.Token);
        var errTask = proc.StandardError.ReadToEndAsync(cts.Token);
        
        await Task.WhenAll(outTask, errTask);
        string output = await outTask;
        
        await proc.WaitForExitAsync(cts.Token);
        sw.Stop();

        // 정규화된 IP 주소 파싱
        var ips = new List<string>();
        bool afterName = false;
        foreach (var line in output.Split('\n'))
        {
            var trimmed = line.Trim();
            if (trimmed.StartsWith("Name:")) afterName = true;
            if (afterName && trimmed.StartsWith("Address"))
            {
                var parts = trimmed.Split(':');
                if (parts.Length > 1) ips.Add(parts[1].Trim());
            }
        }

        string ipStr = ips.Count > 0 ? string.Join(", ", ips) : Loc.Get("DNS_NoResult");
        string icon = name switch { "Google" => "🟢", "Cloudflare" => "🔵", "Quad9" => "🟡", "OpenDNS" => "🔴", _ => "⚪" };
        return $"  {icon} {name} ({server}):  {ipStr} ({sw.ElapsedMilliseconds}ms)";
    }
    catch (OperationCanceledException)
    {
        // 타임아웃 발생 시 즉시 강제 종료하여 좀비 프로세스 누수 원천 차단
        try { proc.Kill(); } catch { }
        return $"  {name} ({server}):  ⏱ " + Loc.Get("DNS_TimeoutBrief5s");
    }
}

// 1) 단일 IP 역방향 직접 쿼리
private async void BtnReverse_Click(object sender, RoutedEventArgs e)
{
    var input = TxtDomain.Text?.Trim();
    if (string.IsNullOrEmpty(input)) return;

    // ★ 입력값이 유효한 IPv4/IPv6 포맷인지 사전 검증 (불필요한 DNS 부하 차단)
    if (!IPAddress.TryParse(input, out IPAddress addr))
    {
        TxtResult.Text = "⚠️ " + Loc.Get("DNS_ReverseNeedsIP");
        TxtStatus.Text = Loc.Get("DNS_NotIPFormat");
        return;
    }

    var sw = Stopwatch.StartNew();
    var revTask = Dns.GetHostEntryAsync(addr);
    var completed = await Task.WhenAny(revTask, Task.Delay(5000));
    sw.Stop();

    if (completed != revTask)
    {
        TxtResult.Text = string.Format("⏱ " + Loc.Get("DNS_ReverseTimeout5s"), input);
        return;
    }

    var entry = await revTask;
    var sb = new StringBuilder();
    sb.AppendLine($"═══ Reverse DNS: {input} ═══");
    sb.AppendLine($"{Loc.Get("DNS_Elapsed")}: {sw.ElapsedMilliseconds}ms");
    sb.AppendLine($"{Loc.Get("DNS_Hostname")}: {entry.HostName}");
    // 결합된 전체 IP 목록 출력
    foreach (var a in entry.AddressList) sb.AppendLine($"  {a}");
}

// 2) 정방향 조회 결과에 딸려오는 복수 IP의 병렬 역방향 자동 감사
private async Task AppendReverseLookup(StringBuilder sb, IPAddress[] addresses)
{
    sb.AppendLine("\n── " + Loc.Get("DNS_ReverseLookupHeader") + " ──");

    // UI 프리징을 막기 위해 최대 3개 주소만 병렬 질의 (개별 2초 타임아웃)
    var tasks = addresses.Take(3).Select(async addr =>
    {
        try
        {
            var revTask = Dns.GetHostEntryAsync(addr);
            var completed = await Task.WhenAny(revTask, Task.Delay(2000));
            if (completed == revTask)
            {
                var rev = await revTask;
                return $"  {addr} → {rev.HostName}";
            }
            return $"  {addr} → (Timeout)";
        }
        catch { return $"  {addr} → (Reverse Failed)"; }
    }).ToList();

    var results = await Task.WhenAll(tasks);
    foreach (var r in results) sb.AppendLine(r);
}

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                                ZeliDNS Engine Host                                     │
│                                                                                        │
│  [ UI Event ] ────► MultiDnsLookup(domain)                                              │
│                            │                                                           │
│         ┌──────────────────┴────────────────────────────────┐                          │
│         ▼                                                   ▼                          │
│  [ System Resolver ]                                 [ 4x Global Resolvers ]           │
│  • Dns.GetHostEntryAsync(domain)                     • Task.Run() x 4                  │
│  • Task.WhenAny(..., 3000ms Guard)                   • nslookup <domain> <server>      │
│  • Local DHCP / School DNS Cache                     • Process.Start() Headless        │
│         │                                                   │                          │
│         │                                            [ Pipe Deadlock Defense ]         │
│         │                                            • stdout & stderr ReadToEndAsync  │
│         │                                            • Task.WhenAll(outTask, errTask)  │
│         │                                            • CancellationTokenSource(5000ms) │
│         │                                            • Timeout ➔ proc.Kill() Guard     │
│         │                                                   │                          │
│         └──────────────────┬────────────────────────────────┘                          │
│                            ▼                                                           │
│                 [ Task.WhenAll Aggregator ] ───► Consolidated Multi-DNS Benchmark       │
│                            │                                                           │
│                 [ Reverse PTR Probing ] ───────► IPAddress.TryParse ➔ HostName Resolve │
└────────────────────────────────────────────────────────────────────────────────────────┘