def _get_fake_transaction(self): #INVALID BULK MESSAGE shared_key = self.comm_service.comsec_core.generate_shared_key(self.comm_service.peerkey) # Pack data into stream fake_stream = self.comm_service.stream_manager.pack_stream( stream_type=constants.PROTO_BULK_TYPE, stream_content=random_stream(), stream_host=self.peer_ip, shared_key=md5hash("INVALID KEY!!!") ) #INVALID MESSAGE ACK fmack_stream = self.comm_service.stream_manager.pack_stream( stream_type=constants.PROTO_MACK_TYPE, stream_content='', stream_host=self.peer_ip, shared_key=shared_key ) return (fake_stream, fmack_stream)
def pack_stream(self, stream_type, stream_content, stream_host, stream_flag=STREAM_TYPES.AUTH, shared_key=None): "Pack data into stream." # Check length of content. if len(stream_content) > constants.STREAM_CONTENT_LEN: raise StreamOverflowError(constants.STREAM_CONTENT_LEN) # Check length of capsule type. if len(stream_type) > constants.STREAM_TYPE_LEN: raise StreamOverflowError(constants.STREAM_TYPE_LEN) # Generate uid stream_uid = generate_uuid(stream_host) # Stream type stream_type = stream_type.upper() # Stream peer key stream_token = None #For testing _debug_stream_content = stream_content # Shuffle content if constants.ENABLE_SHUFFLE: Logger.info("STREAM: Scrambling content...") stream_content = shuffler( string=stream_content, iterations=constants.STREAM_CONT_SHUFF_ITER ) # Check stream signing mode if stream_flag == STREAM_TYPES.UNAUTH: # Stream key is peer key # NOTE peer public key is sent during # authentication. stream_token = num_to_bytes(self.public_key) elif stream_flag == STREAM_TYPES.AUTH: # Generate token at source side stream_token = generate_token(stream_uid, shared_key) # AES Encryption if constants.AES_AVAILABLE: Logger.info("STREAM: Encrypting content...") # Generate iv from stream token iv = md5hash(stream_token, hexdigest=False) # Create AES object AES_obj = AES.new(shared_key, AES.MODE_CBC, iv) # Pad string stream_content = self.pad(stream_content) # Encrypt string stream_content = AES_obj.encrypt(stream_content) # Create stream object stream_obj = Stream( stream_uid, stream_flag, stream_type, stream_content, stream_token, ) # Add stream to store self.add_store( stream_uid, stream_obj.dict ) if stream_flag == STREAM_TYPES.UNAUTH: Logger.info("STREAM: Packing Authentication Stream...") # Pack store into authentication stream stream = struct.pack( "!?{}s{}s{}s{}s".format( constants.STREAM_TYPE_LEN, constants.STREAM_CONTENT_LEN, constants.STREAM_PEER_KEY_LEN, constants.STREAM_CHKSUM_LEN ), self.get_store_item(stream_uid, 'STREAM_FLAG'), self.get_store_item(stream_uid, 'STREAM_TYPE'), self.get_store_item(stream_uid, 'STREAM_CONTENT'), self.get_store_item(stream_uid, 'STREAM_PKEY'), self.get_store_hmac(stream_uid) ) elif stream_flag == STREAM_TYPES.AUTH: Logger.info("STREAM: Packing Message Stream...") # Pack store into message block stream stream = struct.pack( "!?{}s{}s{}s{}s".format( constants.STREAM_TYPE_LEN, constants.STREAM_CONTENT_LEN, constants.STREAM_TOKEN_LEN, constants.STREAM_CHKSUM_LEN ), self.get_store_item(stream_uid, 'STREAM_FLAG'), self.get_store_item(stream_uid, 'STREAM_TYPE'), self.get_store_item(stream_uid, 'STREAM_CONTENT'), self.get_store_item(stream_uid, 'STREAM_PKEY'), self.get_store_hmac(stream_uid) ) else: Logger.error("STREAM: Invalid Stream Flag received.") return None def pkey_action(val): val = md5hash(val) return val if stream_flag == STREAM_TYPES.UNAUTH: Logger.debug("""STREAM: Packing: \n{}""".format( self.storage_table(shorten_len=64, action_dict={"STREAM_PKEY":pkey_action}) )) Logger.debug("""DEBUG STREAM: FLAG: {} TYPE: {} CONTENT: {} KEY: {} CHECKSUM: {} """.format( self.get_store_item(stream_uid, 'STREAM_FLAG'), self.get_store_item(stream_uid, 'STREAM_TYPE'), _debug_stream_content, b64encode(self.get_store_item(stream_uid, 'STREAM_PKEY')), self.get_store_hmac(stream_uid))) # Compress stream if constants.ENABLE_COMPRESSION: Logger.info("STREAM: Compressing Stream...") stream = compress(stream) Logger.info("STREAM: Succesfully packed stream.") return stream
def pkey_action(val): val = md5hash(val) return val
def unpack_stream(self, stream, shared_key=None): "Unpack serial data into stream." # Decompress data stream if constants.ENABLE_COMPRESSION: Logger.info("STREAM: Decompressing Stream...") stream = decompress(stream) # Check if data is of expected chunk size if len(stream) != constants.STREAM_SIZE_AUTH_BLOCK and \ len(stream) != constants.STREAM_SIZE_MSG_BLOCK: raise StreamOverflowError() if len(stream) == constants.STREAM_SIZE_AUTH_BLOCK: Logger.info("STREAM: Unpacking Authentication Stream...") # Unpack auth stream to variables ( stream_flag, stream_type, stream_content, stream_token, stream_hmac ) = struct.unpack( "!?{}s{}s{}s{}s".format( constants.STREAM_TYPE_LEN, constants.STREAM_CONTENT_LEN, constants.STREAM_PEER_KEY_LEN, constants.STREAM_CHKSUM_LEN ), stream ) elif len(stream) == constants.STREAM_SIZE_MSG_BLOCK: Logger.info("STREAM: Unpacking Message Stream...") # Unpack msg block stream to variables ( stream_flag, stream_type, stream_content, stream_token, stream_hmac ) = struct.unpack( "!?{}s{}s{}s{}s".format( constants.STREAM_TYPE_LEN, constants.STREAM_CONTENT_LEN, constants.STREAM_TOKEN_LEN, constants.STREAM_CHKSUM_LEN ), stream ) else: Logger.error("STREAM: Invalid Stream Length received.") return [None] * 3 # Remove all null characters if present stream_content = stream_content.rstrip('\0') stream_token = stream_token.rstrip('\0') # Get uid stream_uid = generate_uuid(self.peer_host) # Get stream object stream_obj = Stream( stream_uid, stream_flag, stream_type, stream_content, stream_token, ) # Add stream to store self.add_store(stream_uid, stream_obj.dict) # Verify stream integrity if not self.check_hmac(stream_uid, stream_hmac): Logger.error("STREAM: Stream Checksum mismatch.") return [None] * 3 # Check stream signing mode if stream_flag == STREAM_TYPES.UNAUTH: # Stream key is peer public key pass elif stream_flag == STREAM_TYPES.AUTH: # Generate token at destination side # Perform key challenge if generate_token(stream_uid, shared_key) != stream_token: Logger.error("STREAM: Token challenge Fail!") Logger.error("STREAM: RCVD: {}".format(b64encode(stream_token))) Logger.error("STREAM: EXPD: {}".format(b64encode(generate_token(stream_uid, shared_key)))) return [None] * 3 else: Logger.info("STREAM: Token challenge Pass!") # AES Decryption if constants.AES_AVAILABLE: Logger.info("STREAM: Decrypting content...") # Generate iv from stream token iv = md5hash(stream_token, hexdigest=False) # Create AES object AES_obj = AES.new(shared_key, AES.MODE_CBC, iv) # Decrypt content stream_content = AES_obj.decrypt(stream_content) # Upad decrypted content stream_content = self.unpad(stream_content) def pkey_action(val): val = md5hash(val) return val if stream_flag == STREAM_TYPES.UNAUTH: Logger.debug("""STREAM: Unpacking: \n{}""".format( self.storage_table(shorten_len=64, action_dict={"STREAM_PKEY":pkey_action}) )) Logger.debug("""DEBUG STREAM: FLAG: {} TYPE: {} CONTENT: {} KEY: {} CHECKSUM: {} """.format( self.get_store_item(stream_uid, 'STREAM_FLAG'), self.get_store_item(stream_uid, 'STREAM_TYPE'), stream_content, b64encode(self.get_store_item(stream_uid, 'STREAM_PKEY')), self.get_store_hmac(stream_uid))) # Unshuffle contentself._storage[sid].hmac() if constants.ENABLE_SHUFFLE: Logger.info("STREAM: Unscrambling content...") stream_content = unshuffler( shuffled_string=stream_content, iterations=constants.STREAM_CONT_SHUFF_ITER ) if stream_flag == STREAM_TYPES.UNAUTH: Logger.info("STREAM: Successfully unpacked AUTH Stream.") return (self.get_store_item(stream_uid, "STREAM_TYPE"), self.get_store_item(stream_uid, "STREAM_CONTENT"), bytes_to_num( self.get_store_item(stream_uid, "STREAM_PKEY") )) elif stream_flag == STREAM_TYPES.AUTH: Logger.info("STREAM: Successfully unpacked MSG Stream.") return (self.get_store_item(stream_uid, "STREAM_TYPE"), stream_content, self.get_store_item(stream_uid, "STREAM_PKEY")) else: Logger.info("STREAM: Unpack of stream unsuccessfull.") return [None] * 3
def _hash_key(self, key): "Return md5 hash of key" return md5hash(key)
# ---Project Path CONSTANTS-----------------------------------------------#### constants.PROJECT_PATH = "{}/../..".format( os.path.dirname(os.path.realpath(__file__)) ) constants.KIVY_RESOURCE_PATH_1 = "{}/data".format(constants.PROJECT_PATH) constants.KIVY_RESOURCE_PATH_2 = "{}/libs/garden/navigationdrawer".format( constants.PROJECT_PATH ) # ------------------------------------------------------------------------#### # ---peer attribute constants---------------------------------------------#### constants.PEER_ID_LEN = 8 constants.PEER_ID = md5hash(uniqueid.id)[0:constants.PEER_ID_LEN] constants.PEER_PORT = 1597 # TODO , p2p functionality doesnt work over the internet # due to which the app is tested over a Local area network # http://docs.openpeer.org/OpenPeerProtocolSpecification/#DesignConsiderations constants.PEER_HOST = get_my_ip()[0] constants.PEER_NAME = "MYPOD" # ------------------------------------------------------------------------#### # ------------------Protocol Stream type CONSTANTS-----------------------#### #-- constants.PROTO_BULK_TYPE = "BULK" constants.PROTO_MACK_TYPE = "MACK" #-- constants.PROTO_AUTH_TYPE = "AUTH"