Requests

def format_incoming_overlay(payload: List[bytes]) -> InnerMessage:
    """Retrieves inner message from overlay message payload.

    Check signature, decrypt, deserialize the inner message

    Args:
        payload: Payload of overlay message.

    Returns:
        Inner message retrieved from overlay payload

    Raises:
        FedbiomedNodeToNodeError: key is too short
        FedbiomedNodeToNodeError: cannot decrypt payload
        FedbiomedNodeToNodeError: bad payload format
        FedbiomedNodeToNodeError: cannot verify payload integrity
    """
    # check payload types (not yet done by message type checks, only checks it's a list)
    if not all(isinstance(p, bytes) for p in payload):
        raise FedbiomedNodeToNodeError(f'{ErrorNumbers.FB324.value}: bad type for node to node payload')

    # decode and ensure only node2node (inner) messages are received

    local_node_private_key = _default_n2n_key
    distant_node_public_key = _default_n2n_key.public_key()

    if _CHUNK_SIZE * 8 > min(local_node_private_key.key_size, distant_node_public_key.key_size):
        raise FedbiomedNodeToNodeError(
            f'{ErrorNumbers.FB324.value}: cannot use key shorter than {_CHUNK_SIZE} bits')

    # decrypt outer payload
    # caveat: decryption can be long for long messages (~10s for 1MB cleartext message)
    try:
        decrypted_chunks = [
            local_node_private_key.decrypt(
                chunk,
                padding.OAEP(
                    mgf=padding.MGF1(algorithm=hashes.SHA256()),
                    algorithm=hashes.SHA256(),
                    label=None
                )
            )
            for chunk in payload
        ]
    except ValueError as e:
        raise FedbiomedNodeToNodeError(
            f'{ErrorNumbers.FB324.value}: cannot decrypt payload: {e}') from e

    decrypted = Serializer.loads(bytes().join(decrypted_chunks))

    if not isinstance(decrypted, dict) or not set(('message', 'signature')) <= set(decrypted):
        raise FedbiomedNodeToNodeError(f'{ErrorNumbers.FB324.value}: bad inner payload format '
                                       f"in received message")

    # verify inner payload
    try:
        distant_node_public_key.verify(
            decrypted['signature'],
            Serializer.dumps(decrypted['message']),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
    except InvalidSignature as e:
        raise FedbiomedNodeToNodeError(
            f'{ErrorNumbers.FB324.value}: cannot verify payload integrity: {e}') from e

    return NodeToNodeMessages.format_incoming_message(decrypted['message'])

def format_outgoing_overlay(message: Message) -> List[bytes]:
    """Creates an overlay message payload from an inner message.

    Serialize, crypt, sign the inner message

    Args:
        message: Inner message to send as overlay payload

    Returns:
        Payload for overlay message

    Raises:
        FedbiomedNodeToNodeError: key is too short
        FedbiomedNodeToNodeError: bad message type
    """
    # robustify from developer error (try to encapsulate a bad message type)
    if not isinstance(message, InnerMessage):
        raise FedbiomedNodeToNodeError(f'{ErrorNumbers.FB324.value}: not an inner message')

    # consider encrypt-sign([message,node_id]) or other see
    # https://theworld.com/~dtd/sign_encrypt/sign_encrypt7.html

    local_node_private_key = _default_n2n_key
    distant_node_public_key = _default_n2n_key.public_key()

    if _CHUNK_SIZE * 8 > min(local_node_private_key.key_size, distant_node_public_key.key_size):
        raise FedbiomedNodeToNodeError(
            f'{ErrorNumbers.FB324.value}: cannot use key shorter than {_CHUNK_SIZE} bits')

    # sign inner payload
    signed = Serializer.dumps({
        'message': message.get_dict(),
        'signature': local_node_private_key.sign(
            Serializer.dumps(message.get_dict()),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()

        )
    })

    # split to chunks and encrypt
    return [
        distant_node_public_key.encrypt(
            signed[i:i + _CHUNK_SIZE],
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        for i in range(0, len(signed), _CHUNK_SIZE)
    ]

def send_nodes(
        grpc_client: GrpcController,
        pending_requests: EventWaitExchange,
        researcher_id: str,
        nodes: List[str],
        messages: List[InnerMessage],
) -> Tuple[bool, List[Any]]:
    """Send message to some other nodes using overlay communications.

        Args:
            grpc_client: object managing the communication with other components
            pending_requests: object for receiving overlay node to node reply messages
            researcher_id: unique ID of researcher connecting the nodes
            nodes: list of node IDs of the destination nodes
            messages: list of the inner messages for the destination nodes
        Returns:
            status: True if all messages are received
            replies: List of replies from each node.
    """
    request_ids = []

    for node, message in zip(nodes, messages):
        message_overlay = NodeMessages.format_outgoing_message(
            {
                'researcher_id': researcher_id,
                'node_id': environ['NODE_ID'],
                'dest_node_id': node,
                'overlay': format_outgoing_overlay(message),
                'command': 'overlay'
            })

        grpc_client.send(message_overlay)

        if isinstance(message, InnerRequestReply):
            request_ids += [message.get_param('request_id')]

    return pending_requests.wait(request_ids, TIMEOUT_NODE_TO_NODE_REQUEST)