Início Tecnologia Conartista: Ligador de rede de terminais leves no PowerShell

Conartista: Ligador de rede de terminais leves no PowerShell

Por
Bouville Fabienne
-
12
0

No cenário digital de hoje, entender rapidamente o que está acontecendo nos bastidores de uma máquina particular person pode ser essential. Apresentando Conartistaum script de PowerShell simplificado e intuitivo projetado especificamente para monitorar as conexões de rede em um único ponto last – supreme para verificações de segurança ou tarefas de diagnóstico sem precisar de ferramentas de peso pesado como o Wireshark.

O que é Conartist?

Conartist é uma ferramenta de monitoramento de rede baseada em PowerShell simples, mas poderosa, criada especificamente para pontos de extremidade única. Perfeito para verificações rápidas por analistas de segurança, sysadmins ou suporte técnico, o Conartist ajuda você a identificar rapidamente a atividade de rede inesperada ou problemática.

Com Conartist, você pode:

  • Registre as conexões TCP ativas junto com os processos responsáveis.
  • Opcionalmente, seize as consultas DNS feitas pelo terminal.
  • Filtre o tráfego IP native (privado) para logs concisos.
  • Monitore continuamente e evite o registro redundante através da detecção de duplicado inteligente.

Como o Conartist funciona?

Aqui está como ele opera:

Inicialização

O script solicita duas perguntas diretas:

  • Se deve filtrar o tráfego native (privado IP).
  • Se deve capturar consultas DNS.

Com base em suas respostas, o Connartist ajusta seu monitoramento adequadamente.

Monitoramento ativo

Conartista continuamente:

  • Logs conexões TCP ativas, incluindo metadados detalhados (tempo, processo, endereço remoto, host remoto).
  • Opcionalmente registra consultas DNS, capturando nomes de consultas e registros de information e hora.
  • Evita entradas duplicadas mantendo o rastreamento interno.

Limpar log

Os dados capturados são formatados e armazenados localmente:

  • Conexões TCP registradas para tcp_log.txt.
  • Consultas de DNS armazenadas em dns_log.txt.

Implementando Conartist

Etapa 1: Preparação

  • Salve o script PowerShell fornecido como ConnArtist.ps1.
  • Verifique se você tem permissões para escrever logs (C:UsersPublic).

Etapa 2: Execução

  • Run PowerShell como administrador.

  • Execute o script:

    powershell.exe -ExecutionPolicy Bypass -File "C:PathToConnArtist.ps1"

  • Prompts de resposta sobre filtragem de tráfego native e captura de DNS com base no seu caso de uso.

Etapa 3: Monitoramento contínuo

  • Conartist monitora a rede a cada 5 segundos, fornecendo informações em tempo actual.
  • Imprensa Ctrl+C para parar de monitorar a qualquer momento.

Exemplo de uso de casos

  • Verificações de segurança: Identifique rapidamente conexões externas inesperadas que podem indicar malware ou atividade não autorizada.
  • Tarefas de diagnóstico: Solucionar problemas de conectividade, identificando conexões problemáticas ou resoluções de DNS.

Personalizando Conartist

Ajuste os locais de log ou intervalos conforme necessário:

$tcpLogFile = "C:UsersPublictcp_log.txt"
$dnsLogFile = "C:UsersPublicdns_log.txt"

# Modify monitoring interval as desired
Begin-Sleep -Seconds 5

Ajustando a filtragem de rede native

Para filtragem precisa, pode ser necessário personalizar as faixas IP privadas da rede native. Modifique a seguinte função para corresponder aos octetos da sua rede:

perform IsPrivateIP($ipAddress) {
    attempt {
        $ip = [System.Net.IPAddress]::Parse($ipAddress)
        if ($ip.AddressFamily -eq 'InterNetwork') { # IPv4
            return ($ipAddress -like '10.*' -or
                    $ipAddress -like '172.16.*' -or
                    $ipAddress -like '192.168.*') # Modify these octets to your native community vary
        } elseif ($ip.AddressFamily -eq 'InterNetworkV6') { # IPv6
            return ($ip.IsIPv6LinkLocal -or $ip.IsIPv6SiteLocal)
        } else {
            return $false
        }
    } catch {
        return $false
    }
}

Por que usar Conartist?

  • Light-weight: Nenhuma instalação ou configurações complexas necessárias.
  • Insights claros: Logs diretos e facilmente legíveis.
  • Focado: Projetado para verificações de ponto em pontos de extremidade únicos.
  • Monitoramento em tempo actual: Detecção rápida de atividades incomuns ou problemas de conexão.

O Connartist simplifica a visibilidade da rede de endpoint, permitindo a identificação rápida de possíveis preocupações de segurança ou solucionando problemas de rede de maneira rápida e eficaz.

Monitoramento feliz!

#One other        /_[]_/
#    tremendous      |] _||_ [|
#       ___     / || /
#      /___       ||
#     (|0 0|)      ||
#   __/{U/}_ ___/vvv
#  /   {~}   / _|_P|
#  | /  ~   /_/   []
#  |_| (____)        
#  _]/______  Barberion  
#     __||_/_     Manufacturing      
#    (_,_||_,_)
#
# Outline log file paths for TCP and DNS logs
$tcpLogFile = "C:UsersPublictcp_log.txt"
$dnsLogFile = "C:UsersPublicdns_log.txt"

# Operate to verify if an IP handle is non-public
perform IsPrivateIP($ipAddress) {
    attempt {
        $ip = [System.Net.IPAddress]::Parse($ipAddress)
        if ($ip.AddressFamily -eq 'InterNetwork') { # IPv4
            return ($ipAddress -like '10.*' -or
                    $ipAddress -like '172.16.*' -or
                    $ipAddress -like '192.168.*')
        } elseif ($ip.AddressFamily -eq 'InterNetworkV6') { # IPv6
            return ($ip.IsIPv6LinkLocal -or $ip.IsIPv6SiteLocal)
        } else {
            return $false
        }
    } catch {
        return $false
    }
}

# Ask the person in the event that they need to filter out native visitors
$filterPrivateIPs = (Learn-Host "Do you need to filter out native visitors? (sure/no)").Trim().ToLower()
$filterPrivate = $filterPrivateIPs -eq 'sure' -or $filterPrivateIPs -eq 'y'

# Ask the person in the event that they need to seize DNS requests
$dnsCaptureInput = (Learn-Host "Do you need to seize DNS requests? (sure/no)").Trim().ToLower()
$captureDNS = $dnsCaptureInput -eq 'sure' -or $dnsCaptureInput -eq 'y'

# Output the monitoring message on the prime
Write-Host "Monitoring community connections. Press Ctrl+C to cease."
Add-Content material -Path $tcpLogFile -Worth "Monitoring TCP connections. Press Ctrl+C to cease."
Add-Content material -Path $dnsLogFile -Worth "Monitoring DNS connections. Press Ctrl+C to cease."

# Outline the headers
$tcpHeader = "{0,-20} {1,-20} {2,-25} {3}" -f "Date/Time", "Course of", "Distant Tackle", "Distant Host"
$dnsHeader = "{0,-20} {1,-30}" -f "Date/Time", "DNS Question"

Write-Host $tcpHeader
Write-Host ("-" * 90)
Add-Content material -Path $tcpLogFile -Worth $tcpHeader
Add-Content material -Path $tcpLogFile -Worth ("-" * 90)

if ($captureDNS) {
    $dnsLogName = "Microsoft-Home windows-DNS-Consumer/Operational"
    if (-not (Get-WinEvent -ListLog $dnsLogName).IsEnabled) {
        Write-Host "Enabling DNS shopper operational log..."
        attempt {
            wevtutil sl $dnsLogName /e:true
        } catch {
            Write-Host "Didn't allow DNS shopper operational log. Chances are you'll must run PowerShell as Administrator."
            $captureDNS = $false
        }
    }
    if ($captureDNS) {
        # Initialize the final DNS verify time
        $lastDNSCheckTime = Get-Date
        # Output the DNS header
        Write-Host $dnsHeader
        Write-Host ("-" * 50)
        Add-Content material -Path $dnsLogFile -Worth $dnsHeader
        Add-Content material -Path $dnsLogFile -Worth ("-" * 50)
    }
}

# To stop duplication, keep hashsets of logged connections and DNS queries
$loggedConnections = @{}
$loggedDNSQueries = @{}

whereas ($true) {
    # Get present community connections
    $currentConnections = Get-NetTCPConnection -State Established

    if ($filterPrivate) {
        $currentConnections = $currentConnections | The place-Object {
            $_.RemoteAddress -ne '127.0.0.1' -and
            $_.RemoteAddress -ne '::1'
        }
    }

    foreach ($conn in $currentConnections) {
        $connectionKey = "$($conn.OwningProcess)|$($conn.RemoteAddress):$($conn.RemotePort)"
        if (-not $loggedConnections.ContainsKey($connectionKey)) {
            if (-not $filterPrivate -or (-not (IsPrivateIP $conn.RemoteAddress))) {
                $dateTime = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
                $course of = Get-Course of -Id $conn.OwningProcess -ErrorAction SilentlyContinue
                $processName = if ($course of) { $course of.ProcessName } else { 'N/A' }
                $remoteHost = $conn.RemoteAddress
                attempt {
                    $dnsEntry = [System.Net.Dns]::GetHostEntry($conn.RemoteAddress)
                    $remoteHost = $dnsEntry.HostName
                } catch {
                    # Couldn't resolve host
                }
                $remoteAddressPort = "$($conn.RemoteAddress):$($conn.RemotePort)"
                $logEntry = "TCP {0,-20} {1,-20} {2,-25} {3}" -f $dateTime, $processName, $remoteAddressPort, $remoteHost
                Add-Content material -Path $tcpLogFile -Worth $logEntry
                Write-Host $logEntry
                # Add the connection to the loggedConnections hashset to stop future duplicates
                $loggedConnections[$connectionKey] = $true
            }
        }
    }

    if ($captureDNS) {
        attempt {
            # Get new DNS question occasions
            $dnsEvents = Get-WinEvent -FilterHashtable @{
                LogName = 'Microsoft-Home windows-DNS-Consumer/Operational';
                Id = 3008;
                StartTime = $lastDNSCheckTime
            } -ErrorAction SilentlyContinue
            
            if ($dnsEvents) {
                foreach ($occasion in $dnsEvents) {
                    $dateTime = $occasion.TimeCreated.ToString('yyyy-MM-dd HH:mm:ss')
                    $queryName = $occasion.Properties[0].Worth
                    if (-not $loggedDNSQueries.ContainsKey($queryName)) {
                        $dnsEntry = "DNS {0,-20} {1,-30}" -f $dateTime, $queryName
                        Add-Content material -Path $dnsLogFile -Worth $dnsEntry
                        Write-Host $dnsEntry
                        # Add the DNS question to the loggedDNSQueries hashset to stop future duplicates
                        $loggedDNSQueries[$queryName] = $true
                    }
                }
                # Replace the final DNS verify time
                $lastDNSCheckTime = Get-Date
            }
        } catch {
            # Suppress any errors associated to DNS occasion fetching
        }
    }

    Begin-Sleep -Seconds 5
}

fonte

ARTIGOS RELACIONADOSMais do autor