Building Secure Chat Apps in Python
Explore our comprehensive guide on developing a secure chat system in Python. This guide will help you strengthen your programming skills and gain hands-on experience in network communication, data encryption, and integrity verification. Whether you're a programming enthusiast or seeking assistance to help your Python assignment, this resource offers valuable insights into creating a robust, secure messaging application. Learn how to build a chat system that can be customized for various applications, from private messaging platforms to secure business communication tools. This project is an excellent opportunity to dive into the world of network programming and cybersecurity, equipping you with the skills to create innovative and secure communication solutions.
Client Code
The Client Code section contains the code responsible for initiating the connection and communication with a server in a client-server architecture. It includes argument parsing to set up essential parameters, such as server name and port. Additionally, this code handles the reading of message and signature files, preparing and sending data to the server, and verifying digital signatures. It ensures secure communication and error handling.
Block 1: Argument Parsing
```python
if __name__ == '__main__':
SERVER_NAME = ""
SERVER_PORT = 0
MESSAGES_FILENAME = ""
SIGNATURES_FILENAME = ""
# Get args variables
if len(sys.argv) > 1:
SERVER_NAME = sys.argv[1]
else:
raise Exception("No server name provided")
if len(sys.argv) > 2:
SERVER_PORT = int(sys.argv[2])
else:
raise Exception("No server port provided")
if len(sys.argv) > 3:
MESSAGES_FILENAME = sys.argv[3]
else:
raise Exception("No messages file provided")
if len(sys.argv) > 4:
SIGNATURES_FILENAME = sys.argv[4]
else:
raise Exception("No signatures file provided")
```
This block is responsible for parsing command-line arguments to get server-related information, such as the server name, server port, messages file, and signatures file.
Block 2: Reading Messages and Signatures Files
```python
# ...
# Read messages and signatures files
messages = []
messages_length = []
with open(MESSAGES_FILENAME, 'r') as file:
line_id = 0
while True:
line = file.readline()
if not line:
break
if line_id % 2 == 0: # Message length
length = int(line)
messages_length.append(length)
else:
message = line
message += '.'
messages.append(message.encode('ascii'))
line_id += 1
# ...
# Now read signatures
signatures = []
with open(SIGNATURES_FILENAME, 'r') as file:
while True:
line = file.readline().strip()
if not line:
break
signatures.append(line)
```
This block reads messages and signatures from their respective files. Messages are stored in `messages` as byte arrays, and their lengths are stored in `messages_length`. Signatures are stored in the `signatures` list.
Block 3: Connecting to the Server
```python
# ...
HOST = socket.gethostname()
client = socket.socket()
client.connect((HOST, SERVER_PORT))
# The first message is a HELLO
message = "HELLO"
messages_counter = 0
# Send hello message
client.send(message.encode())
# Get response
response = client.recv(1024).decode()
print(response)
# ...
```
This block establishes a connection to the server using the `socket` library. It sends an initial "HELLO" message to the server, receives a response, and prints the response.
Block 4: Sending Data and Verifying Signatures
```python
if response == "260 OK":
messages_counter = 0
# For each message...
for message in messages:
client.send("DATA".encode())
client.send(message)
# Read response
response = client.recv(1024).decode()
print(response)
if response != "270 SIG":
print("Error, invalid response. 270 SIG expected")
exit()
# Read second response
response = client.recv(1024).decode()
print(response)
# Compare with signature
if response == signatures[messages_counter]:
client.send("PASS".encode())
else:
client.send("FAIL".encode())
response = client.recv(1024).decode()
print(response)
if response != "260 OK":
print("Error, invalid response. 260 OK expected")
client.close()
exit()
messages_counter += 1
client.send("QUIT".encode())
client close()
else:
print("Error: Invalid response")
exit()
```
This block manages the sending of data messages, verifying signatures, and handling responses from the server. It ensures that the messages are sent and received in the correct order, that signatures are verified, and that the connection is closed properly.
Server Code
In the Server Code section, you'll find the code that sets up and manages the server side of the client-server system. It begins with argument parsing to configure server parameters and involves reading keys from a file. The server listens for incoming client connections, processes "HELLO" messages, and handles data and signature verification. This code ensures that the server side operates efficiently and securely, facilitating secure communication between clients and the server.
Block 5: Argument Parsing (Server)
```python
if __name__ == '__main__':
SERVER_PORT = 0
KEYS_FILE = ""
# Get args variables
if len(sys.argv) > 1:
SERVER_PORT = int(sys.argv[1])
else:
raise Exception("No server port provided")
if len(sys.argv) > 2:
KEYS_FILE = sys.argv[2]
else:
raise Exception("No keys file provided")
```
This block parses command-line arguments for the server, specifically the server port and the keys file.
Block 6: Reading Keys File
```python
# ...
# Read keys file
keys = []
with open(KEYS_FILE, 'r') as file:
while True:
line = file.readline().strip()
if not line:
break
keys.append(line)
```
This block reads the keys from the specified file and stores them in the `keys` list.
Block 7: Starting the Server
```python
# ...
HOST = socket.gethostname()
# Start server
server = socket.socket()
server.bind((HOST, SERVER_PORT))
server.listen(2)
# Get incoming connection
conn, addr = server.accept()
#print("Received connection from", addr)
```
This block sets up the server, binds it to the specified host and port, and starts listening for incoming connections. When a client connects, it accepts the connection and gets a reference to the connection socket (`conn`).
Block 8: Handling Client's "HELLO" Message
```python
# Read response
data = conn.recv(1024).decode()
print(data)
if data != "HELLO":
print("Error, invalid response. HELLO expected")
conn.close()
server.close()
exit()
```
This block handles the initial "HELLO" message from the client. It ensures that the received message is "HELLO" and closes the connection if it's not.
Block 9: Processing Data and Signatures
```python
# ...
while True:
# Read next message
data = conn.recv(1024).decode()
print(data)
match data:
case "DATA":
# Start new hash
hash = ""
# Read all other messages as ASCII
data = conn.recv(1024)
# Unescape each message
# data = data.replace("\n", "")
# print(data.decode())
# Then, split
lines = data.decode().split('\n')
# Read each line
while len(lines) > 0:
message = lines.pop(0)
# print(f"Got message: ->{message}<-")
if message == ".":
break
hash += message
hash += keys[messages_counter]
# print("TO BE HASHED:", hash)
hash = sha256(hash.encode()).hexdigest()
# print(hash)
conn.send("270 SIG".encode())
conn.send(hash.encode())
data = conn.recv(1024).decode()
print(data)
if not data in ["PASS", "FAIL"]:
print("Error, invalid response. Expected PASS/FAIL")
conn.close()
exit()
conn.send("260 OK".encode())
messages_counter += 1
case "QUIT":
conn.close()
exit()
case _:
print("Invalid command, expected DATA or QUIT")
conn.close()
exit()
```
This block is the server's main loop, which continually listens for commands from the client. If the command is "DATA," the server processes the message, verifies the signature, and sends appropriate responses. If the command is "QUIT," the server closes the connection and exits. Other commands are considered invalid.
Conclusion
In conclusion, this code provides a solid foundation for implementing a secure chat system using Python. It illustrates the principles of network communication, data encryption, and integrity verification, essential components of modern secure messaging systems. By understanding and customizing this code, you can develop your encrypted chat system tailored to specific use cases, from private messaging platforms to secure business communication tools. This project is a great opportunity not only to strengthen your programming skills but also to gain invaluable hands-on experience in the fields of network programming and cybersecurity, setting you on a path to create innovative and secure communication solutions.