Rewritten / Code & Performance improved

BornToBeRoot · BornToBeRoot · commit 07affc00faef · 2016-07-06T15:05:15.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1 @@
+Documentation/Thumbs.db
diff --git a/README.md b/README.md
@@ -1,64 +1,37 @@
-# PowerShell Async Port-Scanner
+# PowerShell - IPv4 Port Scanner
 
-Powerful asynchronus Port-Scanner which returns a custom PowerShell-Object with basic informations about the scanned Port-Range include Port-Number, Protocol, Service-Name, Service-Description and Status.
+Powerful asynchronus IPv4 Port Scanner for PowerShell.
 
 ## Description
 
-This is a powerful asynchronus Port-Scanner working with the PowerShell RunspacePool. You can scan any Port-Range you want. The result will show you all open ports Port-Number, Protocol, Service-Name, Service-Description and Status.
-    
-This script also work fine along with my [asychronus IP-Scanner](https://github.com/BornToBeRoot/PowerShell_Async-IPScanner) published on GitHub too. You can easily pipe the output of the IP-Scanner result in this script.
+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.
 
-![Screenshot of Working Scanner and Result](https://github.com/BornToBeRoot/PowerShell_Async-PortScanner/blob/master/Documentation/ScanPortsAsync_Result.png?raw=true)
+The result will contain the Port number, Protocol, Service name, Description and the Status.
 
-## Syntax
+![Screenshot](Documentation/Images/New-IPv4PortScan.png?raw=true "New-IPv4PortScan")
 
-```powershell
-.\ScanPortsAsync.ps1 [-ComputerName] <String> [[-StartPort] <Int32>] [[-EndPort] <Int32>] [[-Threads] <Int32>] [[-UpdateListFromIANA]] [[-Force]] [<CommonParameters>]
-```
+To reach the best possible performance, this script uses a [RunspacePool](https://msdn.microsoft.com/en-US/library/system.management.automation.runspaces.runspacepool(v=vs.85).aspx). As you can see in the following screenshot, the individual tasks are distributed across all cpu cores:
 
-## Example
+![Screenshot](Documentation/Images/New-IPv4PortScan_CPUusage.png?raw=true "CPU usage")
 
-Scan a specific Port-Range (1-500)
+If you are looking for a module... you can find it [here](https://github.com/BornToBeRoot/PowerShell)!
 
-```powershell
-.\ScanPortsAsync.ps1 -ComputerName 192.168.1.100 -StartPort 1 -EndPort 500 | Format-Table
-``` 
-
-You may want to update the official "Service Name and Transport Protocol Port Number Registry" from IANA... Just add the parameter "-UpdateListFromIANA".
-
-```powershell
-.\ScanPortsAsync.ps1 -ComputerName 172.16.2.5 -UpdateListFromIANA
-``` 
-If your PC has enough power, you can use more threads at the same time
+## Syntax
 
 ```powershell
-.\ScanPortsAsync.ps1 -ComputerName test-pc01 -Threads 250
+.\New-IPv4PortScan.ps1 [-ComputerName] <String> [[-StartPort] <Int32>] [[-EndPort] <Int32>] [[-Threads] <Int32>] [[-Force]] [[-UpdateList]] [<CommonParameters>]
 ```
 
-## Output 
+## Example
 
 ```powershell
+PS> .\New-IPv4PortScan.ps1 -ComputerName fritz.box -EndPort 500
+
 Port Protocol ServiceName  ServiceDescription               Status
 ---- -------- -----------  ------------------               ------
   21 tcp      ftp          File Transfer Protocol [Control] open
   53 tcp      domain       Domain Name Server               open
   80 tcp      http         World Wide Web HTTP              open
  139 tcp      netbios-ssn  NETBIOS Session Service          open
  445 tcp      microsoft-ds Microsoft-DS                     open
-``` 
-
-and if no port list is available (should never happend, because it's uploaded on Github)
-
-```powershell
-Port Protocol Status
----- -------- ------
-  21 tcp      open
-  53 tcp      open
-  80 tcp      open
- 139 tcp      open
- 445 tcp      open
-```
-
-## Offical Port List
-
-* [Service Name and Transport Protocol Port Number Registry - IANA.org](https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xml)
+``` 
diff --git a/Scripts/New-IPv4PortScan.ps1 b/Scripts/New-IPv4PortScan.ps1
@@ -11,13 +11,23 @@
     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, Service name, Description and the Status.
+    
     .EXAMPLE
+    .\New-IPv4PortScan.ps1 -ComputerName fritz.box -EndPort 500
 
-    .EXAMPLE
+    Port Protocol ServiceName  ServiceDescription               Status
+    ---- -------- -----------  ------------------               ------
+      21 tcp      ftp          File Transfer Protocol [Control] open
+      53 tcp      domain       Domain Name Server               open
+      80 tcp      http         World Wide Web HTTP              open
+     139 tcp      netbios-ssn  NETBIOS Session Service          open
+     445 tcp      microsoft-ds Microsoft-DS                     open
     
     .LINK
-    https://github.com/BornToBeRoot/PowerShell_IPv4PortScanner
+    https://github.com/BornToBeRoot/PowerShell_IPv4PortScanner/blob/master/README.md
 #>
 
 [CmdletBinding()]
@@ -40,8 +50,8 @@ param(
 
     [Parameter(
         Position=3,
-        HelpMessage='Maximum number of threads at the same time (Default=100)')]
-    [Int32]$Threads=100,
+        HelpMessage='Maximum number of threads at the same time (Default=500)')]
+    [Int32]$Threads=500,
 
     [Parameter(
         Position=4,
@@ -102,8 +112,51 @@ Begin{
             {
                 Rename-Item -Path $XML_PortList_BackupPath -NewName $XML_PortList_Path
             }
+
+            $_.Exception.Message  
         }
     } 
+
+    # Function to assign service with port
+    function AssignServiceWithPort
+    {
+        param(
+            $Result
+        )
+
+        Begin{
+
+        }
+
+        Process{
+            $Service = [String]::Empty
+            $Description = [String]::Empty
+                        
+            foreach($XML_Node in $XML_PortList.Registry.Record)
+            {                
+                if(($Result.Protocol -eq $XML_Node.protocol) -and ($Result.Port -eq $XML_Node.number))
+                {
+                    $Service = $XML_Node.name
+                    $Description = $XML_Node.description
+                    break
+                }
+            }
+                
+            $NewResult = [pscustomobject] @{
+                Port = $Result.Port
+                Protocol = $Result.Protocol
+                ServiceName = $Service
+                ServiceDescription = $Description
+                Status = $Result.Status
+            }
+
+            return $NewResult
+        }  
+
+        End{
+
+        }
+    }
 }
 
 Process{
@@ -113,17 +166,225 @@ Process{
     }
     elseif(-Not([System.IO.File]::Exists($XML_PortList_Path)))
     {
-        Write-Host 'No xml-file to assign service with port found! Use the parameter "-UpdateList" to download the latest version from IANA.org. This warning doesn`t affect the scanning procedure.'
+        Write-Host 'No xml-file to assign service with port found! Use the parameter "-UpdateList" to download the latest version from IANA.org. This warning doesn`t affect the scanning procedure.' -ForegroundColor Yellow
     }
 
+    # Check if it is possible to assign service with port --> import xml-file
     if([System.IO.File]::Exists($XML_PortList_Path))
     {
         $AssignServiceWithPort = $true
+
+        $XML_PortList = [xml](Get-Content -Path $XML_PortList_Path)
     }
     else 
     {
         $AssignServiceWithPort = $false    
     }
+
+    # Validate Port-Range
+    if($StartPort -gt $EndPort)
+    {
+        Write-Host "Invalid Port-Range... Check your input!" -ForegroundColor Red
+        return
+    }
+
+    # Check if host is reachable
+    Write-Verbose "Test if host is reachable..."
+    if(-not(Test-Connection -ComputerName $ComputerName -Count 2 -Quiet))
+    {
+        Write-Host "$ComputerName is not reachable!" -ForegroundColor Red
+
+        if($Force -eq $false)
+        {
+            do {
+                $Answer = Read-Host "Would you like to continue? (perhaps only ICMP is blocked) [yes|no]"
+
+            } while("yes","y","no","n" -notcontains $Answer)
+        
+            if("no","n" -contains $Answer)
+            {
+                return
+            }
+        }
+    }
+
+    $PortsToScan = ($EndPort - $StartPort)
+
+    Write-Verbose "Scanning range from $StartPort to $EndPort ($PortsToScan Ports)"
+    Write-Verbose "Running with max $Threads threads"
+
+    # Check if ComputerName is already an IPv4-Address, if not... try to resolve it
+    $IPv4Address = [String]::Empty
+	
+	if([bool]($ComputerName -as [IPAddress]))
+	{
+		$IPv4Address = $ComputerName
+	}
+	else
+	{
+		# 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))
+		{
+			Write-Host "Could not get IPv4-Address for $ComputerName. (Try to enter an IPv4-Address instead of the Hostname)" -ForegroundColor Red
+            return
+		}		
+	}
+
+    # 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)
+            {
+                $Status = "Open"             
+                $Socket.Close()
+            }
+            else 
+            {
+                $Status = "Closed"    
+            }
+        }
+        catch{
+            $Status = "Closed"
+        }   
+
+        $Result = [pscustomobject] @{
+            Port = $Port
+            Protocol = "tcp"
+        	Status = $Status
+        }
+
+        return $Result
+    }
+
+    Write-Verbose "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 "Setting up Jobs..."
+    
+    #Set up job for each port...
+    foreach($Port in $StartPort..$EndPort)
+    {
+        $ScriptParams =@{
+			IPv4Address = $IPv4Address
+			Port = $Port
+		}
+
+        # Catch when trying to divide through zero
+        try {
+			$Progress_Percent = (($Port - $StartPort) / $PortsToScan) * 100 
+		} 
+		catch { 
+			$Progress_Percent = 100 
+		}
+
+        Write-Progress -Activity "Setting up jobs..." -Id 1 -Status "Current Port: $Port"  -PercentComplete ($Progress_Percent)
+        
+        # Create mew job
+        $Job = [System.Management.Automation.PowerShell]::Create().AddScript($ScriptBlock).AddParameters($ScriptParams)
+        $Job.RunspacePool = $RunspacePool
+        
+        $JobObj = [pscustomobject] @{
+            RunNum = $Port - $StartPort
+            Pipe = $Job
+            Result = $Job.BeginInvoke()
+        }
+
+        # Add job to collection
+        [void]$Jobs.Add($JobObj)
+    }
+
+    Write-Verbose "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 {$_.Result.IsCompleted}
+  
+        # If no jobs finished yet, wait 500 ms and try again
+        if($Jobs_ToProcess -eq $null)
+        {
+            Write-Verbose "No jobs completed, wait 500ms..."
+
+            Start-Sleep -Milliseconds 500
+            continue
+        }
+        
+        # Get jobs, which are not complete yet
+        $Jobs_Remaining = ($Jobs | Where-Object {$_.Result.IsCompleted -eq $false}).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..."
+      
+        Write-Verbose "Processing $(if($Jobs_ToProcess.Count -eq $null){"1"}else{$Jobs_ToProcess.Count}) job(s)..."
+
+        # 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 -ne $null -and $Job_Result.Status -eq "Open")
+            {        
+                if($AssignServiceWithPort)
+                {
+                    AssignServiceWithPort -Result $Job_Result
+                }   
+                else 
+                {
+                    $Job_Result    
+                }             
+            }
+        } 
+
+    } While ($Jobs.Count -gt 0)
+    
+    Write-Verbose "Closing RunspacePool and free resources..."
+
+    # Close the RunspacePool and free resources
+    $RunspacePool.Close()
+    $RunspacePool.Dispose()
+
+    Write-Verbose "Script finished at $(Get-Date)"
 }
 
 End{
diff --git a/Scripts/ScanPortsAsync.ps1 b/Scripts/ScanPortsAsync.ps1
