Skip to main content

How to Build a Simple Secure Chat System Using Netcat

Hang HuAbout 7 minSecurityNetcatLinuxDebianArticle(s)blogfreecodecamp.orgsecuritysecnetcatlinuxdebian

How to Build a Simple Secure Chat System Using Netcat 관련

Security > Article(s)
Article(s)
Security > Article(s)
Article(s)
Linux - Debian > Article(s)
Article(s)
How to Build a Simple Secure Chat System Using Netcat
In this hands-on tutorial, you'll learn how to harness the power of Netcat to build practical networking tools. We’ll start with basic message transmission. Then you'll progress to creating a file transfer system, and you’ll ultimately develop a secu...

In this hands-on tutorial, you'll learn how to harness the power of Netcat to build practical networking tools.

We’ll start with basic message transmission. Then you'll progress to creating a file transfer system, and you’ll ultimately develop a secure chat application with encryption.

Prerequisites

Before we start, you'll need:

  • A Linux-based system: I recommend Ubuntu. Alternatively, you can use the Online Linux Terminal if you don't have Linux installed.
  • Basic terminal knowledge (how to use cd and ls)

Don't worry if you're new to networking - I’ll explain everything as we go!

Install Netcat

Netcat is like a digital "pipe" between computers – anything you put in one end comes out the other. Before we start using it, let's get it installed on your system.

Open your terminal and run these commands:

# Update your system's package list
sudo apt update

# Install Netcat
sudo apt install netcat -y
Update your system's package list
Update your system's package list

To check if the installation worked, run:

nc -h

You should see a message starting with "OpenBSD netcat". If you do, great! If not, try running the installation commands again.

check if the installation worked
check if the installation worked

Your First Network Connection

Before we dive into building tools, let's understand what a network connection actually is. Think of it like a phone call: one person needs to wait for the call (the listener), and another person needs to make the call (the connector).

In networking, we use "ports" to make these connections. You can think of ports like different phone lines – they let multiple conversations happen at the same time.

Let's try making our first connection:

1.

Open a terminal window and create a listener:

nc -l 12345

What did we just do? The -l tells Netcat to "listen" for a connection, and 12345 is the port number we chose. Your terminal will look like it's frozen – that's normal! It's waiting for someone to connect.

Now try typing a message (like "hi") in either window and press Enter. Cool, right? The message appears in the other window! This is exactly how basic network communication works.

making our first connection
making our first connection

To stop the connection, press Ctrl+C in both windows.

What Just Happened?

You just created your first network connection! The first terminal was like someone waiting by a phone, and the second terminal was like someone calling that phone. When they connected, they could send messages back and forth.

How to Build a Simple File Transfer Tool

Now that we understand basic connections, let's build something more useful: a tool to transfer files between computers.

First, let's create a test file to send:

# Create a file with some content
echo "This is my secret message" > secret.txt

To transfer this file, we'll need two terminals again, but this time we'll use them differently:

1.

In the first terminal, set up the receiver:

nc -l 12345 > received_file.txt
transfer file
transfer file

This tells Netcat to:

  • Listen for a connection (-l)
  • Save whatever it receives to a file called received_file.txt (>)

This is similar to our chat system, but instead of typing messages, we're:

  1. Taking content from a file
  2. Sending it through our network connection
  3. Saving it to a new file on the other end

Think of it like sending a document through a fax machine!

How to Create a Secure Chat System

Our previous examples sent everything as plain text – anyone could read it if they intercepted the connection. Let's make something more secure by adding encryption.

First, let's understand what encryption does:

  • It's like putting your message in a locked box
  • Only someone with the right key can open it
  • Even if someone sees the box, they can't read your message

We'll create two scripts: one for sending messages and one for receiving them.

::: tabs 1.

Create the sender script:

nano secure_sender.sh

Copy this code into the file:

#!/bin/bash

echo "Secure Chat - Type your messages below"
echo "Press Ctrl+C to exit"

while true; do
  # Get the message
  read message

  # Encrypt and send it
  echo "$message" | openssl enc -aes-256-cbc -salt -base64 \
    -pbkdf2 -pass pass:chatpassword 2>/dev/null | \
    nc -N localhost 12345
done

This script will:

  1. Read messages from user input.
  2. Encrypt them using OpenSSL's AES-256-CBC encryption (a strong encryption standard).
  3. Send the encrypted message to the specified port.

Press Ctrl+X, then Y, then Enter to save.

Create the sender script
Create the sender script

@tab 2.

Create the receiver script:

nano secure_receiver.sh

Copy this code:

#!/bin/bash

echo "Waiting for messages..."

while true; do
  # Receive and decrypt messages
  nc -l 12345 | openssl enc -aes-256-cbc -d -salt -base64 \
    -pbkdf2 -pass pass:chatpassword 2>/dev/null
done

This script will:

  1. Listen for incoming encrypted messages.
  2. Decrypt them using the same encryption key.
  3. Display the decrypted messages.

Save this file too.

Create the receiver script
Create the receiver script

@tab 3.

Make both scripts executable:

chmod +x secure_sender.sh secure_receiver.sh

@tab 4.

Try it out:

  • In one terminal: ./secure_receiver.sh
  • In another terminal: ./secure_sender.sh

Type a message in the sender terminal. The receiver will show your decrypted message!

Type a message in the sender terminal
Type a message in the sender terminal

Enhancing Our Chat System

Now that we have a working basic chat system, let's make it more user-friendly and informative. We'll add features like timestamps, color-coded messages, and encryption status updates. This enhanced version will help you better understand what's happening during the encryption and transmission process.

If you're comfortable with the basic version, try this improved version:

1.

Create an enhanced sender script (save it as secure_sender_v2.sh):

#!/bin/bash

# Set up color codes for better visibility
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

echo -e "${GREEN}Secure Chat Sender - Started at $(date)${NC}"
echo -e "${BLUE}Type your messages below. Press Ctrl+C to exit${NC}"
echo "----------------------------------------"

while true; do
    # Show prompt with timestamp
    echo -ne "${GREEN}[$(date +%H:%M:%S)]${NC} Your message: "

    # Get the message
    read message

    # Skip if message is empty
    if [ -z "$message" ]; then
        continue
    fi

    # Add timestamp to message
    timestamped_message="[$(date +%H:%M:%S)] $message"

    # Show encryption status
    echo -e "${BLUE}Encrypting and sending message...${NC}"

    # Encrypt and send it, showing the encrypted form
    encrypted=$(echo "$timestamped_message" | openssl enc -aes-256-cbc -salt -base64 \
        -pbkdf2 -iter 10000 -pass pass:chatpassword 2>/dev/null)

    echo -e "${BLUE}Encrypted form:${NC} ${encrypted:0:50}..." # Show first 50 chars
    echo "$encrypted" | nc -N localhost 12345

    echo -e "${GREEN}Message sent successfully!${NC}"
    echo "----------------------------------------"
done
MIT Licensed | Copyright © 2022-present Chan Hee Lee
Copyright © 2024 Hang Hu