From 37145136bff42e56655c9e991dae312fbe56513c Mon Sep 17 00:00:00 2001 From: Fomys Date: Sun, 18 Nov 2018 12:52:55 +0100 Subject: [PATCH] First good version of server --- Pipfile | 2 +- Pipfile.lock | 55 +++++++++++++ client/main.py | 88 ++++++++++----------- client/private.pem | 146 ++++++++++++++++++++++------------ client/receiver.pem | 35 +++++--- private.pem | 51 ++++++++++++ receiver.pem | 14 ++++ server/main.py | 189 ++++++++++++++++++++++++++------------------ 8 files changed, 392 insertions(+), 188 deletions(-) create mode 100644 Pipfile.lock create mode 100644 private.pem create mode 100644 receiver.pem diff --git a/Pipfile b/Pipfile index fb2f2e1..cd065f8 100644 --- a/Pipfile +++ b/Pipfile @@ -4,7 +4,7 @@ verify_ssl = true name = "pypi" [packages] -pycryptodome = "*" +pycryptodomex = "*" [dev-packages] diff --git a/Pipfile.lock b/Pipfile.lock new file mode 100644 index 0000000..1b9995e --- /dev/null +++ b/Pipfile.lock @@ -0,0 +1,55 @@ +{ + "_meta": { + "hash": { + "sha256": "ea1158d96215416c8146e8deedecea8da28400d9f80633238e5816576965f13e" + }, + "pipfile-spec": 6, + "requires": { + "python_version": "3.7" + }, + "sources": [ + { + "name": "pypi", + "url": "https://pypi.org/simple", + "verify_ssl": true + } + ] + }, + "default": { + "pycryptodomex": { + "hashes": [ + "sha256:02c358fa2445821d110857266e4e400f110054694636efe678dc60ba22a1aaef", + "sha256:09989c8a1b83e576d02ad77b9b019648648c569febca41f58fa04b9d9fdd1e8f", + "sha256:0f8fe28aec591d1b86af596c9fc5f75fc0204fb1026188a44e5e1b199780f1e5", + "sha256:0fb58c2065030a5381f3c466aaa7c4de707901badad0d6a0575952bb10e6c35f", + "sha256:0fb9f3e6b28a280436afe9192a9957c7f56e20ceecb73f2d7db807368fdf3aaf", + "sha256:12ff38a68bbd743407018f9dd87d4cc21f9cb28fe2d8ba93beca004ada9a09ff", + "sha256:1650143106383bae79cbbda3701fd9979d0a624dba2ec2fa63f88cae29dd7174", + "sha256:20a646cd0e690b07b7da619bc5b3ee1467243b2e32dfff579825c3ad5d7637ab", + "sha256:284779f0908682657adb8c60d8484174baa0d2620fb1df49183be6e2e06e73ce", + "sha256:2f3ce5bfe81d975c45e4a3cbe2bef15b809acc24f952f5f6aa67c2ae3c1a6808", + "sha256:30ac12f0c9ac8332cc76832fea88a547b49ef60c31f74697ee2584f215723d4f", + "sha256:4f038b815d66dea0b1d4286515d96474204e137eb5d883229616781865902789", + "sha256:57199a867b9991b1950f438b788e818338cee8ed8698e2eebdc5664521ad92a9", + "sha256:5c5349385e9863e3bba6804899f4125c8335f66d090e892d6a5bb915f5c89d4c", + "sha256:5d546fac597b5007d5ff38c50c9031945057a6a6fa1ab7585058165d370ea202", + "sha256:614eddfa0cf325e49b5b803fcb41c9334de79c4b18bf8de07e7737e1efc1d2b9", + "sha256:82ae66244824d50b2b657c32e5912fde70a6e36f41e61f2869151f226204430d", + "sha256:96a733f3be325fb17c2ba79648e85ab446767af3dc3b396f1404b9397aa28fe5", + "sha256:9c3834d27c1cff84e2a5c218e373d80ebbb3edca81912656f16137f7f97e58e0", + "sha256:9f11823636128acbe4e17c35ff668f4d0a9f3133450753a0675525b6413aa1b0", + "sha256:a3f9ad4e3f90f14707776f13b886fbac491ebe65d96a64f3ce0b378e167c3bbf", + "sha256:a89dee72a0f5024cc1cbaf85535eee8d14e891384513145d2f368b5c481dcd54", + "sha256:ccadde651e712093052286ad9ee27f5aa5f657ca688a1bf6d5c41ade709467f3", + "sha256:ced9ea10977dd52cb1b936a92119fc38fcdc5eaa4148f925ef22bbf0f0d4a5bd", + "sha256:eb0c6d3b91d55e3481158ecf77f3963c1725454fdcf5b79302c27c1c9c0d2c2a", + "sha256:f6714569a4039287972c672a8bd4b8d7dc78a601def8b31ffa39cd2fec00cb4b", + "sha256:fa4036582c8755259d4b8f4fe203ae534b7b187dcea143ab53a24e0f3931d547", + "sha256:fb31bb0c8301e5a43d8d7aad22acabef65f28f7ab057eaeb2c21433309cc41e8" + ], + "index": "pypi", + "version": "==3.7.0" + } + }, + "develop": {} +} diff --git a/client/main.py b/client/main.py index e22a84e..b1b28c9 100644 --- a/client/main.py +++ b/client/main.py @@ -7,32 +7,16 @@ import logging.config import os import socket - -#### logging #### -# json decoder for int keys -import threading - -from Crypto.Cipher import PKCS1_OAEP -from Crypto.PublicKey import RSA -from Crypto.Cipher import PKCS1_OAEP - -class Decoder(json.JSONDecoder): - def decode(self, s, **kwargs): - result = super().decode(s) # result = super(Decoder, self).decode(s) for Python 2.x - return self._decode(result) - - def _decode(self, o): - if isinstance(o, str): - try: - return int(o) - except ValueError: - return o - elif isinstance(o, dict): - return {k: self._decode(v) for k, v in o.items()} - elif isinstance(o, list): - return [self._decode(v) for v in o] - else: - return o +try: + # noinspection PyUnresolvedReferences + from Crypto.PublicKey import RSA as RSA + # noinspection PyUnresolvedReferences + from Crypto.Cipher import PKCS1_OAEP + pycryptodome = False +except ModuleNotFoundError: # Pycryptodomex + from Cryptodome.PublicKey import RSA as RSA + from Cryptodome.Cipher import PKCS1_OAEP + pycryptodome = True def setup_logging(default_path='log_config.json', default_level=logging.INFO, env_key='LOG_CFG'): @@ -64,12 +48,24 @@ critical = log_server.critical HOST = '127.0.0.1' PORT = 8888 BUFFER_SIZE = 4096 +CHUNK_SIZE = int(BUFFER_SIZE / 8) clientSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) clientSocket.connect((HOST, PORT)) + # ET ICI ON MET LE CLIENT +def send(to_send): + clientSocket.send(BEGIN_MESSAGE) + i = 0 + for to_send_text in [to_send[i:i + BUFFER_SIZE - 2] for i in range(0, len(to_send), BUFFER_SIZE - 2)]: + print((len(to_send_text)).to_bytes(2, byteorder='big')) + print((len(to_send_text)).to_bytes(2, byteorder='big') + to_send_text.ljust(BUFFER_SIZE, b";")) + clientSocket.send((len(to_send_text)).to_bytes(2, byteorder='big') + to_send_text.ljust(BUFFER_SIZE - 2, b";")) + i += 1 + print(i) + clientSocket.send(END_MESSAGE) BEGIN_MESSAGE = bytes("debut", "ascii").ljust(BUFFER_SIZE, b";") @@ -80,8 +76,8 @@ type: RSASend""" HEADER = bytes(HEADER_TXT, "ascii").ljust(BUFFER_SIZE, b";") ## création des clef RSA -print(1024) -key = RSA.generate(BUFFER_SIZE) +RSA_KEY_SIZE = CHUNK_SIZE * 2 +key = RSA.generate(BUFFER_SIZE * 2) private_key = key.export_key() file_out = open("private.pem", "wb") file_out.write(private_key) @@ -96,33 +92,31 @@ clientSocket.send(to_send) clientSocket.send(END_MESSAGE) print('ok') -# BEGIN -chunk = clientSocket.recv(BUFFER_SIZE) -print(chunk) -crypted = clientSocket.recv(BUFFER_SIZE).rstrip(b';') -for i in range(60): - crypted += clientSocket.recv(BUFFER_SIZE).rstrip(b";") -# END -chunk = clientSocket.recv(BUFFER_SIZE) -print(chunk) +chunk = bytes("", "ascii") +while chunk != BEGIN_MESSAGE: + chunk = clientSocket.recv(BUFFER_SIZE) +last_chunk = chunk +while last_chunk != END_MESSAGE: + last_chunk = clientSocket.recv(BUFFER_SIZE) + chunk += last_chunk + +print(len(chunk[BUFFER_SIZE:-BUFFER_SIZE])) +chunk = chunk[BUFFER_SIZE:-BUFFER_SIZE] # HEADER+AES key are encypted in same time, so decrypt time at same time cipher_rsa = PKCS1_OAEP.new(key) texte_to_decrypt = b'' -for ligne in [crypted[i:i + BUFFER_SIZE] for i in range(0, len(crypted), BUFFER_SIZE)]: +for ligne in [chunk[i:i + BUFFER_SIZE] for i in range(0, len(chunk), BUFFER_SIZE)]: to_decrypt = ligne[2:] - print(ligne) - print(int.from_bytes(ligne[:2], byteorder='big')) to_decrypt = to_decrypt[:int.from_bytes(ligne[:2], byteorder='big')] texte_to_decrypt += to_decrypt +print(len(texte_to_decrypt)) texte = b'' -for to_decrypt in [texte_to_decrypt[i:i + int(BUFFER_SIZE/8)] for i in range(0, len(texte_to_decrypt), int(BUFFER_SIZE/8))]: +for to_decrypt in [texte_to_decrypt[i:i + RSA_KEY_SIZE] for i in range(0, len(texte_to_decrypt), RSA_KEY_SIZE)]: + print(len(to_decrypt)) + print(to_decrypt) + print(texte) + print(len(texte)) texte += cipher_rsa.decrypt(to_decrypt) print(texte) - - - - - - diff --git a/client/private.pem b/client/private.pem index 9903635..8389410 100644 --- a/client/private.pem +++ b/client/private.pem @@ -1,51 +1,99 @@ -----BEGIN RSA PRIVATE KEY----- -MIIJKAIBAAKCAgEAtp/nSjVpOYelOdyJxVrYVKz0otcy33KEZeOvv3Bglq7hFySM -wLLBRuC6vGCMFVVMqQFlrQ4TiD3Z8e+Xf2UkCAzkTNbCg/Mf66A7nruWGriFY2pg -0LaFBAuxAOFHaW2B7yDm3+02atztlGFkTgDW94gPzzhE2gZ/5fULf4wm5HkkKNiY -kg7fqifoed9POV7o0xfyjTm1fRhjy/poBJevOO1h4OMlGM5z3E8HBNceiDUwbdm6 -izu50HHp0AP+7Pja9uO6WuX1dK3n4wm4hrCGpEb+h4m/kKUBEQqzjQqNWFUP4ksm -4G84cFACbGwD7OGm3Y1OVYfGC6Gcus0rdZeWcRQIb0gywOJ0OGmn5XIKGGwdso2n -b0/LDrBWI8BJ7J7TNu5OKg/0kKCA188nqRqnEXV7seIjb4rte6G8uXEaX54ZEBft -4oKNfU+2kCVNJm5w1nQEOjLS9enneYnFblE0FiN4o/G1EIfQHn/D/Yt6q/b7n96f -VFJye3oXikgab31msXpCGXQnGAkbnlwbSyjx98P7Lqg+zCFOMTu7panp0hELQRrC -WJEuoDiPvOuFRLVdvYj1KocfUWKdZ0ljNMNu0c4Ebmc8MW31WDvGWhbIsCmKg+Gt -YODDYIvVqEl5WnYRxLtj8ml2wq4gNRn9Y8rqmhOXHwEoRIGKsIGSgKZrFVkCAwEA -AQKCAgAM+oEz72bKfV7bJVavLV0Za285UWTep2NMYGmBh+l9W/FINUNBgJKmyFrM -/2mFLJo1mpFQwqLVuFuQS5AvMA9m+Q+SfGK3gORAWRNTnQ42WO212n4F5yq91lze -bKQoFG27AlIWEOQgpRHHTUKVHo8oaUWCWwPdoL+fJpKKHno3G3rb4kS5gJAZphtp -6dpV/+447kdBDRxeRwj0mpeg1+zOdWRS2KGuySFHw2AC0ozrbihCbkpJEdYLP8U3 -kMkhqy/YguegBR60C5XitzKjc9ElxJvbIwl3rJpOTT3kZJ8V63mlAeVB5vWSWcVK -UkTXJVQ4A45RGsSS2Ans5p7TjRHWWa2NHcoiRke2kjYMOaH6aGhhzzQ/zO++YEIO -uIaep+kcj4PPnxWacOYrphTvN5J+7DyZmi94fc3M095Rr4Cubb0nW8hP8TawZGAE -vvysiFzHH+v+XjsHzMf7s5Q2DDAl7W8p4qaLHtVp1KrmGRFbTvmkgjPMKImXIx83 -3NiGtI2NHEWxe0rcW9fkggN/sVKuS/N6/Jjp3h4UEsObqId0XllmAD2idJwEO0dI -WRrcje1Ee9LZs9s8YRjURjAbZgynbRq+DIbnmE08L3dXA6hZHsryHO0Ac2aTrWUt -aUgBq8Q+AVPQhIJZUr7T5unKoWrQ42pnXjsf5QajUbr5s/uWFwKCAQEAz6Koc/OC -zBGk1/ZpgqnDpoOYujLT2WzqMRIt9ukCBmF2zSSDjlqM3yyO9yXvnONByAuKqAA1 -JJnaOGdqg+lZiGLSi80o1VFz45mhkaMmKDBXLkptZQWUphtaFXN+g5vUfiQU8mxw -8k968yhzahXyjZZCGjXF+RzsccR8jb97Rk4YK2L1zY1nsPGLueHypnKwIPeVL5Kg -IxEqm254sUejopSppWnvAv8XOUGiqlCN9UVCiemASovzZgRF/hziVDzDrdt00V9j -PZX+9EpiFuK3Oef3frcDfSPzfKdacqKs63x6ia1/7CjJLAEVfUPW69ePFiszfZcq -sOwvurQIl4KvQwKCAQEA4SnZOUJYM1oz0vU0Y1dssB9E+AgUEraslzTYimW3QaPF -NPUKk3PzLt5asY3XeXA8sCFQi5B9Mdixne1BooBQkSGqFFl25IWvKoRen3Ve8ye1 -ZusPb9FH4Z02CqeJtgEDecr9pvVrNYEKxO8nhl3qVwNILKoQtTHZaocNLL5pGBvx -WCvpXG8ACFdYQIz2vJMkpOwwEk41/rxsrXSlFwXkyf4y5F4QHR+9zXNxw+3M1Jt+ -pX0xqMchneG+/O2vnn13+WZ//N6j2r8EJ5pknF00NUyytE3uVmbx8GGDwyNbWn5T -swcsCK0Lx2ydvm9ta3xW20WtF/kWgjyzfUgysc75MwKCAQAqM10Zc/y5jTx7yFFZ -hTeGuGhqL7pvDnvqzU8aR/FpapXCzBEQ9cZ79Yp5IPS6ZlYQWogr7R7f+YUowZwc -g2j3F17Dm0cZVBzBvY/hEc/Hi0us1OO3DJNRz21XvsmP5jQiDyNSwkeSeCT9FtOe -VCegL1HwEc3S+9XyqYTHKovbljPDXbGnvX29sNo9RXcT7Wtux+NCcAKsHekS/jj5 -jx3rBVwVippReZc2w+hTxVuU5ibH8PVqMVee/G9dXnGBvXfn9hqgE0sQUVQoQpX9 -IMcstcDPuFK1NIFgbIMtmXKbygj9wo2lagS5NN8xPoCIHp+uWcl1VSwQGXD5+W1l -neIRAoIBAFrmpDXDnQwOTIHMUHwSnWR1G0jvKftsGD1rLkihS9yKG2GH0983nmO7 -jO3Fj8oND9Mjf/r4ODLZgst5L1hFaUFOT/WrMJ6NgewuSG0j21NbIpcMKs0/tj9V -Uq32eVgrDJYs5z5yMfgFwq1Cx7gtTiAWyRqPBfPAzj99ikoYDSGYllS8VZflkCPN -72kP/8SdutuCJt4dCRtwQoe8YbHrxTPvFeiwON0pJV0+UB2DcYAbzoNNCbFTwzSU -IKDH7HCVwsvDH8SctZXoK+s5H4ko75zc/ABivefP47jiBWnQal8cRPov2Q0fn3PB -W+W34nrUVdRsSrc07mthyiy36w9xuZUCggEBAJ60bcwD/LHVaeThNiQjg0pzP9KY -4014ZBymVvCX7dXhrpLoaQztGP8MN0YBoTMNZ5MMFE27zU7h09QPBSv+/t5x380c -PfRiJHaMbcY3sdm3Gdx0DAlfYhSJ5btdXPRV2/QWACZD7VwE0/X/m9NDdbTKL6Uo -+Fqt8jPkYdcurSg77XImY7H2rEfhhrdqLbUdxAA5OU7QVU1KMyAeykqJ8lo236bu -3XssfMVmKQKv8T2/1TVqCLmnVQLYye1yl06ld+9F6h7L+KkXjmyi8cANplpFKfHf -1zVQUv+TIsU03aWzXyj7WvyOF9osqtIO+xDhc58WZ0YP73WBSgFBsihaqoo= +MIISJwIBAAKCBAEAj00qbP8CXp1dbqXG4vV+chzJx7HvkuTWqB3hQo712LjtseJ/ +i3KltwWHB+QAZ1GyswmJNW2KVDyyIq74d6K1bxy+EoSiXMctZdK3l5xL0JQwCnka +poryAuxwMkqu9scpcZ7rMIsphdvk6V4OmJdLF/LLHLRsiMKGiaYmmzB5nyQDkiQ0 ++Pxmf+baMQ6YT713O9z2aunKdrMl8sQpbms+QUOmj6VLrJ9+ttcpRoTx0LxW0yl3 +bxKM7LrMnHazOEwLR2pnTlHB5NanmDyts1XU6CzxFuCA8o3MLjpOIEw7IrllcDvF +nZrh9SrtzKaCJIXhIT5yS4q/hZ7w9BWZBKzmmiudGmNYeyJUeVfnqk7AnofE4Rb9 +5jnUWQkl3m8h1CkLRS7p0DVTvVqyeEPWXwgvzGhLZP9xBDlQJMuNoRS8xqSy/7KW +dunUt5oWPB/UwAsDLerSWp18Yi1g4q1d8o1S2Q8t5kqOE6U985jyz9YPtCcFYQUD +uyXWaFTTeGEfcY04pKt/rjffiEmJPSdSCmuCIPx56qwzvSoUsWmf/sjquQaCvtIp +ftJhp3L0eoe4BBFPnAybyKeTz8ZBzchZb9h0gH1QxHhMA51kcaJDn8pojNDup5Zg +MjrxAY9LBAhUS1hggAPf88eL23jEKYn8FYFlQ/xuc2N/Hd31IK4U77NMGCGYIVPb +DAmo9hNOWE8wEy50XNklmBIYPpWpWR1nobFHCbyu6Um1vBGYUVEzP7AVAFeUebQT +uvWHk1OZosv8SYeUvcwl3rP+R0+eokjnR7PzXfrB1lBEN+jqBHrRX2Z9GDiJTpCR +axN2dP5zbT+24bhg24mCjelUzvNLUTyguDMJLkfScnOszFmM+d1rtWDLh/AjphoT +fcCb3VWnLCcCJ4fklV0065vMotPlFxXBmFDDDKQlam2tfue/SSJjpE27lcWnXz7t +mH6O4GpOvd4/Og8PWwWRsx9xcRUZsY+6knRYoZ77sHYRxoH/M9RqVf6dxA802gv9 +7+lzLKzE0AeNm40XZnmxI7aUSzi2N93A4ykPf6/HZbN0KqhdJ9PSMTawRZh/KvMx +21El5W7l8GFLJMubfXHQ36dgNOEEFiekF9DoX0l8i8Ev6RdhrHJtJLDVE391yxx1 +hgW/JzB5hmcc8ryhtx7HsBt5vtrxE0JM1/9PxmOqqG9gXNY02ErkTK4TrJGkAx0z +4ZGKh9BSypYtTxPWq5cDuT9q7gZTOnHZ+HtSoWnGRKwwLlLmyo8ACcVXzCbj/Zfq +VcWZkVDM2rlCF9O7xkeAQNJUKvuLMVm4ZlqzM14TKzIOUtquanyx6zbajRNROE95 +Q8QAZw8I3P0pYY3+qX/7D0HJSGSN6cuNsngKAQIDAQABAoIEADSWSsVo54O1F/5s +04miMV7K9blUsOglFijnniyArfN0GbY3ujqAPhPl8WGR6BwCPSO6kiGLK0Iya+SS +dRfiG9bEo3PEPJjzdtNw+nKmpqPKXb7aJk+Lmbg88AdkpMRm3eyWNxS/XOOEiIKj +Q5P3oVUOgj7sbw/Y4upMkMpOhbNC0hSlONNOPIcfPl7WTkqk6saLFdqyJNxebcSi ++9lLfbMRkmQQcq7McQHD/5+jVeIV237uLqgSFKki+8dHQAmezlzMzVBObGr/4szZ +J50yGEmDhI2yoV9hbdZhCx6LGwBpLLJ9HM3zcow3zsBVMlkY0D8U3XifWB0+8ImC +C39Nu+pDqwlt/6BgPsOw4JD9CW6jwDoh59a+zhBGbSEtgyqKTVp8Fs2TZEGOsQO1 +UUvagz/t3g0YOG8mYSS/lh/Qrl3vPsjazqCgurEN2K8Dt10qLWaCT+N0+5pDsNQ+ +bsV92zNQgLWMEotfDlcAf8qJcYXY8/5girf48K+kwV3htlpDStATJ23VjzBCXByW ++2JbhYt5W3wk6W+3q5RXgKFNNeXkX8KK+TNTHQcIBnOYroy/lYlcjyaZaILM7IUJ +ythihI5KboNK6gpBjgStWUegTbGvUoUph++m9Z5u6UZ3kAd+TRttUJfzWH2X2dSs +kFeL/o9uaVHq51EcjMILYB9+mqQX01ddDqjS1CLUzMy/LteyqEntxrbm3EqZO3N/ +a33g2KPzOW6ReEbqENZZlvZP0fADlYSqJcSOnJxysA6+yHsDthfTxJ7UBvtG/dpJ +6VUCizwWkb8PSanHSoA2E7drcyECwQPkyeaCSWzcwAgKKmNBILrZ/bziGg5/g9ah +VzOMdpv1dTwKxuzZzJ2IPtTbXq/Nr8hFfvUhWt3cNtiSxRvTs64/O7e0j+9hG5BJ +vmPT4S8J7jlD9ct1vyZZRHtVNn/0wryzfL2uaXcvJNfPvgF8EU9aDNPAiwAB5QtF +Zw0J38zjCvMbAMD+9moKah48y1/0I7x7yAhYOld/IdYh/PTGH6Ml+Q4XvPprEoNL +s7dLtquj2PVAv3nCFr+FtMaOOmmQAlh4NGRkq8426N/Skfr4jLtC2nSf+FQPJ09K +vwfB1OuvQXNiIWjWgvQYRV5V0z0K5QQ0U5rmib9MiJODdpBwnihttVq18w4bZ7Y9 ++6ShndfMHCUboGo/JYdxMkaaBty8DhhpNwexywrMwP4lXFaJEUQ3ljpBcjsUaD1Z +iiGb8h6wq5wnRA5aXHqDjHgPmgQlG+GEC1X77wXrjgIddHIjetGADqLkIz1Em4MR +6zBgAcDAHrZI01/64ehnP6O4RMwGVtPkeX2EaQwxkGGRN1lPjlhlg38kSwjYtfnI +WKxh38kCggIBALzxR9sfCZaPVrkiskgAnDz6kXFfJNN1z2JHPv2nOYegPaiywBM+ +GMbuRiRjFx7t6q3WXWs4CD5nkLhinM996lBMnQn4J1da/jvLNz4X/72s9CO4a8aI +e/y3NE5YPWL3GMVX/yylKx0yr05wEsmjcRB8QQEuaQselnoEmCHkBOpG1PK5jnGk +w+a5nvV3B1BiP8+p/QM/ujsFtumwvCrMgGPG+HC2XHYSHWfoBgM6K7MBhLgqPmGr +Eyqm7pXSesu9GlbMobAVhsYWyTlxBxoRj7km3F8ad2BMuJbpXUKSdv935yFb8IF9 +DeaM0glN/tCZyY5r6HPbN9FPtYSMRwmQ9s0et1xryN0a900Z3mcqBvWrtl1hKoiH +LNXWkQwWcrqPcpUNkefWPFyffdo/VV+MMR4kPkmorM0BOKPYNsehfWlzKMb2gST1 +tTp8ryEUiiDDDsDVIAU3rFY2577mzwtK5X8p75mA8jGHv7FasiRCwCwhDCIm8LOU +5kSSNQd1owh6w0/LuR/w7aNWTgC7/z+myBH/oqzz2OBhsjLWHkMOhGS0XTmC6KXn +wbre5Gw6OXL+Zcm4iiP/2uMRgQP5FF4iwoBpNCX6sDIMx16SEqE+o8g1bki4Ti3w +7x5e3rCLYJ2CeSRSJZHvtHlKeRGEP27YO8+m9Zg8HUa32SKh7ZZ0lnd/AoICAQDC +KRTFQS6vPakFrxaI7Da3aNuSBmmgT7WLQCm+wjKIHbrqsEebzaG0v7A0OZRWvzuv +j5CJ05Y5BcoHEOR67ZbpVIfQvn9554HDkEkfamCwwaIiqnlV+E8OOEy1KzujkO9g +FvNYsDvCdPmd/LR9i9F1VIDZ3K6aSFli7435Na/wcnGa6+zMthtJOagSmXFkt6nR +a4FSS5qdDkzKlnVcgwXOJk6wrQ8O/gq9ocuRr85yxZ+ofDe8lIAkWsCJXoE7SDXF +WTd8IZ9WcuQ1ArS5CijqkqXy/KhV8THFzwE+xT5Vqdj68XxjuqZoj39X+fs6eeBy +EvEkktl/zb/zCTsAQSOlBY31NyShN3NdrlsS7TvBJR9SzQ8TbB1Rx59rmjDM0U7w +eZ6MtjydpIVautL5cFcibNr9he9jXXmMAeJRP4pZq/txBpNsW9lqidhFwU4tvMHW +q8ImyDommpfML7Le97Q8aA7H6FGmA4+YWcmuvVd3rgHNmM8GTXHz6G1tX4CV/Zh6 +9RVFo90I7hw9+M6i7ybrTCqOqAZ1d2qCLL5Ln7UxIOaLueuPqnNWO9cf8F+RvKBA +4Z0gLMBxi7oyzDDGPgEQOL9NYk/L98Ht6ISR/UtM/5PJGnB4+Sz2r+nLLwA8cTP6 +rQgPixf+qgX2HwJ7eQvvBAhE18ktrF88VVF5lh4+fwKCAgBnh/Ku0BAJ7xs/MRLt +v1/dThO6Qr9EG876dD3A8gvlFFoVAXWcVa9v+gp3T9DQgt/QR6FC6h4iS8+SKX7x +d3aYb5Kxbsfn5xVeIFlx7eaVwZq5pAlybUE7VgwUTee9PdbV9AUAKrU4N5i161Vw +Jd4DgYKBKjQnAqjDzZarI23KDewL4L976CPsXpQKvyFD28JJgUUBrb7XLqdu4AgL +j6legx2JbXO2wvBYClyZEhv154QZAhTSodJL0dL0R7Q/xawUGecTPIhwLPYwQo34 +q9zMQM4KUs9M9l1DXDZdDzKjg8kjj2R3H9YpGcrRjGpvVYWLQ/fI3Dt2ty2optEa +HdQOy6D/xJP5DBisp9slPnM31NKF0oNi8mcP+ZXbQMW3Enlf0WK83biPrFli6MdY +JtKXSJbU99dQMjYeGZDSzNuSl6ald1eGsBiRJtcz0jRqBVglM+Nq2HnXeBh+k6yp +7G1aw9jljTGpEFBq11673dO9mpIyeJH2ZUXUFyV1o/Ek6VfydphHN1aP5O+zGVCh +STtiGWjDSo7xTLc/gfJtHhxPrkFTDTd8CUUvp4kVAMaQC3QtF7CiT0VanTHLwoV1 +m6hmgr8vfHFly3jHilUpA9DtGNIIiO1V4Sq1wphVttnHFUJaM6UglW+X8sXqYkP7 +8gK8Iyl6NJ56LK2Pe5lbkyEL8wKCAgASqtp5YJv5c0c16bCT94oHNkiuEHnFVQSS +X9fjpE4xchJPkCVCYJHki+2IB+UwNfCqH3Z5GeO+lcTnywL8oq04v8zTEA23jb+X +Kt8s6xBizislhBhoYJhROK5/WKnCPyQUrAA3jbIhLxf0zaAY1gGMc1R0HdiXss8N +SRTwWe4Rgx9TEs3QnM2gy69SIniZg2MLZHepjuVNpltRuweLnnlHab11FR52hYxI +0S5+UlXaCRAhpdfCBNERLbyHOJPaPEYXNE22XJEyQZeZVSpFBCoM646S/yG8KZVs +fEuVWmd02wCml+Mqv35SXUGUFs/FvoQK07Fln8zTkdebqU6H5rtjmVYdtnCKI4ev +AR12g2KUXlpVnquNZX6oJzY3pTp95r3dNwQ8aSUIzxGXOJEiNF/cSnT/nQn4Fruh +72hwAVju6C8jncs8xtPvf1NQ2ZYHpbdJSXhAPE4C+igQFKHw+AXXLPYG2FpJSNxc +fH18lG29bvhzaPa2l2mWVsl2k5EMWrZ3U+r4qBmPSz1h4/MSDUZDpy4MSzFbx+Bw +pZaiNLe6AnzIAFcal/vA1b4ILxcxLt6FfmuZ9VOHVzTOv30NAlcd1SbnbMVZSffW +RN3CH4VG4Oe3lRgtOV/OU/l5dIpkRUoHFu3IeMoUzQoHsNGPR4MTNuMIo2qPPpxl +c5qCwyEjRwKCAgAI6zHnC+cA0iwM/hIvi04kV9BMnmT9oqTC8P0FZigBNEyfXB0A +wTwv/Mzeu0j3AXHAF7WKvo+pOKP1TaY7qCrtEAEboh+voGZ7NSyB7qLUcibqwkGW +hsuIJ001LAnO71gNM8OCXuJGJjJ9Bzxw6zGLTrIGk4hkrFukGwTxA5khZRtiOF8+ +cLnyKyCOV3TvgYfZfDIDTw2CsYzVXZgQKY7DQvooys3wqYgkT49GH0nOcKqNasKi +qh73dGwsXAQFITMFIiqS+wFPzFEFG34K1s8tIYbPCEEnU0S1OYVAsb/3jgtBuc/4 +kEOavfzELtDbnYcgJ7MjCVpK0V8T9BOqADIh+ETrjdBirqd9Rbto1n5rpLfNcGF+ +uAfd3nZOJRWCf1CYyzjXqF842Z8uEd1hIfcFimjZFBCx9I6fQcotZ07xTbpfJvYu +8Acz+ssS7zFXkohXH+7I52xAFqKIbgHKSo3tQg2M5dF4tsLXmFqE/BkcF+N+jnEh +F0lRHjzLgBF5mE11jFTi1ROTCsnUJRFrmyuHVH6s2TTf7dwYfhIpKSnFdmvwvh11 +94Ofpev9hNhoEBCH9KPe/mrGFYof95NDS5s74msUDNDh6xfmd/omE1zvK5myIyeP +It5CRw7hwQuE9orhaBXAwRVwC5DkWO8p0BXuowRHgUwAVxNnOtzRm7sq0w== -----END RSA PRIVATE KEY----- \ No newline at end of file diff --git a/client/receiver.pem b/client/receiver.pem index fd1d49a..4e51916 100644 --- a/client/receiver.pem +++ b/client/receiver.pem @@ -1,14 +1,25 @@ -----BEGIN PUBLIC KEY----- -MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAtp/nSjVpOYelOdyJxVrY -VKz0otcy33KEZeOvv3Bglq7hFySMwLLBRuC6vGCMFVVMqQFlrQ4TiD3Z8e+Xf2Uk -CAzkTNbCg/Mf66A7nruWGriFY2pg0LaFBAuxAOFHaW2B7yDm3+02atztlGFkTgDW -94gPzzhE2gZ/5fULf4wm5HkkKNiYkg7fqifoed9POV7o0xfyjTm1fRhjy/poBJev -OO1h4OMlGM5z3E8HBNceiDUwbdm6izu50HHp0AP+7Pja9uO6WuX1dK3n4wm4hrCG -pEb+h4m/kKUBEQqzjQqNWFUP4ksm4G84cFACbGwD7OGm3Y1OVYfGC6Gcus0rdZeW -cRQIb0gywOJ0OGmn5XIKGGwdso2nb0/LDrBWI8BJ7J7TNu5OKg/0kKCA188nqRqn -EXV7seIjb4rte6G8uXEaX54ZEBft4oKNfU+2kCVNJm5w1nQEOjLS9enneYnFblE0 -FiN4o/G1EIfQHn/D/Yt6q/b7n96fVFJye3oXikgab31msXpCGXQnGAkbnlwbSyjx -98P7Lqg+zCFOMTu7panp0hELQRrCWJEuoDiPvOuFRLVdvYj1KocfUWKdZ0ljNMNu -0c4Ebmc8MW31WDvGWhbIsCmKg+GtYODDYIvVqEl5WnYRxLtj8ml2wq4gNRn9Y8rq -mhOXHwEoRIGKsIGSgKZrFVkCAwEAAQ== +MIIEIjANBgkqhkiG9w0BAQEFAAOCBA8AMIIECgKCBAEAj00qbP8CXp1dbqXG4vV+ +chzJx7HvkuTWqB3hQo712LjtseJ/i3KltwWHB+QAZ1GyswmJNW2KVDyyIq74d6K1 +bxy+EoSiXMctZdK3l5xL0JQwCnkaporyAuxwMkqu9scpcZ7rMIsphdvk6V4OmJdL +F/LLHLRsiMKGiaYmmzB5nyQDkiQ0+Pxmf+baMQ6YT713O9z2aunKdrMl8sQpbms+ +QUOmj6VLrJ9+ttcpRoTx0LxW0yl3bxKM7LrMnHazOEwLR2pnTlHB5NanmDyts1XU +6CzxFuCA8o3MLjpOIEw7IrllcDvFnZrh9SrtzKaCJIXhIT5yS4q/hZ7w9BWZBKzm +miudGmNYeyJUeVfnqk7AnofE4Rb95jnUWQkl3m8h1CkLRS7p0DVTvVqyeEPWXwgv +zGhLZP9xBDlQJMuNoRS8xqSy/7KWdunUt5oWPB/UwAsDLerSWp18Yi1g4q1d8o1S +2Q8t5kqOE6U985jyz9YPtCcFYQUDuyXWaFTTeGEfcY04pKt/rjffiEmJPSdSCmuC +IPx56qwzvSoUsWmf/sjquQaCvtIpftJhp3L0eoe4BBFPnAybyKeTz8ZBzchZb9h0 +gH1QxHhMA51kcaJDn8pojNDup5ZgMjrxAY9LBAhUS1hggAPf88eL23jEKYn8FYFl +Q/xuc2N/Hd31IK4U77NMGCGYIVPbDAmo9hNOWE8wEy50XNklmBIYPpWpWR1nobFH +Cbyu6Um1vBGYUVEzP7AVAFeUebQTuvWHk1OZosv8SYeUvcwl3rP+R0+eokjnR7Pz +XfrB1lBEN+jqBHrRX2Z9GDiJTpCRaxN2dP5zbT+24bhg24mCjelUzvNLUTyguDMJ +LkfScnOszFmM+d1rtWDLh/AjphoTfcCb3VWnLCcCJ4fklV0065vMotPlFxXBmFDD +DKQlam2tfue/SSJjpE27lcWnXz7tmH6O4GpOvd4/Og8PWwWRsx9xcRUZsY+6knRY +oZ77sHYRxoH/M9RqVf6dxA802gv97+lzLKzE0AeNm40XZnmxI7aUSzi2N93A4ykP +f6/HZbN0KqhdJ9PSMTawRZh/KvMx21El5W7l8GFLJMubfXHQ36dgNOEEFiekF9Do +X0l8i8Ev6RdhrHJtJLDVE391yxx1hgW/JzB5hmcc8ryhtx7HsBt5vtrxE0JM1/9P +xmOqqG9gXNY02ErkTK4TrJGkAx0z4ZGKh9BSypYtTxPWq5cDuT9q7gZTOnHZ+HtS +oWnGRKwwLlLmyo8ACcVXzCbj/ZfqVcWZkVDM2rlCF9O7xkeAQNJUKvuLMVm4Zlqz +M14TKzIOUtquanyx6zbajRNROE95Q8QAZw8I3P0pYY3+qX/7D0HJSGSN6cuNsngK +AQIDAQAB -----END PUBLIC KEY----- \ No newline at end of file diff --git a/private.pem b/private.pem new file mode 100644 index 0000000..c90e69b --- /dev/null +++ b/private.pem @@ -0,0 +1,51 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIJKAIBAAKCAgEAnyiVFNxPTuctHL12pPcBzumJnSiA7CZtbUbgozPjuVuJJQcf +8FPZEQWFphtUujZVMRi6PX3szkKhOb08pl75yzoA9H1ql5UoutuGExc0PVzaTY5B +tnU38q6XvyWTYz5TNaG2bhd9DuNv9JrMn+/ydClxOGvTd4Y+7VI8RG8HHnwMrwRc +LzQ2FSJD9mVSopFn+5Z0j0idog2O/SsZJM3c8ieLoOHO9vxQO8xVaUIF74nVoNiL +z/YrcAhU9N3y2KcjpAsQBbFznKeQ6AcW5WjC9zZBVLElP2PAVd6EFKY9C6nuodsa +ICqgWZnyCh+tEI8i+IQq2RN1YySv+6Cn929wVM2tDPxaYfziSLkW5Pk9oPJ43xHs +jb8yFUKsoChPmo4Qe4AVkIIbxwVWG0wymWqEuWeiKlc32badxf38dAm9TvgAApZ0 +5cSIV6ieYP+ixjMFa2rrjkPtfcXey6O05D8uTMQx9GPZRNezceRWI89Lip83raWq +jhw+hUvbGaUL0B/z7XD1zskmQ9n+RnhYRVZrYOTw2BWoGoMBC13/g7qG2RR+qrJF +s1PLTbUgrzP5HkVpKzBvi2G3BxXGr0aflOtLrOU275LjdkkJrOiNMdPrGsUe9S9X +PK5irHampxnJOv5oOCQZ0m/bzKXJykZAJF9fX8caOE++kTH0DSqsapE0fC8CAwEA +AQKCAgAErbY4L0O7j4shcaZXshUhBndvob2sc3K7CB7ZXVCf5cNxzbRQJb7XQ8DK +gborYSZ+83miDh4UcBv6LQhn4ZnZMgLOLROhkhZo68QUspVsCls2dWyUFv0GisBW +M54SCEZ86JyKvvEDq4bie1xxhSWs6Xz1CiJkvJMD+etgnZzpdf8PdALbtl6yn1e9 +GfxkX/7dA+64OYu8tEZURdyO2uhYS/ZMS+cAFqmrIFYQaorvIC+h80uk2NktCWmp +6w5U9RDUpSia6jz6SWi2kWLIapx0lOk1uqFcLCv+ujRKwRpBSgUESAMMGASvrZlS +V90IBBUklgoGaI6GVBFCRdY6LVHxeFHB+NauiTrWAL9Urwl68cSGTYZ3tu7yFF20 +cYA8Ec6osX6u2YejFIJSueqvg8r6fle8QBPC4QMTZzXWeI4J4uuf9lhKLcSX6Tg5 +chKQH+NteW8r1RQ6aDQSnG/eGG5WYZIHoLwSPHX419+vRecB+jjWuRJbgBiXKLVS +GNHgu70Vd13Ja1sfPU3HSfDN4SIwsX50/1H9M83ecO3whChCxZBH84u6dC+HxrLW +bjYQsJJyxw3A8lFfhkxLS8fte7QGONysdDM+r9cuDQYw+g5CtDESZ9VM9yblFyHo +xhQl/NKX7sxHeerD2TngTtOSpag1Do0nYveFdGWaq8iaG/WhKQKCAQEAuFb50/X5 +O9VccI3Yok8bSqgeR85XoazolBDP8Jw7FoeOLP97T9uxKuUI1fnh/KJLYxxWsCLc +eByqi8o9OwQ/TVYAVf3UvsCJapryAE6yezOTtbDIRwCl2AiyR4xPEtXtpWtTumEU +HyNHu1xSQ0ndaXzHe6lM+qp3BfAgPjiO/OvH8uZcffAvu6pTOysywAvSNsc7n4a/ +rDMxRXWF4Py+/efYFrklBUQpMi5OUbPah5FU0xQ94BRjaYBDc6p3b7LAojz8jB84 +FLc87/N6x6PtmAQWqlSbqQOtzvgxr3bvzMAoI94f9vOb5HUPOU9juN/5azLN2zKy +j0HTZrnL6pReBwKCAQEA3QeihrgTdGTLYjQ2FSHzUWD9HKtNQAxyvJcODCheEOsg +uuJ6bNqMO6inD2GnWmr+82q0yDwhFh0fqQuFWxzuUX9va2tenm1rzOld0OJvewTB +Vd3JNduSCpu4r5y38vLOnyc1H8aYbqb68MMvFdX5UlMO1pwe2nk+72nWXkHwdgq1 +4H5MvDkfSmBcySgMBJdCLnEJhZzu9xXXmQ2esT0r/AFkq2edRH9OvO9wF7C2zOgz +twyAuTRd8+xhUPe82+/WruQ/UXyzQ2wIKXgpbYRmuJiQZY5Q9wnIxGJlNIOVrdNI +OZxVXIEaoZvAms8z9nJISv/w6tMsDQ/EPrIeegLmmQKCAQAeG5aSWAptC1wdxg0r +9V+vweWwNLN7ZJJYHKbZ1aqQ83L1RoUNdgRpzR60VCvk510IwwglnIwF0ijIzC9U +BE2ShAlqAhtNTIUlNElyY2gjVzk447bSYfi0YDc+GFyR5v75lZ4HQvPWYhzFLT8C +Xn4bTJYITI6WImFuRtn9T5+LD7eIpLdWmnQxYpBViaiwVT3wVHoYhBmqNnJFtfw3 +0xAeyE8y5up1Abz4xTdlgMqgecww7Y1tm+bgxGI/8gev5rIvzWYyPKccOxFo34ue +L9gOjBxnlYoXANLSixcSYYqpFnl34j+2RfOgTL4/zgermmlSaOnWc2FWpJmynYYA +ulrhAoIBAQDQ8Gay809wt9eK/dAiKfXY99ZNQ6HC6gGMRT8CPyas15gZEf6o5++o +dcV2xNlun7ZiZHyAzFZ6kQ1cv4dQmgivAchRwy2ulcFR80i8LVE0+UnJ4d5TCz0C +yjHL0FoTT3QC/w04/IMcFr0g22GnQp5tNBbSyMJhxDu6FlKOx8aHz5gen0XqqBTs +Oit7/F9f95yYSkK2C6PZ7svf4wAgi7MIhkijv07rcWz9LVrJCkPDb71zTF5itR4b +d1iHMalWP2Kx8RHp9fd/xJ/yk6SV4pM37QCS//WJkbY37su82KalqxSbYS1QRLro +ClQIA9cbIO01+LvFP9pkfoMEwVwN+rABAoIBAAePseQxih9i2z4hNCLBj2WANTrw +Vo8UyA3b7qoRFEWv7Md66ts7UhekdMheMKz/H03IvU2K/qRSN/smQE74zKxdzI/X +AqRMEytYcyP+JGzn6j9j3Nv6ByfizFzsyCjbc6fS5bC54O6lVtuwKx2lRUV0QIdK +7Ld58TITc/gCDUpE2ADVmXdnnfCZlhlL23lAek5qvjn03/CAklR7kcmCUhy+NhIB +aErZyTkveKXyTRwXO0AcKMk2Mj3LN+MvWTPfIgPWrrqFRxaj5BRlHcZwzA2gLwgz +10yRDlRnedSxTLMdMMbq0usKoFmez8WMub37/xOaXKpd0kptqYxY2rc7odo= +-----END RSA PRIVATE KEY----- \ No newline at end of file diff --git a/receiver.pem b/receiver.pem new file mode 100644 index 0000000..4fa0ae7 --- /dev/null +++ b/receiver.pem @@ -0,0 +1,14 @@ +-----BEGIN PUBLIC KEY----- +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAnyiVFNxPTuctHL12pPcB +zumJnSiA7CZtbUbgozPjuVuJJQcf8FPZEQWFphtUujZVMRi6PX3szkKhOb08pl75 +yzoA9H1ql5UoutuGExc0PVzaTY5BtnU38q6XvyWTYz5TNaG2bhd9DuNv9JrMn+/y +dClxOGvTd4Y+7VI8RG8HHnwMrwRcLzQ2FSJD9mVSopFn+5Z0j0idog2O/SsZJM3c +8ieLoOHO9vxQO8xVaUIF74nVoNiLz/YrcAhU9N3y2KcjpAsQBbFznKeQ6AcW5WjC +9zZBVLElP2PAVd6EFKY9C6nuodsaICqgWZnyCh+tEI8i+IQq2RN1YySv+6Cn929w +VM2tDPxaYfziSLkW5Pk9oPJ43xHsjb8yFUKsoChPmo4Qe4AVkIIbxwVWG0wymWqE +uWeiKlc32badxf38dAm9TvgAApZ05cSIV6ieYP+ixjMFa2rrjkPtfcXey6O05D8u +TMQx9GPZRNezceRWI89Lip83raWqjhw+hUvbGaUL0B/z7XD1zskmQ9n+RnhYRVZr +YOTw2BWoGoMBC13/g7qG2RR+qrJFs1PLTbUgrzP5HkVpKzBvi2G3BxXGr0aflOtL +rOU275LjdkkJrOiNMdPrGsUe9S9XPK5irHampxnJOv5oOCQZ0m/bzKXJykZAJF9f +X8caOE++kTH0DSqsapE0fC8CAwEAAQ== +-----END PUBLIC KEY----- \ No newline at end of file diff --git a/server/main.py b/server/main.py index 41a179b..83b714a 100644 --- a/server/main.py +++ b/server/main.py @@ -8,40 +8,21 @@ import os import socket import threading -#### logging #### -# json decoder for int keys -from Crypto.Cipher import PKCS1_OAEP -from Crypto.PublicKey import RSA -from Crypto.Random import get_random_bytes +try: + # noinspection PyUnresolvedReferences + from Crypto.PublicKey import RSA as RSA + # noinspection PyUnresolvedReferences + from Crypto.Cipher import PKCS1_OAEP as PKCS1_OAEP + # noinspection PyUnresolvedReferences,PyProtectedMember + from Crypto.Random._UserFriendlyRNG import get_random_bytes as get_random_bytes + pycryptodome = False +except ModuleNotFoundError: # Pycryptodomex + from Cryptodome.PublicKey import RSA as RSA + from Cryptodome.Cipher import PKCS1_OAEP as PKCS1_OAEP + from Cryptodome.Random import get_random_bytes as get_random_bytes -def make_hashable(o): - if isinstance(o, (tuple, list)): - return tuple((make_hashable(e) for e in o)) - elif isinstance(o, dict): - return tuple(sorted((k, make_hashable(v)) for k, v in o.items())) - elif isinstance(o, (set, frozenset)): - return tuple(sorted(make_hashable(e) for e in o)) - return o - - -class Decoder(json.JSONDecoder): - def decode(self, s, **kwargs): - result = super().decode(s) # result = super(Decoder, self).decode(s) for Python 2.x - return self._decode(result) - - def _decode(self, o): - if isinstance(o, str): - try: - return int(o) - except ValueError: - return o - elif isinstance(o, dict): - return {k: self._decode(v) for k, v in o.items()} - elif isinstance(o, list): - return [self._decode(v) for v in o] - else: - return o + pycryptodome = True def setup_logging(default_path='log_config.json', default_level=logging.INFO, env_key='LOG_CFG'): @@ -73,6 +54,7 @@ critical = log_server.critical HOST = '' PORT = 8888 BUFFER_SIZE = 4096 +CHUNK_SIZE = int(BUFFER_SIZE / 8) BEGIN_MESSAGE = bytes("debut".ljust(BUFFER_SIZE, ";"), "ascii") END_MESSAGE = bytes("fin".ljust(BUFFER_SIZE, ";"), "ascii") @@ -87,57 +69,55 @@ main_socket.bind((HOST, PORT)) #### Threads #### -class clientThread(threading.Thread): +class ClientThread(threading.Thread): """Main thread, for each client""" - def __init__(self, clientsocket, ip, port): - """Create clientThread object + def __init__(self, clientsocket, ip_client, port): + """Create ClientThread object - :param clentsocket: Client's socket - :param ip: Client's ip address + :param clientsocket: Client's socket + :param ip_client: Client's ip address :param port: Client's connection PORT :type clientsocket: socket.socket - :type ip: str + :type ip_client: str :type port: int :return: Nothing :rtype: NoneType""" - debug("Creation du thread pour %s" % ip) + debug("Creation du thread pour %s" % ip_client) threading.Thread.__init__(self) # initialisation du thread self.client = clientsocket - self.ip = ip + self.ip = ip_client self.port = port self.running = True self.status = None - debug("Creation du thread pour %s reussie" % ip) + self.rsa_client = None + self.aes_key = get_random_bytes(64) + debug("Creation du thread pour %s reussie" % ip_client) def initialize(self): - """Interpret request header""" + """Initialize connection with client + + :rtype: NoneType + :return: Nothing""" # Receive message - chunk = bytes("", "ascii") - while chunk != BEGIN_MESSAGE: - chunk = self.client.recv(BUFFER_SIZE) - last_chunk = chunk - while last_chunk != END_MESSAGE: - last_chunk = self.client.recv(BUFFER_SIZE) - chunk += last_chunk - # Remove the begening and the end of chunk - util_part = chunk[BUFFER_SIZE:-BUFFER_SIZE] - print(util_part) - header = util_part[:BUFFER_SIZE] - print(header) - content = util_part[BUFFER_SIZE:] + message = self.receive() + # Get informations + header = message[:BUFFER_SIZE] + content = message[BUFFER_SIZE:] + # Extract header data header_txt = header.decode("ascii").rstrip(";") version = header_txt.split("\n")[0] # Extraction des champs du header if version != VERSION: - debug("Pas la bonne version") - self.send(b"Error".ljust(BUFFER_SIZE, b";")) + debug("Incorrect protocol version.") + self.send(b"Error") + # Extract information from header champs = {l.split(": ")[0]: l.split(": ")[1] for l in header_txt.split('\n')[1:]} if champs.get("type", None) is None: - debug("Le champ type n'est pas dans le header") - self.send(b"Error".ljust(BUFFER_SIZE, b";")) + debug("The type field is not in the header") + self.send(b"Error") return if self.status is None and champs["type"] != "RSASend": @@ -148,44 +128,95 @@ class clientThread(threading.Thread): if champs["type"] == "RSASend": debug("Réception de la clef RSA de %s", self.ip) self.rsa_client = content.rstrip(b";").rstrip(b' ') - self.aes_key = get_random_bytes(64) header = bytes((VERSION + "\ntype: init").ljust(BUFFER_SIZE, ";"), 'ascii') content = self.aes_key.ljust(BUFFER_SIZE, b";") self.send_rsa(header + content) return - def send_rsa(self, to_send): - if self.rsa_client is None: - debug("Clef RSA non recue") - self.client.send(b"Error".ljust(BUFFER_SIZE)) + ################################################ COMMUNICATION WITH RSA ################################################ + + def send_rsa(self, to_send, key=None): + """Send message with rsa encryption + + :param to_send: Message to send + :type to_send: bytes + :param key: key to replace self.client_key + :type key: bytes + + :rtype: NoneType + :return: Nothing""" + debug(b"Send with RSA encryption: " + to_send + bytes(str(self.ip), "ascii")) + if key is None: + key = self.rsa_client + if key is None: + info("RSA key not received, connection failure.") + self.client.send(b"Error".ljust(BUFFER_SIZE, bytes(1))) return - # Transform rsakey and generate sessionkey - recipient_key = RSA.import_key(self.rsa_client) - # RSA crypter object + # Get RSA key + print(len(to_send)) + recipient_key = RSA.importKey(key) + # RSA encryption object cipher_rsa = PKCS1_OAEP.new(recipient_key) - # Encrypt session_key - crypted = b"" - for to_send_text in [to_send[i:i + 16] for i in range(0, len(to_send), 16)]: - crypted += cipher_rsa.encrypt(to_send_text) - self.send(crypted) + encrypted = b"" + for to_send_text in [to_send[i:i + CHUNK_SIZE] for i in range(0, len(to_send), CHUNK_SIZE)]: + print(len(to_send_text)) + encrypted += cipher_rsa.encrypt(to_send_text) + print(len(encrypted)) + self.send(encrypted) + return None + + ############################################ COMMUNICATION WITHOUT CRYPTING ############################################ + + def receive(self): + """Receive message from connection + + :rtype: bytes + :return: Message's content""" + chunk = bytes("", "ascii") # Temp variable to store received datas + while chunk != BEGIN_MESSAGE: + chunk = self.client.recv(BUFFER_SIZE) + content = b'' + while chunk != END_MESSAGE: + chunk = self.client.recv(BUFFER_SIZE) + # Get only interesting chucks + if chunk != END_MESSAGE: + # Get content part + # int.from_bytes(chunk[:2], byteorder='big') == Get content size + content += chunk[2:int.from_bytes(chunk[:2], byteorder='big')] + debug(b"Received from" + bytes(str(self.ip), ascii) + b" : " + content) + return content def send(self, to_send): + """Send message to connection + + :param to_send: message to send + :type to_send: bytes + + :return: Nothing + :rtype: NoneType""" + debug(b"Send " + to_send + b" to " + bytes(str(self.ip), "ascii")) + # Sending the message start self.client.send(BEGIN_MESSAGE) i = 0 + print(len(to_send)) for to_send_text in [to_send[i:i + BUFFER_SIZE - 2] for i in range(0, len(to_send), BUFFER_SIZE - 2)]: - print((len(to_send_text)).to_bytes(2, byteorder='big')) - print((len(to_send_text)).to_bytes(2, byteorder='big') + to_send_text.ljust(BUFFER_SIZE, b";")) - self.client.send((len(to_send_text)).to_bytes(2, byteorder='big') + to_send_text.ljust(BUFFER_SIZE - 2, b";")) + self.client.send( + (len(to_send_text)).to_bytes(2, byteorder='big') # Size of the message contained by the chunk + + to_send_text.ljust(BUFFER_SIZE - 2, bytes(1)) # Content of the chunk + ) i += 1 - print(i) + # Sending the message stop self.client.send(END_MESSAGE) + return None def run(self): # main de la connection du client """Run thread mainloop :return: Nothing :rtype: NoneType""" + info(self.ip + "connected, initialize connection...") self.initialize() + info(self.ip + "connection initialized.") print("done") self.client.close() @@ -193,8 +224,8 @@ class clientThread(threading.Thread): if __name__ == "__main__": clients = [] while True: - main_socket.listen(1) # ecoutes des connections entrantes - clientsocket, (ip, PORT) = main_socket.accept() - newClient = clientThread(clientsocket, ip, PORT) + main_socket.listen(1) # Waiting for incoming connections + client_socket, (ip, PORT) = main_socket.accept() + newClient = ClientThread(client_socket, ip, PORT) newClient.start() clients.append(newClient)