Sistema de Comunicação Cliente-Servidor com Criptografia

Este projeto demonstra a comunicação entre cliente e servidor usando sockets TCP em Python, com criptografia básica e registro de logs em arquivo.

Servidor (Linha de Comando)

import socket

servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = "0.0.0.0"
porta = 5555
servidor.bind((host, porta))
servidor.listen(5)

print("Servidor aguardando conexões...")
conexao, endereco = servidor.accept()
print(f"Conexão estabelecida com {endereco}")

def cifrar(texto):
    return ''.join(chr(ord(caractere) + 5) for caractere in texto)

def decifrar(texto):
    return ''.join(chr(ord(caractere) - 5) for caractere in texto)

with open("registro_servidor.txt", "w") as log:
    try:
        while True:
            dados = conexao.recv(1024).decode()
            if not dados:
                break
                
            texto_decifrado = decifrar(dados)
            print(f"Mensagem recebida (cifrada): {dados}")
            print(f"Mensagem decifrada: {texto_decifrado}")
            log.write(f"Recebido cifrado: {dados}\n")
            log.write(f"Decifrado: {texto_decifrado}\n\n")
            
            resposta = input("Resposta: ")
            resposta_cifrada = cifrar(resposta)
            conexao.send(resposta_cifrada.encode())
            log.write(f"Enviado decifrado: {resposta}\n")
            log.write(f"Enviado cifrado: {resposta_cifrada}\n\n")
            
    finally:
        conexao.close()
        servidor.close()

Cliente (Linha de Comando)

import socket

cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cliente.connect(("127.0.0.1", 5555))

def cifrar(texto):
    return ''.join(chr(ord(c) + 5) for c in texto)

def decifrar(texto):
    return ''.join(chr(ord(c) - 5) for c in texto)

with open("registro_cliente.txt", "w") as log:
    try:
        while True:
            mensagem = input("Mensagem: ")
            mensagem_cifrada = cifrar(mensagem)
            cliente.send(mensagem_cifrada.encode())
            log.write(f"Enviado decifrado: {mensagem}\n")
            log.write(f"Enviado cifrado: {mensagem_cifrada}\n\n")
            
            resposta = cliente.recv(1024).decode()
            resposta_decifrada = decifrar(resposta)
            print(f"Resposta recebida (cifrada): {resposta}")
            print(f"Resposta decifrada: {resposta_decifrada}")
            log.write(f"Recebido cifrado: {resposta}\n")
            log.write(f"Decifrado: {resposta_decifrada}\n\n")
            
    finally:
        cliente.close()

Implemenatção com Interface Gráfica

Sistema aprimorado com GUI usando Tkinter e multithreading:

Servidor GUI

import socket
import threading
import tkinter as tk

def cifrar(texto):
    return ''.join(chr(ord(c) + 5) for c in texto)

def decifrar(texto):
    return ''.join(chr(ord(c) - 5) for c in texto)

class ServidorGUI:
    def __init__(self, janela):
        self.janela = janela
        self.janela.title("Servidor de Chat Criptografado")
        
        self.area_chat = tk.Text(janela, state=tk.DISABLED)
        self.area_chat.pack()
        
        self.entrada = tk.Entry(janela)
        self.entrada.pack()
        self.entrada.bind("<Return>", self.enviar_mensagem)
        
        tk.Button(janela, text="Enviar", command=self.enviar_mensagem).pack()
        
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.bind(("0.0.0.0", 5555))
        self.socket.listen(1)
        
        threading.Thread(target=self.aceitar_conexoes, daemon=True).start()
    
    def aceitar_conexoes(self):
        self.conexao, addr = self.socket.accept()
        threading.Thread(target=self.receber_dados, daemon=True).start()
    
    def receber_dados(self):
        while True:
            dados = self.conexao.recv(1024).decode()
            texto_decifrado = decifrar(dados)
            self.mostrar_mensagem(f"Cliente: {texto_decifrado}")
    
    def enviar_mensagem(self, evento=None):
        mensagem = self.entrada.get()
        self.conexao.send(cifrar(mensagem).encode())
        self.mostrar_mensagem(f"Servidor: {mensagem}")
        self.entrada.delete(0, tk.END)
    
    def mostrar_mensagem(self, msg):
        self.area_chat.config(state=tk.NORMAL)
        self.area_chat.insert(tk.END, msg + "\n")
        self.area_chat.config(state=tk.DISABLED)

root = tk.Tk()
app = ServidorGUI(root)
root.mainloop()

Cliente GUI

import socket
import threading
import tkinter as tk

def cifrar(texto):
    return ''.join(chr(ord(c) + 5) for c in texto)

def decifrar(texto):
    return ''.join(chr(ord(c) - 5) for c in texto)

class ClienteGUI:
    def __init__(self, janela):
        self.janela = janela
        self.janela.title("Cliente de Chat Criptografado")
        
        self.area_chat = tk.Text(janela, state=tk.DISABLED)
        self.area_chat.pack()
        
        self.entrada = tk.Entry(janela)
        self.entrada.pack()
        self.entrada.bind("<Return>", self.enviar_mensagem)
        
        tk.Button(janela, text="Enviar", command=self.enviar_mensagem).pack()
        
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.connect(("127.0.0.1", 5555))
        
        threading.Thread(target=self.receber_dados, daemon=True).start()
    
    def receber_dados(self):
        while True:
            dados = self.socket.recv(1024).decode()
            texto_decifrado = decifrar(dados)
            self.mostrar_mensagem(f"Servidor: {texto_decifrado}")
    
    def enviar_mensagem(self, evento=None):
        mensagem = self.entrada.get()
        self.socket.send(cifrar(mensagem).encode())
        self.mostrar_mensagem(f"Cliente: {mensagem}")
        self.entrada.delete(0, tk.END)
    
    def mostrar_mensagem(self, msg):
        self.area_chat.config(state=tk.NORMAL)
        self.area_chat.insert(tk.END, msg + "\n")
        self.area_chat.config(state=tk.DISABLED)

root = tk.Tk()
app = ClienteGUI(root)
root.mainloop()

Análise da Implementação GUI

Prinncipais vantagens da versão com interface gráfica:

• Processamento paralelo com multithreading para operações de rede
• Interface responsiva sem bloqueio durante operações I/O
• Gerenciamento automático de recusros com context managers
• Tratamento robusto de exceções e desconexões
• Separação clara entre lógica de rede e interface