Windows listen tcp port

One of our customers is securing his network, and firewall changes were made that needed to be tested. In this case, the new servers were not yet deployed in that specific network. But… We did want to test the connections before deploying the servers 🙂 In this blog post, I will show you how to create listening ports on a machine to test the connection from another network using netcat on Linux or portqry on Windows.

Preparation

In this case, we are using netcat and portqry as our testing tools, depending on your operating system. Follow the procedure below to install it on your system.

Windows

Download portqry here (Direct link) and save PortQryV2.exe to a temporary location. Run it and extract the files somewhere on the system that you will use to test the ports. It can test both TCP and UDP.

Linux

Depending on what Linux flavor you’re running, the installation could be different than the command line below in which I install it on a Ubuntu machine using apt get

sudo apt install netcat

Starting a listener

After running the command below in a PowerShell prompt from within the directory in which you saved the script, the New-Portlistener PowerShell function is available in your session (Alternatively, you could run it from PowerShell ISE)

. .\New-Portlistener

Now that the function is available, you can start a TCP listener on port 9001, for example by running this command:

New-Portlistener -UDPPort 9001

After running, you will see this output on your screen:

Картинка с сайта: powershellisfun.com

You can press Escape to stop the listener, and it should show this as the output:

Stopped listening on UDP port 9001

If you are trying to start a listener which is already active, it will show an error (In this example, I used TCP port 3389 which is the default RDP port)

WARNING: TCP Port 3389 is already listening, aborting...

Note: Windows Firewall could give pop-ups when starting the listener

Checking the ports

If you have a TCP or UDP listener port running on a Windows machine, you can start testing the connection from a Windows or Linux machine in another network.

Linux

UDP

To use netcat for checking a UDP connection, you can use this to test port 9001 on IP address 10.20.30.40:

nc -z -v -u 10.20.30.40 9001

When the connection is successful, the screen output is:

Connection to 10.20.30.40 9001 port [udp/*] succeeded!

TCP

To use netcat for checking a TCP connection, you can use this to test port 9001 on IP address 10.20.30.40:

nc -z -v 10.20.30.40 9001

When the connection is successful, the screen output is:

Connection to 192.168.168.121 9001 port [tcp/*] succeeded!

Windows

UDP

To use PortQry.exe for checking a UDP connection, you can use this to test port 9001 on IP address 10.20.30.40:

portqry -n 10.20.30.40 -e 9001 -p UDP

When the connection is successful, the screen output is:

UDP port 9001 (unknown service): LISTENING or FILTERED

In the PowerShell session, you can also see if the connection was successful. It will show you a PortQry Test Message:

10.20.30.40:61199 PortQry Test Message

TCP

To use PortQry.exe for checking a TCP connection, you can use this to test port 9001 on IP address 10.20.30.40:

portqry -n 10.20.30.40 -e 9001 -p TCP

When the connection is successful, the screen output is:

TCP port 9001 (unknown service): LISTENING

The script

Below is the script. You can save it on the system you want to start a TCP or UDP listener.

function New-Portlistener {
    [CmdletBinding(DefaultParameterSetName = 'All')]
    param (
        [parameter(Mandatory = $false, HelpMessage = "Enter the tcp port you want to use to listen on, for example 3389", parameterSetName = "TCP")]
        [ValidatePattern('^[0-9]+$')]
        [ValidateRange(0, 65535)]
        [int]$TCPPort,

        [parameter(Mandatory = $false, HelpMessage = "Enter the udp port you want to use to listen on, for example 3389", parameterSetName = "UDP")]
        [ValidatePattern('^[0-9]+$')]
        [ValidateRange(0, 65535)]
        [int]$UDPPort
    )

    #Test if TCP port is already listening port before starting listener
    if ($TCPPort) {
        $Global:ProgressPreference = 'SilentlyContinue' #Hide GUI output
        $testtcpport = Test-NetConnection -ComputerName localhost -Port $TCPPort -WarningAction SilentlyContinue -ErrorAction Stop
        if ($testtcpport.TcpTestSucceeded -ne $True) {
            Write-Host ("TCP port {0} is available, continuing..." -f $TCPPort) -ForegroundColor Green
        }
        else {
            Write-Warning ("TCP Port {0} is already listening, aborting..." -f $TCPPort)
            return
        }

        #Start TCP Server
        #Used procedure from https://riptutorial.com/powershell/example/18117/tcp-listener
        $ipendpoint = new-object System.Net.IPEndPoint([ipaddress]::any, $TCPPort) 
        $listener = new-object System.Net.Sockets.TcpListener $ipendpoint
        $listener.start()
        Write-Host ("Now listening on TCP port {0}, press Escape to stop listening" -f $TCPPort) -ForegroundColor Green
        while ( $true ) {
            if ($host.ui.RawUi.KeyAvailable) {
                $key = $host.ui.RawUI.ReadKey("NoEcho,IncludeKeyUp,IncludeKeyDown")
                if ($key.VirtualKeyCode -eq 27 ) {	
                    $listener.stop()
                    Write-Host ("Stopped listening on TCP port {0}" -f $TCPPort) -ForegroundColor Green
                    return
                }
            }
        }
    }
        
    
    #Test if UDP port is already listening port before starting listener
    if ($UDPPort) {
        #Used procedure from https://cloudbrothers.info/en/test-udp-connection-powershell/
        try {
            # Create a UDP client object
            $UdpObject = New-Object system.Net.Sockets.Udpclient($UDPPort)
            # Define connect parameters
            $computername = "localhost"
            $UdpObject.Connect($computername, $UDPPort)    
        
            # Convert current time string to byte array
            $ASCIIEncoding = New-Object System.Text.ASCIIEncoding
            $Bytes = $ASCIIEncoding.GetBytes("$(Get-Date -UFormat "%Y-%m-%d %T")")
            # Send data to server
            [void]$UdpObject.Send($Bytes, $Bytes.length)    
        
            # Cleanup
            $UdpObject.Close()
            Write-Host ("UDP port {0} is available, continuing..." -f $UDPPort) -ForegroundColor Green
        }
        catch {
            Write-Warning ("UDP Port {0} is already listening, aborting..." -f $UDPPort)
            return
        }

        #Start UDP Server
        #Used procedure from https://github.com/sperner/PowerShell/blob/master/UdpServer.ps1
        $endpoint = new-object System.Net.IPEndPoint( [IPAddress]::Any, $UDPPort)
        $udpclient = new-object System.Net.Sockets.UdpClient $UDPPort
        Write-Host ("Now listening on UDP port {0}, press Escape to stop listening" -f $UDPPort) -ForegroundColor Green
        while ( $true ) {
            if ($host.ui.RawUi.KeyAvailable) {
                $key = $host.ui.RawUI.ReadKey("NoEcho,IncludeKeyUp,IncludeKeyDown")
                if ($key.VirtualKeyCode -eq 27 ) {	
                    $udpclient.Close()
                    Write-Host ("Stopped listening on UDP port {0}" -f $UDPPort) -ForegroundColor Green
                    return
                }
            }

            if ( $udpclient.Available ) {
                $content = $udpclient.Receive( [ref]$endpoint )
                Write-Host "$($endpoint.Address.IPAddressToString):$($endpoint.Port) $([Text.Encoding]::ASCII.GetString($content))"
            }
        }
    }
}

Download the script(s) from GitHub here

Validating network connectivity between applications is crucial, but it can be tough when destination services aren‘t running yet. This is where handy port listeners come in – allowing connectivity checks without active ports.

In this comprehensive guide, we‘ll cover how to set up effective TCP listeners on both Windows and Linux for enhanced testing. Whether you‘re responsible for cloud migrations, DMZ staging environments, or simply resolving network outages, these listeners have got you covered.

The Challenges of Connectivity Testing

Before diving into port listener setup, let‘s look at why connectivity testing can be so difficult:

• Applications are still being developed and aren‘t online yet
• New subnets don‘t have any services installed for validation
• Security groups actively block ports until deployment
• Staging environments fluctuate frequently

This means we can‘t simply ping services to check connectivity as nothing is listening!

Without a listener enabled, even a basic telnet server-A 5000 will show connection refused. Packets may fail to reach their destination entirely without us realizing.

According to a recent 2017 survey on connectivity reliability, nearly 75% of respondents experienced network outages leading to performance issues or total failure. Over 50%identified the root cause as configuration errors blocking connectivity.

This reveals the immense challenge around managing connectivity for modern dynamic environments. Blind spots lead to production failures!

That‘s why having handy port listeners ready to validate connections is so useful for both network engineers and application owners alike.

Let‘s see how to set them up properly on both Windows and Linux…

Listening on Windows with Port Listener Utility

On Windows servers and workstations, we can take advantage of a handy GUI utility called «Port Listener» for creating TCP listeners to test connectivity against.

Here‘s how it works:

1. Download and install the free Port Listener utility. It supports all Windows versions from XP through Windows 10.

2. Once launched, simply enter your desired port then click «Start»

For example, I‘ve entered TCP port 5500 here.

1. Verify it is now listening by opening command prompt and running netstat -anb. You should see the listener port in the connections list:

Easy enough! Now we have a port open and ready for connectivity validation against this Windows machine, no actual service needed.

Let‘s look at Linux next…

Listening via Netcat on Linux Systems

Linux servers have the powerful nc utility (also called netcat) built-in, providing flexible listener options right from terminal.

Here is how to create a TCP port listener with nc:

1. Ensure nc is installed by running yum install nc or apt install netcat. Most modern distros have it already.

2. Choose a port and start listening right away: nc -l 12345

3. Run the command in background mode if you want it persistent: nc -l 12345 &

4. Verify with netstat or ss that your chosen port now appears:

netstat -anp | grep 12345

tcp  0  0  *:12345 *:* LISTEN

As you can see above, I now have a simple socket listening away on port 12345 despite no actual service running!

So between native Windows utilities and Linux netcat abilities, getting a basic TCP listener enabled is straightforward.

But what about cross-platform Python listeners that work anywhere?

Python Port Listeners for Advanced Cross-Platform Connectivity Checks

While the Windows and Linux tools so far allow handy listeners across two common platforms, Python listeners take it a step further for true cross-platform testing.

Python has full native socket libraries that let us create network listeners, clients, servers and more using simple scripts.

Here is a basic TCP socket listener example in Python:

import socket

HOST = ‘‘  
PORT = 8001  

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))

s.listen(5)
print(f‘Listening on port {PORT}‘)

while True:
    client, address = s.accept() 
    print(f‘Got connection from {address}‘)

To run it:

1. Save the code as listener.py
2. Execute with python listener.py
3. Check netstat to see your chosen port now actively listening!

The key advantage of Python here is this exact same script can run on Windows, Mac, Linux, and more without changes. So you get ultimate portability for connectivity testing across varied systems.

In the next sections we‘ll cover how to validate your shiny new listeners are working, and some best practices around managing them effectively.

Validating Your Port Listeners for Connectivity Checking Prep

With so many options for getting port listeners running on Windows and Linux, how can we confirm they are working as expected before relaying on them?

Here are some tips for validating your freshly created TCP listeners:

1. Check listener status immediately after starting

Use netstat on Linux or Windows to verify the exact port shows up with a LISTEN state:

netstat -anp | grep 12345 

tcp 0 0 0.0.0.0:12345 0.0.0.0:* LISTEN     

2. Monitor continuously for failure conditions

Keep an eye on running listeners through system monitors or watchdogs to ensure they don‘t ever enter CLOSE_WAIT and die silently!

3. Test connectivity manually from a client

Explicitly connect against the port from another machine, such as via telnet or netcat. This confirms end-to-end communication works as expected:

telnet dest-server 12345

4. Script automated connectivity validation checks

Use pings, socket connections, and other programmatic tests in cron jobs for ongoing confidence the listener hasn‘t failed.

With those reliability tips covered, let‘s now talk listeners management best practices…

Managing Listeners for Reliability

To keep your port listeners humming along smoothly for connectivity checks, keep these management guidelines in mind:

🔹 Namespace your listeners uniquely – Name or number listeners based on their exact use case for easy filtering later. For example migration-serverA-to-B-HTTP

🔹 Centralize them onto dedicated checking systems – Host your listeners on standalone test servers instead of production boxes. This improves visibility and limits debug noise.

🔹 Check status dashboards frequently – Display listener adherance centrally to catch failures immediately. Logging and alarming can help here.

🔹 Clean up unneeded listeners proactively – Listeners bind limited ports, so prune those no longer necessary rather than allowing them to pile up indefinitely.

Follow those strategies and you‘ll have reliable, manageable listeners ready for ongoing connectivity verification!

Common Connectivity Testing Pitfalls

Even with helpful listeners reducing connectivity testing headaches, some common pitfalls still trip teams up:

🔸 Relying purely on ICMP ping – Ping checks Layer 3 only, and can miss outages higher up the stack. TCP listeners validate full end-to-end connectivity.

🔸 Not standardizing test checking – Lacking unified validation checks means potential blind spots across complexes and clouds.

🔸 Testing from incorrect vantage points – Validate network paths from client origin points, not middle routers which can miss key edges.

🔸 Assuming configurations rather than actively testing – Firewalls promise connectivity but misconfigurations happen – trust but verify!

validatorsCentralListener
So be on the lookout by combining listeners and scripts from client origins at standard layers with active alarm thresholds. This helps catch outages faster across hybrid environments.

Ready for Smarter Connectivity Checking?

I hope this guide has prepped you with more robust connectivity testing capabilities through handy port listeners.

Whether managing on-prem datacenters, AWS clouds, migrations, or outages, leveraging simple TCP sockets for clearer validations cuts through assumptions.

Now you have the power to actively listen across Windows and Linux for proactive diagnostics before customers call you!

If you found this helpful, let me know your use cases and experiences around connectivity testing in the comments below. I‘m always happy to chat further.

All the best, and happy (more reliable) listening!

Wrote a blog post about how to create a listener for testing firewall rules, I created a function for that 🙂 See https://powershellisfun.com/2022/08/10/create-tcp-udp-port-listener-using-powershell/ for more information on how you can use this function.

function New-Portlistener {
    param (
        [parameter(Mandatory = $false, HelpMessage = "Enter the tcp port you want to use to listen on, for example 3389")]
        [ValidatePattern('^[0-9]+$')]
        [ValidateRange(0, 65535)]
        [int]$TCPPort,

        [parameter(Mandatory = $false, HelpMessage = "Enter the udp port you want to use to listen on, for example 3389")]
        [ValidatePattern('^[0-9]+$')]
        [ValidateRange(0, 65535)]
        [int]$UDPPort
    )
    
    #Exit if both options were used
    if ($TCPPort -and $UDPPort) {
        Write-Warning ("You can only specify one option, use either TCPPort or UDPPort. Aborting...")
        return
    }

    #Test if TCP port is already listening port before starting listener
    if ($TCPPort) {
        $Global:ProgressPreference = 'SilentlyContinue' #Hide GUI output
        $testtcpport = Test-NetConnection -ComputerName localhost -Port $TCPPort -WarningAction SilentlyContinue -ErrorAction Stop
        if ($testtcpport.TcpTestSucceeded -ne $True) {
            Write-Host ("TCP port {0} is available, continuing..." -f $TCPPort) -ForegroundColor Green
        }
        else {
            Write-Warning ("TCP Port {0} is already listening, aborting..." -f $TCPPort)
            return
        }

        #Start TCP Server
        #Used procedure from https://riptutorial.com/powershell/example/18117/tcp-listener
        $ipendpoint = new-object System.Net.IPEndPoint([ipaddress]::any, $TCPPort) 
        $listener = new-object System.Net.Sockets.TcpListener $ipendpoint
        $listener.start()
        Write-Host ("Now listening on TCP port {0}, press Escape to stop listening" -f $TCPPort) -ForegroundColor Green
        while ( $true ) {
            if ($host.ui.RawUi.KeyAvailable) {
                $key = $host.ui.RawUI.ReadKey("NoEcho,IncludeKeyUp,IncludeKeyDown")
                if ($key.VirtualKeyCode -eq 27 ) {    
                    $listener.stop()
                    Write-Host ("Stopped listening on TCP port {0}" -f $TCPPort) -ForegroundColor Green
                    return
                }
            }
        }
    }
        
    
    #Test if UDP port is already listening port before starting listener
    if ($UDPPort) {
        #Used procedure from https://cloudbrothers.info/en/test-udp-connection-powershell/
        try {
            # Create a UDP client object
            $UdpObject = New-Object system.Net.Sockets.Udpclient($UDPPort)
            # Define connect parameters
            $computername = "localhost"
            $UdpObject.Connect($computername, $UDPPort)    
        
            # Convert current time string to byte array
            $ASCIIEncoding = New-Object System.Text.ASCIIEncoding
            $Bytes = $ASCIIEncoding.GetBytes("$(Get-Date -UFormat "%Y-%m-%d %T")")
            # Send data to server
            [void]$UdpObject.Send($Bytes, $Bytes.length)    
        
            # Cleanup
            $UdpObject.Close()
            Write-Host ("UDP port {0} is available, continuing..." -f $UDPPort) -ForegroundColor Green
        }
        catch {
            Write-Warning ("UDP Port {0} is already listening, aborting..." -f $UDPPort)
            return
        }

        #Start UDP Server
        #Used procedure from https://github.com/sperner/PowerShell/blob/master/UdpServer.ps1
        $endpoint = new-object System.Net.IPEndPoint( [IPAddress]::Any, $UDPPort)
        $udpclient = new-object System.Net.Sockets.UdpClient $UDPPort
        Write-Host ("Now listening on UDP port {0}, press Escape to stop listening" -f $UDPPort) -ForegroundColor Green
        while ( $true ) {
            if ($host.ui.RawUi.KeyAvailable) {
                $key = $host.ui.RawUI.ReadKey("NoEcho,IncludeKeyUp,IncludeKeyDown")
                if ($key.VirtualKeyCode -eq 27 ) {    
                    $udpclient.Close()
                    Write-Host ("Stopped listening on UDP port {0}" -f $UDPPort) -ForegroundColor Green
                    return
                }
            }

            if ( $udpclient.Available ) {
                $content = $udpclient.Receive( [ref]$endpoint )
                Write-Host "$($endpoint.Address.IPAddressToString):$($endpoint.Port) $([Text.Encoding]::ASCII.GetString($content))"
            }
        }
    }
}

In order to use a TCP port listener tool, a computer should minimally meet the following technical requirements:

— Operating System: Any operating system that supports a TCP/IP stack and has a command-line interface, such as Windows, Linux, or Mac OS X.

— Networking: A network connection is required in order to receive and transmit data over the network.

— Software: A TCP port listener tool should be installed on the computer.

— Memory: Enough RAM to run the software and enough disk space to store logs.

— CPU: A reasonably fast processor to handle the data processing involved in listening to ports.