Question boucle

ForEach-Object %

[code][code]$network = "192.168.1"
$IPRange = 1..254
$PortRange = 1..65535

$stopwatch =  [system.diagnostics.stopwatch]::StartNew()
foreach( $i in $IPRange ) {
    $ip = "$network.$i"

    if ( -not (test-connection $ip -Count 1 -Quiet) ) {
        write-host ". $ip;poste non joignable;$($stopwatch.elapsed.Totalmilliseconds)"
        continue    # passe directement à l'ip suivante
    }

    foreach ( $port in $PortRange ) {
        if ( (test-netconnection -computername $ip -Port $port -WarningAction Silentlycontinue -InformationLevel quiet) ) {
            write-host ". $ip;$port;opérationnel;$($stopwatch.elapsed.Totalmilliseconds)"
        } else {
            write-host ". $ip;$port;bloqué;$($stopwatch.elapsed.Totalmilliseconds)"
        }
    }
}

[code][code]$network = "192.168.1"
$IPRange = 1..254
$PortRange = 1..65535

$ping = new-object System.Net.NetworkInformation.Ping
$tcpclient = New-Object Net.Sockets.TcpClient

$stopwatch =  [system.diagnostics.stopwatch]::StartNew()
foreach( $i in $IPRange ) {
    $ip = "$network.$i"

    $result = $ping.send($ip)
    if ( $result.status -ne "success" ) {
        write-host ". $ip;erreur : $($result.status);$($stopwatch.elapsed.Totalmilliseconds)"
        continue
    }

    foreach ( $port in $PortRange ) {
        try {
            $tcpclient.connect( $ip, $port )
            if ($tcpclient.connected) {
                write-host ". $ip;$port;opérationnel;$($stopwatch.elapsed.Totalmilliseconds)"
                $tcpclient.close()
            }
        } catch {
            write-host ". $ip;$port;bloqué;$($stopwatch.elapsed.Totalmilliseconds)"
        }
    }
}

[code][code]$network = "192.168.1"
$IPRange = 1..254

$IPs = $IPRange | ForEach { "$network.$_" }

$stopwatch =  [system.diagnostics.stopwatch]::StartNew()

#-- crée un système de thread pour réaliser des ping asynchrones --
$Task = foreach( $ip in $IPs ) { (New-Object System.Net.NetworkInformation.Ping).SendPingAsync($ip) }

#-- attend que tous les threads soient terminées --
[Threading.Tasks.Task]::WaitAll($Task)

#-- récupère juste la liste des postes qui ont répondu au ping --
$Task.result | where { $_.status -eq "success" } | ft -auto *
write-host "> terminé en $($stopwatch.elapsed.TotalMilliSeconds) ms"

[code]<#
    .SYNOPSIS
    Powerful asynchronus IPv4 Port Scanner
    .DESCRIPTION
    This powerful asynchronus IPv4 Port Scanner allows you to scan every Port-Range you want (500 to 2600 would work). Only TCP-Ports are scanned.
    The result will contain the Port number, Protocol and the Status.

    .LINK
    https://github.com/BornToBeRoot/PowerShell_IPv4PortScanner/blob/master/README.md
#>

function IPv4PortScan {
    param(
        [Parameter(
            Position = 0,
            Mandatory = $true,
            HelpMessage = 'ComputerName or IPv4-Address of the device which you want to scan')]
        [String]$ComputerName,

        [Parameter(
            Position = 1,
            HelpMessage = 'First port which should be scanned (Default=1)')]
        [ValidateRange(1, 65535)]
        [Int32]$StartPort = 1,

        [Parameter(
            Position = 2,
            HelpMessage = 'Last port which should be scanned (Default=65535)')]
        [ValidateRange(1, 65535)]
        [ValidateScript({
                if ($_ -lt $StartPort) {
                    throw "Invalid Port-Range!"
                }
                else {
                    return $true
                }
            })]
        [Int32]$EndPort = 65535,

        [Parameter(
            Position = 3,
            HelpMessage = 'Maximum number of threads at the same time (Default=512)')]
        [Int32]$Threads = 512
    )

    Process {
        $PortsToScan = ($EndPort - $StartPort)

        Write-Verbose -Message "Scanning range from $StartPort to $EndPort ($PortsToScan Ports)"
        Write-Verbose -Message "Running with max $Threads threads"

        # Check if ComputerName is already an IPv4-Address, if not... try to resolve it
        if ([bool]($ComputerName -as [IPAddress])) {
            $IPv4Address = $ComputerName
        } else {
            $IPv4Address = [String]::Empty
            # Get IP from Hostname (IPv4 only)
            try {
                $AddressList = @(([System.Net.Dns]::GetHostEntry($ComputerName)).AddressList)

                foreach ($Address in $AddressList) {
                    if ($Address.AddressFamily -eq "InterNetwork") {
                        $IPv4Address = $Address.IPAddressToString
                        break
                    }
                }
            } catch { }    # Can't get IPAddressList

            if ([String]::IsNullOrEmpty($IPv4Address)) {
                throw "Could not get IPv4-Address for $ComputerName. (Try to enter an IPv4-Address instead of the Hostname)"
            }
        }

        # Scriptblock --> will run in runspaces (threads)...
        [System.Management.Automation.ScriptBlock]$ScriptBlock = {
            Param(
                $IPv4Address,
                $Port
            )

            try {
                $Socket = New-Object System.Net.Sockets.TcpClient($IPv4Address, $Port)

                if ($Socket.Connected) {
                    $Socket.Close()
                    [pscustomobject] @{
                        Port     = $Port
                        Protocol = "tcp"
                        Status   = "Open"
                    }
                }
            } catch { }
        }

        Write-Verbose -Message "Setting up RunspacePool..."

        # Create RunspacePool and Jobs
        $RunspacePool = [System.Management.Automation.Runspaces.RunspaceFactory]::CreateRunspacePool(1, $Threads, $Host)
        $RunspacePool.Open()
        [System.Collections.ArrayList]$Jobs = @()

        Write-Verbose -Message "Setting up Jobs..."

        # Set up job for each port...
        Write-Progress -Activity "Creating scan jobs..." -Id 1 -Status "Current Port: 0" -PercentComplete (0)
        $i = 0
        $oldpercent = 0
        foreach ($Port in $StartPort..$EndPort) {
            $i++
            $ScriptParams = @{
                IPv4Address = $IPv4Address
                Port        = $Port
            }

            # Catch when trying to divide through zero
            try {
                [int]$Progress_Percent = ($i / $PortsToScan) * 100
            } catch {
                [int]$Progress_Percent = 100
            }

            if ( ($oldpercent -ne $progress_percent) ) {
                Write-Progress -Activity "Creating scan jobs..." -Id 1 -Status "Current Port: $Port" -PercentComplete ($Progress_Percent)
                $oldpercent = $progress_percent
            }
            # Create mew job
            $Job = [System.Management.Automation.PowerShell]::Create().AddScript($ScriptBlock).AddParameters($ScriptParams)
            $Job.RunspacePool = $RunspacePool

            $JobObj = [pscustomobject] @{
                RunNum = $i
                Pipe   = $Job
                Result = $Job.BeginInvoke()
            }

            # Add job to collection
            [void]$Jobs.Add($JobObj)
        }

        Write-Verbose -Message "Waiting for jobs to complete & starting to process results..."

        # Total jobs to calculate percent complete, because jobs are removed after they are processed
        $Jobs_Total = $Jobs.Count

        # Process results, while waiting for other jobs
        Do {
            # Get all jobs, which are completed
            $Jobs_ToProcess = $Jobs | Where-Object -FilterScript { $_.Result.IsCompleted }

            # If no jobs finished yet, wait random between 300 and 480 ms (by step of 60ms) and try again
            if ($null -eq $Jobs_ToProcess) {
                Start-Sleep -Milliseconds ( (get-random -minimum 5 -maximum 8)*60 )
                continue
            }

            # Get jobs, which are not complete yet
            $Jobs_Remaining = $Jobs.count - $Jobs_ToProcess.count

            # Catch when trying to divide through zero
            try {
                $Progress_Percent = 100 - (($Jobs_Remaining / $Jobs_Total) * 100)
            } catch {
                $Progress_Percent = 100
            }

            Write-Progress -Activity "Waiting for jobs to complete... ($($Threads - $($RunspacePool.GetAvailableRunspaces())) of $Threads threads running)" -Id 1 -PercentComplete $Progress_Percent -Status "$Jobs_Remaining remaining..."

            # Processing completed jobs
            foreach ($Job in $Jobs_ToProcess) {
                # Get the result...
                $Job_Result = $Job.Pipe.EndInvoke($Job.Result)
                $Job.Pipe.Dispose()

                # Remove job from collection
                $Jobs.Remove($Job)

                # Check if result is null --> if not, return it
                if ($Job_Result.Status) { $Job_Result }
            }

        } While ($Jobs.Count -gt 0)

        Write-Verbose -Message "Closing RunspacePool and free resources..."

        # Close the RunspacePool and free resources
        $RunspacePool.Close()
        $RunspacePool.Dispose()

        Write-Verbose -Message "Scan for $computername finished at $(Get-Date)"
    }
}

$ip = "192.168.1.xx"

$stopwatch =  [system.diagnostics.stopwatch]::StartNew()

$arrResults = IPv4PortScan -computername $ip -startport 1 -endport 65535 -threads 1024
$arrResults | ft -auto

write-host "> $($arrResults.count) ports ouverts trouvés en $($stopwatch.elapsed.TotalMilliSeconds) ms"