def __init__(self, name: str, config: LogConfig, display: Dict[Users,
Levels]):
if name is not None and not isinstance(name, str):
raise HTypeError("name", name, str, None)
if not isinstance(config, LogConfig):
raise HTypeError("config", config, LogConfig)
if display is not Display.ALL and not isinstance(display, dict):
raise HTypeError("display", display, dict)
self._name = name
self._config = config
self._display = display
for user in self._display:
if user not in self._config.users():
raise LoggerError(
f"Displayed user "
f"must be in {self._config.users()}, rather than {user}.")
if self._display[user] is not Display.ALL\
and not isinstance(self._display[user], Iterable):
raise HTypeError("display of {}".format(user),
self._display[user], Iterable, Display.ALL)
if self._display[user] is Display.ALL:
continue
for level in self._display[user]:
if level not in self._config.levels(user):
raise LoggerError(
f"Displayed "
f"level of '{user}' must be in the "
f"{self._config.levels(user)}, rather than {level}.")
def hash_cls_name(obj: object,
hash_obj_1: HKSHash = __default_sha1,
hash_obj_2: HKSHash = __default_sha256) -> bytes:
if not isinstance(hash_obj_1, HKSHash):
raise HTypeError("hash_obj_1", hash_obj_1, HKSHash)
if not isinstance(hash_obj_2, HKSHash):
raise HTypeError("hash_obj_2", hash_obj_2, HKSHash)
if type(obj).__name__ == 'type' or\
type(obj).__name__ == 'builtin_function_or_method':
cls_name = str(obj).split(".")[-1][:-2].encode()
else:
cls_name = type(obj).__name__.encode()
hash_obj_1.reset()
hash_obj_2.reset()
hash_value_1 = hash_obj_1.finalize(cls_name)
hash_value_2 = hash_obj_2.finalize(cls_name)
hash_value = bytearray(b"\x00\x00")
for c in hash_value_1:
hash_value[0] = hash_value[0] ^ c
for c in hash_value_2:
hash_value[1] = hash_value[1] ^ c
return bytes(hash_value)
def __init__(
self,
cipher: HKSCipher,
name: str,
buffer_size: int,
logger_generator: LoggerGenerator = InvisibleLoggerGenerator(),
display: dict = {}
):
if not isinstance(cipher, HKSCipher):
raise HTypeError("cipher", cipher, HKSCipher)
if not isinstance(buffer_size, int):
raise HTypeError("buffer_size", int)
if buffer_size <= 0:
raise HFormatError("Parameter buffer_size expected an positive integer.")
if not isinstance(logger_generator, LoggerGenerator):
raise HTypeError("logger_generator", logger_generator, LoggerGenerator)
if not isinstance(display, dict):
raise HTypeError("display", display, dict)
if not isinstance(name, str):
raise HTypeError("name", name, str)
self._name = name
self._logger_generator = logger_generator
self._display = display
self._log = self._logger_generator.generate(name, self._display)
self._log(StdUsers.DEV, StdLevels.DEBUG, "Initialized with "
"cipher {}.".format(CipherID.cls2name(type(cipher))))
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.__cipher = cipher
self.__cipher.reset()
self.set_reload_time(STCPSocket.DEFAULT_RELOAD_TIME)
self.set_recv_timeout(None)
self.__packet_encoder = SecurePacketEncoder(self.__cipher)
self.__packet_decoder = SecurePacketDecoder(self.__cipher)
self.__buffer = None
self.__buffer_size = buffer_size
self.__buffer_available = threading.Event()
self._stop_auto_recv = False
self._prepare_close = False
self._is_working = False
def push(self, packet: bytes, append_to_end: bool = True):
if not isinstance(packet, bytes):
raise HTypeError("packet", packet, bytes)
if not isinstance(append_to_end, bool):
raise HTypeError("append_to_end", append_to_end, bool)
self._push_lock.acquire()
if append_to_end:
self._buffer.append(packet)
else:
self._buffer.insert(0, packet)
self._push_lock.release()
def quantizer(float_range: tuple, int_size: int):
if not isinstance(float_range, tuple):
raise HTypeError("float_range", float_range, tuple)
if len(float_range) != 2 or sum(float_range) != 0:
raise HFormatError(
"Parameter float_range must be a symmetric pair.")
if not isinstance(int_size, int):
raise HTypeError("int_size", int_size, int)
SignedBatchNumber.__quantizer.set_float_range(*float_range)
SignedBatchNumber.__quantizer.set_int_size(
int_size - SignedInteger.sign_size() + 1, signed=True)
SignedBatchNumber.__quantizer.compile()
def get_header(self, packet: bytes):
if not isinstance(packet, bytes):
raise HTypeError("packet", packet, bytes)
if len(packet) > MAX_PACKET_SIZE:
raise PacketSizeError("Packet size is too large "
"(expected < {}).".format(MAX_PACKET_SIZE))
if len(packet) < MIN_HEADER_SIZE:
raise IncompletePacketError("Incomplete header.")
header_size, payload_size = struct.unpack(">HI",
packet[:MIN_HEADER_SIZE])
if header_size > MAX_HEADER_SIZE:
raise PacketSizeError("Header size is too large "
"(expected < {}).".format(MAX_HEADER_SIZE))
if len(packet) < header_size:
raise IncompletePacketError("Incomplete header.")
header_dict = {}
header_dict["header_size"] = header_size
header_dict["payload_size"] = payload_size
return header_dict
def decrypt(self, ciphertext: bytes, finalize=True) -> bytes:
if not isinstance(ciphertext, bytes):
raise HTypeError("ciphertext", ciphertext, bytes)
if not self._key:
raise KeyError("Please provide key before calling decrypt()")
if self._in_process is CipherProcess.NONE:
self._in_process = CipherProcess.DECRYPT
self._data = b""
if self._in_process is not CipherProcess.DECRYPT:
raise ResetError("You are in {} process, please call reset() "
"before calling decrypt().".format(self._in_process.name))
if self._iv is None:
raise CipherParameterError("IV has not yet been set.")
self._data += ciphertext
plaintext = b""
while len(self._data) > len(self._key):
data_to_enc, self._data = self._data[:len(self._key)], self._data[len(self._key):]
block = bxor(data_to_enc, self._key)
plaintext += bxor(block, self._iv)
if finalize:
plaintext += self.finalize()
return plaintext
def __init__(self, logger_cls: Type[BaseLogger], **kwargs) -> None:
if not issubclass(logger_cls, BaseLogger):
raise HTypeError("logger_cls", logger_cls, Type[BaseLogger])
super().__init__()
self._logger_cls = logger_cls
self._logger_kwargs = kwargs
def decrypt(self, ciphertext: bytes, finalize=True) -> bytes:
if not isinstance(ciphertext, bytes):
raise HTypeError("ciphertext", ciphertext, bytes)
if not self._key:
raise KeyError("Please provide key before calling decrypt()")
if self._aes is None:
raise CipherParameterError("Please set iv value "
"before calling decrypt().")
if self._in_process is CipherProcess.NONE:
self._in_process = CipherProcess.DECRYPT
self._decryptor = self._aes.decryptor()
self._unpadder = self._pkcs7.unpadder()
if self._in_process is not CipherProcess.DECRYPT:
raise ResetError("You are in {} process, please call reset() "
"before calling decrypt().".format(self._in_process.name))
padded_text = self._decryptor.update(ciphertext)
plaintext = self._unpadder.update(padded_text)
if finalize:
plaintext += self.finalize()
return plaintext
def sendall(self, data: bytes) -> int:
if not isinstance(data, bytes):
raise HTypeError("data", data, bytes)
self.__cipher.reset()
packet = self.__packet_encoder.encode(data)
return self._socket.sendall(packet)
def use_dict(self, print_dict: dict):
if not isinstance(print_dict, dict):
raise HTypeError("print_dict", dict)
for user in print_dict.keys():
for level in print_dict[user]:
self.__call__(user, level, print_dict[user][level])
def decrypt(self, ciphertext: bytes, finalize=True) -> bytes:
if not isinstance(ciphertext, bytes):
raise HTypeError("ciphertext", ciphertext, bytes)
if self._in_process is CipherProcess.NONE:
self._in_process = CipherProcess.DECRYPT
self._stored_digest = b""
if self._in_process is not CipherProcess.DECRYPT:
raise ResetError("You are in {} process, please call reset() "
"before calling decrypt()".format(self._in_process.name))
plaintext = self._cipher.decrypt(ciphertext, finalize=False)
all_plaintext = self._stored_digest + plaintext
actual_plaintext = all_plaintext[ : -self._hash.digest_size]
self._stored_digest = all_plaintext[-self._hash.digest_size : ]
self._hash.update(actual_plaintext)
if finalize:
actual_plaintext += self.finalize()
return actual_plaintext
def encrypt(self, plaintext: bytes, finalize=True) -> bytes:
if not isinstance(plaintext, bytes):
raise HTypeError("plaintext", plaintext, bytes)
if not self._key:
raise KeyError("Please provide key before calling encrypt()")
if self._aes is None:
raise CipherParameterError("Please set nonce "
"value before calling encrypt().")
if self._in_process is CipherProcess.NONE:
self._in_process = CipherProcess.ENCRYPT
self._encryptor = self._aes.encryptor()
if self._in_process is not CipherProcess.ENCRYPT:
raise ResetError("You are in {} process, please call reset() "
"before calling encrypt().".format(self._in_process.name))
ciphertext = self._encryptor.update(plaintext)
if finalize:
ciphertext += self.finalize()
return ciphertext
def finalize(self, msg: bytes = None) -> bytes:
if msg is not None and not isinstance(msg, bytes):
raise HTypeError("msg", msg, bytes, None)
if msg is not None:
self.update(msg)
return self._digest.finalize()
def __init__(self, key: bytes):
if not isinstance(key, bytes) :
raise HTypeError("key", key, bytes)
super().__init__(key, 1)
self._in_process: CipherProcess = CipherProcess.NONE
self._data: bytes = None
self._iv: bytes = None
def set_padding_size(value: int):
if not isinstance(value, int):
raise HTypeError("value", value, int)
if value <= 0:
raise HFormatError("Parameter error expected an positive integer.")
BatchNumber.__PADDING_SIZE = value
def __add__(self, other: BatchNumber):
if not isinstance(other, type(self)):
raise HTypeError("other", other, type(self))
result = super().__add__(other)
result = GenericBatchNumber(result.raw(), len(result),
result.value_size())
result._n_cumulative = self._n_cumulative + other._n_cumulative
return result
def set_sign_size(value: int):
if not isinstance(value, int):
raise HTypeError("value", value, int)
if value < 1:
raise HFormatError(
"The parameter value expected an positive integer.")
SignedInteger.__SIGN_SIZE = value
def set_recv_timeout(self, value: float):
if value is not None and not isinstance(value, (int, float)):
raise HTypeError("value", value, float, int, None)
if value is not None and value < 0:
raise HFormatError("Parameter value expected a non-negative number.")
self._log(StdUsers.DEV, StdLevels.DEBUG, "Set received "
"timeout to {}.".format(value))
self.__recv_timeout = value
def set_reload_time(self, value: float):
if not isinstance(value, (int, float)):
raise HTypeError("value", value, float, int)
if value < 0:
raise HFormatError("Parameter value expected a non-negative number.")
self._log(StdUsers.DEV, StdLevels.DEBUG, "Set reload "
"time to {}.".format(value))
self.__reload_time = value
def __init__(
self,
name: str = None,
logger_generator: LoggerGenerator = InvisibleLoggerGenerator(),
display: dict = {}):
if name is not None and not isinstance(name, str):
raise HTypeError("name", name, str, None)
if not isinstance(logger_generator, LoggerGenerator):
raise HTypeError("logger_generator", logger_generator,
LoggerGenerator)
if not isinstance(display, dict):
raise HTypeError("display", display, dict)
if name is None:
while name is None or name in LocalNode.node_names:
name = str(random.randint(1000000, 9999999))
if name in LocalNode.node_names:
raise ChannelSlotError(f"Name {name} is in use.")
if len(LocalNode.nodes) >= LocalNode.MAX_NODES:
raise ChannelSlotError("No available slot in Local Node list.")
LocalNode.lock.acquire()
LocalNode.node_names.append(name)
LocalNode.nodes.append(self)
LocalNode.lock.release()
self.name = name
self._buffer = ChannelBuffer()
self._closed = False
self._buffer_available = threading.Event()
self.__send_lock = threading.Lock()
self.__recv_lock = threading.Lock()
self._log = logger_generator.generate(name, display)
self._log(StdUsers.DEV, StdLevels.INFO,
"{} join to Local Nodes.".format(name))
def settimeout_raw(self, value: float):
if value is not None and not isinstance(value, (int, float)):
raise HTypeError("value", value, float, int, None)
if value < 0:
raise HFormatError("Parameter value expected a non-negative number.")
self._log(StdUsers.DEV, StdLevels.DEBUG, "Set timeout "
"to {}.".format(value))
return self._socket.settimeout(value)
def __ops__(self, other, operator):
if not isinstance(other, type(self)):
raise HTypeError("other", other, type(self))
if self.size() != other.size():
raise IntegerError("Two operands must be "
"the same size ({} != {}).".format(
self.size(), other.size()))
raw_result = operator(self.raw(), other.raw())
return SignedInteger(raw_result, self.size())
def register(cipher_cls: Type[HKSCipher]):
if not issubclass(cipher_cls, HKSCipher):
raise HTypeError("cipher_cls", cipher_cls, Type[HKSCipher])
if hash_cls_name(cipher_cls) in CipherID._cipher_hashs.keys():
raise CipherIDError()
CipherID._cipher_hashs[hash_cls_name(cipher_cls)] = cipher_cls
CipherID._cipher_names[cipher_cls.__name__] = cipher_cls
CipherID._cipher_hashs_invert[cipher_cls] = hash_cls_name(cipher_cls)
CipherID._cipher_names_invert[cipher_cls] = cipher_cls.__name__
return cipher_cls
def set_param(self, index: int, value: bytes) -> None:
if not isinstance(value, bytes):
raise HTypeError("value", value, bytes)
if index == 0:
if len(value) != len(self._key):
raise CipherParameterError("IV of XorCipher must be a bytes object "
"which is the same size as the key.")
else:
self._iv = value
else:
raise CipherParameterError("Index exceeds (XorCipher use only one parameter).")
def get_enum(cls: Iterable, obj: object, default: object = unknown):
if not isinstance(cls, Iterable) and not issubclass(cls, Enum):
raise HTypeError("cls", cls, Iterable, Type[Enum])
if default == _Default.unknown:
default = Default.unknown
for e in cls:
if e.value == obj or e == obj:
return e
return default
def __call__(self, user: Users, level: Levels, *values, **kwargs):
if not isinstance(user, Users):
raise HTypeError("user", user, Users)
if not isinstance(level, Levels):
raise HTypeError("level", level, Levels)
if user not in self._config.users():
raise LoggerError(
f"User must be in "
f"{list(self._config.users())}, rather than {user}.")
if level not in self._config.levels(user):
raise LoggerError(
f"Level of '{user}' "
f"must be in {self._config.levels(user)}, rather than {level}."
)
if user not in self._display:
return
if self._display[
user] is not Display.ALL and level not in self._display[user]:
return
output = self._config.output(user)
output.open()
now = datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")
if self._name:
output.write(f"{now} {level.name.upper()} [{self._name}] -",
*values, **kwargs)
else:
output.write(f"{now} {level.name.upper()} -", *values, **kwargs)
output.close()
def send(self, destination_name: str, message: bytes, obj: object = None):
if not isinstance(destination_name, str):
raise HTypeError("destination_name", destination_name, str)
if not isinstance(message, bytes):
raise HTypeError("message", message, bytes)
self.__send_lock.acquire()
if isinstance(message, bytes) is False:
raise Exception("Message must be a bytes object.")
if self._closed:
raise ChannelClosedError("Channel closed.")
try:
slot_of_destination = LocalNode.node_names.index(destination_name)
destination_node: LocalNode = LocalNode.nodes[slot_of_destination]
except ValueError:
raise ChannelSlotError(
f"Channel name {destination_name} doesn't exist.")
destination_node._buffer.push(self.name, message, obj)
destination_node._buffer_available.set()
self.__send_lock.release()
def __init__(
self,
decoder: PacketDecoder,
name: str,
logger_generator: LoggerGenerator = InvisibleLoggerGenerator(),
display: dict = {}
) -> None:
if not isinstance(decoder, PacketDecoder):
raise HTypeError("decoder", decoder, PacketDecoder)
if name is not None and not isinstance(name, str):
raise HTypeError("name", name, str, None)
self._buffer = []
self._packet_decoder = decoder
self.__print = logger_generator.generate(name, display)
self._current_packet = b""
self._current_packet_size = 0
self._expected_current_packet_size = 0
self._push_lock = threading.Lock()
def __init__(self, key: bytes):
if not isinstance(key, bytes):
raise HTypeError("key", key, bytes)
if len(key) * 8 not in algorithms.AES.key_sizes:
raise CipherParameterError("Key size of AES must be in {} (bits), "
"not {} (bytes).".format(
set(algorithms.AES.key_sizes),
len(key)
))
super().__init__(key, number_of_params=1)
self._aes: Cipher = None
self._encryptor: CipherContext = None
self._decryptor: CipherContext = None
self._in_process: CipherProcess = CipherProcess.NONE
self._nonce = None
