def get_unique_words(self, file_path): all_unique_words = [] files = glob.glob(file_path, recursive=True) for file in files: document_identifier = 'document' + str(self.document_number) self.document_number += 1 unique_word_count = 0 unique_words_in_document = set() f = open(file, 'r') for line in f: for word in line.split(): word = word.lower() if word not in unique_words_in_document: unique_words_in_document.add(word) unique_word_count += 1 f.close() if unique_word_count > self.unique_word_count: self.unique_word_count = unique_word_count+25 all_unique_words.append((document_identifier, unique_words_in_document)) # Create an encrypted file and store it in the encrypted files folder encrypt = Encryption(file, document_identifier) encrypt.encrypt() return all_unique_words
def enable(): try: #hutil.do_parse_context('Enable') # Ensure the same configuration is executed only once # If the previous enable failed, we do not have retry logic here. # Since the custom script may not work in an intermediate state # hutil.exit_if_enabled() # we need to freeze the file system first """ protectedSettings is the privateConfig passed from Powershell. """ protected_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('protectedSettings') public_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('publicSettings') para_parser = ParameterParser(protected_settings, public_settings) encryption = Encryption(para_parser) encryption.encrypt() hutil.do_exit(0, 'Enable', 'success','0', 'Enable Succeeded') except Exception, e: print(str(e)) hutil.error("Failed to enable the extension with error: %s, stack trace: %s" % (str(e), traceback.format_exc())) hutil.do_exit(1, 'Enable','error','1', 'Enable failed.')
def sendMessage(event=None, filePath=''): global sock message = my_msg.get() if message == "{list_nodes}": listAllNodes() return message = '\x01' + message if len(filePath) > 0: message = open(filePath, 'rb').read() message = '\x02' + message dest_to = destin_select.get() if dest_to == "{to_all}": msg_list.insert(END, "me: " + message) my_msg.set("") if args.encryption: message = Encryption.encrypt(message) broadcastMessage(message) return destHash = md5.new(dest_to).digest() kDest = knownTable[destHash] msg_list.insert(END, "me: " + message) my_msg.set("") pChunkedType = '\x0E' if args.encryption else '\x06' pWholeType = '\x0A' if args.encryption else '\x02' if args.encryption: message = Encryption.encrypt(message) if len(message) > 59: left = len(message) % 47 packageNumbers = (len(message) - left) / 47 for x in xrange(packageNumbers): msg = message[x*47:(x+1)*47] streamId = 0 packet = None packetNumber = 0 if left == 0 and x == packageNumbers - 1: packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', destHash, pChunkedType, buildChunkedPayload(streamId, x, msg, '\x01'), kDest['IP'], kDest['PORT']) else: packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', destHash, pChunkedType, buildChunkedPayload(streamId, x, msg), kDest['IP'], kDest['PORT']) sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber) if left > 0: packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', destHash, pChunkedType, buildChunkedPayload(streamId, packageNumbers, message[packageNumbers*47:], '\x01'), kDest['IP'], kDest['PORT']) sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber) else: packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', destHash, pWholeType, message, kDest['IP'], kDest['PORT']) sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber) pass
class TestDecryptMethod(unittest.TestCase): """Testing class to test all encryption related actions """ def setUp(self): self.enc = Encryption(b"defaultD", "defaultP") # def tearDown(self): # something here? def test_decrypt(self): self.enc.encrypt() d_data = self.enc.decrypt() self.assertEqual(self.enc.data, d_data)
def sendRoutingTable(neighborIP, neighborPORT, neighborEMAIL): message = retrieveRoutingTable() pChunkedType = '\x0D' if args.encryption else '\x05' pWholeType = '\x09' if args.encryption else '\x01' if args.encryption: message = Encryption.encrypt(message) if len(message) > 59: left = len(message) % 47 packageNumbers = (len(message) - left) / 47 for x in xrange(packageNumbers): msg = message[x*47:(x+1)*47] streamId = 0 packet = None packetNumber = 0 if left == 0 and x == packageNumbers - 1: packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', neighborEMAIL, pChunkedType, buildChunkedPayload(streamId, x, msg, '\x01'), neighborIP, neighborPORT) else: packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', neighborEMAIL, pChunkedType, buildChunkedPayload(streamId, x, msg), neighborIP, neighborPORT) sendPacket(packet, neighborIP, neighborPORT ,packetNumber) if left > 0: packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', neighborEMAIL, pChunkedType, buildChunkedPayload(streamId, packageNumbers, message[packageNumbers*47:], '\x01'), neighborIP, neighborPORT) sendPacket(packet, neighborIP, neighborPORT ,packetNumber) else: packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', neighborEMAIL, pWholeType, message, neighborIP, neighborPORT) sendPacket(packet, neighborIP, neighborPORT ,packetNumber) pass
def _writer(self, log): """ Saves the log in a dat file. :param log: An array of pressed keys. """ if not os.path.exists(os.path.dirname("logs/")): try: os.makedirs(os.path.dirname("logs/")) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: raise with open("logs/INTEcoin.dat", "ab") as file: toWrite = "" for i, key in enumerate(log): # Removes repeated spaces and enters if i > 0: if str(key) == "Key.space" and str( log[i - 1]) == "Key.space": continue if str(key) == "Key.enter" and str( log[i - 1]) == "Key.enter": continue key = self._parse( key) # Converts the key to a readable character toWrite += key file.write(Encryption.encrypt(toWrite)) file.write( b"@" ) # Puts a separator for the encryption diod see Fernet using this as the cypher text file.close()
class TestEncryptMethod(unittest.TestCase): """Testing class to test all encryption related actions """ def setUp(self): self.enc = Encryption(b"defaultD", "defaultP") def test_encrypt0(self): self.enc.encrypt() d_data = self.enc.decrypt() self.assertEqual(self.enc.data, d_data) """ Test salt is not same """ def test_encrypt1(self): self.enc1 = Encryption(b"HELLO RED BULL ALL DAY IPA", "fee fi fo") hash1 = self.enc.encrypt() self.enc2 = Encryption(b"HELLO RED BULL ALL DAY IPA", "fee fi fo") hash2 = self.enc2.encrypt() self.assertNotEqual(hash1, hash2)
def main(): enc = Encryption() print("Encrypting message: The Queen Can't Roll When Sand is in the Jar.") message = "The Queen Can't Roll When Sand is in the Jar." message = enc.encrypt(message) print(message) print() print("Decrypting message:") message = enc.decrypt(message) print(message) input("--Press any key to end--")
def upload_file(): if "file" not in request.files: return "No file provided" elif "key" not in request.form: return "No key provided" file = request.files["file"] key = request.form["key"] file_data = file.read() if len(file_data) <= 8: return "File is too small." elif len(key) < 4: return "Key is too short. Must be between 4 and 56 characters." elif len(key) > 56: return "Key is too long. Must be between 4 and 56 characters." cipher = Encryption(key) encrypted_file_data, iv = cipher.encrypt(file_data) name = file.filename.split(".") if len(name) == 1: extension = "" else: extension = ".".join(name[1:]) file_id = f"{uuid.uuid4().hex}.{extension}" with open(os.path.join(app.config["UPLOAD_FOLDER"], file_id), "wb") as f: f.write(encrypted_file_data) id = generate_random_id() redis_cli.set(id, file_id) redis_cli.set(f"{id}-iv", iv) redis_cli.set(f"{id}-key", hashlib.sha512(key.encode()).hexdigest()) return f"https://trimly.fm/{id}"
def authenticate(self, shared_secret_key, receiver_q, sender_q, mode, auth_res, token): """ Authenticates server and client, returns a session key """ client_auth_str = "I'm client" server_auth_str = "I'm server" NUM_BYTES_DH = 32 # Going for 256-bit a/b values in diffie-hellman NUM_BYTES_NONCE = 8 # Going for 64-bit nonce TIMEOUT_DELAY = 5 # Timeout waiting on response after 5 seconds logging.info('Authenticating') # Diffie-Hellman Group 14 2024-bit Key exchange values p = 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF g = 0x2 # Client Mode if (mode == Mode.CLIENT): # First message to server in the form: # "client_msg, ra" # client_msg: "I'm client" # ra : client generated nonce ra = Random.get_random_bytes(NUM_BYTES_NONCE) msg = [client_auth_str, ra] msg = pickle.dumps(msg) logging.info("Message to send: " + client_auth_str + "," + str(ra)) wait_if_debug(token) try: sender_q.put(msg, True, TIMEOUT_DELAY) except: auth_res.error = True logging.info("Timed out writing client's first message") return # Expect server response in the form: # "rb, E("server_msg, ra, B", Kab)" # rb : new nonce from server # server_msg: "I'm server" # ra : return of previously generated nonce # B : server generated half of diffie-hellman (g^b mod p) # Kab : shared secret key between client and server try: if (token.debug): resp = receiver_q.get(True) else: resp = receiver_q.get(True, TIMEOUT_DELAY) except: auth_res.error = True wait_if_debug(token) logging.info("Timed out waiting for server's first reply") try: resp = pickle.loads(resp) rb = resp[0] ciphertext = resp[1] #logging.info("Ciphertext received from server: " + str(ciphertext)) plaintext = Encryption.decrypt(ciphertext, shared_secret_key) #wait_if_debug(token) except Exception as e: logging.info("Message from server wasn't formatted correctly") logging.info('Error: ' + str(e)) auth_res.error = True return try: plaintext = pickle.loads(plaintext) server_msg = plaintext[0] ra_reply = plaintext[1] B = int(plaintext[2]) logging.info("Plaintext received: ") logging.info('Server message: ' + str(server_msg)) logging.info('ra returned: ' + str(ra_reply)) logging.info('Server B: ' + str(B)) wait_if_debug(token) if (server_msg != server_auth_str): logging.info("Message from server didn't say 'I'm server'") auth_res.error = True return if (ra_reply != ra): logging.info( "Reterned nonce ra_reply not equal sent nonce ra") auth_res.error = True return except Exception as e: logging.info("Message from server wasn't formatted correctly") logging.info('Error: ' + str(e)) wait_if_debug(token) auth_res.error = True return # Send final authorization message in the form: # "E("client_msg, rb, A", Kab)" # client_msg: "I'm client" # rb : nonce received from server # A : client generated half of diffie-hellman (g^a mod p) # Kab : shared secret key between client and server a = Random.get_random_bytes(NUM_BYTES_DH) a_int = int.from_bytes(a, byteorder='big') A = pow(g, a_int, p) plaintext = [client_auth_str, rb, A] logging.info("Plaintext to be sent: ") logging.info('Client message: ' + str(client_auth_str)) logging.info('rb returned : ' + str(rb)) logging.info('Client A: ' + str(A)) wait_if_debug(token) plaintext = pickle.dumps(plaintext) ciphertext = Encryption.encrypt(plaintext, shared_secret_key) logging.info("Ciphertext to be sent: " + str(ciphertext)) wait_if_debug(token) msg = [ciphertext] msg = pickle.dumps(msg) try: sender_q.put(msg, True, TIMEOUT_DELAY) logging.info("Sending message to server...") except: logging.info("Timed out writing client's second message") auth_res.error = True return # Calculate newly established session key session_key = pow(B, a_int, p) logging.info("Session key: " + str(session_key)) wait_if_debug(token) auth_res.dh = session_key auth_res.error = False # Server Mode else: # Wait for message from client in the form: # "client_msg, ra" # client_msg: "I'm client" # ra : client generated nonce while (1): try: if (token.debug): resp = receiver_q.get(True) break else: resp = receiver_q.get(True, TIMEOUT_DELAY) break except: logging.info("Still waiting for client's first message") continue try: resp = pickle.loads(resp) client_msg = resp[0] ra = resp[1] logging.info("Message recieved from client") logging.info('Client message: ' + str(client_msg)) logging.info('ra: ' + str(ra)) wait_if_debug(token) if (client_msg != client_auth_str): logging.info("Message from client didn't say 'I'm client'") wait_if_debug(token) auth_res.error = True return except Exception as e: logging.info("Message from client wasn't formatted correctly") logging.info('Exception: ' + str(e)) wait_if_debug(token) auth_res.error = True return # Send reply to client in the form: # "rb, E("server_msg,ra,dh_b", Kab) # rb : server generated nonce # server_msg: "I'm server" # ra : nonce received from client # B : server generated half of diffie-hellman (g^b mod p) # Kab : shared secret key between client and server rb = Random.get_random_bytes(NUM_BYTES_NONCE) b = Random.get_random_bytes(NUM_BYTES_DH) b_int = int.from_bytes(b, byteorder='big') B = pow(g, b_int, p) plaintext = [server_auth_str, ra, B] logging.info("Plaintext to be sent: ") logging.info('rb: ' + str(rb)) logging.info('server_mgs: ' + server_auth_str) logging.info('ra: ' + str(ra)) logging.info('B: ' + str(B)) wait_if_debug(token) plaintext = pickle.dumps(plaintext) ciphertext = Encryption.encrypt(plaintext, shared_secret_key) msg = [rb, ciphertext] msg = pickle.dumps(msg) logging.info('Server: Message: ' + str(rb) + ',' + str(ciphertext)) wait_if_debug(token) try: sender_q.put(msg, True, TIMEOUT_DELAY) logging.info("Sending message to client...") except: logging.info("Timed out writing server's first message") wait_if_debug(token) auth_res.error = True return # Wait for final message from client in the form: # "E("client_msg, rb, A", Kab)" # client_msg: "I'm client" # rb : return of previously generated nonce # A : client generated half of diffie-hellman (g^a mod p) # Kab : shared secret key between client and server try: if (token.debug): resp = receiver_q.get(True) else: resp = receiver_q.get(True, TIMEOUT_DELAY) except: logging.info("Timed out waiting for client's second message") wait_if_debug(token) auth_res.error = True return try: resp = pickle.loads(resp) ciphertext = resp[0] logging.info('Ciphertext received: ' + str(ciphertext)) wait_if_debug(token) plaintext = Encryption.decrypt(ciphertext, shared_secret_key) plaintext = pickle.loads(plaintext) client_msg = plaintext[0] rb_reply = plaintext[1] A = int(plaintext[2]) logging.info('Plaintext received: ') logging.info('client_msg: ' + client_msg) logging.info('rb: ' + str(rb)) logging.info('A: ' + str(A)) # TODO: For some reason adding the wait below would hang the system #self.wait_if_debug(debug, token) if (client_msg != client_auth_str): logging.info("Message from client didn't say 'I'm client'") wait_if_debug(token) auth_res.error = True return if (rb_reply != rb): logging.info( "Returned nonce rb_reply not equal sent nonce rb") wait_if_debug(token) auth_res.error = True return except Exception as e: logging.info("Message from client wasn't formatted correctly") logging.info(e) wait_if_debug(token) auth_res.error = True return # Calculate newly established session key session_key = pow(A, b_int, p) logging.info("Session key: " + str(session_key)) wait_if_debug(token) auth_res.dh = session_key auth_res.error = False return
class RemoteFS: def __init__(self, server: CubicServer, key): self.server = server self.crypto = Encryption(key) self.clear() def clear(self): self.dict = {} self.all_block_hashes = set() def generate_dict(self, items): items1, items2 = itertools.tee(items) iterable = itertools.chain.from_iterable( (item.path, item.meta) for item in items1) data = list(self.crypto.parallel_decrypt(iterable)) paths, metas = data[::2], data[1::2] for item, path, meta in zip(items2, paths, metas): path = path.decode('utf8', errors='surrogateescape') meta = json.loads(meta.decode()) mode = meta['mode'] mtime = meta['mtime'] is_dir = path.endswith('/') n = Node(is_dir=is_dir, mode=mode, mtime=mtime) if is_dir: path = path[:-1] else: n.size = meta['size'] n.block_hashes = item.blocks self.all_block_hashes.update(n.block_hashes) self.dict[path] = n def fetch_remote(self): logging.info('Downloading remote file list') items = self.server.get_tree() self.clear() self.generate_dict(items) logging.info('%s items in total', len(self.dict)) def check_hashes(self, hashes): hashes = list(hashes) logging.info('Checking remote existing blocks') exists = [ hash for hash, exist in zip(hashes, self.server.bulk_head_block(hashes)) if exist ] logging.info('%s of %s blocks exists', len(exists), len(hashes)) return exists def update_remote(self, *, add, remove): logging.info('Updating directory tree') remove_list = [] for path in remove: remove_list.append( self.crypto.encrypt( (path + ('/' if self.dict[path].is_dir else '')).encode( 'utf8', errors='surrogateescape'))) add_list = [] for path, node in add.items(): if node.is_dir: add_list.append( SDK_Node( self.crypto.encrypt( (path + '/').encode('utf8', errors='surrogateescape')), self.crypto.encrypt( json.dumps({ 'mode': node.mode, 'mtime': node.mtime }).encode()), [], )) else: add_list.append( SDK_Node( self.crypto.encrypt( path.encode('utf8', errors='surrogateescape')), self.crypto.encrypt( json.dumps({ 'mode': node.mode, 'mtime': node.mtime, 'size': node.size }).encode()), node.block_hashes, )) self.server.post_tree(put_items=add_list, delete_paths=remove_list) logging.info('Directory tree updated') def put_blocks(self, blocks): self.put_encrypted_blocks( [self.crypto.encrypt(block) for block in blocks]) def put_encrypted_blocks(self, blocks): logging.info('Uploading %s blocks, total size %s bytes', len(blocks), sum(len(b) for b in blocks)) self.server.bulk_post_block(blocks) def get_block(self, hash): return self.crypto.decrypt(self.server.get_block(hash))
class RabbitMQ_Client(): def __init__(self, config, mac, key): self.mac = mac self.config = config self.credentials = pika.PlainCredentials(config["rabbitmq_login"], config["rabbitmq_password"]) self.buffer = deque(maxlen=128) self.connected = False self.send_thread = Thread(target=self.send_messages_thread) self.send_thread.start() self.pooling_connect() self.encryption = Encryption(key) print(" [*] RabbitMQ client created.") def send_messages_thread(self): while 1: while self.connected and len(self.buffer) > 0: message = self.buffer.popleft() if self.publish_to_rabbit(message) > 0: self.buffer.appendleft(message) sleep(0.01) def publish(self, message): self.buffer.append(message) def publish_to_rabbit(self, message): try: self.channel.basic_publish(exchange='inbound.dojot.exchange', routing_key=self.mac, body=self.encryption.encrypt(message)) except Exception as e: print(e) print(" [*] Connection Closed. Trying to reconnect.") self.connected = False if self.connect(): self.channel.basic_publish(exchange='inbound.dojot.exchange', routing_key=self.mac, body=message) else: self.pooling_connect() return 2 print(f" [x] Sent {message} to server") return 0 def pooling_connect(self): self._thread = Thread(target=self._connection_thread) self._thread.start() def _connection_thread(self): while 1: print(" [*] RabbitMQ Client - Trying to Connect to RabbitMQ.") if self.connect(): print(" [*] RabbitMQ Client - RabbitMQ unreachable.") sleep(1) else: break print(" [*] RabbitMQ Client - Connected to RabbitMQ.") def connect(self): try: self.connection = pika.BlockingConnection( pika.ConnectionParameters( host=self.config["rabbitmq_server_ip"], credentials=self.credentials, heartbeat_interval=30)) self.channel = self.connection.channel() self.channel.exchange_declare(exchange='inbound.dojot.exchange', exchange_type='topic', durable=True) self.connected = True except: print(" [*] Could NOT connect to RabbitMQ. Network unreachable.") return 1 return 0 def deinit(self): self.connection.close()
def run(self): th1 = threading.Thread(target=self.senddata) th1.daemon = True th1.start() th2 = threading.Thread(target=self.server) th2.daemon = True th2.start() while True: data = self.client_socket.recv(4096) if not data: break if data.decode()[:9] == 'send_file': ip, port = data.decode()[10:].split(':') p2psocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) p2psocket.connect((ip, int(port))) DH = GenerateKey(self.rollnumber) p2psocket.send(str(DH.hashkey).encode()) peerhash = int(p2psocket.recv(4096).decode()) DH.gen_key(peerhash) En = Encryption(DH.finalkey) data = En.encrypt((self.user_name + ' : sent a file').encode()) p2psocket.send(data) filename = self.filepath.split('/')[-1] p2psocket.recv(4096) data = En.encrypt(filename.encode()) p2psocket.send(data) try: with open(self.filepath, 'rb') as f: l = f.read(4096) while (l): data = En.encrypt(l) p2psocket.send(data) l = f.read(4096) p2psocket.recv(4096) except FileNotFoundError as e: print("ERROR:", e) p2psocket.close() elif data.decode()[:4].lower() == 'send': ip, port = data.decode()[5:].split(':') p2psocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) p2psocket.connect((ip, int(port))) DH = GenerateKey(self.rollnumber) p2psocket.send(str(DH.hashkey).encode()) peerhash = int(p2psocket.recv(4096).decode()) DH.gen_key(peerhash) En = Encryption(DH.finalkey) data = En.encrypt( (self.user_name + ' : ' + self.text).encode()) p2psocket.send(data) p2psocket.close() elif data.decode()[:15] == 'group_send_file': data = data.decode()[16:] members = data.split(';')[:-1] groupname = data.split(';')[-1] for i in members: ip, port = i.split(':') p2psocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) p2psocket.connect((ip, int(port))) DH = GenerateKey(self.rollnumber) p2psocket.send(str(DH.hashkey).encode()) peerhash = int(p2psocket.recv(4096).decode()) DH.gen_key(peerhash) En = Encryption(DH.finalkey) data = En.encrypt((self.user_name + ' ' + groupname + ' : sent a file').encode()) p2psocket.send(data) filename = self.filepath.split('/')[-1] p2psocket.recv(4096) data = En.encrypt(filename.encode()) p2psocket.send(data) try: with open(self.filepath, 'rb') as f: l = f.read(4096) while (l): data = En.encrypt(l) p2psocket.send(data) l = f.read(4096) p2psocket.recv(4096) except FileNotFoundError as e: print("ERROR:", e) p2psocket.close() elif data.decode()[:10].lower() == 'group_send': data = data.decode()[11:] members = data.split(';')[:-1] groupname = data.split(';')[-1] for i in members: ip, port = i.split(':') p2psocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) p2psocket.connect((ip, int(port))) DH = GenerateKey(self.rollnumber) p2psocket.send(str(DH.hashkey).encode()) peerhash = int(p2psocket.recv(4096).decode()) DH.gen_key(peerhash) En = Encryption(DH.finalkey) data = En.encrypt((self.user_name + ' ' + groupname + ' : ' + self.text).encode()) p2psocket.send(data) p2psocket.close() elif data.decode()[:4].lower() == 'list_groups': print(data.decode()[5:]) else: print(data.decode())
class Client: def __init__(self, address, display_message, start_new_server): """ :param address: адресс сервера, например: ('127.0.0.1' , 25000) :param display_message: функция которая будет вызываться при получении сообщения :param start_new_server: функция которая будет вызываться когда нужно создать новый сервер """ self.server_address = address self.display_message = display_message self._start_new_server = start_new_server self.connections_list = [] self.connections_info = [] self._encryption = Encryption() self.has_new_connections_info = True self._running = True self.sock = socket.socket() thread = Thread(target=self._receive_data) thread.daemon = True thread.start() def _receive_data(self): try: self.sock.connect(self.server_address) self.display_message("system", "connection successful", "blue") thread = Thread(target=self._send_description) thread.daemon = True thread.start() except socket.error as e: self.display_message("system", "unable to connect", "blue") print("clent error: " + str(e)) return while self._running: try: data = self.sock.recv(1024) if not data: raise socket.error else: self._handle_data(data) except socket.error: if not self._running: return self.display_message("system", "server has disconnected", "blue") self._handle_server_down() break def _handle_data(self, data): # данные в посылаются в формате json messages = self._encryption.decrypt(data).decode().split( "}{") # разделение пакетов json if len(messages) > 1: messages = [messages[0] + "}" ] + ["{" + i + "}" for i in messages[1:-1]] + ["{" + messages[-1]] for message in messages: self._handle_message(message) def send_message(self, name, text, color): config = configparser.ConfigParser() config.read("config.ini") self.sock.sendall( self._encryption.encrypt( json.dumps({ "username": name, "text": text, "color": color }).encode())) def _handle_message(self, message): json_data = json.loads(message) if "connections_list" in json_data: if len(json_data["connections_list"]) == 0: self.connections_list = [] else: self.connections_list = [ tuple(l) for l in json_data["connections_list"] ] elif "users_data" in json_data: self.connections_info = list(json_data["users_data"]) self.has_new_connections_info = True else: self.display_message(json_data["username"], json_data["text"], json_data["color"]) def _handle_server_down(self): # обработка отключения сервера, выбор клиента создающего новый сервер self.connections_list.sort(key=lambda tup: str(tup)) if self.connections_list[0] == self.sock.getsockname(): self._start_new_server(('', 25000)) self.server_address = ('127.0.0.1', 25000) self.display_message("system", "you are now hosting server", "blue") else: self.server_address = (self.connections_list[0][0], 25000) time.sleep(1) self.sock.close() self.sock = socket.socket() thread = Thread(target=self._receive_data) thread.daemon = True thread.start() def _send_description(self): # отправляет описание пользователя, когда требуется prev_modified = 0 while self._running: modified = os.path.getmtime("config.ini") if prev_modified < modified: config = configparser.ConfigParser() config.read("config.ini") name = config.get("USER INFORMATION", "username") color = config.get("USER INFORMATION", "color") status = config.get("USER INFORMATION", "status") self.sock.sendall( self._encryption.encrypt( json.dumps({ "userdata": { "username": name, "color": color, "status": status } }).encode())) prev_modified = modified time.sleep(1) def stop(self): self._running = False self.sock.shutdown(socket.SHUT_RDWR) self.sock.close()
class Server: def __init__(self, server_address): """ :param server_address: например: ('127.0.0.1', 25000) """ self.address = server_address self._sock = socket.socket() self._sock.bind(self.address) self._connections = {} self._main_client = None self._messages = [] self._encryption = Encryption() self._running = True self._sock.listen(32) self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) thread = Thread(target=self._waiting_for_connections) thread.daemon = True thread.start() thread = Thread(target=self._send_to_all) thread.daemon = True thread.start() def _waiting_for_connections(self): while self._running: try: connection, address = self._sock.accept() if not self._main_client: self._main_client = address self._connections.update({ connection: json.loads( self._encryption.decrypt( connection.recv(1024)).decode())['userdata'] }) self._send_current_connections() self._send_system_message("new connection established with " + str(address)) thread = Thread(target=self.receive_data, args=[connection, address]) thread.daemon = True thread.start() except socket.error as e: if not self._running: return print( "error: seems like you are not connected to the internet") print(e) def receive_data(self, connection, address): while self._running: try: data = connection.recv(1024) except socket.error: if not self._running: break self._send_system_message("client " + str(address) + " has disconnected") self._connections.pop(connection) self._send_current_connections() break if data: messages = self._encryption.decrypt(data).decode().split("}{") if len(messages) > 1: messages = [messages[0] + "}"] + [ "{" + i + "}" for i in messages[1:-1] ] + ["{" + messages[-1]] for message in messages: self._handle_message(message, connection) def _handle_message(self, message, connection): json_data = json.loads(message) if "userdata" in json_data: self._connections[connection] = json_data['userdata'] self._send_current_connections() else: self._messages.append(message) def _send_to_all(self): while self._running: if self._messages: for message in self._messages[:]: for connection in self._connections.keys(): connection.sendall( self._encryption.encrypt(message.encode())) self._messages.remove(message) time.sleep(0.1) time.sleep(0.01) def _send_system_message(self, text): self._messages.append( json.dumps({ "username": "******", "text": text, "color": "blue" })) def _send_current_connections(self): c_list = [ c.getpeername() for c in self._connections.keys() if c.getpeername() != self._main_client ] self._messages.append(json.dumps({"connections_list": c_list})) time.sleep(0.1) self._messages.append( json.dumps({"users_data": list(self._connections.values())})) def stop(self): self._running = False for connection in list(self._connections.keys()): connection.shutdown(socket.SHUT_RDWR) connection.close() self._sock.close()
import time from encryption import Encryption from decryption import Decryption PUBLIC_KEY = 'master_keys/public-key.pem' PRIVATE_KEY = 'master_keys/private-key.pem' CONTENT = "Hello, my name is João" print('Encrypt and Decrypt:\n"{}"\n'.format(CONTENT)) print('Key-pair:\n{}\n{}\n'.format(PUBLIC_KEY, PRIVATE_KEY)) START_ENCRYPTION = time.time() encryption = Encryption(PUBLIC_KEY) content_encrypted = encryption.encrypt(CONTENT) END_ENCRYPTION = time.time() - START_ENCRYPTION print("Content Encrypted:\n{}\n".format(content_encrypted)) START_DECRYPTION = time.time() decryption = Decryption(PRIVATE_KEY) content_decrypted = decryption.decrypt(content_encrypted) print("Content Decrypted:\n{}\n".format(content_decrypted)) print("{:.4f} seconds to encrypt.\n{:.4f} seconds to decrypt.".format( END_ENCRYPTION, (time.time() - START_DECRYPTION)))
while choice < 1 or choice > maxValue: printValues(theList) choice = getInputAsInt() return choice # Start Config br = FirstStep(linkPorrum) titles, choises = br.getChoices() numberOfCourses = len(titles) print "Please introduce the correct answers !" print numberOfCourses, "courses detected. Please choose yours." course = printAndChoose(titles, numberOfCourses) selectedCourse = choises[course - 1].name br.chooseCourse(selectedCourse) names = br.getNames() numberOfNames = len(names) print numberOfNames, "names detected. Please choose yours." name = printAndChoose(names, numberOfNames) selectedName = names[name - 1] password = "" while len(password) == 0: password = easygui.passwordbox(msg='Password:'******'Encryption message', default='') passphrase = "" while len(passphrase) == 0: passphrase = easygui.passwordbox(msg='Passphrase:', title='Encryption message', default='') enc = Encryption(password, passphrase) fileConfig = open ("marks.cfg", 'w') fileConfig.write("%s\n"%selectedCourse) fileConfig.write("%s\n"%selectedName) fileConfig.write("%s"%enc.encrypt()) print "All data saved !"