Para o presente trabalho deve ser criado um chat criptográfico multithread.

Protocolo:

a) Conexão e Identificação 1 - Cliente conecta com servidor e recebe a chave pública. 2 - Cliente gera a chave secreta, criptografa com a pública, e envia para o servidor. 3 - Cliente envia o nome criptografado. 4 - Servidor decriptografa e gera mensagem de "(Usuário X) conectado". 5 - Servidor envia a mensagem para todos os clientes, criptografando para cada um.

b) Envio de mensagem 1 - Cliente envia mensagem criptografada para o servidor. 2 - Servidor decriptografa a mensagem e anexa a origem: "(Usuário X): mensagem". 5 - Servidor envia a mensagem para todos os clientes, criptografando para cada um.

c) Recepção assíncrona no cliente 1 - Cliente recebe mensagem criptografada do servidor. 2 - Cliente decriptografa a mensagem com sua chave secreta.

Em seguida deve ser definido um modelo de stress test, permitindo as seguintes variações:

Número de Threads no pool do servidor (10, 100, 500)
Número de conexões (10, 100, 500)
Número de pacotes por conexão (10, 100, 1K)
Tamanho do pacote (100 bytes, 1K, 10K)
Feitos os testes, tabule os resultados e indique o tempo médio de resposta.

Faça o código completo em linguagem Python.

Perguntas primordiais: -- Até onde o aumento de Threads melhorou a performance? -- Que fatores impactaram o processamento concorrente ou paralelo? -- Que fatores impactaram o processamento distribuído?

Question

Para o presente trabalho deve ser criado um chat criptográfico multithread.

Protocolo:

a) Conexão e Identificação 1 - Cliente conecta com servidor e recebe a chave pública. 2 - Cliente gera a chave secreta, criptografa com a pública, e envia para o servidor. 3 - Cliente envia o nome criptografado. 4 - Servidor decriptografa e gera mensagem de "(Usuário X) conectado". 5 - Servidor envia a mensagem para todos os clientes, criptografando para cada um.

b) Envio de mensagem 1 - Cliente envia mensagem criptografada para o servidor. 2 - Servidor decriptografa a mensagem e anexa a origem: "(Usuário X): mensagem". 5 - Servidor envia a mensagem para todos os clientes, criptografando para cada um.

c) Recepção assíncrona no cliente 1 - Cliente recebe mensagem criptografada do servidor. 2 - Cliente decriptografa a mensagem com sua chave secreta.

Em seguida deve ser definido um modelo de stress test, permitindo as seguintes variações:

Número de Threads no pool do servidor (10, 100, 500)
Número de conexões (10, 100, 500)
Número de pacotes por conexão (10, 100, 1K)
Tamanho do pacote (100 bytes, 1K, 10K)
Feitos os testes, tabule os resultados e indique o tempo médio de resposta.

Faça o código completo em linguagem Python.

Perguntas primordiais: -- Até onde o aumento de Threads melhorou a performance? -- Que fatores impactaram o processamento concorrente ou paralelo? -- Que fatores impactaram o processamento distribuído?

Accepted Answer

OK, vamos criar um chat criptográfico multithread em Python, implementar um modelo de stress test e analisar os resultados. Este é um projeto complexo, então vamos dividi-lo em partes gerenciáveis.

**1. Implementação do Chat Criptográfico Multithread**

Aqui está um esboço do código para o servidor e cliente. Usaremos RSA para criptografia e sockets para comunicação.

```python
import socket
import threading
import rsa
import time
import os

# Funções auxiliares
def gerar_chaves():
    """Gera chaves pública e privada RSA."""
    return rsa.newkeys(2048)

def criptografar(mensagem, chave_publica):
    """Criptografa a mensagem usando a chave pública."""
    return rsa.encrypt(mensagem.encode('utf-8'), chave_publica)

def descriptografar(mensagem_criptografada, chave_privada):
    """Descriptografa a mensagem usando a chave privada."""
    try:
        return rsa.decrypt(mensagem_criptografada, chave_privada).decode('utf-8')
    except rsa.pkcs1.DecryptionError:
        return None

# --- Servidor ---
class Servidor:
    def __init__(self, host, port, pool_size=10):
        self.host = host
        self.port = port
        self.pool_size = pool_size
        self.clientes = {}  # {socket: (nome, chave_publica)}
        self.chave_privada, self.chave_publica = gerar_chaves()
        self.thread_pool = []
        self.socket_servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.lock = threading.Lock()  # Lock para acesso seguro aos recursos compartilhados

def iniciar(self):
        self.socket_servidor.bind((self.host, self.port))
        self.socket_servidor.listen(5)
        print(f"Servidor ouvindo em {self.host}:{self.port}")

for _ in range(self.pool_size):
            thread = threading.Thread(target=self.tratar_conexoes)
            self.thread_pool.append(thread)
            thread.daemon = True  # Encerra a thread quando o programa principal termina
            thread.start()

# Aguarda indefinidamente por novas conexões
        while True:
            cliente_socket, endereco = self.socket_servidor.accept()
            print(f"Nova conexão de {endereco}")
            # Envia o socket do cliente para a fila de trabalho
            self.adicionar_cliente_fila(cliente_socket)

def tratar_conexoes(self):
        while True:
            cliente_socket = self.obter_cliente_fila()
            if cliente_socket:
                try:
                    self.lidar_com_cliente(cliente_socket)
                except Exception as e:
                    print(f"Erro ao lidar com o cliente: {e}")
                finally:
                    self.remover_cliente(cliente_socket)
                    cliente_socket.close()

def lidar_com_cliente(self, cliente_socket):
        try:
            # 1. Enviar chave pública do servidor
            cliente_socket.send(rsa.save_pkcs1(self.chave_publica))

# 2. Receber chave secreta criptografada do cliente
            chave_secreta_criptografada = cliente_socket.recv(2048)
            chave_secreta = descriptografar(chave_secreta_criptografada, self.chave_privada)
            if not chave_secreta:
                print("Erro ao descriptografar a chave secreta do cliente.")
                return

# 3. Receber nome de usuário criptografado
            nome_criptografado = cliente_socket.recv(2048)
            nome = descriptografar(nome_criptografado, rsa.PublicKey.load_pkcs1(chave_secreta.encode('utf-8')))
            if not nome:
                print("Erro ao descriptografar o nome do cliente.")
                return

with self.lock:
                self.clientes[cliente_socket] = (nome, rsa.PublicKey.load_pkcs1(chave_secreta.encode('utf-8')))
            print(f"Cliente {nome} conectado.")

# 4. Enviar mensagem de conexão para todos os clientes
            mensagem_conexao = f"(Usuário {nome}) conectado".encode('utf-8')
            self.enviar_mensagem_para_todos(mensagem_conexao, cliente_socket)

# Lidar com mensagens subsequentes
            while True:
                mensagem_criptografada = cliente_socket.recv(2048)
                if not mensagem_criptografada:
                    break

mensagem = descriptografar(mensagem_criptografada, rsa.PublicKey.load_pkcs1(chave_secreta.encode('utf-8')))
                if not mensagem:
                    print(f"Erro ao descriptografar mensagem de {nome}.")
                    continue

mensagem_completa = f"({nome}): {mensagem}".encode('utf-8')
                self.enviar_mensagem_para_todos(mensagem_completa, cliente_socket)

except Exception as e:
            print(f"Erro na comunicação com o cliente: {e}")
        finally:
            self.remover_cliente(cliente_socket)
            cliente_socket.close()
            print(f"Conexão com o cliente {nome} encerrada.")

def enviar_mensagem_para_todos(self, mensagem, socket_remetente):
        with self.lock:
            for socket_cliente, (nome_cliente, chave_publica) in self.clientes.items():
                if socket_cliente != socket_remetente:
                    mensagem_criptografada = criptografar(mensagem.decode('utf-8'), chave_publica)
                    try:
                        socket_cliente.send(mensagem_criptografada)
                    except Exception as e:
                        print(f"Erro ao enviar mensagem para {nome_cliente}: {e}")
                        self.remover_cliente(socket_cliente)

def adicionar_cliente_fila(self, cliente_socket):
        with self.lock:
            self.fila_clientes.append(cliente_socket)
            self.condicao.notify()  # Notifica uma thread em espera

def obter_cliente_fila(self):
        with self.lock:
            while not self.fila_clientes:
                self.condicao.wait()  # Aguarda até que haja um cliente na fila
            return self.fila_clientes.pop(0)

def remover_cliente(self, cliente_socket):
        with self.lock:
            if cliente_socket in self.clientes:
                nome_cliente = self.clientes[cliente_socket][0]
                del self.clientes[cliente_socket]
                print(f"Cliente {nome_cliente} desconectado.")

def fechar(self):
        for thread in self.thread_pool:
            thread.join()
        self.socket_servidor.close()
        print("Servidor encerrado.")

# --- Cliente ---
class Cliente:
    def __init__(self, host, port, nome):
        self.host = host
        self.port = port
        self.nome = nome
        self.socket_cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.chave_privada, self.chave_publica = gerar_chaves()
        self.chave_publica_servidor = None
        self.chave_secreta = os.urandom(16).hex()  # Chave secreta para criptografia simétrica
        self.thread_recepcao = None

def conectar(self):
        try:
            self.socket_cliente.connect((self.host, self.port))

# 1. Receber chave pública do servidor
            self.chave_publica_servidor = rsa.PublicKey.load_pkcs1(self.socket_cliente.recv(2048))

# 2. Enviar chave secreta criptografada
            chave_secreta_criptografada = criptografar(self.chave_secreta, self.chave_publica_servidor)
            self.socket_cliente.send(chave_secreta_criptografada)

# 3. Enviar nome criptografado
            nome_criptografado = criptografar(self.nome, self.chave_publica_servidor)
            self.socket_cliente.send(nome_criptografado)

self.thread_recepcao = threading.Thread(target=self.receber_mensagens)
            self.thread_recepcao.daemon = True
            self.thread_recepcao.start()

print("Conectado ao servidor. Digite suas mensagens:")

except Exception as e:
            print(f"Erro ao conectar: {e}")
            self.socket_cliente.close()
            exit()

def enviar_mensagem(self, mensagem):
        try:
            mensagem_criptografada = criptografar(mensagem, self.chave_publica_servidor)
            self.socket_cliente.send(mensagem_criptografada)
        except Exception as e:
            print(f"Erro ao enviar mensagem: {e}")
            self.fechar()

def receber_mensagens(self):
        while True:
            try:
                mensagem_criptografada = self.socket_cliente.recv(2048)
                if not mensagem_criptografada:
                    break

mensagem = descriptografar(mensagem_criptografada, rsa.PublicKey.load_pkcs1(self.chave_secreta.encode('utf-8')))
                if mensagem:
                    print(mensagem)
                else:
                    print("Mensagem ilegível.")
            except Exception as e:
                print(f"Erro ao receber mensagem: {e}")
                break
        self.fechar()

def fechar(self):
        self.socket_cliente.close()
        print("Conexão encerrada.")

# --- Main ---
if __name__ == "__main__":
    host = '127.0.0.1'
    port = 12345

# Iniciar servidor em uma thread separada
    servidor = Servidor(host, port, pool_size=500)
    thread_servidor = threading.Thread(target=servidor.iniciar)
    thread_servidor.daemon = True
    thread_servidor.start()

# Esperar um pouco para o servidor iniciar
    time.sleep(1)

# Iniciar múltiplos clientes
    num_clientes = 10
    clientes = []
    for i in range(num_clientes):
        nome_cliente = f"Cliente{i+1}"
        cliente = Cliente(host, port, nome_cliente)
        cliente.conectar()
        clientes.append(cliente)
        time.sleep(0.5)  # Esperar um pouco entre as conexões dos clientes

# Enviar mensagens de teste
    time.sleep(2)  # Esperar um pouco antes de enviar mensagens
    for cliente in clientes:
        for j in range(5):
            mensagem_teste = f"Mensagem de teste {j+1} de {cliente.nome}"
            cliente.enviar_mensagem(mensagem_teste)
            time.sleep(0.2)  # Esperar um pouco entre as mensagens

# Manter o programa rodando por um tempo
    time.sleep(10)

# Fechar clientes e servidor
    for cliente in clientes:
        cliente.fechar()
    servidor.fechar()
```

**2. Modelo de Stress Test**

Agora, vamos criar um script para executar o stress test. Este script irá:

1.  Iniciar o servidor com um número específico de threads.
2.  Conectar um número específico de clientes ao servidor.
3.  Cada cliente enviará um número específico de pacotes de um tamanho específico.
4.  Medir o tempo total para completar todas as operações.

```python
import time
import statistics
import subprocess

def executar_teste(num_threads, num_conexoes, num_pacotes, tamanho_pacote):
    """Executa um teste com as configurações especificadas."""

# Comando para iniciar o servidor
    comando_servidor = [
        "python", "servidor.py",  # Substitua pelo nome do seu arquivo servidor
        "--threads", str(num_threads)
    ]

# Inicia o servidor em um subprocesso
    processo_servidor = subprocess.Popen(comando_servidor, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    time.sleep(2)  # Espera o servidor iniciar

tempos = []
    for _ in range(num_conexoes):
        # Comando para iniciar o cliente
        comando_cliente = [
            "python", "cliente.py",  # Substitua pelo nome do seu arquivo cliente
            "--pacotes", str(num_pacotes),
            "--tamanho", str(tamanho_pacote)
        ]

inicio = time.time()
        processo_cliente = subprocess.Popen(comando_cliente, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        processo_cliente.wait()  # Espera o cliente terminar
        fim = time.time()
        tempos.append(fim - inicio)

# Encerra o servidor
    processo_servidor.terminate()
    processo_servidor.wait()

return tempos

def main():
    """Função principal para executar os testes."""
    num_threads_lista = [10, 100, 500]
    num_conexoes_lista = [10, 100, 500]
    num_pacotes_lista = [10, 100, 1000]
    tamanho_pacote_lista = [100, 1024, 10240]  # 100 bytes, 1KB, 10KB

resultados = []

for num_threads in num_threads_lista:
        for num_conexoes in num_conexoes_lista:
            for num_pacotes in num_pacotes_lista:
                for tamanho_pacote in tamanho_pacote_lista:
                    print(f"Executando teste com: Threads={num_threads}, Conexões={num_conexoes}, Pacotes={num_pacotes}, Tamanho={tamanho_pacote}")
                    tempos = executar_teste(num_threads, num_conexoes, num_pacotes, tamanho_pacote)
                    tempo_medio = statistics.mean(tempos) if tempos else 0
                    resultados.append({
                        "Threads": num_threads,
                        "Conexões": num_conexoes,
                        "Pacotes": num_pacotes,
                        "Tamanho": tamanho_pacote,
                        "Tempo Médio": tempo_medio
                    })
                    print(f"Tempo médio: {tempo_medio:.2f} segundos
")

# Imprimir resultados tabulados
    print("Resultados dos Testes:")
    print("----------------------------------------------------------------------------------")
    print("Threads | Conexões | Pacotes | Tamanho (Bytes) | Tempo Médio (Segundos)")
    print("----------------------------------------------------------------------------------")
    for resultado in resultados:
        print(f"{resultado['Threads']:7} | {resultado['Conexões']:8} | {resultado['Pacotes']:7} | {resultado['Tamanho']:15} | {resultado['Tempo Médio']:20.2f}")
    print("----------------------------------------------------------------------------------")

if __name__ == "__main__":
    main()
```

**3. Análise dos Resultados**

Após executar os testes, você terá uma tabela de resultados. Aqui estão algumas perguntas primordiais que você pode responder com base nesses resultados:

*   **Até onde o aumento de Threads melhorou a performance?**
    *   Analise como o tempo médio de resposta muda à medida que você aumenta o número de threads. Em algum ponto, aumentar o número de threads pode não melhorar (ou até piorar) a performance devido ao overhead de gerenciamento de threads (context switching).
*   **Que fatores impactaram o processamento concorrente ou paralelo?**
    *   **Overhead de Threading:** A criação e gerenciamento de threads têm um custo. Em cenários com pouca carga, esse overhead pode ser maior do que o benefício da concorrência.
    *   **Gargalos de I/O:** Se a maior parte do tempo é gasto esperando por operações de I/O (como enviar e receber dados pela rede), aumentar o número de threads pode não ajudar muito.
    *   **Contentores:** O acesso a estruturas de dados compartilhadas (como a lista de clientes) precisa ser sincronizado para evitar condições de corrida. O uso excessivo de locks pode reduzir a concorrência.
*   **Que fatores impactaram o processamento distribuído?**
    *   **Latência da Rede:** A latência entre o servidor e os clientes pode ser um fator limitante, especialmente com um grande número de clientes.
    *   **Largura de Banda:** A quantidade de dados que podem ser transmitidos pela rede em um determinado período de tempo. Se a largura de banda for limitada, isso pode afetar o desempenho.
    *   **Criptografia:** A criptografia adiciona uma sobrecarga significativa. Algoritmos de criptografia mais complexos (chaves maiores) aumentam o tempo de processamento.

**Considerações Adicionais**

*   **Escalabilidade:** Este modelo simples pode não ser suficiente para testar a escalabilidade em cenários reais. Em um ambiente de produção, você precisaria considerar fatores como balanceamento de carga, replicação e tolerância a falhas.
*   **Monitoramento:** Durante os testes, use ferramentas de monitoramento do sistema (como `top`, `htop`, `iostat`) para observar o uso de CPU, memória e rede. Isso pode ajudar a identificar gargalos.
*   **Otimização:** Com base nos resultados dos testes, você pode otimizar o código. Por exemplo, você pode usar um algoritmo de criptografia mais eficiente, reduzir o número de locks ou otimizar as operações de I/O.

Este é um ponto de partida. Você precisará adaptar e expandir este código para atender às suas necessidades específicas.

Para o presente trabalho deve ser criado um chat criptográfi...

Ask a question and receive an answer instantly