DEV Community: Raghavvram Johnson

Simple TCP Server in Python

Raghavvram Johnson — Thu, 01 Oct 2026 16:33:35 +0000

TCP Server

Creating TCP servers in Python is just as easy as creating a client. You might want to use your own TCP server when writing command shells or crafting a proxy (both of which we’ll do later). Let’s start by creating a standard multi-threaded TCP server. Crank out the code below:

import socket
import threading

bind_ip = "0.0.0.0"
bind_port = 9999

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((bind_ip, bind_port))
server.listen(5)
print(f"[*] Listening on {bind_ip}:{bind_port}")

def handle_client(client_socket):
    request = client_socket.recv(1024)
    print(f"[*] Received: {request.decode()}")
    client_socket.send(b"ACK!")
    client_socket.close()

while True:
    client, addr = server.accept()
    print(f"[*] Accepted connection from: {addr[0]}:{addr[1]}")
    client_handler = threading.Thread(target=handle_client, args=(client,))
    client_handler.start()

To start off, we pass in the IP address and port we want the server to listen on.
Next we tell the server to start listening with a maximum backlog of connections set to 5.
We then put the server into its main loop, where it is waiting for an incoming connection.
When a client connects, we receive the client socket into the client variable, and the remote connection details into the addr variable.
We then create a new thread object that points to our handle_client function, and we pass it the client socket object as an argument.
We then start the thread to handle the client connection, and our main server loop is ready to handle another incoming connection.
The handle_client function performs the recv() and then sends a simple message back to the client.

import socket

target_host = "127.0.01"
target_port = 9999

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((target_host, target_port))
client.send(b"AAABBBCCC")
response = client.recv(4096)

print(response.decode())

If you use the TCP client that we built earlier, you can send some test packets to the server and you should see output like the following:

[] Listening on 0.0.0.0:9999
[] Accepted connection from: 127.0.0.1:62512
[*] Received: ABCDE

That’s it! Pretty simple.

Simple UDP Client in Python

Raghavvram Johnson — Thu, 01 Oct 2026 16:29:28 +0000

A Python UDP client is not much different than a TCP client; we need to make only two small changes to get it to send packets in UDP form.

import socket

target_host = "127.0.0.1"
target_port = 80

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client.sendto(b"AAABBBCCC", (target_host, target_port))
data, addr = client.recvfrom(4096)
print(data.decode())

As you can see, we change the socket type to SOCK_DGRAM when creating the socket object.
The next step is to simply call sendto(), passing in the data and the server you want to send the data to.
Because UDP is a connectionless protocol, there is no call to connect() beforehand.
The last step is to call recvfrom() to receive UDP data back.
You will also notice that it returns both the data and the details of the remote host and port.

Simple TCP Client in Python

Raghavvram Johnson — Thu, 01 Oct 2026 16:00:12 +0000

This is a guide to write a quick simple TCP client in pure python.

First of all, why would anyone need this ?
Industry Servers dosent have tools like curl or wget, and most of the time have restricted network access, so downloading using the package manager isn't possible too.

But most if not all of the time, you can find a version of python installed.

So we will try to make a TCP client without any additional libraries, just using the buit in Sockets Library

import socket

target_host = "www.google.com"
target_port = 80

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((target_host, target_port))
client.send(b"GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
response = client.recv(4096)

print(response.decode())

We first create a socket object with the AF_INET and SOCK_STREAM parameters.

The AF_INET parameter is saying we are going to use a standard IPv4 address or hostname, and SOCK_STREAM indicates that this will be a TCP client.
We then connect the client to the server and send it some data.
The last step is to receive some data back and print out the response.
This is the simplest form of a TCP client, but the one you will write most often.

In the above code snippet, we are making some serious assumptions about sockets that you definitely want to be aware of. The first assumption is that our connection will always succeed, and the second is that the server is always expecting us to send data first (as opposed to servers that expect to send data to you first and await your response). Our third assumption is that the server will always send us data back in a timely fashion. We make these assumptions largely for simplicity’s sake. While programmers have varied opinions about how to deal with blocking sockets, exception-handling in sockets, and the like, it’s quite rare for pentesters to build these niceties into the quick-and-dirty tools for recon or exploitation work, so we’ll omit them.