def __validate(number: int, position: int, length: int, value: int = 0):
if not isinstance(number, int):
raise HTypeError("number", number, int)
if not isinstance(position, int):
raise HTypeError("position", position, int)
if not isinstance(value, int):
raise HTypeError("value", value, int)
if length is not None and not isinstance(length, int):
raise HTypeError("length", length, int, None)
if position < 0:
raise HFormatError("Parameter position and "
"length expected a non-negative integer.")
if length is None:
length = value.bit_length()
if length <= 0:
raise HFormatError("Parameter length expected a positive integer.")
if position - length + 1 < 0:
raise BitwiseError("You cannot access {} "
"bits starting from {}-th position.".format(
length, position))
def update_header(self, key: str, value: str):
if not isinstance(key, str):
raise HTypeError("key", key, str)
if not isinstance(value, str):
raise HTypeError("value", value, str)
self.__header.update({key: value})
def __setitem__(self, index: HKSEnum, value: str):
if self.__type is None:
raise HTTPTypeError("HTTPType must be set before configuring.")
if not isinstance(value, str):
raise HTypeError("value", value, str)
if not isinstance(index, self.__type):
raise HTypeError("index", index, self.__type)
self.__start_line[index] = value
def set_output(self, user: Users, output: Output):
if not isinstance(user, Users):
raise HTypeError("user", user, Users)
if not isinstance(output, Output):
raise HTypeError("output", output, Output)
if user not in self.__user_level.keys():
raise LogConfigError("User {} does "
"not exist.".format(user))
self.__user_output[user] = output
def derive_key(shared_key: bytes, key_size: int) -> bytes:
if not isinstance(shared_key, bytes):
raise HTypeError("shared_key", shared_key, bytes)
if not isinstance(key_size, int):
raise HTypeError("key_size", key_size, int)
return HKDF(
algorithm=hashes.SHA256(),
length=key_size,
salt=None,
info=b'handshake data',
).derive(shared_key)
def int2float(number: int, float_size: int = 4):
if not isinstance(number, int):
raise HTypeError("number", number, int)
if not isinstance(float_size, int):
raise HTypeError("float_size", float_size, int)
if float_size not in (4, 8):
raise HFormatError("Parameter float_size only "
"can be 4 (as float) or 8 (as double).")
fmt = "!d" if float_size == 8 else "!f"
packed_number = number.to_bytes(float_size, "big")
return struct.unpack(fmt, packed_number)[0]
def __init__(self, filename: str, mode: str = "at") -> None:
if not isinstance(filename, str):
raise HTypeError("filename", filename, str)
if not isinstance(mode, str):
raise HTypeError("mode", mode, str)
if mode not in ("at", "wt"):
raise HFormatError("Parameter mode must be 'at' or 'wt'.")
super().__init__()
self.__filename = filename
self.__mode = mode
self.__file = None
def __init__(self, p: int = None, g: int = None) -> None:
if p is not None and not isinstance(p, int):
raise HTypeError("p", p, int, None)
if g is not None and not isinstance(g, int):
raise HTypeError("g", g, int, None)
if not p:
p = DiffieHellmanExchange.DEFAULT_P
if not g:
g = DiffieHellmanExchange.DEFAULT_G
params_numbers = dh.DHParameterNumbers(p, g)
self._parameters = params_numbers.parameters(default_backend())
self.__private_key = self._parameters.generate_private_key()
def bxor(A: bytes, B: bytes):
if not isinstance(A, bytes):
raise HTypeError("A", A, bytes)
if not isinstance(B, bytes):
raise HTypeError("B", B, bytes)
if len(A) != len(B):
raise HFormatError("Parameter A and B expected to be the same size.")
iA = int.from_bytes(A, "big")
iB = int.from_bytes(B, "big")
iR = iA ^ iB
return iR.to_bytes(len(A), "big")
def _add_level_one_element(self, user: Users, level: Levels):
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.__user_level.keys():
raise LogConfigError("User {} does "
"not exist.".format(user))
if level in self.__user_level[user]:
raise LogConfigError("Level {} has "
"already existed.".format(level))
self.__user_level[user].add(level)
def float2int(number: float, float_size: int = 4):
if not isinstance(number, float):
raise HTypeError("number", number, float)
if not isinstance(float_size, int):
raise HTypeError("float_size", float_size, int)
if float_size not in (4, 8):
raise HFormatError("Parameter float_size only "
"can be 4 (as float) or 8 (as double).")
fmt = "!d" if float_size == 8 else "!f"
packed_number = struct.pack(fmt, number)
return int.from_bytes(packed_number, "big")
def parse(packet: bytes):
if not isinstance(packet, (bytes, bytearray)):
raise HTypeError("packet", packet, bytes, bytearray)
http_packet = HTTPPacket()
header, body = packet.split(b"\r\n\r\n")
header = header.split(b"\r\n")
tmp_start_line = header[0].split(b" ")
if b"HTTP/" in tmp_start_line[
0]: # If protocol version is in first element of start line
http_packet.type(HTTPType.RESPONSE)
http_packet[
HTTPRESPONSE.PROTOCOL_VERSION] = tmp_start_line[0].decode()
http_packet[HTTPRESPONSE.STATUS_CODE] = tmp_start_line[1].decode()
http_packet[HTTPRESPONSE.STATUS_TEXT] = tmp_start_line[2].decode()
else:
http_packet.type(HTTPType.REQUEST)
http_packet[HTTPREQUEST.HTTP_METHOD] = tmp_start_line[0].decode()
http_packet[
HTTPREQUEST.REQUEST_TARGET] = tmp_start_line[1].decode()
http_packet[
HTTPREQUEST.PROTOCOL_VERSION] = tmp_start_line[2].decode()
for field in header[1:]:
key, value = field.split(b": ")
http_packet.update_header(key.decode(), value.decode())
http_packet.body(body.decode())
return http_packet
def body(self, body: str = None):
if body is None:
return self.__body
if not isinstance(body, str):
raise HTypeError("body", body, str, None)
self.__body = body
def output(self, user: str):
if not isinstance(user, Users):
raise HTypeError("user", user, Users)
if user not in self.__user_level.keys():
raise LogConfigError("User {} does "
"not exist.".format(user))
return self.__user_output[user]
def copy(self, other, overwrite: bool = True):
if not isinstance(other, Done):
raise HTypeError("other", other, Done)
for key in other.__attributes.keys():
if (key in self.__attributes.keys()
and overwrite) or (key not in self.__attributes.keys()):
self.__attributes[key] = other.__attributes[key]
setattr(self, key, self.__attributes[key])
def add_user(self, user: Users):
if not isinstance(user, Users):
raise HTypeError("user", user, Users)
if user in self.__user_level.keys():
raise LogConfigError("User {} has ready existed in config.".format(user))
self.__user_level[user] = set()
self.__user_output[user] = None
def exchange(self, public_key: dh.DHPublicKey) -> bytes:
if not isinstance(public_key, dh.DHPublicKey):
raise HTypeError("public_key", public_key, dh.DHPublicKey)
if self.__private_key is None:
raise ResetError(
"The reset() must be called before calling exchange().")
common_key = self.__private_key.exchange(public_key)
self.__private_key = None
return common_key
def type(self, type: HTTPType = None):
if type == None:
return self.__type
if not isinstance(type, HTTPType):
raise HTypeError("type", type, HTTPType, None)
if type is HTTPType.RESPONSE:
self.__type = HTTPRESPONSE
else:
self.__type = HTTPREQUEST
self.__start_line = {}
def max_natural_number(bit_length: int):
"""
Return the max natural number has the size of bit_length.\n
Example: `max_natural_number(8) = 255`.
"""
if not isinstance(bit_length, int):
raise HTypeError("bit_length", bit_length, int)
if bit_length <= 0:
raise HFormatError(
"Parameter bit_length expected a positive integer.")
return ~(1 << bit_length) + (1 << (bit_length + 1))
def __init__(self, io: ReadableIO):
self._io = io
self._stream = None
if isinstance(io, str):
self._stream = open(io, "rb")
self._beigin_position = self._stream.tell()
if isinstance(io, (bytes, bytearray)):
self._stream = io.copy()
self._index = 0
if isinstance(io, bytes):
self._stream = bytearray(self._stream)
if isinstance(io, IO.BufferedIOBase):
self._stream = io
self._beigin_position = self._stream.tell()
if self._stream is None:
raise HTypeError("io", io, ReadableIO)
def error():
a = 7
raise HTypeError("A", a, float)
def update_body(self, body: str):
if not isinstance(body, str):
raise HTypeError("body", body, str)
self.__body += body
