국방·공공 전산실 엔드포인트 보안 감사와 데이터 유출 0초 방어: ZeliScan의 온디바이스 포트 스캐너·자격증명 누출 진단 및 USB 보안 거버넌스 아키텍처

// ── SemaphoreSlim 병렬 제어와 IAsyncEnumerable 스트리밍 포트 스캔 ──
public static async IAsyncEnumerable<PortScanResult> ScanPortsAsync(
    int[] ports,
    string targetHost = "127.0.0.1",
    int timeoutMs = 500,
    int maxParallel = 50,
    IProgress<(int scanned, int total, int openCount)> progress = null,
    [EnumeratorCancellation] CancellationToken token = default)
{
    var resultQueue = new ConcurrentQueue<PortScanResult>();
    int scanned = 0, openCount = 0, total = ports.Length;

    // netstat -ano 출력과 실행 프로세스 PID 매핑 딕셔너리 사전 수집
    var pidMap = await GetPortPidMapAsync(token);

    var semaphore = new SemaphoreSlim(maxParallel);
    var tasks = new List<Task>();

    foreach (var port in ports)
    {
        if (token.IsCancellationRequested) break;
        await semaphore.WaitAsync(token);

        tasks.Add(Task.Run(async () =>
        {
            try
            {
                bool isOpen = await IsPortOpenAsync(targetHost, port, timeoutMs, token);
                if (isOpen)
                {
                    var (serviceName, risk, detail, actionGuide, contextNote) = PortScanResult.LookupPort(port);
                    pidMap.TryGetValue(port, out var procInfo);

                    var result = new PortScanResult
                    {
                        Port = port,
                        Protocol = "TCP",
                        State = "Open",
                        ServiceName = serviceName,
                        ProcessName = procInfo.name ?? "",
                        ProcessId = procInfo.pid,
                        RiskLevel = risk,
                        RiskDetail = detail,
                        ActionGuide = actionGuide,
                        ContextNote = contextNote,
                        ScannedAt = DateTime.Now
                    };

                    resultQueue.Enqueue(result);
                    Interlocked.Increment(ref openCount);
                }
                Interlocked.Increment(ref scanned);
                progress?.Report((scanned, total, openCount));
            }
            finally
            {
                semaphore.Release();
            }
        }, token));
    }

    // 결과 큐에 적재되는 즉시 UI 스레드로 비동기 yield 반환
    while (tasks.Any(t => !t.IsCompleted) || !resultQueue.IsEmpty)
    {
        if (token.IsCancellationRequested) yield break;
        while (resultQueue.TryDequeue(out var result))
            yield return result;

        try { await Task.Delay(30, token); }
        catch (OperationCanceledException) { yield break; }
    }
}

// ── P/Invoke를 통한 무중단 프로세스 경로 조회 및 디지털 서명 검증 ──
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
private static extern bool QueryFullProcessImageName(
    IntPtr hProcess, int dwFlags, StringBuilder lpExeName, ref int lpdwSize);

public static string GetProcessPath(int pid)
{
    IntPtr hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid);
    if (hProcess == IntPtr.Zero) return "";

    try
    {
        var sb = new StringBuilder(1024);
        int size = sb.Capacity;
        if (QueryFullProcessImageName(hProcess, 0, sb, ref size))
            return sb.ToString();
    }
    finally
    {
        CloseHandle(hProcess);
    }
    return "";
}

// ── 의심 프로세스 대상 Authenticode 전자서명 검증 (성능 최적화) ──
private static (bool isSigned, string signerName) CheckSignature(string filePath)
{
    try
    {
        using var cert = X509Certificate.CreateFromSignedFile(filePath);
        return (true, cert.Subject);
    }
    catch
    {
        return (false, ""); // 전자서명이 없거나 위조됨
    }
}

// ── USBSTOR 레지스트리를 통한 과거 연결 이력 복원 및 BadUSB 탐지 ──
private static List<UsbDeviceInfo> GetHistoricalDevices(List<UsbDeviceInfo> connected)
{
    var result = new List<UsbDeviceInfo>();
    var connectedIds = new HashSet<string>(connected.Select(d => d.SerialNumber), StringComparer.OrdinalIgnoreCase);

    try
    {
        // 윈도우 커널이 영구 기록하는 USB 저장장치 연결 히스토리
        using var key = Registry.LocalMachine.OpenSubKey(@"SYSTEM\CurrentControlSet\Enum\USBSTOR");
        if (key == null) return result;

        foreach (var devName in key.GetSubKeyNames())
        {
            using var devKey = key.OpenSubKey(devName);
            if (devKey == null) continue;

            foreach (var serial in devKey.GetSubKeyNames())
            {
                if (connectedIds.Contains(serial)) continue; // 현재 꽂혀 있는 장치는 제외

                using var serialKey = devKey.OpenSubKey(serial);
                string friendlyName = serialKey?.GetValue("FriendlyName") as string ?? devName;

                result.Add(new UsbDeviceInfo
                {
                    DeviceName = friendlyName,
                    DeviceId = $"USBSTOR\\{devName}\\{serial}",
                    DeviceType = "DiskDrive",
                    SerialNumber = serial,
                    IsCurrentlyConnected = false // 과거에 연결되었던 흔적!
                });
            }
        }
    }
    catch { }
    return result;
}

// ── 악성 공격 도구 시그니처 및 복합 HID 장치 판별 ──
private static void EvaluateSuspicious(UsbDeviceInfo device)
{
    string combined = $"{device.DeviceName} {device.Manufacturer} {device.DeviceId}".ToLowerInvariant();

    foreach (var keyword in SuspiciousKeywords)
    {
        if (combined.Contains(keyword))
        {
            device.IsSuspicious = true;
            device.SuspiciousReason = $"알려진 하드웨어 해킹 공격 도구: {keyword}";
            return;
        }
    }

    // 대용량 저장장치 외형인데 HID 복합 장치로 인식되는 경우 -> BadUSB 의심
    if (device.DeviceType == "HID" && device.DeviceName.Contains("Composite", StringComparison.OrdinalIgnoreCase))
    {
        device.IsSuspicious = true;
        device.SuspiciousReason = "복합 HID 키보드 위장 장치 — BadUSB 주입 공격 의심";
    }
}