first commit

Author: cassiofb-dev

.gitignore

@@ -0,0 +1 @@
+__pycache__

README.md

@@ -0,0 +1,68 @@
+<h1 align="center">
+  Python P2P Crypt Chat App
+</h1>
+
+<h4 align="center">Chat over <a href="https://en.wikipedia.org/wiki/Berkeley_sockets">Berkeley Sockets</a> with encryption, p2p and over internet (needs port fowarding).</h4>
+
+<p align="center">
+  <a href="#about">About</a> •
+  <a href="#features">Features</a> •
+  <a href="#usage">Usage</a> •
+  <a href="#credits">Credits</a> •
+  <a href="#license">License</a>
+</p>
+
+![cefet](https://i.imgur.com/K0E5iFC.jpg)
+
+## About
+
+This is a simple python program made for university work. It uses python socket, threads and a encryption package. This program uses P2P and client-server architecture.
+
+## Features
+
+* Interactive Chat
+  * Send and view replies.
+* Multi-client
+  * Create a lobby with your friends
+* P2P
+  * Run your own server and client to make a direct connection with another clients
+* Encryption
+  * Make your messages safe with [fernet](https://github.com/pyca/cryptography).
+
+## Usage
+
+To run this program you will need [git](https://git-scm.com/), [python](https://www.python.org/), [request](https://github.com/psf/requests), [cryptography](https://github.com/pyca/cryptography). On your console:
+
+```bash
+# Clone the repository
+git clone https://github.com/cassiofb-dev/python-p2p-crypt-chat
+
+# Go inside
+cd python-p2p-crypt-chat
+
+# Install dependencies
+pip install requests
+pip install cryptography
+
+# run application
+py p2p.py
+```
+
+## Credits
+
+This app uses the following open source projects:
+
+* [Git](https://github.com/git/git)
+* [Python](https://www.python.org/)
+* [Requests](https://github.com/psf/requests)
+* [Cryptography](https://github.com/pyca/cryptography)
+
+## License
+
+MIT
+
+---
+
+> [Acesse meu site](https://cassiofernando.netlify.app/) &nbsp;&middot;&nbsp;
+> GitHub [@cassiofb-dev](https://github.com/cassiofb-dev) &nbsp;&middot;&nbsp;
+> Twitter [@cassiofb_dev](https://twitter.com/cassiofb_dev)

client.py

@@ -0,0 +1,54 @@
+import socket, os
+from cryptography.fernet import Fernet
+
+class Client():
+  def __init__(self, server_url=socket.gethostbyname(socket.gethostname()), server_port="25565"):
+    self.server_url = server_url
+    self.server_port = int(server_port)
+    self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    self.connected = False
+    self.fernet = None
+
+  def send_message(self):
+    client_message = input("enter a message >> ")
+    self.client_socket.send(self.encode_message(client_message))
+
+  def exit(self):
+    self.client_socket.send(self.encode_message("3"))
+    self.client_socket.close()
+    self.connected = False
+
+  def init_crypt_service(self):
+    fernet_key = bytes(input("enter fernet key >> "), "utf-8")
+    self.fernet =Fernet(fernet_key)
+    self.client_socket.send(bytes("4", "utf-8"))
+
+  def start(self):
+    self.client_socket.connect((self.server_url, self.server_port))
+    self.connected = True
+    while self.connected:
+      print("esperando mensagem...")
+      server_message = self.decode_message(self.client_socket.recv(4096))
+      os.system('cls' if os.name == 'nt' else 'clear')
+      print(f"{server_message}")
+      user_input = input(f"(1) send message, (2) refresh chat, (3) exit{', (4) start crypt service ' if self.fernet == None else ' '}>> ")[0]
+      if user_input == "1": self.send_message()
+      elif user_input == "2": self.client_socket.send(self.encode_message("2"))
+      elif user_input == "3": self.exit()
+      elif user_input == "4": self.init_crypt_service()
+      else: self.exit()
+  
+  def encode_message(self, message: str):
+    bytes_message = bytes(message, "utf-8")
+    coded_message = bytes_message if self.fernet == None else self.fernet.encrypt(bytes_message)
+    return coded_message
+
+  def decode_message(self, bytes_message: bytes):
+    print(f"message: {bytes_message.decode()}")
+    decoded_message = (bytes_message if self.fernet == None else self.fernet.decrypt(bytes_message)).decode()
+    return decoded_message
+
+if __name__ == "__main__":
+  custom_config = input("custom config? (s/n) >> ")[0] == "s"
+  client = Client() if custom_config == False else Client(input("enter server hostname >> "), input("enter server port >> "))
+  client.start()

p2p.py

@@ -0,0 +1,36 @@
+import time, socket
+from client import Client
+from server import Server
+
+def init_server(): Server().start()
+def init_client(): Client(input("client: enter server hostname >> "), input("client: enter server port >> ")).start()
+
+def init_p2p_default(
+  server_use_crypto=False,
+  server_port_for_server="25565",
+  server_hostname_for_client=socket.gethostbyname(socket.gethostname()),
+  server_port_for_client="25565",
+):
+  server = Server(server_port=server_port_for_server, use_crypt=server_use_crypto)
+  client = Client(server_hostname_for_client, server_port_for_client)
+
+  server.start()
+  while server.server_started == False: time.sleep(0.2)
+  input("p2p: server started, press any key to start client...")
+  client.start()
+
+def init_p2p_custom(): init_p2p_default(
+  server_use_crypto=input("type (1) to encrypt server >> ") == "1",
+  server_port_for_server=input("server: enter port >> "),
+  server_hostname_for_client=input("client: enter server hostname >> "),
+  server_port_for_client=input("client: enter server port >> "),
+)
+
+def init_p2p():
+  user_input = input("(1) client mode, (2) server mode, (3) p2p default mode, (4) p2p custom mode >> ")[0]
+  if   user_input == "1": init_client()
+  elif user_input == "2": init_server()
+  elif user_input == "3": init_p2p_default()
+  elif user_input == "4": init_p2p_custom()
+
+if __name__ == "__main__": init_p2p()

server.py

@@ -0,0 +1,94 @@
+import socket, threading, requests, time, os
+from cryptography.fernet import Fernet
+
+class ClientThread(threading.Thread):
+  def __init__(self, client_socket: socket.socket, client_address: tuple[str, int], server: "Server"):
+    threading.Thread.__init__(self)
+    self.client_socket = client_socket
+    self.client_address = client_address
+    self.server = server
+    self.username = "no_username"
+    self.has_to_start_crypt_service = self.server.server_use_crypt
+    self.has_to_send_username = True
+
+  def run(self):
+    client_message = None
+    while True:
+      if self.has_to_start_crypt_service:
+        self.client_socket.send(bytes("server: fernet enabled, please start crypt service\n", "utf-8"))
+        client_message = self.client_socket.recv(4096).decode()
+        if client_message == "4": self.has_to_start_crypt_service = False
+      elif self.has_to_send_username:
+        self.client_socket.send(self.encode_message("server: connected to server, enter a username or send '1'\n"))
+        client_message = self.decode_message(self.client_socket.recv(4096))
+        if client_message != "1": self.username = client_message
+        if client_message != "2":
+          self.server.usernames.append(self.username)
+          self.server.messages.append(f"server: ({self.username}) joined the chat")
+          self.has_to_send_username = False
+      else:
+        self.send_server_chat()
+        client_message = self.decode_message(self.client_socket.recv(4096))
+        if client_message == "3": break
+        client_username_message = f"({self.username}): {client_message}"
+        if client_message != "2": self.server.messages.append(client_username_message)
+    self.server.usernames.remove(self.username)
+    self.server.messages.append(f"server: ({self.username}) left the chat")
+  
+  def send_server_chat(self):
+    server_message = ""
+    server_message += f"server: your username is ({self.username}), have a nice chat\n"
+    server_message += "\n".join(self.server.messages)
+    server_message += f"\n\nserver: your username is: ({self.username}), there are ({len(self.server.usernames)}) online users"
+    self.client_socket.send(self.encode_message(server_message))
+
+
+  def encode_message(self, message: str):
+    bytes_message = bytes(message, "utf-8")
+    coded_message = bytes_message if self.server.server_fernet == None else self.server.server_fernet.encrypt(bytes_message)
+    return coded_message
+
+  def decode_message(self, bytes_message: bytes):
+    decoded_message = (bytes_message if self.server.server_fernet == None else self.server.server_fernet.decrypt(bytes_message)).decode()
+    return decoded_message
+
+class Server(threading.Thread):
+  def __init__(self, server_url=socket.gethostbyname(socket.gethostname()), server_port="25565", use_crypt=False):
+    threading.Thread.__init__(self)
+    self.server_url = server_url
+    self.server_port = int(server_port)
+    self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    self.server_started = False
+    self.usernames = []
+    self.messages = []
+    self.server_use_crypt = use_crypt
+    if self.server_use_crypt == False:
+      self.server_fernet_key = None
+      self.server_fernet = None
+    else:
+      self.server_fernet_key = Fernet.generate_key()
+      self.server_fernet = Fernet(self.server_fernet_key)
+      print(f"server starting on crypto mode, paste key for clients: {self.server_fernet_key.decode()}\n5 seconds to clear key and start server...")
+      time.sleep(5)
+      os.system('cls' if os.name == 'nt' else 'clear')
+
+  def run(self):
+    self.server_socket.bind((self.server_url, self.server_port))
+    print(f"server started on ({self.server_url}:{self.server_port})")
+    print(f"server public ip: {requests.get('https://api.ipify.org').text}")
+    self.server_started = True
+    while True:
+      self.server_socket.listen(1)
+      client_socket, client_address = self.server_socket.accept()
+      client_thread = ClientThread(client_socket, client_address, self)
+      client_thread.start()
+
+if __name__ == "__main__":
+  custom_config = input("custom config? (s/n) >> ")[0] == "s"
+  server = Server() if custom_config == False else Server(
+    server_url=input("enter server hostname >> "),
+    server_port=input("enter server port >> "),
+    use_crypt=input("use encryption? (s/n) >> ")[0] == "s",
+  )
+  server.start()