AESNetworkHandler Class Reference

Public Member Functions
	__init__ (self, CryptoHandler crypto, int buffer_size=1024)
bool	send (self, socket.socket sock, str|bytes data)
str|bool	receive (self, socket.socket sock)

Protected Member Functions
bytes|None	_recv_all (self, sock, int n)

Protected Attributes
	_crypto
	_buffer_size
	_header_size
	_chunk_overhead
	_max_chunk_body_size

Detailed Description

@brief Initializes the AESNetworkHandler.
@param crypto An instance of CryptoHandler used for encryption and decryption.
@param buffer_size The size of the buffer for each chunk (default: 1024 bytes).

Definition at line 17 of file AESNetworkHandler.py.

Constructor & Destructor Documentation

__init__()

__init__	(		self,
		CryptoHandler	crypto,
		int	buffer_size = 1024
	)

Definition at line 23 of file AESNetworkHandler.py.

    def __init__(self, crypto: CryptoHandler, buffer_size: int=1024):
        self._crypto = crypto
        self._buffer_size = buffer_size
        self._header_size = 10
        self._chunk_overhead = self._header_size + 1
        self._max_chunk_body_size = buffer_size - self._chunk_overhead
 

Member Function Documentation

_recv_all()

bytes | None _recv_all (   self,   sock, int  n  )

protected

Definition at line 70 of file AESNetworkHandler.py.

    def _recv_all(self, sock, n: int) -> bytes | None:
        buf = b''
        while len(buf) < n:
            chunk = sock.recv(n - len(buf))
            if not chunk:
                return None
            buf += chunk
        return buf
    

receive()

str | bool receive	(		self,
		socket.socket	sock
	)

Definition at line 86 of file AESNetworkHandler.py.

    def receive(self, sock: socket.socket) -> str | bool:
        buffer = bytearray()
        received_chunks = None
        total_chunks = None
 
        try:
            while True:
                sock.settimeout(10)
                head = self._recv_all(sock, self._header_size)
                if head is None:
                    print("[RECEIVE ERROR] Timeout or socket closed before header")
                    return False
 
                total_chunks_read = (
                    (head[0] << 24) |
                    (head[1] << 16) |
                    (head[2] << 8)  |
                    (head[3] << 0)
                )
                chunk_index = (
                    (head[4] << 24) |
                    (head[5] << 16) |
                    (head[6] << 8)  |
                    (head[7] << 0)
                )
                chunk_len = (head[8] << 8) | head[9]
 
                needed = self._header_size + chunk_len + 1
                if needed > self._buffer_size:
                    print(f"[RECEIVE ERROR] chunk_len {chunk_len} inconsistent (need {needed} > {self._buffer_size})")
                    return False
 
                # Read payload plus EOT
                payload_plus_eot = self._recv_all(sock, chunk_len + 1)
                if payload_plus_eot is None:
                    print(f"[RECEIVE ERROR] Timeout or socket closed while reading payload for chunk {chunk_index}")
                    return False
 
                # Check EOT marker
                if payload_plus_eot[-1] != 0x04:
                    print(f"[RECEIVE ERROR] Missing or misplaced EOT for chunk {chunk_index}")
                    return False
 
                remainder_padding = self._buffer_size - needed
                if remainder_padding > 0:
                    pad = self._recv_all(sock, remainder_padding)
                    if pad is None:
                        print(f"[RECEIVE ERROR] Timeout or socket closed while reading padding for chunk {chunk_index}")
                        return False
 
                # Initialize tracking on the first chunk
                if total_chunks is None:
                    total_chunks = total_chunks_read
                    if total_chunks <= 0:
                        print(f"[RECEIVE ERROR] invalid total_chunks = {total_chunks}")
                        return False
                    received_chunks = [False] * total_chunks
 
                # Validate chunk_index
                if not (0 <= chunk_index < total_chunks):
                    print(f"[RECEIVE ERROR] chunk_index {chunk_index} out of bounds (total {total_chunks})")
                    return False
                
                if received_chunks[chunk_index]:
                    print(f"[RECEIVE ERROR] duplicate chunk {chunk_index}")
                    return False
 
                # Extract and append the ciphertext
                ciphertext = payload_plus_eot[:chunk_len]
                buffer.extend(ciphertext)
                received_chunks[chunk_index] = True
 
                # If all chunks are received, break
                if all(received_chunks):
                    break
 
            return self._crypto.decrypt(bytes(buffer))
 
        except Exception as e:
            print(f"[RECEIVE EXCEPTION] {e}")
            return False

send()

bool send	(		self,
		socket.socket	sock,
		str | bytes	data
	)

Definition at line 38 of file AESNetworkHandler.py.

    def send(self, sock: socket.socket, data: str | bytes) -> bool:
        try:
            encrypted = self._crypto.encrypt(data)
            total_len = len(encrypted)
            nb_chunks = (total_len + self._max_chunk_body_size - 1) // self._max_chunk_body_size
 
            for i in range(nb_chunks):
                chunk_data = encrypted[i * self._max_chunk_body_size : (i + 1) * self._max_chunk_body_size]
                
                chunk = bytearray(self._buffer_size)
                chunk[0] = (nb_chunks >> 24) & 0xFF
                chunk[1] = (nb_chunks >> 16) & 0xFF
                chunk[2] = (nb_chunks >> 8) & 0xFF
                chunk[3] = (nb_chunks >> 0) & 0xFF
 
                chunk[4] = (i >> 24) & 0xFF
                chunk[5] = (i >> 16) & 0xFF
                chunk[6] = (i >> 8) & 0xFF
                chunk[7] = (i >> 0) & 0xFF
 
                chunk[8] = (len(chunk_data) >> 8) & 0xFF
                chunk[9] = len(chunk_data) & 0xFF
 
                chunk[10:10 + len(chunk_data)] = chunk_data
                chunk[10 + len(chunk_data)] = 0x04
 
                sock.sendall(chunk)
            return True
        except Exception as e:
            print(f"[SEND ERROR] {e}")
            return False
    

Member Data Documentation

_buffer_size

_buffer_size

protected

Definition at line 25 of file AESNetworkHandler.py.

_chunk_overhead

_chunk_overhead

protected

Definition at line 27 of file AESNetworkHandler.py.

_crypto

_crypto

protected

Definition at line 24 of file AESNetworkHandler.py.

_header_size

_header_size

protected

Definition at line 26 of file AESNetworkHandler.py.

_max_chunk_body_size

_max_chunk_body_size

protected

Definition at line 28 of file AESNetworkHandler.py.

---

The documentation for this class was generated from the following file:

• AESNetworkHandler.py