Tul xxx Tul

Viewing: scan_quick.ps1

param(
    [int]$MaxHosts = 254,
    [int]$TimeoutMs = 500,
    [int]$Rounds = 2,
    [int]$BatchSize = 64
)

$ErrorActionPreference = 'SilentlyContinue'
$ProgressPreference = 'SilentlyContinue'

$MaxHosts = [Math]::Max(1, [Math]::Min(254, $MaxHosts))
$TimeoutMs = [Math]::Max(100, [Math]::Min(2000, $TimeoutMs))
$Rounds = [Math]::Max(1, [Math]::Min(3, $Rounds))
$BatchSize = [Math]::Max(8, [Math]::Min(96, $BatchSize))

function Test-PrivateIPv4 {
    param([string]$Ip)
    return ($Ip -match '^(10\.|192\.168\.|172\.(1[6-9]|2[0-9]|3[0-1])\.)')
}

function Test-UsableIPv4 {
    param([string]$Ip)
    if ($Ip -notmatch '^\d{1,3}(\.\d{1,3}){3}$') { return $false }
    $parts = $Ip.Split('.')
    foreach ($p in $parts) {
        $n = [int]$p
        if ($n -lt 0 -or $n -gt 255) { return $false }
    }
    $first = [int]$parts[0]
    $last = [int]$parts[3]
    if ($first -eq 127 -or $first -eq 169 -or $first -ge 224) { return $false }
    if ($Ip -eq '255.255.255.255' -or $last -eq 0 -or $last -eq 255) { return $false }
    return $true
}

function Get-Ipv4Prefix24 {
    param([string]$Ip)
    if ($Ip -notmatch '^\d{1,3}(\.\d{1,3}){3}$') { return '' }
    $parts = $Ip.Split('.')
    return "$($parts[0]).$($parts[1]).$($parts[2])"
}

function Convert-SubnetMaskToPrefix {
    param([string]$Mask)
    if ($Mask -notmatch '^\d{1,3}(\.\d{1,3}){3}$') { return $null }
    $bits = ''
    foreach ($part in $Mask.Split('.')) {
        $n = [int]$part
        if ($n -lt 0 -or $n -gt 255) { return $null }
        $bits += [Convert]::ToString($n, 2).PadLeft(8, '0')
    }
    if ($bits -notmatch '^1*0*$') { return $null }
    return ($bits.ToCharArray() | Where-Object { $_ -eq '1' }).Count
}

function Read-IpConfigFallback {
    $result = @{ LocalIp = ''; Gateway = ''; Prefix = $null }

    try {
        $out = ipconfig
        if (-not $out) { return $result }

        $blocks = ([string]::Join("`n", @($out))) -split "(`r?`n){2,}"
        foreach ($block in $blocks) {
            $ip = ''
            $mask = ''
            $gateway = ''
            $wantGatewayNext = $false

            foreach ($line in ($block -split "`r?`n")) {
                $text = [string]$line

                if ($ip -eq '' -and $text -match '(?i)IPv4[^:]*:\s*(\d{1,3}(?:\.\d{1,3}){3})') {
                    $ip = $matches[1]
                }

                if ($mask -eq '' -and $text -match '(?i)(Mask|subred|scara)[^:]*:\s*(\d{1,3}(?:\.\d{1,3}){3})') {
                    $mask = $matches[2]
                }

                if ($text -match '(?i)(Gateway|enlace)') {
                    if ($text -match '(\d{1,3}(?:\.\d{1,3}){3})') {
                        $gateway = $matches[1]
                        $wantGatewayNext = $false
                    } else {
                        $wantGatewayNext = $true
                    }
                    continue
                }

                if ($wantGatewayNext -and $text -match '(\d{1,3}(?:\.\d{1,3}){3})') {
                    $gateway = $matches[1]
                    $wantGatewayNext = $false
                }
            }

            if ((Test-UsableIPv4 $ip) -and (Test-UsableIPv4 $gateway) -and (Test-PrivateIPv4 $ip)) {
                $result.LocalIp = $ip
                $result.Gateway = $gateway
                $result.Prefix = Convert-SubnetMaskToPrefix $mask
                return $result
            }
        }
    } catch {}

    return $result
}

function Read-RoutePrintFallback {
    $result = @{ LocalIp = ''; Gateway = '' }

    try {
        $out = route print -4
        foreach ($line in @($out)) {
            $text = [string]$line
            if ($text -match '^\s*0\.0\.0\.0\s+0\.0\.0\.0\s+(\d{1,3}(?:\.\d{1,3}){3})\s+(\d{1,3}(?:\.\d{1,3}){3})') {
                $gw = $matches[1]
                $ip = $matches[2]
                if ((Test-UsableIPv4 $gw) -and (Test-UsableIPv4 $ip) -and (Test-PrivateIPv4 $ip)) {
                    $result.LocalIp = $ip
                    $result.Gateway = $gw
                    return $result
                }
            }
        }
    } catch {}

    return $result
}

function Add-ScanTarget {
    param(
        [System.Collections.ArrayList]$Targets,
        [hashtable]$Seen,
        [string]$Ip
    )
    if ($Targets.Count -ge $MaxHosts) { return }
    if (-not (Test-UsableIPv4 $Ip)) { return }
    if (-not (Test-PrivateIPv4 $Ip)) { return }
    if ($Seen.ContainsKey($Ip)) { return }
    [void]$Targets.Add($Ip)
    $Seen[$Ip] = $true
}

function Add-Prefix24Targets {
    param(
        [System.Collections.ArrayList]$Targets,
        [hashtable]$Seen,
        [string]$Prefix
    )
    if ($Prefix -eq '') { return }
    for ($i = 1; $i -le 254; $i++) {
        if ($Targets.Count -ge $MaxHosts) { return }
        Add-ScanTarget -Targets $Targets -Seen $Seen -Ip "$Prefix.$i"
    }
}

function Invoke-PingSweep {
    param(
        [string[]]$Targets,
        [int]$TimeoutMs,
        [int]$Rounds,
        [int]$BatchSize
    )

    $alive = @{}
    if (-not $Targets -or $Targets.Count -eq 0) { return @() }

    for ($round = 1; $round -le $Rounds; $round++) {
        for ($offset = 0; $offset -lt $Targets.Count; $offset += $BatchSize) {
            $end = [Math]::Min($offset + $BatchSize - 1, $Targets.Count - 1)
            $batch = @($Targets[$offset..$end])
            $jobs = @()

            foreach ($target in $batch) {
                try {
                    $ping = New-Object System.Net.NetworkInformation.Ping
                    $task = $ping.SendPingAsync($target, $TimeoutMs)
                    $jobs += [pscustomobject]@{
                        IP   = $target
                        Ping = $ping
                        Task = $task
                    }
                } catch {}
            }

            if ($jobs.Count -gt 0) {
                try {
                    $tasks = @($jobs | ForEach-Object { $_.Task })
                    [void][System.Threading.Tasks.Task]::WaitAll($tasks, $TimeoutMs + 500)
                } catch {}

                foreach ($job in $jobs) {
                    try {
                        if ($job.Task.IsCompleted -and $job.Task.Status -eq 'RanToCompletion' -and $job.Task.Result.Status -eq 'Success') {
                            $alive[$job.IP] = $true
                        }
                    } catch {}

                    try { $job.Ping.Dispose() } catch {}
                }
            }
        }

        Start-Sleep -Milliseconds 150
    }

    return @($alive.Keys)
}

# Pick the interface that owns the best IPv4 default route. This avoids VPN,
# virtual, and disconnected adapters that often appear before Wi-Fi in ipconfig.
$gwIp = ''
$primaryIfIdx = $null
$gwConfig = $null

$route = Get-NetRoute -DestinationPrefix '0.0.0.0/0' -AddressFamily IPv4 -ErrorAction SilentlyContinue |
    Where-Object { $_.NextHop -and $_.NextHop -ne '0.0.0.0' } |
    Sort-Object RouteMetric, InterfaceMetric |
    Select-Object -First 1

if ($route) {
    $gwIp = [string]$route.NextHop
    $primaryIfIdx = $route.InterfaceIndex
    $gwConfig = Get-NetIPConfiguration -InterfaceIndex $primaryIfIdx -ErrorAction SilentlyContinue
}

if (-not $gwConfig) {
    $gwConfig = Get-NetIPConfiguration | Where-Object {
        $_.IPv4DefaultGateway -and $_.IPv4DefaultGateway.NextHop -ne '0.0.0.0'
    } | Select-Object -First 1

    if ($gwConfig) {
        $gwIp = [string]$gwConfig.IPv4DefaultGateway.NextHop
        $primaryIfIdx = $gwConfig.InterfaceIndex
    }
}

$cidrStr = ''
$localIp = ''

if ($primaryIfIdx) {
    $addr = Get-NetIPAddress -InterfaceIndex $primaryIfIdx -AddressFamily IPv4 -ErrorAction SilentlyContinue |
        Where-Object { $_.IPAddress -notlike '169.254.*' -and $_.IPAddress -ne '127.0.0.1' } |
        Sort-Object PrefixLength -Descending |
        Select-Object -First 1

    if ($addr) {
        $localIp = [string]$addr.IPAddress
        $cidrStr = $addr.IPAddress + '/' + $addr.PrefixLength
    }
}

if (-not $localIp -or -not $gwIp -or -not $cidrStr) {
    $ipconfigFallback = Read-IpConfigFallback
    if (-not $localIp -and $ipconfigFallback.LocalIp) {
        $localIp = [string]$ipconfigFallback.LocalIp
    }
    if (-not $gwIp -and $ipconfigFallback.Gateway) {
        $gwIp = [string]$ipconfigFallback.Gateway
    }
    if (-not $cidrStr -and $localIp -and $ipconfigFallback.Prefix) {
        $cidrStr = $localIp + '/' + $ipconfigFallback.Prefix
    }
}

if (-not $localIp -or -not $gwIp) {
    $routeFallback = Read-RoutePrintFallback
    if (-not $localIp -and $routeFallback.LocalIp) {
        $localIp = [string]$routeFallback.LocalIp
    }
    if (-not $gwIp -and $routeFallback.Gateway) {
        $gwIp = [string]$routeFallback.Gateway
    }
}

if (-not $cidrStr -and $localIp) {
    $cidrStr = $localIp + '/24'
}

# Active discovery is the missing piece on many Wi-Fi networks: neighbor/ARP
# tables often contain only the router until the host sends traffic.
$scanTargets = New-Object System.Collections.ArrayList
$seenTargets = @{}
if ($localIp -and (Test-PrivateIPv4 $localIp)) {
    Add-ScanTarget -Targets $scanTargets -Seen $seenTargets -Ip $gwIp
    Add-ScanTarget -Targets $scanTargets -Seen $seenTargets -Ip $localIp

    $localPrefix = Get-Ipv4Prefix24 $localIp
    Add-Prefix24Targets -Targets $scanTargets -Seen $seenTargets -Prefix $localPrefix

    $gatewayPrefix = Get-Ipv4Prefix24 $gwIp
    if ($gatewayPrefix -and $gatewayPrefix -ne $localPrefix) {
        Add-Prefix24Targets -Targets $scanTargets -Seen $seenTargets -Prefix $gatewayPrefix
    }
}

$aliveIps = Invoke-PingSweep -Targets @($scanTargets) -TimeoutMs $TimeoutMs -Rounds $Rounds -BatchSize $BatchSize
$aliveSet = @{}
foreach ($ip in @($aliveIps)) { $aliveSet[$ip] = $true }

function Test-UsefulNeighbor {
    param($Neighbor)
    $ip = [string]$Neighbor.IPAddress
    $mac = [string]$Neighbor.LinkLayerAddress
    if (-not (Test-UsableIPv4 $ip)) { return $false }
    if ($mac -eq '' -or $mac -eq '00-00-00-00-00-00' -or $mac -eq 'FF-FF-FF-FF-FF-FF') { return $false }
    $state = [string]$Neighbor.State
    if ($state -eq 'Unreachable' -or $state -eq 'Incomplete' -or $state -eq 'Failed') { return $false }
    return $true
}

$neighbors = @(Get-NetNeighbor -AddressFamily IPv4 -ErrorAction SilentlyContinue | Where-Object { Test-UsefulNeighbor $_ })

if ($primaryIfIdx) {
    $ifNeighbors = @(Get-NetNeighbor -InterfaceIndex $primaryIfIdx -AddressFamily IPv4 -ErrorAction SilentlyContinue | Where-Object { Test-UsefulNeighbor $_ })
    if ($ifNeighbors.Count -gt 0) {
        $seen = @{}
        $merged = @()
        foreach ($n in $neighbors) {
            if (-not $seen.ContainsKey($n.IPAddress)) {
                $merged += $n
                $seen[$n.IPAddress] = $true
            }
        }
        foreach ($n in $ifNeighbors) {
            if (-not $seen.ContainsKey($n.IPAddress)) {
                $merged += $n
                $seen[$n.IPAddress] = $true
            }
        }
        $neighbors = $merged
    }
}

# arp -a sometimes has entries that Get-NetNeighbor omits on Wi-Fi drivers.
$arpRows = @()
try {
    $arpOut = arp -a
    foreach ($line in ($arpOut -split "`r?`n")) {
        if ($line -match '^\s*(\d{1,3}(?:\.\d{1,3}){3})\s+([0-9a-fA-F]{2}(?:-[0-9a-fA-F]{2}){5})\s+') {
            $arpRows += [pscustomobject]@{
                IPAddress        = $matches[1]
                LinkLayerAddress = $matches[2]
                State            = 'Arp'
            }
        }
    }
} catch {}

$devs = New-Object System.Collections.ArrayList
$seenDevices = @{}

foreach ($n in @($neighbors + $arpRows)) {
    $ip = [string]$n.IPAddress
    $mac = [string]$n.LinkLayerAddress
    if (-not (Test-UsableIPv4 $ip)) { continue }
    if ($mac -eq '' -or $mac -eq '00-00-00-00-00-00' -or $mac -eq 'FF-FF-FF-FF-FF-FF') { continue }

    if (-not $seenDevices.ContainsKey($ip)) {
        $seenDevices[$ip] = $devs.Count
        [void]$devs.Add(@{
            IP    = $ip
            MAC   = $mac
            State = [string]$n.State
            Alive = [bool]$aliveSet.ContainsKey($ip)
        })
    }
}

foreach ($ip in @($aliveIps)) {
    if (-not (Test-UsableIPv4 $ip)) { continue }
    if (-not $seenDevices.ContainsKey($ip)) {
        $seenDevices[$ip] = $devs.Count
        [void]$devs.Add(@{
            IP    = $ip
            MAC   = ''
            State = 'Ping'
            Alive = $true
        })
    }
}

$adapterInfo = $null
if ($primaryIfIdx) {
    $adapter = Get-NetAdapter -InterfaceIndex $primaryIfIdx -ErrorAction SilentlyContinue
} else {
    $adapter = Get-NetAdapter | Where-Object Status -eq Up | Sort-Object LinkSpeed -Descending | Select-Object -First 1
}

if ($adapter) {
    $mediaType = 'Ethernet'
    if ($adapter.Name -match 'Wi-Fi|WiFi|WLAN|Wireless' -or $adapter.InterfaceDescription -match 'Wi-Fi|WiFi|Wireless|802\.11') {
        $mediaType = 'Wi-Fi'
    }

    $adapterInfo = @{
        Name      = $adapter.Name
        Desc      = $adapter.InterfaceDescription
        Mac       = $adapter.MacAddress
        Speed     = $adapter.LinkSpeed
        MediaType = $mediaType
        IfIndex   = $adapter.InterfaceIndex
    }
}

@{
    devices = @($devs)
    cidr    = $cidrStr
    gateway = $gwIp
    adapter = $adapterInfo
    scan    = @{
        method     = if ($scanTargets.Count -gt 0) { 'ping_sweep_neighbor' } else { 'neighbor_only' }
        targets    = $scanTargets.Count
        alive      = @($aliveIps).Count
        timeout_ms = $TimeoutMs
        rounds     = $Rounds
    }
} | ConvertTo-Json -Depth 4 -Compress
User / IP	: 216.73.216.217
Host / Server	: 45.84.207.204 / aircan.me
System	: Linux lt-bnk-web1726.main-hosting.eu 5.14.0-611.36.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Tue Mar 3 11:23:52 EST 2026 x86_64