From 6385c3e52b5db02c0e76b5b3a6c9310d78416969 Mon Sep 17 00:00:00 2001
From: Aarys Sahler <aarys.sahler@gmail.com>
Date: Tue, 2 Jan 2024 18:57:18 +0100
Subject: [PATCH 01/11] Initial commit

---
 client.py                                  |  39 +++++++++++++++++++++
 ether/__init__.py                          |   6 ++++
 ether/__pycache__/__init__.cpython-311.pyc | Bin 0 -> 195 bytes
 ether/__pycache__/protocol.cpython-311.pyc | Bin 0 -> 538 bytes
 ether/protocol.py                          |  11 ++++++
 5 files changed, 56 insertions(+)
 create mode 100644 client.py
 create mode 100644 ether/__init__.py
 create mode 100644 ether/__pycache__/__init__.cpython-311.pyc
 create mode 100644 ether/__pycache__/protocol.cpython-311.pyc
 create mode 100644 ether/protocol.py

diff --git a/client.py b/client.py
new file mode 100644
index 0000000..1e12cc5
--- /dev/null
+++ b/client.py
@@ -0,0 +1,39 @@
+#
+# This file is part of the eTh3r project, written, hosted and distributed under MIT License
+#  - eTh3r network, 2023-2024
+#
+
+import sys
+from ether.protocol import Client
+
+def help(code=0):
+    print(" - di0xane - A simple ether python client ")
+    print("")
+    print("Usage: client.py [server ip] [server port (default=2142)] <parameters>")
+    print("")
+    print("Available parameters:")
+    print(" -v  verbose")
+    print("")
+    sys.exit(code)
+
+
+if "-h" in sys.argv:
+    help()
+
+if len(sys.argv) < 2:
+    help(code=1)
+
+ip = sys.argv[1]
+port = 2142
+verbose = False
+
+try:
+    port = int(sys.argv[2])
+except:
+    pass
+
+if "-v" in sys.argv:
+    verbose = True
+
+if verbose:
+    print(f"[*] connecting to {ip}:{port}")
diff --git a/ether/__init__.py b/ether/__init__.py
new file mode 100644
index 0000000..ceee5a8
--- /dev/null
+++ b/ether/__init__.py
@@ -0,0 +1,6 @@
+#
+# This file is part of the eTh3r project, written, hosted and distributed under MIT License
+#  - eTh3r network, 2023-2024
+#
+
+import ether.protocol
diff --git a/ether/__pycache__/__init__.cpython-311.pyc b/ether/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea1e4380a2e1e6cd7111425402ed66d00a83f237
GIT binary patch
literal 195
zcmZ3^%ge<81W$dZq)r9Wk3k$5V1hC}^8p#t8B!Qh7;_k+7*iO788n$*f+YPknQrl=
zmSm(B=@k^^m*gks=iFii^H(x_1}XTZt)G#fo2s9fSX5c850o)3(of0EuSm>G1@Tgg
z^yA|*^D;}~<Mj$Ee{tC4=BJeAq}mm60QE8gaj_(j_`uA_$oPSWfl=%NgD5g8Vgt$o
E0RKNSNdN!<

literal 0
HcmV?d00001

diff --git a/ether/__pycache__/protocol.cpython-311.pyc b/ether/__pycache__/protocol.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..52c892f296883f6996ed056c180185aca4ffdf89
GIT binary patch
literal 538
zcmZuty-ve05I#GhgsPzn4}io%h13kJhyex$q%Le(tSB~WL>d=6l_*n(4m<!--vEUA
z8azamm5D7VOr5xES|n7?^5^e<zVqo`eZL84i|c3gj_(IK8*|sBIz}=B36iA{0*5P*
zd<xQe;Q({IwS`Qw8|b*7<o4oqboH>cQyn0gfdZ_BkV`g&(2*QfPSLnb6P4xhrj{hc
z9lTWofhNF8)_X%JT&vPsO9h9^lc28$Du^O8wt>p~rzVhzeuy$fo-)DE=v>D-?GDF<
zCq$AZxe$--`p51ju!qg;F2V#BUhB!NkV3EHk|c`;N{FH<#6ZhYO1ve+{U}Q7j3Ke1
zF%2!$cm%Y-6_96-5GKE;<ZQ<;VH;{aNjtn~SRLP~yzcb3`_enBM>#ibET&D^3xv{P
ajFl~5`xBo|>2ii2ZNnGEzW+(ACinpvsc>Te

literal 0
HcmV?d00001

diff --git a/ether/protocol.py b/ether/protocol.py
new file mode 100644
index 0000000..8af3caa
--- /dev/null
+++ b/ether/protocol.py
@@ -0,0 +1,11 @@
+#
+# This file is part of the eTh3r project, written, hosted and distributed under MIT License
+#  - eTh3r network, 2023-2024
+#
+
+import socket
+
+class Client():
+    def __init__(self):
+        pass
+

From 1dc79383b072901e36f04c22d3784e8e871663d9 Mon Sep 17 00:00:00 2001
From: Aarys Sahler <aarys.sahler@gmail.com>
Date: Tue, 2 Jan 2024 18:58:50 +0100
Subject: [PATCH 02/11] fixed gitignore?

---
 .gitignore                                 |   1 +
 ether/__pycache__/__init__.cpython-311.pyc | Bin 195 -> 0 bytes
 ether/__pycache__/protocol.cpython-311.pyc | Bin 538 -> 0 bytes
 3 files changed, 1 insertion(+)
 create mode 100644 .gitignore
 delete mode 100644 ether/__pycache__/__init__.cpython-311.pyc
 delete mode 100644 ether/__pycache__/protocol.cpython-311.pyc

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a99c943
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+ether/__pycache__/
diff --git a/ether/__pycache__/__init__.cpython-311.pyc b/ether/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index ea1e4380a2e1e6cd7111425402ed66d00a83f237..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 195
zcmZ3^%ge<81W$dZq)r9Wk3k$5V1hC}^8p#t8B!Qh7;_k+7*iO788n$*f+YPknQrl=
zmSm(B=@k^^m*gks=iFii^H(x_1}XTZt)G#fo2s9fSX5c850o)3(of0EuSm>G1@Tgg
z^yA|*^D;}~<Mj$Ee{tC4=BJeAq}mm60QE8gaj_(j_`uA_$oPSWfl=%NgD5g8Vgt$o
E0RKNSNdN!<

diff --git a/ether/__pycache__/protocol.cpython-311.pyc b/ether/__pycache__/protocol.cpython-311.pyc
deleted file mode 100644
index 52c892f296883f6996ed056c180185aca4ffdf89..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 538
zcmZuty-ve05I#GhgsPzn4}io%h13kJhyex$q%Le(tSB~WL>d=6l_*n(4m<!--vEUA
z8azamm5D7VOr5xES|n7?^5^e<zVqo`eZL84i|c3gj_(IK8*|sBIz}=B36iA{0*5P*
zd<xQe;Q({IwS`Qw8|b*7<o4oqboH>cQyn0gfdZ_BkV`g&(2*QfPSLnb6P4xhrj{hc
z9lTWofhNF8)_X%JT&vPsO9h9^lc28$Du^O8wt>p~rzVhzeuy$fo-)DE=v>D-?GDF<
zCq$AZxe$--`p51ju!qg;F2V#BUhB!NkV3EHk|c`;N{FH<#6ZhYO1ve+{U}Q7j3Ke1
zF%2!$cm%Y-6_96-5GKE;<ZQ<;VH;{aNjtn~SRLP~yzcb3`_enBM>#ibET&D^3xv{P
ajFl~5`xBo|>2ii2ZNnGEzW+(ACinpvsc>Te


From 01701daab30f686149b0d3116a829e853700bad9 Mon Sep 17 00:00:00 2001
From: Aarys Sahler <aarys.sahler@gmail.com>
Date: Tue, 2 Jan 2024 19:26:21 +0100
Subject: [PATCH 03/11] Simple protocol management

---
 .gitignore         |  1 +
 client.py          |  3 ++
 crypto/__init__.py |  6 ++++
 crypto/gpg.py      |  8 +++++
 ether/protocol.py  | 87 ++++++++++++++++++++++++++++++++++++++++++++--
 5 files changed, 103 insertions(+), 2 deletions(-)
 create mode 100644 crypto/__init__.py
 create mode 100644 crypto/gpg.py

diff --git a/.gitignore b/.gitignore
index a99c943..b849933 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 ether/__pycache__/
+crypto/__pycache__/
diff --git a/client.py b/client.py
index 1e12cc5..1f87ee8 100644
--- a/client.py
+++ b/client.py
@@ -37,3 +37,6 @@ def help(code=0):
 
 if verbose:
     print(f"[*] connecting to {ip}:{port}")
+
+client = Client(ip, port)
+client.connect()
diff --git a/crypto/__init__.py b/crypto/__init__.py
new file mode 100644
index 0000000..e984f99
--- /dev/null
+++ b/crypto/__init__.py
@@ -0,0 +1,6 @@
+#
+# This file is part of the eTh3r project, written, hosted and distributed under MIT License
+#  - eTh3r network, 2023-2024
+#
+
+import crypto.gpg
diff --git a/crypto/gpg.py b/crypto/gpg.py
new file mode 100644
index 0000000..6dd8325
--- /dev/null
+++ b/crypto/gpg.py
@@ -0,0 +1,8 @@
+#
+# This file is part of the eTh3r project, written, hosted and distributed under MIT License
+#  - eTh3r network, 2023-2024
+#
+
+import gnupg
+
+
diff --git a/ether/protocol.py b/ether/protocol.py
index 8af3caa..55fb358 100644
--- a/ether/protocol.py
+++ b/ether/protocol.py
@@ -4,8 +4,91 @@
 #
 
 import socket
+from stuct import pack
+
+ACK = 0xa0
 
 class Client():
-    def __init__(self):
-        pass
+    def __init__(self, ip, port=2142):
+        self.dest = ip
+        self.port = port
+
+        self.bind = None
+        self.vers = 0x0001
+        self.pub = None
+
+    def setPub(self, pub):
+        if type(pub) != bytes:
+            print("FATAL! Pub key must be bytes")
+            return 1
+
+        if len(pub) > 65535:
+            print("FATAL! Pub key length must be smaller than 65535")
+            return 2
+
+        self.pub = pub
+        return 0
+
+    def _connect(self):
+        try:
+            self.bind = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.bind.connect((ip, port))
+        except e:
+            print("FATAL! Can't connect to server:" + str(e))
+            return 1
+
+        return 0 
+
+    def _send_vers(self):
+        try:
+            self.bind.send((0x0531b00b << 16) + self.vers)
+
+            resp = self.bind.recv(1)
+
+            if resp != ACK:
+                print("FATAL! Received " + str(hex(resp)) + " from server")
+                return 2
+        except e:
+            print("FATAL! Can't send version: " + str(e))
+            return 1
+
+        return 0
+
+    def _send_key(self):
+        try:
+            pckt = pack("ii", 0x0e1f, len(self.pub))
+            pckt += self.pub
+
+            self.bind.send(pckt)
+
+            resp = self.bind.recv(1)
+
+            if resp != ACK:
+                print("FATAL! Received " + str(hex(resp)) + " from server")
+                return 2
+        except e:
+            print("FATAL! Can't send key: " + str(e))
+            return 1
+
+        return 0
+
+
+    def connect(self):
+        res = self._connect()
+
+        if res != 0:
+            return
+
+        res = self._send_vers()
+
+        if res != 0:
+            return
+
+        if self.pub is None:
+            print("FATAL! No key provided")
+            return
+
+        res = self._send_key()
 
+        if res != 0:
+            return

From 11b55352ec1baff89a7cee010c45d7d98e0166bd Mon Sep 17 00:00:00 2001
From: Aarys Sahler <aarys.sahler@gmail.com>
Date: Tue, 2 Jan 2024 19:39:27 +0100
Subject: [PATCH 04/11] Refactored arg management + added gnupg backend support

---
 client.py     | 58 +++++++++++++++++++++++++++++++++++++++++++--------
 crypto/gpg.py |  3 +++
 2 files changed, 52 insertions(+), 9 deletions(-)

diff --git a/client.py b/client.py
index 1f87ee8..585190a 100644
--- a/client.py
+++ b/client.py
@@ -5,6 +5,7 @@
 
 import sys
 from ether.protocol import Client
+from crypto.gpg import getKey
 
 def help(code=0):
     print(" - di0xane - A simple ether python client ")
@@ -12,31 +13,70 @@ def help(code=0):
     print("Usage: client.py [server ip] [server port (default=2142)] <parameters>")
     print("")
     print("Available parameters:")
-    print(" -v  verbose")
+    print(" -v          verbose")
+    print(" -i          interractive, com disabled")
+    print(" -k <keyid>  specify key")
     print("")
     sys.exit(code)
 
 
-if "-h" in sys.argv:
-    help()
-
-if len(sys.argv) < 2:
-    help(code=1)
-
 ip = sys.argv[1]
 port = 2142
 verbose = False
+local = False
+key_id = None
+pub_key = None
+
+if len(sys.argv) < 2:
+    help(code=1)
 
 try:
     port = int(sys.argv[2])
 except:
     pass
 
-if "-v" in sys.argv:
-    verbose = True
+skip = 0
+for (i, arg) in enumerate(sys.argv):
+    while skip > 0:
+        skip -= 1
+
+    if arg == "-h":
+        help()
+    
+    if arg == "-v":
+        verbose = True
+
+    if arg == "-i":
+        local = True
+
+    if arg == "-k":
+        try:
+            key_id = sys.argv()[i+1]
+            skip = 1
+
+            pub_key = getKey(key_id)
+
+            if len(pub_key) == 0:
+                print("FATAL! Provided key was not found")
+        except:
+            help()
+
 
 if verbose:
     print(f"[*] connecting to {ip}:{port}")
 
+    if key_id is not None:
+        print(f"[*] Using key id {key_id}, len={len(pub_key)}")
+
 client = Client(ip, port)
+
+if local:
+    client.setPub(pub_key)
+else:
+    print("FATAL! Com protocol not yet written")
+    sys.exit(2)
+
 client.connect()
+
+if local:
+    pass
diff --git a/crypto/gpg.py b/crypto/gpg.py
index 6dd8325..28e70fc 100644
--- a/crypto/gpg.py
+++ b/crypto/gpg.py
@@ -5,4 +5,7 @@
 
 import gnupg
 
+gpg = gnupg.GPG()
 
+def getKey(key_id):
+    return gpg.export_keys(key_id, False, armor=False)

From d0c5fffec59111d6828e06735c483fb9a65d5339 Mon Sep 17 00:00:00 2001
From: Aarys Sahler <aarys.sahler@gmail.com>
Date: Tue, 2 Jan 2024 20:26:54 +0100
Subject: [PATCH 05/11] Fixed smol error

---
 client.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/client.py b/client.py
index 585190a..0323d57 100644
--- a/client.py
+++ b/client.py
@@ -37,8 +37,9 @@ def help(code=0):
 
 skip = 0
 for (i, arg) in enumerate(sys.argv):
-    while skip > 0:
+    if skip > 0:
         skip -= 1
+        continue
 
     if arg == "-h":
         help()

From ba6003019f956974d80a846a898be8031dcd8dab Mon Sep 17 00:00:00 2001
From: Portevent <porte@magous.fr>
Date: Sat, 16 Mar 2024 10:56:34 +0100
Subject: [PATCH 06/11] feat : Refactor the client

---
 client.py                                     |  83 ------
 client/__init__.py                            |   0
 client/client.py                              |  48 ++++
 client/simple_client/__init__.py              |   0
 client/simple_client/input.py                 |  63 +++++
 client/simple_client/simple_client.py         | 267 ++++++++++++++++++
 .../simple_client_connection_state.py         |  50 ++++
 connection/__init__.py                        |   0
 connection/connection.py                      |  45 +++
 connection/fake_server.py                     |  42 +++
 crypto/__init__.py                            |   1 -
 crypto/gpg.py                                 |  11 -
 display/__init__.py                           |   0
 display/display.py                            |  52 ++++
 display/simple_curses.py                      | 147 ++++++++++
 ether/__init__.py                             |   6 -
 ether/protocol.py                             |  94 ------
 exceptions/__init__.py                        |   0
 exceptions/exceptions.py                      |  14 +
 identity_provider/__init__.py                 |   0
 identity_provider/gpg.py                      |  25 ++
 identity_provider/identity_provider.py        |  10 +
 identity_provider/simple_key.py               |  16 ++
 main.py                                       |  13 +
 misc/__init__.py                              |   0
 misc/hex_enumerator.py                        |  68 +++++
 models/__init__.py                            |   0
 models/identity.py                            |  54 ++++
 models/message.py                             |  51 ++++
 models/packet.py                              | 154 ++++++++++
 models/room.py                                |  44 +++
 31 files changed, 1163 insertions(+), 195 deletions(-)
 delete mode 100644 client.py
 create mode 100644 client/__init__.py
 create mode 100644 client/client.py
 create mode 100644 client/simple_client/__init__.py
 create mode 100644 client/simple_client/input.py
 create mode 100644 client/simple_client/simple_client.py
 create mode 100644 client/simple_client/simple_client_connection_state.py
 create mode 100644 connection/__init__.py
 create mode 100644 connection/connection.py
 create mode 100644 connection/fake_server.py
 delete mode 100644 crypto/gpg.py
 create mode 100644 display/__init__.py
 create mode 100644 display/display.py
 create mode 100644 display/simple_curses.py
 delete mode 100644 ether/__init__.py
 delete mode 100644 ether/protocol.py
 create mode 100644 exceptions/__init__.py
 create mode 100644 exceptions/exceptions.py
 create mode 100644 identity_provider/__init__.py
 create mode 100644 identity_provider/gpg.py
 create mode 100644 identity_provider/identity_provider.py
 create mode 100644 identity_provider/simple_key.py
 create mode 100644 main.py
 create mode 100644 misc/__init__.py
 create mode 100644 misc/hex_enumerator.py
 create mode 100644 models/__init__.py
 create mode 100644 models/identity.py
 create mode 100644 models/message.py
 create mode 100644 models/packet.py
 create mode 100644 models/room.py

diff --git a/client.py b/client.py
deleted file mode 100644
index 0323d57..0000000
--- a/client.py
+++ /dev/null
@@ -1,83 +0,0 @@
-#
-# This file is part of the eTh3r project, written, hosted and distributed under MIT License
-#  - eTh3r network, 2023-2024
-#
-
-import sys
-from ether.protocol import Client
-from crypto.gpg import getKey
-
-def help(code=0):
-    print(" - di0xane - A simple ether python client ")
-    print("")
-    print("Usage: client.py [server ip] [server port (default=2142)] <parameters>")
-    print("")
-    print("Available parameters:")
-    print(" -v          verbose")
-    print(" -i          interractive, com disabled")
-    print(" -k <keyid>  specify key")
-    print("")
-    sys.exit(code)
-
-
-ip = sys.argv[1]
-port = 2142
-verbose = False
-local = False
-key_id = None
-pub_key = None
-
-if len(sys.argv) < 2:
-    help(code=1)
-
-try:
-    port = int(sys.argv[2])
-except:
-    pass
-
-skip = 0
-for (i, arg) in enumerate(sys.argv):
-    if skip > 0:
-        skip -= 1
-        continue
-
-    if arg == "-h":
-        help()
-    
-    if arg == "-v":
-        verbose = True
-
-    if arg == "-i":
-        local = True
-
-    if arg == "-k":
-        try:
-            key_id = sys.argv()[i+1]
-            skip = 1
-
-            pub_key = getKey(key_id)
-
-            if len(pub_key) == 0:
-                print("FATAL! Provided key was not found")
-        except:
-            help()
-
-
-if verbose:
-    print(f"[*] connecting to {ip}:{port}")
-
-    if key_id is not None:
-        print(f"[*] Using key id {key_id}, len={len(pub_key)}")
-
-client = Client(ip, port)
-
-if local:
-    client.setPub(pub_key)
-else:
-    print("FATAL! Com protocol not yet written")
-    sys.exit(2)
-
-client.connect()
-
-if local:
-    pass
diff --git a/client/__init__.py b/client/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/client/client.py b/client/client.py
new file mode 100644
index 0000000..b11ece5
--- /dev/null
+++ b/client/client.py
@@ -0,0 +1,48 @@
+from abc import ABC, abstractmethod
+
+from models.identity import Identity
+
+
+class Client(ABC):
+    """
+    Abstract class to define the basics of a Dioxane Client
+    """
+
+    # Client information, doesn't interfer with Eth3r
+    name: str
+    version: str = "0.1"
+
+    ether_version: int = 0x0001  # Which version of Eth3r it implements
+    identity: Identity  # Key used by the client
+
+    def __init__(self, identity: Identity, name: str = "DIOXANE"):
+        """
+        Instantiate a client
+        :param identity: Key and KeyId of the client
+        :param name: Name of the client
+        """
+        self.identity = identity
+        self.name = name
+
+    @abstractmethod
+    def receive_pck(self, pck: bytearray):
+        """
+        Process packet recieve from the server
+        :param pck: Packet
+        """
+        pass
+    
+    @abstractmethod
+    def send_pck(self, pck: bytearray):
+        """
+        Send Packet to server
+        :param pck: bytes to send
+        """
+        pass
+
+    def _exit(self, code: int = 0):
+        """
+        Close the client
+        :param code: error code
+        """
+        exit(code)
diff --git a/client/simple_client/__init__.py b/client/simple_client/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/client/simple_client/input.py b/client/simple_client/input.py
new file mode 100644
index 0000000..3c579c9
--- /dev/null
+++ b/client/simple_client/input.py
@@ -0,0 +1,63 @@
+import curses
+
+from client.client import Client
+
+
+class Input:
+    client: Client  # TOREWORK : Input needs at least a SimpleClient, but will result in a circular import error
+    listening: bool
+    prompt: str
+    prompt_cursor: int
+
+    def __init__(self, client):
+        self.valid_char = list('/. ')
+        self.client = client
+        self._reset_prompt()
+
+    def _reset_prompt(self):
+        self.prompt = ""
+        self.prompt_cursor = 0
+        self.prompt_updated()
+
+    def start_listening(self):
+        self.listening = True
+        self.prompt = ""
+        while self.listening:
+            char: int = self.client.display.stdscr.getch()
+
+            if char == -1:
+                pass
+            else:
+                if char == 0xa:  # Enter key
+                    try:
+                        self.client.command(self.prompt)
+                    except Exception as e:
+                        self.client.display.display_log(str(e))
+                    finally:
+                        self._reset_prompt()
+
+                elif char == curses.KEY_LEFT:
+                    self.prompt_cursor -= 1
+                    if self.prompt_cursor < 0:
+                        self.prompt_cursor = 0
+
+                elif char == curses.KEY_RIGHT:
+                    self.prompt_cursor += 1
+                    if self.prompt_cursor > len(self.prompt):
+                        self.prompt_cursor = len(self.prompt)
+
+                elif char == 8:  # Del key
+                    self.prompt = self.prompt[:self.prompt_cursor-1] + self.prompt[self.prompt_cursor:]
+                    self.prompt_cursor -= 1
+
+                elif char == curses.KEY_DC:
+                    self.prompt = self.prompt[:self.prompt_cursor] + self.prompt[self.prompt_cursor+1:]
+
+                else:
+                    self.prompt = self.prompt[:self.prompt_cursor] + chr(char) + self.prompt[self.prompt_cursor:]
+                    self.prompt_cursor += 1
+
+            self.prompt_updated()
+
+    def prompt_updated(self):
+        self.client.display.update_prompt(self.prompt, self.prompt_cursor)
diff --git a/client/simple_client/simple_client.py b/client/simple_client/simple_client.py
new file mode 100644
index 0000000..8795c63
--- /dev/null
+++ b/client/simple_client/simple_client.py
@@ -0,0 +1,267 @@
+from threading import Thread
+
+from client.client import Client
+from client.simple_client.simple_client_connection_state import Server, ConnectionState
+from misc.hex_enumerator import bytes_to_str, bytes_to_int, str_to_bytes
+from models.identity import Identity
+from models.message import Message
+from models.packet import Packet, PacketCode
+
+from connection.fake_server import FakeConnection
+
+from display.display import Display
+from display.simple_curses import SimpleCurses
+
+from client.simple_client.input import Input
+from exceptions.exceptions import MalformedPacketException, UnknownRecipient
+from models.room import RoomState, Room
+
+
+class SimpleClient(Client):
+    """
+    SimpleClient is a basic implementation of Eth3r.
+    It works with a Display to output message and input prompt
+    It works along a Server, which handle a connection and the state of Eth3r's connection
+    """
+    display: Display  # TOREWORK : SimpleClient require at least Simple Curses but
+    server: Server
+    input: Input
+
+    # Mapping Id to Room (/!\ this is a weird way to handle room and may lead to many confusions. Will be improved as
+    # eth3r improves its room system)
+    rooms: dict[Identity, Room]
+
+    contactsByName: dict[str, int]  # Map contacts name to their key_id
+    contactsByKey: dict[int, Identity]  # Map key_id to Identity
+
+    serverThread: Thread
+    intputThread: Thread
+
+    def __init__(self, identity: Identity, name: str = "DIOXANE"):
+        super().__init__(identity, name)
+
+        self.display = SimpleCurses(self)
+
+        # Start the server
+        self.server = Server(FakeConnection(), self)
+        self.server.connection.attach(self)
+        self.serverThread = Thread(target=self.server.connection.start_listening, daemon=True)
+        self.serverThread.start()
+
+        # Start the input thread
+        self.input = Input(self)
+        self.intputThread = Thread(target=self.input.start_listening)
+        self.intputThread.start()
+
+        self.rooms = {}
+        self.room_ids = {}
+        self.contactsByName = {}
+        self.contactsByKey = {}
+
+    def send_pck(self, pck: bytearray):
+        self.server.connection.send(pck)
+
+    def receive_pck(self, pck: bytearray):
+        self.display.display_debug("Received " + bytes_to_str(pck))
+        try:
+            if bytes_to_int(pck) == 0x0:
+                self._exit(0)
+
+            self.interpret(Packet(pck))
+        except MalformedPacketException as e:
+            self.display.display_error(str(e))
+        except NotImplementedError as e:
+            self.display.display_error(str(e))
+        except BaseException as e:
+            self.display.display_error(f"Unexpected error while reading {bytes_to_str(pck)} : {e}")
+
+    def interpret(self, packet: Packet):
+        match packet.code:
+            case PacketCode.ACK:
+                self._match_ack_to_something(packet)
+            case PacketCode.KNOCK_RESPONSE:
+                accepted = packet.options[0] == b'1'
+                key_id_length, key_id = packet.options[1][0], packet.options[1][1:]
+                recipient = self.getIdentity(key_id)
+                if recipient not in self.rooms:
+                    return self.display.display_error(f"Recieving a {'positive' if accepted else 'negative'}"
+                                                      f" knocking response from {recipient}"
+                                                      f" but never asked them in the first place")
+
+                if self.rooms[recipient].state == RoomState.KNOCKING:
+                    self.display.display_debug(f'Server forwarded {recipient}\'s response to our knock but we never'
+                                               f'recieved ACK from the server itself. We won\'t mind and pretend it did')
+                    self.rooms[recipient].state = RoomState.KNOCKING_ACK
+
+                if self.rooms[recipient].state == RoomState.KNOCKING_ACK:
+                    self.rooms[recipient].state = RoomState.KNOCK_ACCEPTED if accepted else RoomState.KNOCK_REFUSED
+                else:
+                    return self.display.display_error(f"Recieving a {'positive' if accepted else 'negative'}"
+                                                      f" knocking response from {recipient}"
+                                                      f" but we were {self.rooms[recipient].state}")
+
+            case _:
+                self.display.display_error(f"{hex(packet.code)} reception not yet implemented")
+
+    def _match_ack_to_something(self, packet: Packet):
+        """
+        Find what is acknoledged by an ACK Packet. In fact, it will acknoledge the first task that was waiting for it.
+        Missing Packet can led to a missing acknoledgement and further ACK will be missunterpreted.
+        To fix in the eth3r protocol
+        :param packet: ACK Packet
+        """
+        if self.server.state == ConnectionState.CONNECTION_INITIALIZED_VERSION:
+            return self.send_key()
+
+        if self.server.state == ConnectionState.CONNECTION_INITIALIZED_KEY:
+            return self._validate_connection()
+
+        for room in self.rooms.values():
+            if room.state == RoomState.KNOCKING:
+                room.state = RoomState.KNOCKING_ACK
+                return self.display.display_debug("Knock ack by server")
+
+        self.display.display_debug(f"Received unexpected ACK : {packet}")
+
+    def connect(self):
+        """
+        Send a HEY package to the server
+        """
+        try:
+            self.display.display_log(f"Connecting as {self.identity}")
+            self.send_pck(self.server.get_hey_packet())
+            self.server.state = ConnectionState.CONNECTION_INITIALIZED_VERSION
+        except BaseException as e:
+            self.display.display_error(f"Can't connect to server : {str(e)}")
+
+    def send_key(self):
+        """
+        Send a Key package to the server
+        """
+        self.display.display_debug(f"Send my key : {bytes_to_str(self.identity.key)}")
+        self.send_pck(self.server.get_send_key_packet())
+        self.server.state = ConnectionState.CONNECTION_INITIALIZED_KEY
+
+    def _validate_connection(self):
+        """
+        Validate a connection to the server
+        """
+        self.display.display_success("Connected")
+        self.server.state = ConnectionState.CONNECTED
+
+    def knock(self, recipient: Identity):
+        """
+        Send a Knock to someone
+        :param recipient: Recipient to knock
+        """
+        self.display.display_log(f'Knocking {recipient}')
+        self.rooms[recipient] = Room(recipient)
+        self.rooms[recipient].state = RoomState.KNOCKING
+        self.send_pck(Packet(PacketCode.KNOCK_SEND, recipient.get_key_id_pair()))
+
+    def add_message_in_room(self, room_id: int, message: Message):
+        """
+        Display a message in a room
+        :param room_id: Room id
+        :param message: Message to display
+        """
+        """
+        NOT_TESTED
+        """
+        self.rooms[room_id].add_message(message)
+        self.display.display_message(message)
+
+    def send_message_in(self, room_id: int, payload: bytearray):
+        """
+        Send a message in a room
+        :param room_id: Room id
+        :param payload: payload
+        :return:
+        """
+        """
+        NOT_TESTED
+        """
+        if room_id not in self.rooms or self.rooms[room_id].state != RoomState.IN_ROOM:
+            self.display.display_error("Room isn't ready " + room_id)
+        else:
+            message: Message = Message(sender=self.identity, room=self.rooms[room_id], payload=payload, ack=False)
+            self.add_message_in_room(room_id, message)
+            self.server.connection.send(message.get_send_package())
+
+    def getIdentity(self, identity: str | bytearray) -> Identity:
+        """
+        Fetch the contact list for an Identity
+        :param identity: Name or key_id of the identity
+        :return: Identity
+        """
+        key_id: int = -1
+
+        if type(identity) is str:
+            # Trying by name
+            for name in self.contactsByName.keys():
+                if identity in name:
+                    return self.contactsByKey[self.contactsByName[name]]
+
+            if identity[0:2] == "0x":
+                key_id = int(identity[2:], 16)
+            else:
+                key_id = int(identity, 16)
+
+        if type(identity) is bytearray:
+            key_id = bytes_to_int(identity)
+
+        # Trying by key_id
+        try:
+            if key_id in self.contactsByKey:
+                return self.contactsByKey[key_id]
+        except ValueError as e:
+            pass
+
+        raise UnknownRecipient(identity)
+
+    def registerIdentity(self, identity: Identity):
+        """
+        Insert an Identity in the contact list
+        :param identity: Identity to register
+        """
+        self.contactsByKey[identity.key_id] = identity
+        self.contactsByName[identity.name] = identity.key_id
+
+    def command(self, text: str):
+        """
+        Execute a command
+        :param text: Command
+        """
+        options = text.split(" ")
+        command = options.pop(0)
+        self._command(command, options)
+
+    def _command(self, command: str, options: list[str]):
+        """
+        Execute a command
+        :param command: Command name
+        :param options: Options list
+        :return:
+        """
+        match command:
+            case 'knock':
+                try:
+                    self.knock(self.getIdentity(options[0]))
+                except UnknownRecipient as e:
+                    self.display.display_error("Unknown recipient : " + str(e))
+                except BaseException as e:
+                    self.display.display_error(e)
+
+            case 'echo':
+                self.display.display_message(' '.join(options))
+
+            case 'server':
+                self.server.connection.receive(b''.join(map(str_to_bytes, options)))
+
+            case _:
+                self.display.display_error("Unknown command")
+                self.display.display_log(command)
+
+    def _exit(self, code: int = 0):
+        self.display.exit()
+        super()._exit(code)
diff --git a/client/simple_client/simple_client_connection_state.py b/client/simple_client/simple_client_connection_state.py
new file mode 100644
index 0000000..c95fe62
--- /dev/null
+++ b/client/simple_client/simple_client_connection_state.py
@@ -0,0 +1,50 @@
+from enum import Enum, auto
+
+from client.client import Client
+from connection.connection import Connection
+from models.packet import Packet, PacketCode
+
+
+class ConnectionState(Enum):
+    DECONNECTED = auto()
+    CONNECTION_INITIALIZED_VERSION = auto()
+    CONNECTION_INITIALIZED_VERSION_ACK = auto()
+    CONNECTION_INITIALIZED_KEY = auto()
+    CONNECTION_INITIALIZED_KEY_ACK = auto()
+    CONNECTED = auto()
+
+
+class Server:
+    """
+    Server is a class that handle both the communication (over internet/other medium) and the state of the connection
+    to the Eth3r server (I.E. whereas the client is properly authentificated or waiting for the response)
+    """
+    connection: Connection  # A connection to operate over
+    state: ConnectionState  # The state of the connection with the Eth3r server
+    client: Client  # Reference back to the client
+    attempt: int  # Connection attempt NOT_YET_IMPLEMENTED
+    errors: list[str]  # List of error NOT_YET_IMPLEMENTED
+
+    def __init__(self, connection: Connection, client: Client):
+        """
+        Instantiate the Server, with a Deconnected state
+        :param connection: Connection
+        :param client: Client
+        """
+        self.connection = connection
+        self.client = client
+        self.state = ConnectionState.DECONNECTED
+
+    def get_hey_packet(self) -> Packet:
+        """
+        Build the Hey packet to connect the client to the server
+        :return: Hey Packet
+        """
+        return Packet(PacketCode.HEY, [self.client.ether_version.to_bytes(2, 'big')])
+
+    def get_send_key_packet(self):
+        """
+        Build the Key Packet
+        :return:
+        """
+        return Packet(PacketCode.SEND_KEY, self.client.identity.get_key_pair())
diff --git a/connection/__init__.py b/connection/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/connection/connection.py b/connection/connection.py
new file mode 100644
index 0000000..ad76d2e
--- /dev/null
+++ b/connection/connection.py
@@ -0,0 +1,45 @@
+from abc import ABC, abstractmethod
+
+from client.client import Client
+
+
+class Connection(ABC):
+    """
+    Abstract class that represent a way to connect to a server, send and receive packets.
+    It implements the Observer / Observable pattern
+    """
+    """
+    Remark: this class is a bit overkill, since we probably won't have multiple client listening to the same connection
+    """
+    _observers: list[Client]
+
+    def __init__(self):
+        self._observers = []
+
+    def attach(self, observer):
+        if observer not in self._observers:
+            self._observers.append(observer)
+
+    def detach(self, observer):
+        if observer in self._observers:
+            self._observers.remove(observer)
+
+    def _notify_observers(self, pck: bytearray):
+        for observer in self._observers:
+            observer.receive_pck(pck)
+
+    @abstractmethod
+    def start_listening(self):
+        """
+        Activate the connection and listen for incomming packet
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def send(self, pck: bytearray):
+        """
+        Send packet over the connection
+        :param pck: bytes to send
+        :return:
+        """
+        raise NotImplementedError
diff --git a/connection/fake_server.py b/connection/fake_server.py
new file mode 100644
index 0000000..91f597c
--- /dev/null
+++ b/connection/fake_server.py
@@ -0,0 +1,42 @@
+import time
+
+from connection.connection import Connection
+from misc.hex_enumerator import int_to_bytes
+from models.packet import Packet, PacketCode
+
+
+class FakeConnection(Connection):
+    """
+    FakeConnection is an implementation of Connection intended for debug purposes.
+    It won't actually connect to anything, and can be asked to send any packet.
+    It has a list of packets to send, and will send them over time (default delay is one every 2 sec)
+    It will reply to any packet recieved with an ACK (can be turned off during init)
+    """
+    _packets: list[bytearray]  # List of packet to send (FIFO)
+    _reply_with_ACK: int = 2  # Time in second between two packet
+    _delay: int = 2  # Time in second between two packet
+
+    def __init__(self):
+        self._packets = []
+        super().__init__()
+
+    def start_listening(self):
+        while True:
+            if len(self._packets) > 0:
+                self._notify_observers(self._packets.pop(0))
+            time.sleep(self._delay)
+
+    def send(self, pck: bytearray | Packet):
+        if type(pck) is Packet:
+            pck = pck.to_bytes()
+            # Supposely send them
+
+        if self._reply_with_ACK:
+            self.receive(int_to_bytes(PacketCode.ACK.value) + pck)
+
+    def receive(self, pck: bytearray):
+        """
+        Ask the FakeConnection to simulate receiving a packet
+        :param pck: Packet to receive
+        """
+        self._packets.append(pck)
diff --git a/crypto/__init__.py b/crypto/__init__.py
index e984f99..1b5c3fd 100644
--- a/crypto/__init__.py
+++ b/crypto/__init__.py
@@ -3,4 +3,3 @@
 #  - eTh3r network, 2023-2024
 #
 
-import crypto.gpg
diff --git a/crypto/gpg.py b/crypto/gpg.py
deleted file mode 100644
index 28e70fc..0000000
--- a/crypto/gpg.py
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# This file is part of the eTh3r project, written, hosted and distributed under MIT License
-#  - eTh3r network, 2023-2024
-#
-
-import gnupg
-
-gpg = gnupg.GPG()
-
-def getKey(key_id):
-    return gpg.export_keys(key_id, False, armor=False)
diff --git a/display/__init__.py b/display/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/display/display.py b/display/display.py
new file mode 100644
index 0000000..106f40b
--- /dev/null
+++ b/display/display.py
@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+
+from client.client import Client
+from models.message import Message
+
+
+class Display(ABC):
+    """
+    Abstract class to define the bases of a Display
+    It has to be able to display message and error/log/etc
+    It has to be able to display the prompt as it is typed
+    """
+    client: Client
+
+    def __init__(self, client: Client):
+        self.client = client
+
+    @abstractmethod
+    def update_prompt(self, prompt: str, cursor: int):
+        """
+        Display the prompt
+        :param prompt: prompt
+        :param cursor: position of the cursor, from 0 to len(prompt)
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def display_message(self, message: Message | str):
+        raise NotImplementedError
+
+    @abstractmethod
+    def display_error(self, text: str):
+        raise NotImplementedError
+
+    @abstractmethod
+    def display_log(self, text: str):
+        raise NotImplementedError
+
+    @abstractmethod
+    def display_debug(self, text: str):
+        raise NotImplementedError
+
+    @abstractmethod
+    def display_success(self, text: str):
+        raise NotImplementedError
+
+    @abstractmethod
+    def exit(self):
+        """
+        Close the display
+        """
+        raise NotImplementedError
diff --git a/display/simple_curses.py b/display/simple_curses.py
new file mode 100644
index 0000000..96c91ba
--- /dev/null
+++ b/display/simple_curses.py
@@ -0,0 +1,147 @@
+import curses
+from enum import IntEnum, auto
+
+from client.client import Client
+from display.display import Display
+from models.message import Message, MessageType
+
+
+class SimpleCursesColor(IntEnum):
+    CLASSIC = auto()
+    MESSAGE_SEND = auto()
+    MESSAGE_RECIEVE = auto()
+    SUCCESS = auto()
+    ERROR = auto()
+    DEBUG = auto()
+    LOG = auto()
+
+
+class SimpleCurses(Display):
+    """
+    
+    """
+    width: int
+    height: int
+    message_count: int = 1
+    prompt_cursor: int = 0
+
+    color_variation: dict[SimpleCursesColor]
+
+    def __init__(self, client: Client):
+        super().__init__(client)
+
+        self.stdscr = curses.initscr()
+        curses.noecho()
+        curses.cbreak()
+        if curses.has_colors():
+            curses.start_color()
+            curses.use_default_colors()
+            curses.init_pair(SimpleCursesColor.CLASSIC, curses.COLOR_WHITE, -1)
+            curses.init_pair(SimpleCursesColor.MESSAGE_SEND, curses.COLOR_BLUE, -1)
+            curses.init_pair(SimpleCursesColor.MESSAGE_RECIEVE, curses.COLOR_CYAN, -1)
+            curses.init_pair(SimpleCursesColor.SUCCESS, curses.COLOR_GREEN, -1)
+            curses.init_pair(SimpleCursesColor.ERROR, curses.COLOR_RED, -1)
+            curses.init_pair(SimpleCursesColor.DEBUG, curses.COLOR_YELLOW, -1)
+            curses.init_pair(SimpleCursesColor.LOG, curses.COLOR_WHITE, -1)
+        self.color_variation = {SimpleCursesColor.CLASSIC: 0, SimpleCursesColor.MESSAGE_SEND: 0,
+                                SimpleCursesColor.MESSAGE_RECIEVE: 0, SimpleCursesColor.SUCCESS: curses.A_BOLD,
+                                SimpleCursesColor.DEBUG: 0, SimpleCursesColor.ERROR: curses.A_BOLD,
+                                SimpleCursesColor.LOG: curses.A_ITALIC}
+
+        self.stdscr.keypad(True)
+        # self.stdscr.leaveok(True)
+        self.width = curses.COLS
+        self.height = curses.LINES
+
+        self._display_box()
+
+    def _display_line(self, height: int = 0, left_txt: str = "", middle_txt: str = "", right_txt: str = "",
+                      space_between: bool = True, fillingchar: str = "="):
+        first_half: int = int(self.width / 2) - int(len(middle_txt) / 2) - len(left_txt) - (2 if space_between else 0)
+        second_half: int = self.width - len(left_txt + middle_txt + right_txt) - (4 if space_between else 0) \
+                           - first_half - 1
+
+        self.stdscr.addstr(height, 0, left_txt + (" " if space_between else "")
+                           + fillingchar * first_half + (" " if space_between else "")
+                           + middle_txt + (" " if space_between else "")
+                           + fillingchar * second_half + (" " if space_between else "")
+                           + right_txt)
+        self._update_cursor()
+        self.stdscr.refresh()
+
+
+    def _display_box(self):
+        self._display_line(height=0, middle_txt=self.client.name, right_txt=self.client.version)
+        self._display_line(height=self.height - 1, left_txt="> ", fillingchar=" ")
+
+    def update_prompt(self, prompt: str, cursor: int):
+        self.prompt_cursor = cursor
+        self._display_line(height=self.height - 1, left_txt="> " + prompt, fillingchar=" ")
+        self._update_cursor()
+
+    def _display(self, text: str, color: SimpleCursesColor):
+        self.stdscr.addstr(self.message_count, 0, text, curses.color_pair(color) | self.color_variation[color])
+        self.message_count += 1
+        self._update_cursor()
+        self.stdscr.refresh()
+
+    def display_message(self, message: Message | str):
+        if type(message) is str:
+            return self.display_message(Message(payload=message, message_type=MessageType.LOG))
+
+        header = ""
+        color = SimpleCursesColor.CLASSIC
+
+        if message.message_type == MessageType.ERROR:
+            header = f"/!\\ "
+            color = SimpleCursesColor.ERROR
+
+        if message.message_type == MessageType.LOG:
+            header = f"- "
+            color = SimpleCursesColor.LOG
+
+        if message.message_type == MessageType.DEBUG:
+            header = f"~ "
+            color = SimpleCursesColor.DEBUG
+
+        if message.message_type == MessageType.SUCCESS:
+            header = f"[✔] "
+            color = SimpleCursesColor.SUCCESS
+
+        if message.message_type == MessageType.SENT:
+            header = f"[{message.recipient}] "
+            color = SimpleCursesColor.MESSAGE_SEND
+
+        if message.message_type == MessageType.RECEIVE:
+            if message.sender:
+                header = f"[{message.sender}] "
+            elif message.room:
+                header = f"[{message.room}]"
+            color = SimpleCursesColor.MESSAGE_RECIEVE
+
+        self._display(header + bytes.fromhex(hex(message.payload)[2:]).decode('utf-8'), color)
+
+    def display_error(self, text: str):
+        return self.display_message(Message(payload=text, message_type=MessageType.ERROR))
+
+    def display_log(self, text: str):
+        return self.display_message(Message(payload=text, message_type=MessageType.LOG))
+
+    def display_debug(self, text: str):
+        return self.display_message(Message(payload=text, message_type=MessageType.DEBUG))
+
+    def display_success(self, text: str):
+        return self.display_message(Message(payload=text, message_type=MessageType.SUCCESS))
+
+    def _update_cursor(self, y=None, x=None):
+        if y is None:
+            y = self.height - 1
+        if x is None:
+            x = self.prompt_cursor + 2
+        self.stdscr.move(y, x)
+
+    def exit(self):
+        curses.nocbreak()
+        curses.echo()
+        self.stdscr.keypad(False)
+        curses.endwin()
diff --git a/ether/__init__.py b/ether/__init__.py
deleted file mode 100644
index ceee5a8..0000000
--- a/ether/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-#
-# This file is part of the eTh3r project, written, hosted and distributed under MIT License
-#  - eTh3r network, 2023-2024
-#
-
-import ether.protocol
diff --git a/ether/protocol.py b/ether/protocol.py
deleted file mode 100644
index 55fb358..0000000
--- a/ether/protocol.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#
-# This file is part of the eTh3r project, written, hosted and distributed under MIT License
-#  - eTh3r network, 2023-2024
-#
-
-import socket
-from stuct import pack
-
-ACK = 0xa0
-
-class Client():
-    def __init__(self, ip, port=2142):
-        self.dest = ip
-        self.port = port
-
-        self.bind = None
-        self.vers = 0x0001
-        self.pub = None
-
-    def setPub(self, pub):
-        if type(pub) != bytes:
-            print("FATAL! Pub key must be bytes")
-            return 1
-
-        if len(pub) > 65535:
-            print("FATAL! Pub key length must be smaller than 65535")
-            return 2
-
-        self.pub = pub
-        return 0
-
-    def _connect(self):
-        try:
-            self.bind = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            self.bind.connect((ip, port))
-        except e:
-            print("FATAL! Can't connect to server:" + str(e))
-            return 1
-
-        return 0 
-
-    def _send_vers(self):
-        try:
-            self.bind.send((0x0531b00b << 16) + self.vers)
-
-            resp = self.bind.recv(1)
-
-            if resp != ACK:
-                print("FATAL! Received " + str(hex(resp)) + " from server")
-                return 2
-        except e:
-            print("FATAL! Can't send version: " + str(e))
-            return 1
-
-        return 0
-
-    def _send_key(self):
-        try:
-            pckt = pack("ii", 0x0e1f, len(self.pub))
-            pckt += self.pub
-
-            self.bind.send(pckt)
-
-            resp = self.bind.recv(1)
-
-            if resp != ACK:
-                print("FATAL! Received " + str(hex(resp)) + " from server")
-                return 2
-        except e:
-            print("FATAL! Can't send key: " + str(e))
-            return 1
-
-        return 0
-
-
-    def connect(self):
-        res = self._connect()
-
-        if res != 0:
-            return
-
-        res = self._send_vers()
-
-        if res != 0:
-            return
-
-        if self.pub is None:
-            print("FATAL! No key provided")
-            return
-
-        res = self._send_key()
-
-        if res != 0:
-            return
diff --git a/exceptions/__init__.py b/exceptions/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/exceptions/exceptions.py b/exceptions/exceptions.py
new file mode 100644
index 0000000..2323011
--- /dev/null
+++ b/exceptions/exceptions.py
@@ -0,0 +1,14 @@
+class EndOfEnumerator(BaseException):
+    pass
+
+
+class MalformedPacketException(BaseException):
+    pass
+
+
+class UnknownRecipient(BaseException):
+    pass
+
+
+class MalformedMessageException(Exception):
+    pass
diff --git a/identity_provider/__init__.py b/identity_provider/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/identity_provider/gpg.py b/identity_provider/gpg.py
new file mode 100644
index 0000000..facff11
--- /dev/null
+++ b/identity_provider/gpg.py
@@ -0,0 +1,25 @@
+#
+# This file is part of the eTh3r project, written, hosted and distributed under MIT License
+#  - eTh3r network, 2023-2024
+#
+
+import gnupg
+
+from identity_provider.identity_provider import IdentityProvider
+from models.identity import Identity
+
+gpg = gnupg.GPG()
+
+# UNTESTED
+class GPGKeyProvider(IdentityProvider):
+    @staticmethod
+    def getIdentity(identity: str) -> Identity:
+        # TODO : This is only the backbone of GPG Key Provider
+        # It hasn't been verified and may not even work
+        key = gpg.export_keys(identity, False, armor=False)
+        key_id = int(f"0x1312") # Todo : use gpg to get key_id
+        return Identity(name=identity,
+                        key_length=len(hex(key))-2,
+                        key=hex(key),
+                        key_id_length=len(hex(key_id))-2,
+                        key_id=hex(key_id))
diff --git a/identity_provider/identity_provider.py b/identity_provider/identity_provider.py
new file mode 100644
index 0000000..f61c957
--- /dev/null
+++ b/identity_provider/identity_provider.py
@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+from models.identity import Identity
+
+
+class IdentityProvider(ABC):
+    @staticmethod
+    @abstractmethod
+    def getIdentity(identity: str) -> Identity:
+        pass
diff --git a/identity_provider/simple_key.py b/identity_provider/simple_key.py
new file mode 100644
index 0000000..f9dce68
--- /dev/null
+++ b/identity_provider/simple_key.py
@@ -0,0 +1,16 @@
+from identity_provider.identity_provider import IdentityProvider
+from models.identity import Identity
+
+
+class SimpleKeyProvider(IdentityProvider):
+    @staticmethod
+    def getIdentity(identity: str) -> Identity:
+        return Identity(name=identity,
+                        key_length=4,
+                        key=int(f"0x1312{identity}"),
+                        key_id_length=2,
+                        key_id=int(f"0x{identity}"))
+
+
+baba: Identity = SimpleKeyProvider.getIdentity("baba")
+fefe: Identity = SimpleKeyProvider.getIdentity("fefe")
\ No newline at end of file
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..f3e72fe
--- /dev/null
+++ b/main.py
@@ -0,0 +1,13 @@
+from client.simple_client.simple_client import SimpleClient
+from models.identity import Identity
+
+if __name__ == '__main__':
+    me: Identity = Identity(name="Amus", key_id_length=2, key_id=0x1312, key_length=4, key=0x1312b00b)
+
+    baophes: Identity = Identity(2, 0x964d, name="Baophes")
+    cysalia: Identity = Identity(2, 0xa156, name="Cysalia")
+
+    client = SimpleClient(me, "DIOXANE")
+    client.connect()
+    client.registerIdentity(baophes)
+    client.registerIdentity(cysalia)
diff --git a/misc/__init__.py b/misc/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/misc/hex_enumerator.py b/misc/hex_enumerator.py
new file mode 100644
index 0000000..1fedb74
--- /dev/null
+++ b/misc/hex_enumerator.py
@@ -0,0 +1,68 @@
+from exceptions.exceptions import EndOfEnumerator
+
+
+def int_to_bytes(value: int) -> bytearray:
+    """
+    Cast an int into a bytearray
+    :param value:
+    :return:
+    """
+    hexstr = hex(value)
+    if len(hexstr) % 2 == 1:
+        hexstr = "0x0" + hexstr[2:]
+    return str_to_bytes(hexstr)
+
+
+def bytes_to_int(value: bytearray) -> int:
+    """
+    Cast a byte array into int
+    :param value: Byte array
+    :return: Int
+    """
+    return int.from_bytes(value, 'big')
+
+
+def str_to_bytes(value: str) -> bytearray:
+    """
+    Cast a hex string into a bytearray
+    :param value: String containing hex digits, starting with "0x" or not
+    :return: Byte array
+    """
+    if value[0:2] == '0x':
+        return bytearray.fromhex(value[2:])
+    else:
+        return bytearray.fromhex(value)
+
+
+def bytes_to_str(value: bytearray) -> str:
+    """
+    Cast a bytearray into a hex string
+    :param value: Byte array
+    :return: String formated as 0x....
+    """
+    return hex(int.from_bytes(value, 'big'))
+
+
+def _read_bytes(bytesEnumerator: enumerate, size: int | bytearray = 1, value: bytearray = bytearray(0)) -> bytearray:
+    """
+    Read bytes from an enumerator and return them as a bytearray
+    :param bytesEnumerator: enumerator
+    :param size: how many bytes to read from
+    :param value: precedent bytes to add in the bytearray returned (before the read bytes)
+    :return: Byte array
+    """
+    if type(size) == bytearray:
+        size = bytes_to_int(size)
+
+    _value = value.copy()
+
+    for i in range(size):
+
+        pos, nextByte = next(bytesEnumerator, (None, None))
+
+        if nextByte is None:
+            raise EndOfEnumerator
+
+        _value.append(nextByte)
+
+    return _value
diff --git a/models/__init__.py b/models/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/models/identity.py b/models/identity.py
new file mode 100644
index 0000000..8a42c3b
--- /dev/null
+++ b/models/identity.py
@@ -0,0 +1,54 @@
+from misc.hex_enumerator import bytes_to_str, int_to_bytes
+
+
+class Identity:
+    """
+    Hold the information about a key pair
+    """
+    name: str
+    key: bytearray
+    key_length: int
+    key_id: bytearray
+    key_id_length: int
+
+    def __init__(self, key_id_length: int, key_id: int | bytearray,
+                 key_length: int = None, key: int | bytearray = None,
+                 name: str = None):
+        if type(key_id) == int:
+            key_id = key_id.to_bytes(key_id_length, 'big')
+        if type(key) == int:
+            key = key.to_bytes(key_length, 'big')
+
+        self.name = name or bytes_to_str(key_id)
+        self.key = key
+        self.key_length = key_length
+        self.key_id = key_id
+        self.key_id_length = key_id_length
+
+    def set_key(self, length: int, key: int):
+        self.key_length = length
+        self.key = key
+
+    def get_key_bytes(self):
+        return int_to_bytes(self.key_length).append(self.key)
+
+    def get_key_pair(self) -> list[bytearray]:
+        return [int_to_bytes(self.key_length), self.key]
+
+    def get_key_id_bytes(self):
+        return int_to_bytes(self.key_id_length).append(self.key_id)
+
+    def get_key_id_pair(self) -> list[bytearray]:
+        return [int_to_bytes(self.key_id_length), self.key_id]
+
+    def __repr__(self):
+        if self.key is None:
+            return f"[{self.name} : {bytes_to_str(self.key_id)} -> ???]"
+        else:
+            return f"[{self.name} : {bytes_to_str(self.key_id)} -> {bytes_to_str(self.key)}]"
+
+    def __str__(self):
+        return self.name
+
+    def __hash__(self):
+        return hash(self.key_id)
diff --git a/models/message.py b/models/message.py
new file mode 100644
index 0000000..c341834
--- /dev/null
+++ b/models/message.py
@@ -0,0 +1,51 @@
+from enum import Enum, auto
+
+from models.identity import Identity
+from models.packet import Packet, PacketCode
+
+
+class MessageType(Enum):
+    SENT = auto()
+    RECEIVE = auto()
+    SUCCESS = auto()
+    LOG = auto()
+    DEBUG = auto()
+    ERROR = auto()
+
+
+class Message:
+    """
+    Generic class to define a Message structure
+    It must contains a payload
+    It can have a sender, a recipient or a room
+    """
+    payload: bytearray  # Content of the message
+    sender: Identity  # Sender
+    recipient: Identity  # Recipient
+    room: "Room"  # Room where it was sent/recieved
+    ack: bool  # Was it ACK by the server (for sent message)
+    message_type: MessageType  # Type
+
+    def __init__(self, payload: bytearray | str, sender: Identity = None, recipient: Identity = None,
+                 room: "Room" = None, ack: bool = True, message_type: MessageType = None):
+        """
+        Create a message, whome payload can be define by a bytearray or a str (will be cast in ascii bytesarray)
+        :param payload: Byte array or string
+        :param sender: Sender
+        :param recipient: Recipient
+        :param room: Room
+        :param ack: ACK by the server (Default is True)
+        :param message_type: Type
+        """
+        if type(payload) is str:
+            payload = bytearray(payload.encode())
+
+        self.payload = payload
+        self.sender = sender
+        self.recipient = recipient
+        self.room = room
+        self.ack = ack
+        self.message_type = message_type
+
+    def get_send_package(self):
+        return Packet(PacketCode.MESSAGE_SEND, self.recipient.get_key_id_pair().append(self.payload))
diff --git a/models/packet.py b/models/packet.py
new file mode 100644
index 0000000..598ba4f
--- /dev/null
+++ b/models/packet.py
@@ -0,0 +1,154 @@
+from enum import IntEnum
+
+from exceptions.exceptions import MalformedPacketException, EndOfEnumerator
+from misc.hex_enumerator import _read_bytes, int_to_bytes, str_to_bytes, bytes_to_str, bytes_to_int
+
+
+class PacketCode(IntEnum):
+    HEY = 0x0531b00b
+    ACK = 0xa0
+    SEND_KEY = 0x0e1f
+
+    KNOCK_SEND = 0xee
+    KNOCK_RECIEVE = 0xae
+    KNOCK_RESPONSE = 0xab
+    ROOM_NEW = 0xac
+    ROOM_CLOSE = 0xaf
+
+    KEY_REQUEST = 0xba
+    KEY_RESPONSE = 0xa0ba
+    KEY_UNKNOWN = 0xca
+
+    MESSAGE_SEND = 0xda
+
+    ERR_WRONG_PACKET_LENGTH = 0xa1
+    ERR_WRONG_PACKET_ID = 0xa2
+    ERR_UNSUPPORTED_VERSION = 0xa4
+    ERR_INCOMPLETE_KEY = 0xaa
+    ERR_KEY_MALFORMED = 0xab
+    ERR_KEY_PAYLOAD_MALFORMED = 0xac
+    ERR_MALFORMATION = 0xba
+    ERR_OUT_OF_PATH = 0xe0
+    ERR_UNKNOWN_PACKET_ID = 0xfd
+    ERR_NOT_IMPLEMENTED = 0xfe
+    ERR_FAULTY_READING = 0xff
+
+
+class Packet:
+    """
+    Eth3r Packet
+    """
+    code: PacketCode
+    options: list[bytearray]
+
+    def __init__(self, payload: bytearray | bytes | int | str | PacketCode, options: list[bytearray] = []):
+
+        self.options = options.copy()
+        bytesEnumerator: enumerate
+
+        if type(payload) is PacketCode:
+            self.code = payload
+
+        if type(payload) is int:
+            try:
+                payload = int_to_bytes(payload)
+            except ValueError:
+                raise MalformedPacketException("Non-hexadecimal number in payload")
+
+        if type(payload) is str:
+            try:
+                payload = str_to_bytes(payload)
+            except ValueError:
+                raise MalformedPacketException("Non-hexadecimal number in payload")
+
+        if type(payload) is bytearray or type(payload) is bytes:
+            bytesEnumerator = enumerate(payload)
+            self._set_code_from_enumerator(bytesEnumerator)
+            try:
+                self._set_options_from_enumerator(bytesEnumerator)
+            except EndOfEnumerator:
+                raise MalformedPacketException("Packet options doesn't match expected size of "
+                                               + self.code.name + " : " + bytes_to_str(payload))
+
+
+    def _set_code_from_enumerator(self, bytesEnumerator):
+        code = bytearray(b'')
+        while bytes_to_int(code) not in PacketCode.value2member_map_:
+            try:
+                code = _read_bytes(bytesEnumerator, 1, code)
+            except EndOfEnumerator:
+                raise MalformedPacketException("PacketCode doesn't correspond to an implemented code : "
+                                               + bytes_to_str(code))
+        self.code = PacketCode(bytes_to_int(code))
+
+    def _set_options_from_enumerator(self, bytesEnumerator):
+        match self.code:
+            case PacketCode.HEY:
+                self.options += _read_bytes(bytesEnumerator, 2)
+
+            case PacketCode.ACK:
+                try:
+                    nextByte = _read_bytes(bytesEnumerator)
+
+                    # An KEY_RESPONSE PacketCode can be confused with an ACK as they both start with 0xa0
+                    # Thus ACK followed by 0xba are converted into a simple KEY_RESPONSE
+                    if nextByte == int_to_bytes(0xba):
+                        self.code = PacketCode.KEY_RESPONSE
+                    else:
+                        while True:
+                            try:
+                                nextByte = _read_bytes(bytesEnumerator, 1, value=nextByte)
+                            except EndOfEnumerator:
+                                break
+                        self.options.append(nextByte)
+                except EndOfEnumerator:
+                    pass
+
+            case PacketCode.SEND_KEY | PacketCode.KEY_RESPONSE:
+                key_length = _read_bytes(bytesEnumerator, 2)
+                self.options += [key_length, _read_bytes(bytesEnumerator, key_length)]
+
+            case PacketCode.KNOCK_SEND | PacketCode.KNOCK_RECIEVE | PacketCode.ROOM_CLOSE | PacketCode.KEY_REQUEST \
+                 | PacketCode.KEY_UNKNOWN:
+                key_length = _read_bytes(bytesEnumerator, 1)
+                self.options += [key_length, _read_bytes(bytesEnumerator, key_length)]
+
+            case PacketCode.KNOCK_RESPONSE:
+                response = _read_bytes(bytesEnumerator, 1)
+                key_length = _read_bytes(bytesEnumerator, 1)
+                self.options += [response, key_length, _read_bytes(bytesEnumerator, key_length)]
+
+            case PacketCode.ROOM_NEW:
+                room_length = _read_bytes(bytesEnumerator, 1)
+                room_id = _read_bytes(bytesEnumerator, room_length)
+
+                key_length = _read_bytes(bytesEnumerator, 1)
+                key_id = _read_bytes(bytesEnumerator, key_length)
+
+                self.options += [room_length, room_id, key_length, key_id]
+
+            case PacketCode.MESSAGE_SEND:
+                raise NotImplementedError(f"Package {self.code} is not yet implemented")
+
+            # Error
+            case PacketCode.ERR_WRONG_PACKET_LENGTH | PacketCode.ERR_WRONG_PACKET_ID | \
+                 PacketCode.ERR_UNSUPPORTED_VERSION | PacketCode.ERR_INCOMPLETE_KEY | PacketCode.ERR_KEY_MALFORMED | \
+                 PacketCode.ERR_KEY_PAYLOAD_MALFORMED | PacketCode.ERR_MALFORMATION | PacketCode.ERR_OUT_OF_PATH | \
+                 PacketCode.ERR_UNKNOWN_PACKET_ID | PacketCode.ERR_NOT_IMPLEMENTED | PacketCode.ERR_FAULTY_READING:
+                raise NotImplementedError(f"Package {self.code} is not yet implemented")
+
+    def to_bytes(self):
+        return int_to_bytes(self.code) + b"".join(self.options)
+
+    def __str__(self):
+        return "<Packet " + self.code.name + " " + " ".join(list(map(hex, self.options))) + ">"
+
+
+# packet: Packet = Packet(0x123456)
+# packet_HEY: Packet = Packet("0x0531b00b a001")
+# packet_ACK: Packet = Packet("0xa0")
+# packet_KEY_REQUEST: Packet = Packet("0xba 02 baba")
+# packet_KEY_REQUEST2: Packet = Packet("0xba 04 baba202")
+# packet_ROOM_NEW: Packet = Packet("0xac 02cafe 02baba")
+
+# packet_TESt: Packet = Packet(PacketCode.SEND_KEY, me.get_key_pair())
diff --git a/models/room.py b/models/room.py
new file mode 100644
index 0000000..faadda4
--- /dev/null
+++ b/models/room.py
@@ -0,0 +1,44 @@
+from enum import Enum, auto
+
+from models.identity import Identity
+from models.message import Message, MessageType
+
+
+class RoomState(Enum):
+    INEXISTANT = auto()
+    KNOCKING = auto()
+    KNOCKING_ACK = auto()
+    KNOCK_ACCEPTED = auto()
+    KNOCK_REFUSED = auto()
+    IN_ROOM = auto()
+    ROOM_CLOSED = auto()
+
+
+class Room:
+    """
+    Basic class to keep track of the state of a Room
+    """
+    name: str  # Client side name, doesn't interfer with Eth3r
+    state: RoomState  # State of the room
+    # Recipient of the room has to be saved client side so we can know afterward who is talking in the room
+    recipient: Identity
+    messages: list[Message]  # List of message in the room
+
+    def __init__(self, recipient: Identity):
+        self.recipient = recipient
+        self.name = str(recipient)
+        self.state = RoomState.INEXISTANT
+        self.messages = []
+
+    def add_message(self, message: Message):
+        """
+        Add message in the room
+        :param message: Message
+        """
+        if message.type is None:
+            if message.recipient == self.recipient:
+                message.type = MessageType.SENT
+            if message.sender == self.recipient:
+                message.type = MessageType.RECEIVE
+
+        self.messages.append(message)

From 4fb4108f2cef37a5aeaabf97d5d5b2005e462442 Mon Sep 17 00:00:00 2001
From: Portevent <porte@magous.fr>
Date: Sun, 17 Mar 2024 14:23:37 +0100
Subject: [PATCH 07/11] feat : Add PudCurses, an alternative to SimpleCurses
 which implement scrolling

---
 client/simple_client/input.py         | 14 +++-
 client/simple_client/simple_client.py |  3 +-
 display/pad_curses.py                 | 86 ++++++++++++++++++++++++
 display/simple_curses.py              | 95 ++++++++++++++++++---------
 4 files changed, 166 insertions(+), 32 deletions(-)
 create mode 100644 display/pad_curses.py

diff --git a/client/simple_client/input.py b/client/simple_client/input.py
index 3c579c9..de9864b 100644
--- a/client/simple_client/input.py
+++ b/client/simple_client/input.py
@@ -23,7 +23,7 @@ def start_listening(self):
         self.listening = True
         self.prompt = ""
         while self.listening:
-            char: int = self.client.display.stdscr.getch()
+            char: int = self.client.display.input_windows.getch()
 
             if char == -1:
                 pass
@@ -46,6 +46,18 @@ def start_listening(self):
                     if self.prompt_cursor > len(self.prompt):
                         self.prompt_cursor = len(self.prompt)
 
+                elif char == curses.KEY_UP:
+                    self.client.display.scroll(-1)
+
+                elif char == curses.KEY_DOWN:
+                    self.client.display.scroll(1)
+
+                elif char == curses.KEY_SR:
+                    self.client.display.scroll(-1)
+
+                elif char == curses.KEY_SF:
+                    self.client.display.scroll(1)
+
                 elif char == 8:  # Del key
                     self.prompt = self.prompt[:self.prompt_cursor-1] + self.prompt[self.prompt_cursor:]
                     self.prompt_cursor -= 1
diff --git a/client/simple_client/simple_client.py b/client/simple_client/simple_client.py
index 8795c63..55ade42 100644
--- a/client/simple_client/simple_client.py
+++ b/client/simple_client/simple_client.py
@@ -2,6 +2,7 @@
 
 from client.client import Client
 from client.simple_client.simple_client_connection_state import Server, ConnectionState
+from display.pad_curses import PadCurses
 from misc.hex_enumerator import bytes_to_str, bytes_to_int, str_to_bytes
 from models.identity import Identity
 from models.message import Message
@@ -40,7 +41,7 @@ class SimpleClient(Client):
     def __init__(self, identity: Identity, name: str = "DIOXANE"):
         super().__init__(identity, name)
 
-        self.display = SimpleCurses(self)
+        self.display = PadCurses(self)
 
         # Start the server
         self.server = Server(FakeConnection(), self)
diff --git a/display/pad_curses.py b/display/pad_curses.py
new file mode 100644
index 0000000..72642ed
--- /dev/null
+++ b/display/pad_curses.py
@@ -0,0 +1,86 @@
+import curses
+
+from client.client import Client
+from display.simple_curses import SimpleCurses, SimpleCursesColor
+from models.message import Message, MessageType
+
+
+class PadCurses(SimpleCurses):
+    """
+    Technical improvement to Simple Curses to use pad.
+    This allows scrolling
+    """
+    message_pad_height: int = 100
+    message_pad: "_CursesWindow" = None
+    prompt_windows: "_CursesWindow" = None
+    header_windows: "_CursesWindow" = None
+    windows_scroll: int = 0
+    windows_scroll_jump: bool = False
+
+    def __init__(self, client: Client):
+        super().__init__(client)
+        self.message_pad = curses.newpad(self.message_pad_height, self.width)
+        # self.stdscr.border('│', '│', '─', '─', '┌', '┐', '└', '┘')
+        self.header_windows = curses.newwin(1, self.width, 0, 0)
+        self.prompt_windows = curses.newwin(1, self.width, self.height - 1, 0)
+        self.prompt_windows.keypad(True)
+        self.prompt_windows.nodelay(True)
+        self.input_windows = self.prompt_windows
+        self._display_base_gui()
+
+    def _display_all_messages(self):
+        self.message_pad.clear()
+        i: int = 0
+        for message in self.messages:
+            self._display_message(message, i)
+            i += 1
+
+    def _display(self, text: str, height: int, color: SimpleCursesColor):
+        self.message_pad.addstr(height, 0, text, curses.color_pair(color) | self.color_variation[color])
+        self._update_cursor()
+        self._update_scroll()
+
+    def scroll(self, scroll_delta: int = 0):
+        if scroll_delta != 0:
+            self.windows_scroll = max(min(0, len(self.messages)), self.windows_scroll + scroll_delta)
+        self._update_scroll()
+
+    def _update_scroll(self):
+        self.message_pad.noutrefresh(self.windows_scroll, 0, 1, 0, self.height - 2, self.width - 1)
+        curses.doupdate()
+
+    def _display_base_gui(self):
+        """
+        Display the client base GUI
+        """
+        if self.header_windows is None:
+            return
+        self._display_line(height=0, middle_txt=self.client.name, right_txt=self.client.version,
+                           windows=self.header_windows)
+        self._display_all_messages()
+        self._display_line(height=0, left_txt="> ", fillingchar=" ", windows=self.prompt_windows)
+
+    def update_prompt(self, prompt: str, cursor: int):
+        self.prompt_cursor = cursor
+        self._display_line(height=0, left_txt="> " + prompt, fillingchar=" ", windows=self.prompt_windows)
+        self._update_cursor()
+
+    def display_message(self, message: Message | str):
+        if type(message) is str:
+            return self.display_message(Message(payload=message, message_type=MessageType.LOG))
+
+        self.messages.append(message)
+        if self.windows_scroll_jump or self.windows_scroll + 1 == len(self.messages) - (self.height - 2):
+            self.windows_scroll = max(0, len(self.messages) - (self.height - 2))
+
+        if len(self.messages) > self.message_pad_height:
+            self.messages = self.messages[self.message_pad_height - self.height:self.message_pad_height]
+            self.windows_scroll -= self.message_pad_height - self.height
+            self._display_all_messages()
+        else:
+            self._display_message(message, len(self.messages) - 1)
+
+    def _update_cursor(self, y=0, x=None):
+        if x is None:
+            x = self.prompt_cursor + 2
+        self.prompt_windows.move(y, x)
diff --git a/display/simple_curses.py b/display/simple_curses.py
index 96c91ba..0e2c18a 100644
--- a/display/simple_curses.py
+++ b/display/simple_curses.py
@@ -27,10 +27,14 @@ class SimpleCurses(Display):
 
     color_variation: dict[SimpleCursesColor]
 
+    messages: list[Message]
+    input_windows: "_CursesWindow"
+
     def __init__(self, client: Client):
         super().__init__(client)
 
         self.stdscr = curses.initscr()
+        self.input_windows = self.stdscr
         curses.noecho()
         curses.cbreak()
         if curses.has_colors():
@@ -52,42 +56,51 @@ def __init__(self, client: Client):
         # self.stdscr.leaveok(True)
         self.width = curses.COLS
         self.height = curses.LINES
+        self.messages = []
+        self.message_pad = curses.newpad(self.width, 100)
 
-        self._display_box()
+        self._display_base_gui()
 
-    def _display_line(self, height: int = 0, left_txt: str = "", middle_txt: str = "", right_txt: str = "",
-                      space_between: bool = True, fillingchar: str = "="):
-        first_half: int = int(self.width / 2) - int(len(middle_txt) / 2) - len(left_txt) - (2 if space_between else 0)
-        second_half: int = self.width - len(left_txt + middle_txt + right_txt) - (4 if space_between else 0) \
-                           - first_half - 1
-
-        self.stdscr.addstr(height, 0, left_txt + (" " if space_between else "")
-                           + fillingchar * first_half + (" " if space_between else "")
-                           + middle_txt + (" " if space_between else "")
-                           + fillingchar * second_half + (" " if space_between else "")
-                           + right_txt)
+    def _display(self, text: str, height: int, color: SimpleCursesColor):
+        self.stdscr.addstr(height, 0, text, curses.color_pair(color) | self.color_variation[color])
         self._update_cursor()
         self.stdscr.refresh()
 
+    def _get_line(self, left_txt: str = "", middle_txt: str = "", right_txt: str = "",
+                  space_between: bool = True, fillingchar: str = "=") -> str:
 
-    def _display_box(self):
-        self._display_line(height=0, middle_txt=self.client.name, right_txt=self.client.version)
-        self._display_line(height=self.height - 1, left_txt="> ", fillingchar=" ")
+        first_half: int = int(self.width / 2) - int(len(middle_txt) / 2) - len(left_txt) - (2 if space_between else 0)
+        second_half: int = self.width - len(left_txt + middle_txt + right_txt) - (4 if space_between else 0) \
+                           - first_half - 1
+        return left_txt + (" " if space_between else "") \
+               + fillingchar * first_half + (" " if space_between else "") \
+               + middle_txt + (" " if space_between else "") \
+               + fillingchar * second_half + (" " if space_between else "") \
+               + right_txt
 
-    def update_prompt(self, prompt: str, cursor: int):
-        self.prompt_cursor = cursor
-        self._display_line(height=self.height - 1, left_txt="> " + prompt, fillingchar=" ")
+    def _display_line(self, height: int = 0, left_txt: str = "", middle_txt: str = "", right_txt: str = "",
+                      space_between: bool = True, fillingchar: str = "=", windows=None):
+        """
+        Display a full line
+        :param height: Position of the line
+        :param left_txt: Text on the left
+        :param middle_txt: Text in the middle
+        :param right_txt: Text on the right
+        :param space_between: Whether or not to add space around text (default is true)
+        :param fillingchar: Char used to fill the line (default is =)
+        """
+        text: str = self._get_line(left_txt, middle_txt, right_txt, space_between, fillingchar)
+        windows.addstr(height, 0, text)
         self._update_cursor()
+        windows.refresh()
 
-    def _display(self, text: str, color: SimpleCursesColor):
-        self.stdscr.addstr(self.message_count, 0, text, curses.color_pair(color) | self.color_variation[color])
-        self.message_count += 1
-        self._update_cursor()
-        self.stdscr.refresh()
+    def _display_all_messages(self):
+        i: int = 1
+        for message in self.messages:
+            self._display_message(message, i)
+            i += 1
 
-    def display_message(self, message: Message | str):
-        if type(message) is str:
-            return self.display_message(Message(payload=message, message_type=MessageType.LOG))
+    def _display_message(self, message: Message, height: int):
 
         header = ""
         color = SimpleCursesColor.CLASSIC
@@ -119,7 +132,31 @@ def display_message(self, message: Message | str):
                 header = f"[{message.room}]"
             color = SimpleCursesColor.MESSAGE_RECIEVE
 
-        self._display(header + bytes.fromhex(hex(message.payload)[2:]).decode('utf-8'), color)
+        self._display(header + message.payload.decode(), height, color)
+
+    def _display_base_gui(self):
+        """
+        Display the client base GUI
+        """
+        self._display_line(height=0, middle_txt=self.client.name, right_txt=self.client.version, windows=self.stdscr)
+        self._display_all_messages()
+        self._display_line(height=self.height - 1, left_txt="> ", fillingchar=" ", windows=self.stdscr)
+
+    def update_prompt(self, prompt: str, cursor: int):
+        self.prompt_cursor = cursor
+        self._display_line(height=self.height - 1, left_txt="> " + prompt, fillingchar=" ", windows=self.stdscr)
+        self._update_cursor()
+
+    def display_message(self, message: Message | str):
+        if type(message) is str:
+            return self.display_message(Message(payload=message, message_type=MessageType.LOG))
+
+        self.messages.append(message)
+        if len(self.messages) > self.height - 2:
+            self.messages.pop(0)
+            self._display_all_messages()
+        else:
+            self._display_message(message, len(self.messages))
 
     def display_error(self, text: str):
         return self.display_message(Message(payload=text, message_type=MessageType.ERROR))
@@ -133,9 +170,7 @@ def display_debug(self, text: str):
     def display_success(self, text: str):
         return self.display_message(Message(payload=text, message_type=MessageType.SUCCESS))
 
-    def _update_cursor(self, y=None, x=None):
-        if y is None:
-            y = self.height - 1
+    def _update_cursor(self, y=0, x=None):
         if x is None:
             x = self.prompt_cursor + 2
         self.stdscr.move(y, x)

From f841ffedae56fe4b8e38675da1f35bc89d9081a0 Mon Sep 17 00:00:00 2001
From: Portevent <porte@magous.fr>
Date: Mon, 18 Mar 2024 13:14:00 +0100
Subject: [PATCH 08/11] feat : Implement other packet such as message, room
 creation and suppression

---
 client/simple_client/PacketGenerator.py       |  41 +++
 client/simple_client/identity_manager.py      |  51 ++++
 client/simple_client/input.py                 |   2 +-
 client/simple_client/simple_client.py         | 254 ++++++++++++------
 .../simple_client_connection_state.py         |  14 -
 connection/fake_server.py                     |  10 +-
 display/pad_curses.py                         |   1 +
 display/simple_curses.py                      |  19 +-
 main.py                                       |   5 +-
 models/identity.py                            |  23 +-
 models/message.py                             |   7 +-
 models/packet.py                              |  18 +-
 models/room.py                                |   8 +-
 13 files changed, 335 insertions(+), 118 deletions(-)
 create mode 100644 client/simple_client/PacketGenerator.py
 create mode 100644 client/simple_client/identity_manager.py

diff --git a/client/simple_client/PacketGenerator.py b/client/simple_client/PacketGenerator.py
new file mode 100644
index 0000000..3cb25c3
--- /dev/null
+++ b/client/simple_client/PacketGenerator.py
@@ -0,0 +1,41 @@
+from client.client import Client
+from models.identity import Identity
+from models.message import Message
+from models.packet import Packet, PacketCode
+
+
+class PacketGenerator:
+    client: Client
+
+    def __init__(self, client: Client):
+        self.client = client
+
+    def get_hey_packet(self) -> Packet:
+        """
+        Build a Hey packet to connect the client to the server
+        :return: Hey Packet
+        """
+        return Packet(PacketCode.HEY, [self.client.ether_version.to_bytes(2, 'big')])
+
+    def get_send_key_packet(self) -> Packet:
+        """
+        Build a Key Packet
+        :return: Key Packet
+        """
+        return Packet(PacketCode.SEND_KEY, self.client.identity.get_key_pair())
+
+    def get_send_message_packet(self, message: Message) -> Packet:
+        """
+        Build a Message Packet
+        :param message: Message to send
+        :return: Message Send Packet
+        """
+        return Packet(PacketCode.MESSAGE_SEND, message.room.id.get_key_id_pair().append(message.payload))
+
+    def get_knock_packet(self, recipient: Identity) -> Packet:
+        """
+        Build a Kncok Packet
+        :param recipient: Client to knock
+        :return: Knock Packet
+        """
+        return Packet(PacketCode.KNOCK_SEND, recipient.get_key_id_pair())
diff --git a/client/simple_client/identity_manager.py b/client/simple_client/identity_manager.py
new file mode 100644
index 0000000..74d80fa
--- /dev/null
+++ b/client/simple_client/identity_manager.py
@@ -0,0 +1,51 @@
+from exceptions.exceptions import UnknownRecipient
+from misc.hex_enumerator import bytes_to_int, bytes_to_str
+from models.identity import Identity
+
+
+class IdentityManager:
+
+    contactsByName: dict[str, str]  # Map contacts name to their key_id
+    contactsByKey: dict[str, Identity]  # Map key_id to Identity
+
+    def __init__(self):
+        self.contactsByName = {}
+        self.contactsByKey = {}
+
+    def getIdentity(self, identity: str | bytearray) -> Identity:
+        """
+        Fetch the contact list for an Identity
+        :param identity: Name or key_id of the identity
+        :return: Identity
+        """
+        key_id: str = ""
+
+        if type(identity) is str:
+            # Trying by name
+            for name in self.contactsByName.keys():
+                if identity in name:
+                    return self.contactsByKey[self.contactsByName[name]]
+
+            if identity[0:2] == "0x":
+                key_id = identity[2:]
+
+        if type(identity) is bytearray:
+            key_id = bytes_to_str(identity)[2:]
+
+        # Trying by key_id
+        try:
+            if key_id in self.contactsByKey:
+                return self.contactsByKey[key_id]
+        except ValueError as e:
+            pass
+
+        raise UnknownRecipient(identity)
+
+    def registerIdentity(self, identity: Identity):
+        """
+        Insert an Identity in the contact list
+        :param identity: Identity to register
+        """
+        key_id: str = bytes_to_str(identity.key_id)[2:]
+        self.contactsByKey[key_id] = identity
+        self.contactsByName[identity.name] = key_id
diff --git a/client/simple_client/input.py b/client/simple_client/input.py
index de9864b..0434d6a 100644
--- a/client/simple_client/input.py
+++ b/client/simple_client/input.py
@@ -65,7 +65,7 @@ def start_listening(self):
                 elif char == curses.KEY_DC:
                     self.prompt = self.prompt[:self.prompt_cursor] + self.prompt[self.prompt_cursor+1:]
 
-                else:
+                elif chr(char).isalnum() or chr(char) in self.valid_char:
                     self.prompt = self.prompt[:self.prompt_cursor] + chr(char) + self.prompt[self.prompt_cursor:]
                     self.prompt_cursor += 1
 
diff --git a/client/simple_client/simple_client.py b/client/simple_client/simple_client.py
index 55ade42..dd33a73 100644
--- a/client/simple_client/simple_client.py
+++ b/client/simple_client/simple_client.py
@@ -1,24 +1,25 @@
 from threading import Thread
 
 from client.client import Client
+from client.simple_client.PacketGenerator import PacketGenerator
+from client.simple_client.identity_manager import IdentityManager
 from client.simple_client.simple_client_connection_state import Server, ConnectionState
 from display.pad_curses import PadCurses
 from misc.hex_enumerator import bytes_to_str, bytes_to_int, str_to_bytes
 from models.identity import Identity
-from models.message import Message
+from models.message import Message, MessageType
 from models.packet import Packet, PacketCode
 
 from connection.fake_server import FakeConnection
 
 from display.display import Display
-from display.simple_curses import SimpleCurses
 
 from client.simple_client.input import Input
 from exceptions.exceptions import MalformedPacketException, UnknownRecipient
 from models.room import RoomState, Room
 
 
-class SimpleClient(Client):
+class SimpleClient(Client, IdentityManager):
     """
     SimpleClient is a basic implementation of Eth3r.
     It works with a Display to output message and input prompt
@@ -31,17 +32,20 @@ class SimpleClient(Client):
     # Mapping Id to Room (/!\ this is a weird way to handle room and may lead to many confusions. Will be improved as
     # eth3r improves its room system)
     rooms: dict[Identity, Room]
-
-    contactsByName: dict[str, int]  # Map contacts name to their key_id
-    contactsByKey: dict[int, Identity]  # Map key_id to Identity
+    roomRecipients: dict[Identity, Identity] # Map Room id to their Recipient
 
     serverThread: Thread
     intputThread: Thread
 
+    packetGenerator: PacketGenerator
+
+    auto_connect: bool = False
+
     def __init__(self, identity: Identity, name: str = "DIOXANE"):
         super().__init__(identity, name)
 
         self.display = PadCurses(self)
+        self.packetGenerator = PacketGenerator(self)
 
         # Start the server
         self.server = Server(FakeConnection(), self)
@@ -55,11 +59,17 @@ def __init__(self, identity: Identity, name: str = "DIOXANE"):
         self.intputThread.start()
 
         self.rooms = {}
-        self.room_ids = {}
+        self.roomRecipients = {}
         self.contactsByName = {}
         self.contactsByKey = {}
 
-    def send_pck(self, pck: bytearray):
+        if self.auto_connect:
+            self.connect()
+
+    def send_pck(self, pck: bytearray | Packet):
+        if type(pck) is Packet:
+            pck = pck.to_bytes()
+        self.display.display_debug("Sent " + bytes_to_str(pck))
         self.server.connection.send(pck)
 
     def receive_pck(self, pck: bytearray):
@@ -74,16 +84,39 @@ def receive_pck(self, pck: bytearray):
         except NotImplementedError as e:
             self.display.display_error(str(e))
         except BaseException as e:
-            self.display.display_error(f"Unexpected error while reading {bytes_to_str(pck)} : {e}")
+            self.display.display_error(f"Unexpected error while reading {bytes_to_str(pck)} : {type(e)} {e}")
 
     def interpret(self, packet: Packet):
         match packet.code:
             case PacketCode.ACK:
                 self._match_ack_to_something(packet)
+
+            case PacketCode.KNOCK_RECIEVE:
+                key_id_length, key_id = packet.options
+                try:
+                    recipient = self.getIdentity(key_id)
+
+                    self.display.display_log(
+                        f"Recieved a knock request from {recipient}.")
+                except UnknownRecipient:
+                    recipient = Identity(key_id=key_id, key_id_length=key_id_length)
+                    self.registerIdentity(recipient)
+                    self.display.display_log(
+                        f"Recieved a knock request from {recipient} but we don't know who it is.")
+                    self.display.display_debug(f"We can use /rename {recipient} <name> to set their name")
+
+                self.rooms[recipient] = Room(recipient)
+                self.rooms[recipient].state = RoomState.KNOCKING_ACK
+
             case PacketCode.KNOCK_RESPONSE:
-                accepted = packet.options[0] == b'1'
-                key_id_length, key_id = packet.options[1][0], packet.options[1][1:]
-                recipient = self.getIdentity(key_id)
+                accepted = packet.options[0] == b'\x01'
+                key_id_length, key_id = packet.options[1], packet.options[2]
+                try:
+                    recipient = self.getIdentity(key_id)
+                except UnknownRecipient:
+                    self.display.display_error(f"Recieved a knock response from {bytes_to_str(key_id)} but we don't know who it is.")
+                    return self.display.display_debug(f"Have we ever ask them in the first place ?")
+
                 if recipient not in self.rooms:
                     return self.display.display_error(f"Recieving a {'positive' if accepted else 'negative'}"
                                                       f" knocking response from {recipient}"
@@ -95,14 +128,83 @@ def interpret(self, packet: Packet):
                     self.rooms[recipient].state = RoomState.KNOCKING_ACK
 
                 if self.rooms[recipient].state == RoomState.KNOCKING_ACK:
-                    self.rooms[recipient].state = RoomState.KNOCK_ACCEPTED if accepted else RoomState.KNOCK_REFUSED
+                    if accepted:
+                        self.rooms[recipient].state = RoomState.KNOCK_ACCEPTED
+                        return self.display.display_success(f"{recipient} accepted our knock")
+                    else:
+                        self.rooms[recipient].state = RoomState.KNOCK_REFUSED
+                        return self.display.display_error(f"{recipient} refused our knock")
                 else:
                     return self.display.display_error(f"Recieving a {'positive' if accepted else 'negative'}"
                                                       f" knocking response from {recipient}"
                                                       f" but we were {self.rooms[recipient].state}")
+            case PacketCode.ROOM_NEW:
+                room_key_length, room_key, key_id_length, key_id = packet.options
+                try:
+                    recipient = self.getIdentity(key_id)
+                except UnknownRecipient:
+                    self.display.display_error(
+                        f"Recieved a room with {bytes_to_str(key_id)} but we don't know who it is.")
+                    return self.display.display_debug(f"Have we ever ask them in the first place ?")
+
+                if recipient not in self.rooms:
+                    self.display.display_error(f"Recieving a room with {recipient}"
+                                                      f" but never asked them in the first place")
+                    self.display.display_log(f"Room with {recipient} joined anyway")
+                    self.rooms[recipient] = Room(recipient)
+                    self._join_room(recipient, room_key)
+                    return
+
+                match self.rooms[recipient].state:
+                    case RoomState.KNOCK_REFUSED:
+                        self.display.display_error(f"Server created a room with {recipient} despite we/they refused.")
+                        self.display.display_log(f"Joining room with {recipient} anyway")
+                    case RoomState.KNOCK_ACCEPTED:
+                        self.display.display_log(f"Room with {recipient} successfully joined")
+                    case _:
+                        self.display.display_error(f"Server created a room with {recipient}"
+                                                   f"but we were {self.rooms[recipient].state}")
+                        self.display.display_log(f"Joining room with {recipient} anyway")
+
+                self._join_room(recipient, room_key)
+
+            case PacketCode.MESSAGE_SEND:
+                room_key_length, room_key, encryption, payload = packet.options
+                room_id = Identity(key_id = room_key, key_id_length=room_key_length)
+                if room_id not in self.roomRecipients:
+                    return self.display.display_error(f"Recieved a message in room {room_id} despite we are not in it :"
+                                               f" {payload.decode('ascii')}")
+                
+                recipient = self.roomRecipients[room_id]
+                if self.rooms[recipient].state != RoomState.IN_ROOM:
+                    self.display.display_error(f"We recieved a message in room with {recipient} "
+                                               f"but it was {self.rooms[recipient].state}")
+
+                message: Message = Message(room=self.rooms[recipient],
+                                           message_type=MessageType.RECEIVE,
+                                           payload=payload, ack=True)
+                self._display_message(message)
+
+            case PacketCode.ROOM_CLOSE:
+                room_key_length, room_key = packet.options
+                room_id = Identity(key_id=room_key, key_id_length=room_key_length)
+                if room_id not in self.roomRecipients:
+                    return self.display.display_error(f"Server tells us it is closing room {room_id} "
+                                                      f"despite we are not in it")
+                recipient: Identity = self.roomRecipients[room_id]
+                if self.rooms[recipient].state != RoomState.IN_ROOM:
+                    self.display.display_error(f"Server tells us it is closing room with {recipient} "
+                                                      f"despite the room being {self.rooms[recipient].state}")
+                self.rooms[recipient].state = RoomState.ROOM_CLOSED
 
             case _:
-                self.display.display_error(f"{hex(packet.code)} reception not yet implemented")
+                self.display.display_error(f"This version of client yet not know how to interpret {packet.code.name}")
+
+    def _join_room(self, recipient: Identity, room_id: bytearray):
+        room_id = Identity(name=f"Room with {recipient.name}", key_id=room_id)
+        self.roomRecipients[room_id] = recipient
+        self.rooms[recipient].state = RoomState.IN_ROOM
+        self.rooms[recipient].id = room_id
 
     def _match_ack_to_something(self, packet: Packet):
         """
@@ -122,26 +224,34 @@ def _match_ack_to_something(self, packet: Packet):
                 room.state = RoomState.KNOCKING_ACK
                 return self.display.display_debug("Knock ack by server")
 
+            for message in room.messages:
+                if not message.ack:
+                    message.ack = True
+                    return self.display.update_message(message)
+
         self.display.display_debug(f"Received unexpected ACK : {packet}")
 
     def connect(self):
         """
-        Send a HEY package to the server
+        Send a HEY packet to the server
         """
         try:
             self.display.display_log(f"Connecting as {self.identity}")
-            self.send_pck(self.server.get_hey_packet())
+            self.send_pck(self.packetGenerator.get_hey_packet())
             self.server.state = ConnectionState.CONNECTION_INITIALIZED_VERSION
         except BaseException as e:
             self.display.display_error(f"Can't connect to server : {str(e)}")
 
     def send_key(self):
         """
-        Send a Key package to the server
+        Send a Key packet to the server
         """
-        self.display.display_debug(f"Send my key : {bytes_to_str(self.identity.key)}")
-        self.send_pck(self.server.get_send_key_packet())
-        self.server.state = ConnectionState.CONNECTION_INITIALIZED_KEY
+        try:
+            self.display.display_debug(f"Send my key : {bytes_to_str(self.identity.key)}")
+            self.send_pck(self.packetGenerator.get_send_key_packet())
+            self.server.state = ConnectionState.CONNECTION_INITIALIZED_KEY
+        except BaseException as e:
+            self.display.display_error(f"Can't connect to server : {str(e)}")
 
     def _validate_connection(self):
         """
@@ -158,75 +268,32 @@ def knock(self, recipient: Identity):
         self.display.display_log(f'Knocking {recipient}')
         self.rooms[recipient] = Room(recipient)
         self.rooms[recipient].state = RoomState.KNOCKING
-        self.send_pck(Packet(PacketCode.KNOCK_SEND, recipient.get_key_id_pair()))
+        self.send_pck(self.packetGenerator.get_knock_packet(recipient))
 
-    def add_message_in_room(self, room_id: int, message: Message):
+    def _display_message(self, message: Message):
         """
         Display a message in a room
-        :param room_id: Room id
         :param message: Message to display
         """
-        """
-        NOT_TESTED
-        """
-        self.rooms[room_id].add_message(message)
+        message.room.add_message(message)
         self.display.display_message(message)
 
-    def send_message_in(self, room_id: int, payload: bytearray):
+    def send_message_to(self, recipient: Identity, payload: bytearray | str):
         """
-        Send a message in a room
-        :param room_id: Room id
+        Send a message to someone
+        :param recipient: Recipient of the message
         :param payload: payload
-        :return:
-        """
-        """
-        NOT_TESTED
         """
-        if room_id not in self.rooms or self.rooms[room_id].state != RoomState.IN_ROOM:
-            self.display.display_error("Room isn't ready " + room_id)
-        else:
-            message: Message = Message(sender=self.identity, room=self.rooms[room_id], payload=payload, ack=False)
-            self.add_message_in_room(room_id, message)
-            self.server.connection.send(message.get_send_package())
-
-    def getIdentity(self, identity: str | bytearray) -> Identity:
-        """
-        Fetch the contact list for an Identity
-        :param identity: Name or key_id of the identity
-        :return: Identity
-        """
-        key_id: int = -1
-
-        if type(identity) is str:
-            # Trying by name
-            for name in self.contactsByName.keys():
-                if identity in name:
-                    return self.contactsByKey[self.contactsByName[name]]
+        if recipient not in self.rooms:
+            return self.display.display_error(f"Room with {recipient} doesn't exists")
 
-            if identity[0:2] == "0x":
-                key_id = int(identity[2:], 16)
-            else:
-                key_id = int(identity, 16)
+        if self.rooms[recipient].state != RoomState.IN_ROOM:
+            return self.display.display_error(f"Room with {recipient} isn't ready : {self.rooms[recipient].state}")
 
-        if type(identity) is bytearray:
-            key_id = bytes_to_int(identity)
-
-        # Trying by key_id
-        try:
-            if key_id in self.contactsByKey:
-                return self.contactsByKey[key_id]
-        except ValueError as e:
-            pass
-
-        raise UnknownRecipient(identity)
-
-    def registerIdentity(self, identity: Identity):
-        """
-        Insert an Identity in the contact list
-        :param identity: Identity to register
-        """
-        self.contactsByKey[identity.key_id] = identity
-        self.contactsByName[identity.name] = identity.key_id
+        message: Message = Message(sender=self.identity, room=self.rooms[recipient], message_type=MessageType.SENT,
+                                   payload=payload, ack=False)
+        self._display_message(message)
+        self.send_pck(self.packetGenerator.get_send_message_packet(message))
 
     def command(self, text: str):
         """
@@ -254,11 +321,44 @@ def _command(self, command: str, options: list[str]):
                     self.display.display_error(e)
 
             case 'echo':
+                if len(options) < 1:
+                    return self.display.display_error("echo require a text to display")
                 self.display.display_message(' '.join(options))
 
+            case 'send':
+                if len(options) < 2:
+                    return self.display.display_error("send require two arguments : <recipient> and a message")
+                try:
+                    room_id = self.getIdentity(options.pop(0))
+                except UnknownRecipient as e:
+                    return self.display.display_error("Unknown recipient : " + str(e))
+
+                text = " ".join(options)
+                self.send_message_to(room_id, text)
+
+            case 'connect':
+                self.connect()
+
             case 'server':
                 self.server.connection.receive(b''.join(map(str_to_bytes, options)))
 
+            case 'list':
+                if len(options) < 1:
+                    options = ['contacts']
+                match options[0]:
+                    case 'contacts':
+                        for contact in self.contactsByKey.values():
+                            self.display.display_log(f"{contact} : {bytes_to_str(contact.key_id)}")
+                    case 'rooms':
+                        for room in self.rooms.values():
+                            self.display.display_log(f"{room.name} : {room.state}")
+            case 'help':
+                self.display.display_debug("connect")
+                self.display.display_debug("knock <recipient> <message>")
+                self.display.display_debug("send <recipient> <message>")
+                self.display.display_debug("list <contacts/rooms>")
+                self.display.display_debug("server <pck>")
+                self.display.display_debug("echo <message>")
             case _:
                 self.display.display_error("Unknown command")
                 self.display.display_log(command)
diff --git a/client/simple_client/simple_client_connection_state.py b/client/simple_client/simple_client_connection_state.py
index c95fe62..dc99f98 100644
--- a/client/simple_client/simple_client_connection_state.py
+++ b/client/simple_client/simple_client_connection_state.py
@@ -34,17 +34,3 @@ def __init__(self, connection: Connection, client: Client):
         self.connection = connection
         self.client = client
         self.state = ConnectionState.DECONNECTED
-
-    def get_hey_packet(self) -> Packet:
-        """
-        Build the Hey packet to connect the client to the server
-        :return: Hey Packet
-        """
-        return Packet(PacketCode.HEY, [self.client.ether_version.to_bytes(2, 'big')])
-
-    def get_send_key_packet(self):
-        """
-        Build the Key Packet
-        :return:
-        """
-        return Packet(PacketCode.SEND_KEY, self.client.identity.get_key_pair())
diff --git a/connection/fake_server.py b/connection/fake_server.py
index 91f597c..0ea39ad 100644
--- a/connection/fake_server.py
+++ b/connection/fake_server.py
@@ -13,8 +13,8 @@ class FakeConnection(Connection):
     It will reply to any packet recieved with an ACK (can be turned off during init)
     """
     _packets: list[bytearray]  # List of packet to send (FIFO)
-    _reply_with_ACK: int = 2  # Time in second between two packet
-    _delay: int = 2  # Time in second between two packet
+    _reply_with_ACK: bool = False  # Reply packet recieved with ACK + pck
+    _delay: float = 0.1  # Time in second between two packet
 
     def __init__(self):
         self._packets = []
@@ -26,10 +26,8 @@ def start_listening(self):
                 self._notify_observers(self._packets.pop(0))
             time.sleep(self._delay)
 
-    def send(self, pck: bytearray | Packet):
-        if type(pck) is Packet:
-            pck = pck.to_bytes()
-            # Supposely send them
+    def send(self, pck: bytearray):
+        # Supposely send them
 
         if self._reply_with_ACK:
             self.receive(int_to_bytes(PacketCode.ACK.value) + pck)
diff --git a/display/pad_curses.py b/display/pad_curses.py
index 72642ed..dbba84f 100644
--- a/display/pad_curses.py
+++ b/display/pad_curses.py
@@ -80,6 +80,7 @@ def display_message(self, message: Message | str):
         else:
             self._display_message(message, len(self.messages) - 1)
 
+
     def _update_cursor(self, y=0, x=None):
         if x is None:
             x = self.prompt_cursor + 2
diff --git a/display/simple_curses.py b/display/simple_curses.py
index 0e2c18a..1273ed4 100644
--- a/display/simple_curses.py
+++ b/display/simple_curses.py
@@ -122,17 +122,17 @@ def _display_message(self, message: Message, height: int):
             color = SimpleCursesColor.SUCCESS
 
         if message.message_type == MessageType.SENT:
-            header = f"[{message.recipient}] "
+            if message.ack:
+                header = f"[To   {message.room.recipient}] "
+            else:
+                header = f"(To   {message.room.recipient}) "
             color = SimpleCursesColor.MESSAGE_SEND
 
         if message.message_type == MessageType.RECEIVE:
-            if message.sender:
-                header = f"[{message.sender}] "
-            elif message.room:
-                header = f"[{message.room}]"
+            header = f"[From {message.room.recipient}] "
             color = SimpleCursesColor.MESSAGE_RECIEVE
 
-        self._display(header + message.payload.decode(), height, color)
+        self._display(header + message.payload.decode("ascii"), height, color)
 
     def _display_base_gui(self):
         """
@@ -170,6 +170,13 @@ def display_debug(self, text: str):
     def display_success(self, text: str):
         return self.display_message(Message(payload=text, message_type=MessageType.SUCCESS))
 
+    def update_message(self, message: Message):
+        try:
+            index: int = self.messages.index(message)
+            self._display_message(message, index)
+        except ValueError:
+            self.display_error(f"Trying to update message but can't find it : {message.payload.decode('ascii')}")
+
     def _update_cursor(self, y=0, x=None):
         if x is None:
             x = self.prompt_cursor + 2
diff --git a/main.py b/main.py
index f3e72fe..52692cb 100644
--- a/main.py
+++ b/main.py
@@ -4,10 +4,9 @@
 if __name__ == '__main__':
     me: Identity = Identity(name="Amus", key_id_length=2, key_id=0x1312, key_length=4, key=0x1312b00b)
 
-    baophes: Identity = Identity(2, 0x964d, name="Baophes")
-    cysalia: Identity = Identity(2, 0xa156, name="Cysalia")
+    baophes: Identity = Identity(key_id=0x964d, name="Baophes")
+    cysalia: Identity = Identity(key_id=0xa156, name="Cysalia")
 
     client = SimpleClient(me, "DIOXANE")
-    client.connect()
     client.registerIdentity(baophes)
     client.registerIdentity(cysalia)
diff --git a/models/identity.py b/models/identity.py
index 8a42c3b..1acef08 100644
--- a/models/identity.py
+++ b/models/identity.py
@@ -11,13 +11,25 @@ class Identity:
     key_id: bytearray
     key_id_length: int
 
-    def __init__(self, key_id_length: int, key_id: int | bytearray,
+    def __init__(self, key_id: int | bytearray, key_id_length: int = None,
                  key_length: int = None, key: int | bytearray = None,
                  name: str = None):
         if type(key_id) == int:
-            key_id = key_id.to_bytes(key_id_length, 'big')
+            if key_id_length is None:
+                key_id = int_to_bytes(key_id)
+            else:
+                key_id = key_id.to_bytes(key_id_length, 'big')
         if type(key) == int:
-            key = key.to_bytes(key_length, 'big')
+            if key_length is None:
+                key = int_to_bytes(key)
+            else:
+                key = key.to_bytes(key_length, 'big')
+
+        if key_id is not None and key_id_length is None:
+            key_id_length = len(key_id)
+
+        if key is not None and key_length is None:
+            key_length = len(key)
 
         self.name = name or bytes_to_str(key_id)
         self.key = key
@@ -50,5 +62,8 @@ def __repr__(self):
     def __str__(self):
         return self.name
 
+    def __eq__(self, other):
+        return hash(self) == hash(other)
+
     def __hash__(self):
-        return hash(self.key_id)
+        return hash(bytes_to_str(self.key_id))
diff --git a/models/message.py b/models/message.py
index c341834..60409a4 100644
--- a/models/message.py
+++ b/models/message.py
@@ -1,3 +1,4 @@
+import random
 from enum import Enum, auto
 
 from models.identity import Identity
@@ -25,6 +26,7 @@ class Message:
     room: "Room"  # Room where it was sent/recieved
     ack: bool  # Was it ACK by the server (for sent message)
     message_type: MessageType  # Type
+    id: int  # Random int
 
     def __init__(self, payload: bytearray | str, sender: Identity = None, recipient: Identity = None,
                  room: "Room" = None, ack: bool = True, message_type: MessageType = None):
@@ -40,6 +42,7 @@ def __init__(self, payload: bytearray | str, sender: Identity = None, recipient:
         if type(payload) is str:
             payload = bytearray(payload.encode())
 
+        self.id = random.getrandbits(10)
         self.payload = payload
         self.sender = sender
         self.recipient = recipient
@@ -47,5 +50,5 @@ def __init__(self, payload: bytearray | str, sender: Identity = None, recipient:
         self.ack = ack
         self.message_type = message_type
 
-    def get_send_package(self):
-        return Packet(PacketCode.MESSAGE_SEND, self.recipient.get_key_id_pair().append(self.payload))
+    def __hash__(self):
+        return hash(self.id)
diff --git a/models/packet.py b/models/packet.py
index 598ba4f..b3b78d6 100644
--- a/models/packet.py
+++ b/models/packet.py
@@ -43,6 +43,8 @@ class Packet:
 
     def __init__(self, payload: bytearray | bytes | int | str | PacketCode, options: list[bytearray] = []):
 
+        if options is None:
+            options = []
         self.options = options.copy()
         bytesEnumerator: enumerate
 
@@ -128,14 +130,26 @@ def _set_options_from_enumerator(self, bytesEnumerator):
                 self.options += [room_length, room_id, key_length, key_id]
 
             case PacketCode.MESSAGE_SEND:
-                raise NotImplementedError(f"Package {self.code} is not yet implemented")
+                room_length = _read_bytes(bytesEnumerator, 1)
+
+                room_id = _read_bytes(bytesEnumerator, room_length)
+                encryption = _read_bytes(bytesEnumerator, 1)
+
+                payload = bytearray(b'')
+                while True:
+                    try:
+                        payload = _read_bytes(bytesEnumerator, 1, value=payload)
+                    except EndOfEnumerator:
+                        break
+
+                self.options += [room_length, room_id, encryption, payload]
 
             # Error
             case PacketCode.ERR_WRONG_PACKET_LENGTH | PacketCode.ERR_WRONG_PACKET_ID | \
                  PacketCode.ERR_UNSUPPORTED_VERSION | PacketCode.ERR_INCOMPLETE_KEY | PacketCode.ERR_KEY_MALFORMED | \
                  PacketCode.ERR_KEY_PAYLOAD_MALFORMED | PacketCode.ERR_MALFORMATION | PacketCode.ERR_OUT_OF_PATH | \
                  PacketCode.ERR_UNKNOWN_PACKET_ID | PacketCode.ERR_NOT_IMPLEMENTED | PacketCode.ERR_FAULTY_READING:
-                raise NotImplementedError(f"Package {self.code} is not yet implemented")
+                raise NotImplementedError(f"Reading a packet {self.code.name} is not yet implemented")
 
     def to_bytes(self):
         return int_to_bytes(self.code) + b"".join(self.options)
diff --git a/models/room.py b/models/room.py
index faadda4..988b96d 100644
--- a/models/room.py
+++ b/models/room.py
@@ -23,22 +23,24 @@ class Room:
     # Recipient of the room has to be saved client side so we can know afterward who is talking in the room
     recipient: Identity
     messages: list[Message]  # List of message in the room
+    id: Identity  # Id of the room server side
 
     def __init__(self, recipient: Identity):
         self.recipient = recipient
         self.name = str(recipient)
         self.state = RoomState.INEXISTANT
         self.messages = []
+        self.id = None
 
     def add_message(self, message: Message):
         """
         Add message in the room
         :param message: Message
         """
-        if message.type is None:
+        if message.message_type is None:
             if message.recipient == self.recipient:
-                message.type = MessageType.SENT
+                message.message_type = MessageType.SENT
             if message.sender == self.recipient:
-                message.type = MessageType.RECEIVE
+                message.message_type = MessageType.RECEIVE
 
         self.messages.append(message)

From 328f110762bf86e5ace645ae81d7b8c40e60246d Mon Sep 17 00:00:00 2001
From: Portevent <porte@magous.fr>
Date: Mon, 18 Mar 2024 18:27:28 +0100
Subject: [PATCH 09/11] fix : Correct Knocks and Rooms

---
 client/simple_client/simple_client.py | 85 +++++++++++++--------------
 models/knock.py                       | 26 ++++++++
 models/room.py                        | 18 ++----
 3 files changed, 72 insertions(+), 57 deletions(-)
 create mode 100644 models/knock.py

diff --git a/client/simple_client/simple_client.py b/client/simple_client/simple_client.py
index dd33a73..1209cb9 100644
--- a/client/simple_client/simple_client.py
+++ b/client/simple_client/simple_client.py
@@ -7,6 +7,7 @@
 from display.pad_curses import PadCurses
 from misc.hex_enumerator import bytes_to_str, bytes_to_int, str_to_bytes
 from models.identity import Identity
+from models.knock import Knock, KnockState
 from models.message import Message, MessageType
 from models.packet import Packet, PacketCode
 
@@ -16,7 +17,7 @@
 
 from client.simple_client.input import Input
 from exceptions.exceptions import MalformedPacketException, UnknownRecipient
-from models.room import RoomState, Room
+from models.room import Room
 
 
 class SimpleClient(Client, IdentityManager):
@@ -29,10 +30,9 @@ class SimpleClient(Client, IdentityManager):
     server: Server
     input: Input
 
-    # Mapping Id to Room (/!\ this is a weird way to handle room and may lead to many confusions. Will be improved as
-    # eth3r improves its room system)
+    knock: dict[Identity, Knock]
     rooms: dict[Identity, Room]
-    roomRecipients: dict[Identity, Identity] # Map Room id to their Recipient
+    roomRecipients: dict[Identity, Identity] # Map Recipient to their Room id
 
     serverThread: Thread
     intputThread: Thread
@@ -58,10 +58,9 @@ def __init__(self, identity: Identity, name: str = "DIOXANE"):
         self.intputThread = Thread(target=self.input.start_listening)
         self.intputThread.start()
 
+        self.knock = {}
         self.rooms = {}
         self.roomRecipients = {}
-        self.contactsByName = {}
-        self.contactsByKey = {}
 
         if self.auto_connect:
             self.connect()
@@ -105,8 +104,8 @@ def interpret(self, packet: Packet):
                         f"Recieved a knock request from {recipient} but we don't know who it is.")
                     self.display.display_debug(f"We can use /rename {recipient} <name> to set their name")
 
-                self.rooms[recipient] = Room(recipient)
-                self.rooms[recipient].state = RoomState.KNOCKING_ACK
+                self.knock[recipient] = Knock(recipient)
+                self.knock[recipient].state = KnockState.KNOCKING_RECEIVED
 
             case PacketCode.KNOCK_RESPONSE:
                 accepted = packet.options[0] == b'\x01'
@@ -117,27 +116,27 @@ def interpret(self, packet: Packet):
                     self.display.display_error(f"Recieved a knock response from {bytes_to_str(key_id)} but we don't know who it is.")
                     return self.display.display_debug(f"Have we ever ask them in the first place ?")
 
-                if recipient not in self.rooms:
+                if recipient not in self.knock:
                     return self.display.display_error(f"Recieving a {'positive' if accepted else 'negative'}"
                                                       f" knocking response from {recipient}"
                                                       f" but never asked them in the first place")
 
-                if self.rooms[recipient].state == RoomState.KNOCKING:
+                if self.knock[recipient].state == KnockState.KNOCKING:
                     self.display.display_debug(f'Server forwarded {recipient}\'s response to our knock but we never'
                                                f'recieved ACK from the server itself. We won\'t mind and pretend it did')
-                    self.rooms[recipient].state = RoomState.KNOCKING_ACK
+                    self.knock[recipient].state = KnockState.KNOCKING_ACK
 
-                if self.rooms[recipient].state == RoomState.KNOCKING_ACK:
+                if self.knock[recipient].state == KnockState.KNOCKING_ACK:
                     if accepted:
-                        self.rooms[recipient].state = RoomState.KNOCK_ACCEPTED
+                        self.knock[recipient].state = KnockState.KNOCK_ACCEPTED
                         return self.display.display_success(f"{recipient} accepted our knock")
                     else:
-                        self.rooms[recipient].state = RoomState.KNOCK_REFUSED
+                        self.knock[recipient].state = KnockState.KNOCK_REFUSED
                         return self.display.display_error(f"{recipient} refused our knock")
                 else:
                     return self.display.display_error(f"Recieving a {'positive' if accepted else 'negative'}"
                                                       f" knocking response from {recipient}"
-                                                      f" but we were {self.rooms[recipient].state}")
+                                                      f" but we were {self.knock[recipient].state}")
             case PacketCode.ROOM_NEW:
                 room_key_length, room_key, key_id_length, key_id = packet.options
                 try:
@@ -147,19 +146,18 @@ def interpret(self, packet: Packet):
                         f"Recieved a room with {bytes_to_str(key_id)} but we don't know who it is.")
                     return self.display.display_debug(f"Have we ever ask them in the first place ?")
 
-                if recipient not in self.rooms:
+                if recipient not in self.knock:
                     self.display.display_error(f"Recieving a room with {recipient}"
                                                       f" but never asked them in the first place")
                     self.display.display_log(f"Room with {recipient} joined anyway")
-                    self.rooms[recipient] = Room(recipient)
                     self._join_room(recipient, room_key)
                     return
 
-                match self.rooms[recipient].state:
-                    case RoomState.KNOCK_REFUSED:
+                match self.knock[recipient].state:
+                    case KnockState.KNOCK_REFUSED:
                         self.display.display_error(f"Server created a room with {recipient} despite we/they refused.")
                         self.display.display_log(f"Joining room with {recipient} anyway")
-                    case RoomState.KNOCK_ACCEPTED:
+                    case KnockState.KNOCK_ACCEPTED:
                         self.display.display_log(f"Room with {recipient} successfully joined")
                     case _:
                         self.display.display_error(f"Server created a room with {recipient}"
@@ -171,16 +169,15 @@ def interpret(self, packet: Packet):
             case PacketCode.MESSAGE_SEND:
                 room_key_length, room_key, encryption, payload = packet.options
                 room_id = Identity(key_id = room_key, key_id_length=room_key_length)
-                if room_id not in self.roomRecipients:
+                if room_id not in self.rooms:
                     return self.display.display_error(f"Recieved a message in room {room_id} despite we are not in it :"
                                                f" {payload.decode('ascii')}")
-                
-                recipient = self.roomRecipients[room_id]
-                if self.rooms[recipient].state != RoomState.IN_ROOM:
-                    self.display.display_error(f"We recieved a message in room with {recipient} "
-                                               f"but it was {self.rooms[recipient].state}")
 
-                message: Message = Message(room=self.rooms[recipient],
+                if self.rooms[room_id].closed:
+                    self.display.display_error(f"We recieved a message in room {room_id} "
+                                               f"but it was closed")
+
+                message: Message = Message(room=room_id,
                                            message_type=MessageType.RECEIVE,
                                            payload=payload, ack=True)
                 self._display_message(message)
@@ -188,14 +185,14 @@ def interpret(self, packet: Packet):
             case PacketCode.ROOM_CLOSE:
                 room_key_length, room_key = packet.options
                 room_id = Identity(key_id=room_key, key_id_length=room_key_length)
-                if room_id not in self.roomRecipients:
+                if room_id not in self.rooms:
                     return self.display.display_error(f"Server tells us it is closing room {room_id} "
                                                       f"despite we are not in it")
-                recipient: Identity = self.roomRecipients[room_id]
-                if self.rooms[recipient].state != RoomState.IN_ROOM:
-                    self.display.display_error(f"Server tells us it is closing room with {recipient} "
-                                                      f"despite the room being {self.rooms[recipient].state}")
-                self.rooms[recipient].state = RoomState.ROOM_CLOSED
+
+                if self.rooms[room_id].closed:
+                    self.display.display_error(f"Server tells us it is closing room {room_id}"
+                                               f" despite it already being closed")
+                self.rooms[room_id].close = True
 
             case _:
                 self.display.display_error(f"This version of client yet not know how to interpret {packet.code.name}")
@@ -203,8 +200,7 @@ def interpret(self, packet: Packet):
     def _join_room(self, recipient: Identity, room_id: bytearray):
         room_id = Identity(name=f"Room with {recipient.name}", key_id=room_id)
         self.roomRecipients[room_id] = recipient
-        self.rooms[recipient].state = RoomState.IN_ROOM
-        self.rooms[recipient].id = room_id
+        self.rooms[recipient] = Room(recipient, room_id)
 
     def _match_ack_to_something(self, packet: Packet):
         """
@@ -219,11 +215,12 @@ def _match_ack_to_something(self, packet: Packet):
         if self.server.state == ConnectionState.CONNECTION_INITIALIZED_KEY:
             return self._validate_connection()
 
-        for room in self.rooms.values():
-            if room.state == RoomState.KNOCKING:
-                room.state = RoomState.KNOCKING_ACK
+        for knock in self.knock.values():
+            if knock.state == KnockState.KNOCKING:
+                knock.state = KnockState.KNOCKING_ACK
                 return self.display.display_debug("Knock ack by server")
 
+        for room in self.rooms.values():
             for message in room.messages:
                 if not message.ack:
                     message.ack = True
@@ -266,8 +263,8 @@ def knock(self, recipient: Identity):
         :param recipient: Recipient to knock
         """
         self.display.display_log(f'Knocking {recipient}')
-        self.rooms[recipient] = Room(recipient)
-        self.rooms[recipient].state = RoomState.KNOCKING
+        self.knock[recipient] = Knock(recipient)
+        self.knock[recipient].state = KnockState.KNOCKING
         self.send_pck(self.packetGenerator.get_knock_packet(recipient))
 
     def _display_message(self, message: Message):
@@ -284,11 +281,13 @@ def send_message_to(self, recipient: Identity, payload: bytearray | str):
         :param recipient: Recipient of the message
         :param payload: payload
         """
-        if recipient not in self.rooms:
+        if recipient not in self.roomRecipients:
             return self.display.display_error(f"Room with {recipient} doesn't exists")
 
-        if self.rooms[recipient].state != RoomState.IN_ROOM:
-            return self.display.display_error(f"Room with {recipient} isn't ready : {self.rooms[recipient].state}")
+        room_id: Identity = self.roomRecipients[recipient]
+
+        if self.rooms[room_id].closed:
+            return self.display.display_error(f"Room with {recipient} is closed")
 
         message: Message = Message(sender=self.identity, room=self.rooms[recipient], message_type=MessageType.SENT,
                                    payload=payload, ack=False)
diff --git a/models/knock.py b/models/knock.py
new file mode 100644
index 0000000..be180c3
--- /dev/null
+++ b/models/knock.py
@@ -0,0 +1,26 @@
+from enum import Enum, auto
+
+from models.identity import Identity
+from models.message import Message, MessageType
+
+
+class KnockState(Enum):
+    KNOCKING = auto()
+    KNOCKING_ACK = auto()
+    KNOCKING_RECEIVED = auto()
+    KNOCK_ACCEPTED = auto()
+    KNOCK_REFUSED = auto()
+
+
+class Knock:
+    """
+    Basic class to keep track of the state of a Knock
+    """
+    state: KnockState  # State of the room
+    # Recipient of the room has to be saved client side so we can know afterward who is talking in the room
+    recipient: Identity
+
+    def __init__(self, recipient: Identity):
+        self.recipient = recipient
+        self.state = KnockState.KNOCKING
+
diff --git a/models/room.py b/models/room.py
index 988b96d..e9bccaf 100644
--- a/models/room.py
+++ b/models/room.py
@@ -4,33 +4,23 @@
 from models.message import Message, MessageType
 
 
-class RoomState(Enum):
-    INEXISTANT = auto()
-    KNOCKING = auto()
-    KNOCKING_ACK = auto()
-    KNOCK_ACCEPTED = auto()
-    KNOCK_REFUSED = auto()
-    IN_ROOM = auto()
-    ROOM_CLOSED = auto()
-
-
 class Room:
     """
     Basic class to keep track of the state of a Room
     """
     name: str  # Client side name, doesn't interfer with Eth3r
-    state: RoomState  # State of the room
+    closed: bool  # State of the room
     # Recipient of the room has to be saved client side so we can know afterward who is talking in the room
     recipient: Identity
     messages: list[Message]  # List of message in the room
     id: Identity  # Id of the room server side
 
-    def __init__(self, recipient: Identity):
+    def __init__(self, recipient: Identity, id: Identity):
         self.recipient = recipient
         self.name = str(recipient)
-        self.state = RoomState.INEXISTANT
+        self.closed = False
         self.messages = []
-        self.id = None
+        self.id = id
 
     def add_message(self, message: Message):
         """

From 5aa67fa9af244f4af494fa007bf08a09906f9ce0 Mon Sep 17 00:00:00 2001
From: Portevent <porte@magous.fr>
Date: Mon, 18 Mar 2024 18:28:46 +0100
Subject: [PATCH 10/11] fix : Typo

---
 client/simple_client/simple_client_connection_state.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/client/simple_client/simple_client_connection_state.py b/client/simple_client/simple_client_connection_state.py
index dc99f98..5b2f544 100644
--- a/client/simple_client/simple_client_connection_state.py
+++ b/client/simple_client/simple_client_connection_state.py
@@ -2,11 +2,10 @@
 
 from client.client import Client
 from connection.connection import Connection
-from models.packet import Packet, PacketCode
 
 
 class ConnectionState(Enum):
-    DECONNECTED = auto()
+    DISCONNECTED = auto()
     CONNECTION_INITIALIZED_VERSION = auto()
     CONNECTION_INITIALIZED_VERSION_ACK = auto()
     CONNECTION_INITIALIZED_KEY = auto()

From 5fbb612de2b207b93bca93c2ebf1093f64c01e2c Mon Sep 17 00:00:00 2001
From: Portevent <porte@magous.fr>
Date: Wed, 20 Mar 2024 10:41:16 +0100
Subject: [PATCH 11/11] fix : Minor corrections for a cleaner code

---
 client/client.py                              |   8 ++
 client/display_client.py                      |  19 ++++
 client/io_client.py                           |  19 ++++
 client/simple_client/identity_manager.py      |   4 +-
 client/simple_client/input.py                 |   4 +-
 ...PacketGenerator.py => packet_generator.py} |   8 +-
 client/simple_client/simple_client.py         | 100 ++++++++----------
 .../simple_client_connection_state.py         |  12 ++-
 connection/fake_server.py                     |   2 +-
 display/display.py                            |   8 +-
 display/pad_curses.py                         |   9 +-
 display/simple_curses.py                      |  24 +++--
 identity_provider/gpg.py                      |   5 +-
 identity_provider/simple_key.py               |   2 +-
 misc/hex_enumerator.py                        |   2 +-
 models/knock.py                               |   1 -
 models/message.py                             |   8 +-
 models/packet.py                              |  53 ++++------
 models/room.py                                |   8 +-
 models/room_message.py                        |  24 +++++
 20 files changed, 187 insertions(+), 133 deletions(-)
 create mode 100644 client/display_client.py
 create mode 100644 client/io_client.py
 rename client/simple_client/{PacketGenerator.py => packet_generator.py} (77%)
 create mode 100644 models/room_message.py

diff --git a/client/client.py b/client/client.py
index b11ece5..697d777 100644
--- a/client/client.py
+++ b/client/client.py
@@ -46,3 +46,11 @@ def _exit(self, code: int = 0):
         :param code: error code
         """
         exit(code)
+
+    @abstractmethod
+    def command(self, text: str):
+        """
+        Execute a command
+        :param text: Command
+        """
+        pass
diff --git a/client/display_client.py b/client/display_client.py
new file mode 100644
index 0000000..627795f
--- /dev/null
+++ b/client/display_client.py
@@ -0,0 +1,19 @@
+from abc import ABC
+
+from client.client import Client
+from display.pad_curses import PadCurses
+from display.simple_curses import SimpleCurses
+from models.identity import Identity
+
+
+class DisplayClient(Client, ABC):
+    display: SimpleCurses
+
+    def __init__(self, identity: Identity, name: str = "DIOXANE"):
+        super().__init__(identity, name)
+
+        self.display = PadCurses(self)
+
+    def _exit(self, code: int = 0):
+        self.display.exit()
+        super()._exit(code)
diff --git a/client/io_client.py b/client/io_client.py
new file mode 100644
index 0000000..bdc673c
--- /dev/null
+++ b/client/io_client.py
@@ -0,0 +1,19 @@
+from abc import ABC
+from threading import Thread
+
+from client.display_client import DisplayClient
+from client.simple_client.input import Input
+from models.identity import Identity
+
+
+class IoClient(DisplayClient, ABC):
+    input: Input
+    intputThread: Thread
+
+    def __init__(self, identity: Identity, name: str = "DIOXANE"):
+        super().__init__(identity, name)
+
+        # Start the input thread
+        self.input = Input(self)
+        self.intputThread = Thread(target=self.input.start_listening)
+        self.intputThread.start()
diff --git a/client/simple_client/identity_manager.py b/client/simple_client/identity_manager.py
index 74d80fa..e288955 100644
--- a/client/simple_client/identity_manager.py
+++ b/client/simple_client/identity_manager.py
@@ -1,5 +1,5 @@
 from exceptions.exceptions import UnknownRecipient
-from misc.hex_enumerator import bytes_to_int, bytes_to_str
+from misc.hex_enumerator import bytes_to_str
 from models.identity import Identity
 
 
@@ -36,7 +36,7 @@ def getIdentity(self, identity: str | bytearray) -> Identity:
         try:
             if key_id in self.contactsByKey:
                 return self.contactsByKey[key_id]
-        except ValueError as e:
+        except ValueError:
             pass
 
         raise UnknownRecipient(identity)
diff --git a/client/simple_client/input.py b/client/simple_client/input.py
index 0434d6a..53f1f9e 100644
--- a/client/simple_client/input.py
+++ b/client/simple_client/input.py
@@ -1,10 +1,10 @@
 import curses
 
-from client.client import Client
+from client.display_client import DisplayClient
 
 
 class Input:
-    client: Client  # TOREWORK : Input needs at least a SimpleClient, but will result in a circular import error
+    client: DisplayClient
     listening: bool
     prompt: str
     prompt_cursor: int
diff --git a/client/simple_client/PacketGenerator.py b/client/simple_client/packet_generator.py
similarity index 77%
rename from client/simple_client/PacketGenerator.py
rename to client/simple_client/packet_generator.py
index 3cb25c3..377d469 100644
--- a/client/simple_client/PacketGenerator.py
+++ b/client/simple_client/packet_generator.py
@@ -1,7 +1,7 @@
 from client.client import Client
 from models.identity import Identity
-from models.message import Message
 from models.packet import Packet, PacketCode
+from models.room_message import RoomMessage
 
 
 class PacketGenerator:
@@ -24,14 +24,16 @@ def get_send_key_packet(self) -> Packet:
         """
         return Packet(PacketCode.SEND_KEY, self.client.identity.get_key_pair())
 
-    def get_send_message_packet(self, message: Message) -> Packet:
+    # noinspection PyMethodMayBeStatic
+    def get_send_message_packet(self, message: RoomMessage) -> Packet:
         """
         Build a Message Packet
         :param message: Message to send
         :return: Message Send Packet
         """
-        return Packet(PacketCode.MESSAGE_SEND, message.room.id.get_key_id_pair().append(message.payload))
+        return Packet(PacketCode.MESSAGE_SEND, message.room.room_id.get_key_id_pair().append(message.payload))
 
+    # noinspection PyMethodMayBeStatic
     def get_knock_packet(self, recipient: Identity) -> Packet:
         """
         Build a Kncok Packet
diff --git a/client/simple_client/simple_client.py b/client/simple_client/simple_client.py
index 1209cb9..30ef3a1 100644
--- a/client/simple_client/simple_client.py
+++ b/client/simple_client/simple_client.py
@@ -1,41 +1,33 @@
 from threading import Thread
 
-from client.client import Client
-from client.simple_client.PacketGenerator import PacketGenerator
+from client.io_client import IoClient
+from client.simple_client.packet_generator import PacketGenerator
 from client.simple_client.identity_manager import IdentityManager
 from client.simple_client.simple_client_connection_state import Server, ConnectionState
-from display.pad_curses import PadCurses
 from misc.hex_enumerator import bytes_to_str, bytes_to_int, str_to_bytes
 from models.identity import Identity
 from models.knock import Knock, KnockState
-from models.message import Message, MessageType
+from models.message import MessageType
 from models.packet import Packet, PacketCode
 
-from connection.fake_server import FakeConnection
-
-from display.display import Display
-
-from client.simple_client.input import Input
 from exceptions.exceptions import MalformedPacketException, UnknownRecipient
 from models.room import Room
+from models.room_message import RoomMessage
 
 
-class SimpleClient(Client, IdentityManager):
+class SimpleClient(IoClient, IdentityManager):
     """
     SimpleClient is a basic implementation of Eth3r.
     It works with a Display to output message and input prompt
     It works along a Server, which handle a connection and the state of Eth3r's connection
     """
-    display: Display  # TOREWORK : SimpleClient require at least Simple Curses but
     server: Server
-    input: Input
 
-    knock: dict[Identity, Knock]
+    knocks: dict[Identity, Knock]
     rooms: dict[Identity, Room]
-    roomRecipients: dict[Identity, Identity] # Map Recipient to their Room id
+    roomRecipients: dict[Identity, Identity]  # Map Recipient to their Room id
 
     serverThread: Thread
-    intputThread: Thread
 
     packetGenerator: PacketGenerator
 
@@ -44,21 +36,15 @@ class SimpleClient(Client, IdentityManager):
     def __init__(self, identity: Identity, name: str = "DIOXANE"):
         super().__init__(identity, name)
 
-        self.display = PadCurses(self)
         self.packetGenerator = PacketGenerator(self)
 
         # Start the server
-        self.server = Server(FakeConnection(), self)
+        self.server = Server(self)
         self.server.connection.attach(self)
         self.serverThread = Thread(target=self.server.connection.start_listening, daemon=True)
         self.serverThread.start()
 
-        # Start the input thread
-        self.input = Input(self)
-        self.intputThread = Thread(target=self.input.start_listening)
-        self.intputThread.start()
-
-        self.knock = {}
+        self.knocks = {}
         self.rooms = {}
         self.roomRecipients = {}
 
@@ -104,8 +90,8 @@ def interpret(self, packet: Packet):
                         f"Recieved a knock request from {recipient} but we don't know who it is.")
                     self.display.display_debug(f"We can use /rename {recipient} <name> to set their name")
 
-                self.knock[recipient] = Knock(recipient)
-                self.knock[recipient].state = KnockState.KNOCKING_RECEIVED
+                self.knocks[recipient] = Knock(recipient)
+                self.knocks[recipient].state = KnockState.KNOCKING_RECEIVED
 
             case PacketCode.KNOCK_RESPONSE:
                 accepted = packet.options[0] == b'\x01'
@@ -113,30 +99,32 @@ def interpret(self, packet: Packet):
                 try:
                     recipient = self.getIdentity(key_id)
                 except UnknownRecipient:
-                    self.display.display_error(f"Recieved a knock response from {bytes_to_str(key_id)} but we don't know who it is.")
+                    self.display.display_error(f"Recieved a knock response from {bytes_to_str(key_id)}"
+                                               f"but we don't know who it is.")
                     return self.display.display_debug(f"Have we ever ask them in the first place ?")
 
-                if recipient not in self.knock:
+                if recipient not in self.knocks:
                     return self.display.display_error(f"Recieving a {'positive' if accepted else 'negative'}"
                                                       f" knocking response from {recipient}"
                                                       f" but never asked them in the first place")
 
-                if self.knock[recipient].state == KnockState.KNOCKING:
+                if self.knocks[recipient].state == KnockState.KNOCKING:
                     self.display.display_debug(f'Server forwarded {recipient}\'s response to our knock but we never'
-                                               f'recieved ACK from the server itself. We won\'t mind and pretend it did')
-                    self.knock[recipient].state = KnockState.KNOCKING_ACK
+                                               f'recieved ACK from the server itself.'
+                                               f'We won\'t mind and pretend it did')
+                    self.knocks[recipient].state = KnockState.KNOCKING_ACK
 
-                if self.knock[recipient].state == KnockState.KNOCKING_ACK:
+                if self.knocks[recipient].state == KnockState.KNOCKING_ACK:
                     if accepted:
-                        self.knock[recipient].state = KnockState.KNOCK_ACCEPTED
+                        self.knocks[recipient].state = KnockState.KNOCK_ACCEPTED
                         return self.display.display_success(f"{recipient} accepted our knock")
                     else:
-                        self.knock[recipient].state = KnockState.KNOCK_REFUSED
+                        self.knocks[recipient].state = KnockState.KNOCK_REFUSED
                         return self.display.display_error(f"{recipient} refused our knock")
                 else:
                     return self.display.display_error(f"Recieving a {'positive' if accepted else 'negative'}"
                                                       f" knocking response from {recipient}"
-                                                      f" but we were {self.knock[recipient].state}")
+                                                      f" but we were {self.knocks[recipient].state}")
             case PacketCode.ROOM_NEW:
                 room_key_length, room_key, key_id_length, key_id = packet.options
                 try:
@@ -146,14 +134,14 @@ def interpret(self, packet: Packet):
                         f"Recieved a room with {bytes_to_str(key_id)} but we don't know who it is.")
                     return self.display.display_debug(f"Have we ever ask them in the first place ?")
 
-                if recipient not in self.knock:
+                if recipient not in self.knocks:
                     self.display.display_error(f"Recieving a room with {recipient}"
-                                                      f" but never asked them in the first place")
+                                               f" but never asked them in the first place")
                     self.display.display_log(f"Room with {recipient} joined anyway")
                     self._join_room(recipient, room_key)
                     return
 
-                match self.knock[recipient].state:
+                match self.knocks[recipient].state:
                     case KnockState.KNOCK_REFUSED:
                         self.display.display_error(f"Server created a room with {recipient} despite we/they refused.")
                         self.display.display_log(f"Joining room with {recipient} anyway")
@@ -161,25 +149,25 @@ def interpret(self, packet: Packet):
                         self.display.display_log(f"Room with {recipient} successfully joined")
                     case _:
                         self.display.display_error(f"Server created a room with {recipient}"
-                                                   f"but we were {self.rooms[recipient].state}")
+                                                   f"but we were {self.knocks[recipient].state}")
                         self.display.display_log(f"Joining room with {recipient} anyway")
 
                 self._join_room(recipient, room_key)
 
             case PacketCode.MESSAGE_SEND:
                 room_key_length, room_key, encryption, payload = packet.options
-                room_id = Identity(key_id = room_key, key_id_length=room_key_length)
+                room_id = Identity(key_id=room_key, key_id_length=room_key_length)
                 if room_id not in self.rooms:
                     return self.display.display_error(f"Recieved a message in room {room_id} despite we are not in it :"
-                                               f" {payload.decode('ascii')}")
+                                                      f" {payload.decode('ascii')}")
 
                 if self.rooms[room_id].closed:
                     self.display.display_error(f"We recieved a message in room {room_id} "
                                                f"but it was closed")
 
-                message: Message = Message(room=room_id,
-                                           message_type=MessageType.RECEIVE,
-                                           payload=payload, ack=True)
+                message: RoomMessage = RoomMessage(room=room_id,
+                                                   message_type=MessageType.RECEIVE,
+                                                   payload=payload, ack=True)
                 self._display_message(message)
 
             case PacketCode.ROOM_CLOSE:
@@ -192,7 +180,7 @@ def interpret(self, packet: Packet):
                 if self.rooms[room_id].closed:
                     self.display.display_error(f"Server tells us it is closing room {room_id}"
                                                f" despite it already being closed")
-                self.rooms[room_id].close = True
+                self.rooms[room_id].closed = True
 
             case _:
                 self.display.display_error(f"This version of client yet not know how to interpret {packet.code.name}")
@@ -215,7 +203,7 @@ def _match_ack_to_something(self, packet: Packet):
         if self.server.state == ConnectionState.CONNECTION_INITIALIZED_KEY:
             return self._validate_connection()
 
-        for knock in self.knock.values():
+        for knock in self.knocks.values():
             if knock.state == KnockState.KNOCKING:
                 knock.state = KnockState.KNOCKING_ACK
                 return self.display.display_debug("Knock ack by server")
@@ -263,11 +251,11 @@ def knock(self, recipient: Identity):
         :param recipient: Recipient to knock
         """
         self.display.display_log(f'Knocking {recipient}')
-        self.knock[recipient] = Knock(recipient)
-        self.knock[recipient].state = KnockState.KNOCKING
+        self.knocks[recipient] = Knock(recipient)
+        self.knocks[recipient].state = KnockState.KNOCKING
         self.send_pck(self.packetGenerator.get_knock_packet(recipient))
 
-    def _display_message(self, message: Message):
+    def _display_message(self, message: RoomMessage):
         """
         Display a message in a room
         :param message: Message to display
@@ -289,8 +277,9 @@ def send_message_to(self, recipient: Identity, payload: bytearray | str):
         if self.rooms[room_id].closed:
             return self.display.display_error(f"Room with {recipient} is closed")
 
-        message: Message = Message(sender=self.identity, room=self.rooms[recipient], message_type=MessageType.SENT,
-                                   payload=payload, ack=False)
+        message: RoomMessage = RoomMessage(sender=self.identity, room=self.rooms[recipient],
+                                           message_type=MessageType.SENT,
+                                           payload=payload, ack=False)
         self._display_message(message)
         self.send_pck(self.packetGenerator.get_send_message_packet(message))
 
@@ -350,18 +339,17 @@ def _command(self, command: str, options: list[str]):
                             self.display.display_log(f"{contact} : {bytes_to_str(contact.key_id)}")
                     case 'rooms':
                         for room in self.rooms.values():
-                            self.display.display_log(f"{room.name} : {room.state}")
+                            self.display.display_log(f"{room.name} : {room.closed=}")
+                    case 'knocks':
+                        for knock in self.knocks.values():
+                            self.display.display_log(f"{knock.recipient.name} : {knock.state}")
             case 'help':
                 self.display.display_debug("connect")
                 self.display.display_debug("knock <recipient> <message>")
                 self.display.display_debug("send <recipient> <message>")
-                self.display.display_debug("list <contacts/rooms>")
+                self.display.display_debug("list <contacts/rooms/knocks>")
                 self.display.display_debug("server <pck>")
                 self.display.display_debug("echo <message>")
             case _:
                 self.display.display_error("Unknown command")
                 self.display.display_log(command)
-
-    def _exit(self, code: int = 0):
-        self.display.exit()
-        super()._exit(code)
diff --git a/client/simple_client/simple_client_connection_state.py b/client/simple_client/simple_client_connection_state.py
index 5b2f544..3f6c848 100644
--- a/client/simple_client/simple_client_connection_state.py
+++ b/client/simple_client/simple_client_connection_state.py
@@ -1,7 +1,7 @@
 from enum import Enum, auto
 
 from client.client import Client
-from connection.connection import Connection
+from connection.fake_server import FakeConnection
 
 
 class ConnectionState(Enum):
@@ -18,18 +18,20 @@ class Server:
     Server is a class that handle both the communication (over internet/other medium) and the state of the connection
     to the Eth3r server (I.E. whereas the client is properly authentificated or waiting for the response)
     """
-    connection: Connection  # A connection to operate over
+    connection: FakeConnection  # A connection to operate over
     state: ConnectionState  # The state of the connection with the Eth3r server
     client: Client  # Reference back to the client
     attempt: int  # Connection attempt NOT_YET_IMPLEMENTED
     errors: list[str]  # List of error NOT_YET_IMPLEMENTED
 
-    def __init__(self, connection: Connection, client: Client):
+    def __init__(self, client: Client, connection: FakeConnection = None):
         """
-        Instantiate the Server, with a Deconnected state
+        Instantiate the Server, with a Disconnected state
         :param connection: Connection
         :param client: Client
         """
+        if connection is None:
+            connection = FakeConnection()
         self.connection = connection
         self.client = client
-        self.state = ConnectionState.DECONNECTED
+        self.state = ConnectionState.DISCONNECTED
diff --git a/connection/fake_server.py b/connection/fake_server.py
index 0ea39ad..f0cc3a2 100644
--- a/connection/fake_server.py
+++ b/connection/fake_server.py
@@ -2,7 +2,7 @@
 
 from connection.connection import Connection
 from misc.hex_enumerator import int_to_bytes
-from models.packet import Packet, PacketCode
+from models.packet import PacketCode
 
 
 class FakeConnection(Connection):
diff --git a/display/display.py b/display/display.py
index 106f40b..960e2d1 100644
--- a/display/display.py
+++ b/display/display.py
@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 
 from client.client import Client
-from models.message import Message
+from models.room_message import RoomMessage
 
 
 class Display(ABC):
@@ -25,7 +25,11 @@ def update_prompt(self, prompt: str, cursor: int):
         raise NotImplementedError
 
     @abstractmethod
-    def display_message(self, message: Message | str):
+    def display_message(self, message: RoomMessage | str):
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_message(self, message: RoomMessage | str):
         raise NotImplementedError
 
     @abstractmethod
diff --git a/display/pad_curses.py b/display/pad_curses.py
index dbba84f..16407cc 100644
--- a/display/pad_curses.py
+++ b/display/pad_curses.py
@@ -2,7 +2,8 @@
 
 from client.client import Client
 from display.simple_curses import SimpleCurses, SimpleCursesColor
-from models.message import Message, MessageType
+from models.message import MessageType
+from models.room_message import RoomMessage
 
 
 class PadCurses(SimpleCurses):
@@ -46,6 +47,7 @@ def scroll(self, scroll_delta: int = 0):
         self._update_scroll()
 
     def _update_scroll(self):
+        # noinspection PyArgumentList
         self.message_pad.noutrefresh(self.windows_scroll, 0, 1, 0, self.height - 2, self.width - 1)
         curses.doupdate()
 
@@ -65,9 +67,9 @@ def update_prompt(self, prompt: str, cursor: int):
         self._display_line(height=0, left_txt="> " + prompt, fillingchar=" ", windows=self.prompt_windows)
         self._update_cursor()
 
-    def display_message(self, message: Message | str):
+    def display_message(self, message: RoomMessage | str):
         if type(message) is str:
-            return self.display_message(Message(payload=message, message_type=MessageType.LOG))
+            return self.display_message(RoomMessage(payload=message, message_type=MessageType.LOG))
 
         self.messages.append(message)
         if self.windows_scroll_jump or self.windows_scroll + 1 == len(self.messages) - (self.height - 2):
@@ -80,7 +82,6 @@ def display_message(self, message: Message | str):
         else:
             self._display_message(message, len(self.messages) - 1)
 
-
     def _update_cursor(self, y=0, x=None):
         if x is None:
             x = self.prompt_cursor + 2
diff --git a/display/simple_curses.py b/display/simple_curses.py
index 1273ed4..1815241 100644
--- a/display/simple_curses.py
+++ b/display/simple_curses.py
@@ -3,7 +3,8 @@
 
 from client.client import Client
 from display.display import Display
-from models.message import Message, MessageType
+from models.message import MessageType
+from models.room_message import RoomMessage
 
 
 class SimpleCursesColor(IntEnum):
@@ -27,7 +28,7 @@ class SimpleCurses(Display):
 
     color_variation: dict[SimpleCursesColor]
 
-    messages: list[Message]
+    messages: list[RoomMessage]
     input_windows: "_CursesWindow"
 
     def __init__(self, client: Client):
@@ -100,7 +101,7 @@ def _display_all_messages(self):
             self._display_message(message, i)
             i += 1
 
-    def _display_message(self, message: Message, height: int):
+    def _display_message(self, message: RoomMessage, height: int):
 
         header = ""
         color = SimpleCursesColor.CLASSIC
@@ -147,9 +148,9 @@ def update_prompt(self, prompt: str, cursor: int):
         self._display_line(height=self.height - 1, left_txt="> " + prompt, fillingchar=" ", windows=self.stdscr)
         self._update_cursor()
 
-    def display_message(self, message: Message | str):
+    def display_message(self, message: RoomMessage | str):
         if type(message) is str:
-            return self.display_message(Message(payload=message, message_type=MessageType.LOG))
+            return self.display_message(RoomMessage(payload=message, message_type=MessageType.LOG))
 
         self.messages.append(message)
         if len(self.messages) > self.height - 2:
@@ -159,18 +160,18 @@ def display_message(self, message: Message | str):
             self._display_message(message, len(self.messages))
 
     def display_error(self, text: str):
-        return self.display_message(Message(payload=text, message_type=MessageType.ERROR))
+        return self.display_message(RoomMessage(payload=text, message_type=MessageType.ERROR))
 
     def display_log(self, text: str):
-        return self.display_message(Message(payload=text, message_type=MessageType.LOG))
+        return self.display_message(RoomMessage(payload=text, message_type=MessageType.LOG))
 
     def display_debug(self, text: str):
-        return self.display_message(Message(payload=text, message_type=MessageType.DEBUG))
+        return self.display_message(RoomMessage(payload=text, message_type=MessageType.DEBUG))
 
     def display_success(self, text: str):
-        return self.display_message(Message(payload=text, message_type=MessageType.SUCCESS))
+        return self.display_message(RoomMessage(payload=text, message_type=MessageType.SUCCESS))
 
-    def update_message(self, message: Message):
+    def update_message(self, message: RoomMessage):
         try:
             index: int = self.messages.index(message)
             self._display_message(message, index)
@@ -187,3 +188,6 @@ def exit(self):
         curses.echo()
         self.stdscr.keypad(False)
         curses.endwin()
+
+    def scroll(self, value: int):
+        pass
diff --git a/identity_provider/gpg.py b/identity_provider/gpg.py
index facff11..d7bb9b3 100644
--- a/identity_provider/gpg.py
+++ b/identity_provider/gpg.py
@@ -10,14 +10,15 @@
 
 gpg = gnupg.GPG()
 
+
 # UNTESTED
 class GPGKeyProvider(IdentityProvider):
     @staticmethod
     def getIdentity(identity: str) -> Identity:
         # TODO : This is only the backbone of GPG Key Provider
         # It hasn't been verified and may not even work
-        key = gpg.export_keys(identity, False, armor=False)
-        key_id = int(f"0x1312") # Todo : use gpg to get key_id
+        key = gpg.export_keys(identity, False)
+        key_id = int(f"0x1312")  # Todo : use gpg to get key_id
         return Identity(name=identity,
                         key_length=len(hex(key))-2,
                         key=hex(key),
diff --git a/identity_provider/simple_key.py b/identity_provider/simple_key.py
index f9dce68..5d9d1fe 100644
--- a/identity_provider/simple_key.py
+++ b/identity_provider/simple_key.py
@@ -13,4 +13,4 @@ def getIdentity(identity: str) -> Identity:
 
 
 baba: Identity = SimpleKeyProvider.getIdentity("baba")
-fefe: Identity = SimpleKeyProvider.getIdentity("fefe")
\ No newline at end of file
+fefe: Identity = SimpleKeyProvider.getIdentity("fefe")
diff --git a/misc/hex_enumerator.py b/misc/hex_enumerator.py
index 1fedb74..c5d7a03 100644
--- a/misc/hex_enumerator.py
+++ b/misc/hex_enumerator.py
@@ -43,7 +43,7 @@ def bytes_to_str(value: bytearray) -> str:
     return hex(int.from_bytes(value, 'big'))
 
 
-def _read_bytes(bytesEnumerator: enumerate, size: int | bytearray = 1, value: bytearray = bytearray(0)) -> bytearray:
+def read_bytes(bytesEnumerator: enumerate, size: int | bytearray = 1, value: bytearray = bytearray(0)) -> bytearray:
     """
     Read bytes from an enumerator and return them as a bytearray
     :param bytesEnumerator: enumerator
diff --git a/models/knock.py b/models/knock.py
index be180c3..548e279 100644
--- a/models/knock.py
+++ b/models/knock.py
@@ -1,7 +1,6 @@
 from enum import Enum, auto
 
 from models.identity import Identity
-from models.message import Message, MessageType
 
 
 class KnockState(Enum):
diff --git a/models/message.py b/models/message.py
index 60409a4..04927e2 100644
--- a/models/message.py
+++ b/models/message.py
@@ -2,7 +2,6 @@
 from enum import Enum, auto
 
 from models.identity import Identity
-from models.packet import Packet, PacketCode
 
 
 class MessageType(Enum):
@@ -18,24 +17,22 @@ class Message:
     """
     Generic class to define a Message structure
     It must contains a payload
-    It can have a sender, a recipient or a room
+    It can have a sender, a recipient
     """
     payload: bytearray  # Content of the message
     sender: Identity  # Sender
     recipient: Identity  # Recipient
-    room: "Room"  # Room where it was sent/recieved
     ack: bool  # Was it ACK by the server (for sent message)
     message_type: MessageType  # Type
     id: int  # Random int
 
     def __init__(self, payload: bytearray | str, sender: Identity = None, recipient: Identity = None,
-                 room: "Room" = None, ack: bool = True, message_type: MessageType = None):
+                 ack: bool = True, message_type: MessageType = None):
         """
         Create a message, whome payload can be define by a bytearray or a str (will be cast in ascii bytesarray)
         :param payload: Byte array or string
         :param sender: Sender
         :param recipient: Recipient
-        :param room: Room
         :param ack: ACK by the server (Default is True)
         :param message_type: Type
         """
@@ -46,7 +43,6 @@ def __init__(self, payload: bytearray | str, sender: Identity = None, recipient:
         self.payload = payload
         self.sender = sender
         self.recipient = recipient
-        self.room = room
         self.ack = ack
         self.message_type = message_type
 
diff --git a/models/packet.py b/models/packet.py
index b3b78d6..9b12b02 100644
--- a/models/packet.py
+++ b/models/packet.py
@@ -1,7 +1,7 @@
 from enum import IntEnum
 
 from exceptions.exceptions import MalformedPacketException, EndOfEnumerator
-from misc.hex_enumerator import _read_bytes, int_to_bytes, str_to_bytes, bytes_to_str, bytes_to_int
+from misc.hex_enumerator import read_bytes, int_to_bytes, str_to_bytes, bytes_to_str, bytes_to_int
 
 
 class PacketCode(IntEnum):
@@ -41,7 +41,7 @@ class Packet:
     code: PacketCode
     options: list[bytearray]
 
-    def __init__(self, payload: bytearray | bytes | int | str | PacketCode, options: list[bytearray] = []):
+    def __init__(self, payload: bytearray | bytes | int | str | PacketCode, options: list[bytearray] = None):
 
         if options is None:
             options = []
@@ -72,12 +72,11 @@ def __init__(self, payload: bytearray | bytes | int | str | PacketCode, options:
                 raise MalformedPacketException("Packet options doesn't match expected size of "
                                                + self.code.name + " : " + bytes_to_str(payload))
 
-
     def _set_code_from_enumerator(self, bytesEnumerator):
         code = bytearray(b'')
         while bytes_to_int(code) not in PacketCode.value2member_map_:
             try:
-                code = _read_bytes(bytesEnumerator, 1, code)
+                code = read_bytes(bytesEnumerator, 1, code)
             except EndOfEnumerator:
                 raise MalformedPacketException("PacketCode doesn't correspond to an implemented code : "
                                                + bytes_to_str(code))
@@ -86,11 +85,11 @@ def _set_code_from_enumerator(self, bytesEnumerator):
     def _set_options_from_enumerator(self, bytesEnumerator):
         match self.code:
             case PacketCode.HEY:
-                self.options += _read_bytes(bytesEnumerator, 2)
+                self.options += read_bytes(bytesEnumerator, 2)
 
             case PacketCode.ACK:
                 try:
-                    nextByte = _read_bytes(bytesEnumerator)
+                    nextByte = read_bytes(bytesEnumerator)
 
                     # An KEY_RESPONSE PacketCode can be confused with an ACK as they both start with 0xa0
                     # Thus ACK followed by 0xba are converted into a simple KEY_RESPONSE
@@ -99,7 +98,7 @@ def _set_options_from_enumerator(self, bytesEnumerator):
                     else:
                         while True:
                             try:
-                                nextByte = _read_bytes(bytesEnumerator, 1, value=nextByte)
+                                nextByte = read_bytes(bytesEnumerator, 1, value=nextByte)
                             except EndOfEnumerator:
                                 break
                         self.options.append(nextByte)
@@ -107,38 +106,38 @@ def _set_options_from_enumerator(self, bytesEnumerator):
                     pass
 
             case PacketCode.SEND_KEY | PacketCode.KEY_RESPONSE:
-                key_length = _read_bytes(bytesEnumerator, 2)
-                self.options += [key_length, _read_bytes(bytesEnumerator, key_length)]
+                key_length = read_bytes(bytesEnumerator, 2)
+                self.options += [key_length, read_bytes(bytesEnumerator, key_length)]
 
             case PacketCode.KNOCK_SEND | PacketCode.KNOCK_RECIEVE | PacketCode.ROOM_CLOSE | PacketCode.KEY_REQUEST \
                  | PacketCode.KEY_UNKNOWN:
-                key_length = _read_bytes(bytesEnumerator, 1)
-                self.options += [key_length, _read_bytes(bytesEnumerator, key_length)]
+                key_length = read_bytes(bytesEnumerator, 1)
+                self.options += [key_length, read_bytes(bytesEnumerator, key_length)]
 
             case PacketCode.KNOCK_RESPONSE:
-                response = _read_bytes(bytesEnumerator, 1)
-                key_length = _read_bytes(bytesEnumerator, 1)
-                self.options += [response, key_length, _read_bytes(bytesEnumerator, key_length)]
+                response = read_bytes(bytesEnumerator, 1)
+                key_length = read_bytes(bytesEnumerator, 1)
+                self.options += [response, key_length, read_bytes(bytesEnumerator, key_length)]
 
             case PacketCode.ROOM_NEW:
-                room_length = _read_bytes(bytesEnumerator, 1)
-                room_id = _read_bytes(bytesEnumerator, room_length)
+                room_length = read_bytes(bytesEnumerator, 1)
+                room_id = read_bytes(bytesEnumerator, room_length)
 
-                key_length = _read_bytes(bytesEnumerator, 1)
-                key_id = _read_bytes(bytesEnumerator, key_length)
+                key_length = read_bytes(bytesEnumerator, 1)
+                key_id = read_bytes(bytesEnumerator, key_length)
 
                 self.options += [room_length, room_id, key_length, key_id]
 
             case PacketCode.MESSAGE_SEND:
-                room_length = _read_bytes(bytesEnumerator, 1)
+                room_length = read_bytes(bytesEnumerator, 1)
 
-                room_id = _read_bytes(bytesEnumerator, room_length)
-                encryption = _read_bytes(bytesEnumerator, 1)
+                room_id = read_bytes(bytesEnumerator, room_length)
+                encryption = read_bytes(bytesEnumerator, 1)
 
                 payload = bytearray(b'')
                 while True:
                     try:
-                        payload = _read_bytes(bytesEnumerator, 1, value=payload)
+                        payload = read_bytes(bytesEnumerator, 1, value=payload)
                     except EndOfEnumerator:
                         break
 
@@ -156,13 +155,3 @@ def to_bytes(self):
 
     def __str__(self):
         return "<Packet " + self.code.name + " " + " ".join(list(map(hex, self.options))) + ">"
-
-
-# packet: Packet = Packet(0x123456)
-# packet_HEY: Packet = Packet("0x0531b00b a001")
-# packet_ACK: Packet = Packet("0xa0")
-# packet_KEY_REQUEST: Packet = Packet("0xba 02 baba")
-# packet_KEY_REQUEST2: Packet = Packet("0xba 04 baba202")
-# packet_ROOM_NEW: Packet = Packet("0xac 02cafe 02baba")
-
-# packet_TESt: Packet = Packet(PacketCode.SEND_KEY, me.get_key_pair())
diff --git a/models/room.py b/models/room.py
index e9bccaf..2dc09f5 100644
--- a/models/room.py
+++ b/models/room.py
@@ -1,5 +1,3 @@
-from enum import Enum, auto
-
 from models.identity import Identity
 from models.message import Message, MessageType
 
@@ -13,14 +11,14 @@ class Room:
     # Recipient of the room has to be saved client side so we can know afterward who is talking in the room
     recipient: Identity
     messages: list[Message]  # List of message in the room
-    id: Identity  # Id of the room server side
+    room_id: Identity  # Id of the room server side
 
-    def __init__(self, recipient: Identity, id: Identity):
+    def __init__(self, recipient: Identity, room_id: Identity):
         self.recipient = recipient
         self.name = str(recipient)
         self.closed = False
         self.messages = []
-        self.id = id
+        self.room_id = room_id
 
     def add_message(self, message: Message):
         """
diff --git a/models/room_message.py b/models/room_message.py
new file mode 100644
index 0000000..df50329
--- /dev/null
+++ b/models/room_message.py
@@ -0,0 +1,24 @@
+from models.identity import Identity
+from models.message import MessageType, Message
+from models.room import Room
+
+
+class RoomMessage(Message):
+    """
+    Message that can be in a room
+    """
+    room: Room  # Room where it was sent/recieved
+
+    def __init__(self, payload: bytearray | str, sender: Identity = None, recipient: Identity = None,
+                 room: Room = None, ack: bool = True, message_type: MessageType = None):
+        """
+        Create a message, whome payload can be define by a bytearray or a str (will be cast in ascii bytesarray)
+        :param payload: Byte array or string
+        :param sender: Sender
+        :param recipient: Recipient
+        :param room: Room
+        :param ack: ACK by the server (Default is True)
+        :param message_type: Type
+        """
+        super().__init__(payload, sender, recipient, ack, message_type)
+        self.room = room