def test_generate_key_create_different_key_when_called_multiple_times():
# Given
baseline = generate_key_32()
# When
result = generate_key_32()
if result == baseline:
result = generate_key_32()
# Then
assert baseline != result
def test_generate_key_32_can_create_key_from_input_key():
# Given
key1 = b"test"
key2 = b"another_test"
baseline = generate_key_32(key1)
# When
result1 = generate_key_32(key1)
result2 = generate_key_32(key2)
# Then
assert baseline == result1
assert baseline != result2
def test_change_key_correctly_change_the_key():
# Given
key_old = generate_key_32()
key_new = generate_key_32()
# When
udp_socket = UDPSocket(key=key_old, socket_port=50015).start()
udp_socket.change_key(key_new)
# Then
assert udp_socket.get_key() == key_new
udp_socket.stop()
time.sleep(.5)
def test_udp_socket_send_encrypted_messages_when_encryption_in_transit_set_to_true(
):
# Given
key = generate_key_32()
msg = b"tests"
socket_ip = "127.0.0.1"
socket_port = 50017
test_socket_port = 50018
n_msg = 2
test_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
test_socket.bind((socket_ip, test_socket_port))
test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
udp_socket = UDPSocket(key=key,
socket_ip=socket_ip,
socket_port=socket_port,
max_queue_size=n_msg,
encryption_in_transit=True).start()
# When
udp_socket.sendto(msg, (socket_ip, test_socket_port))
rcv_msg = test_socket.recv(100)
time.sleep(.1)
udp_socket.stop()
test_socket.close()
time.sleep(.5)
# Then
assert rcv_msg != msg
assert msg == udp_socket._decrypt(rcv_msg)
def test_change_key_correctly_change_the_fernet_encoder():
# Given
key_old = generate_key_32()
key_new = generate_key_32()
msg = b"tests"
# When
udp_socket = UDPSocket(key=key_old, socket_port=50016).start()
msg_crypt = udp_socket._encrypt(msg)
msg_decrypt_old = udp_socket._decrypt(msg_crypt)
udp_socket.change_key(key_new)
# Then
assert msg_decrypt_old == msg
udp_socket.stop()
time.sleep(.5)
def test_generate_key_32_create_a_key_of_32_bytes():
# Given
expected_length = 32
# When
result = generate_key_32()
# Then
assert len(result) == expected_length
assert type(result) == bytes
def test_new_udp_socket_correctly_set_encryption_key():
# Given
key = generate_key_32()
# When
udp_socket = UDPSocket(key=key, socket_port=50012).start()
# Then
assert udp_socket.get_key() == key
udp_socket.stop()
time.sleep(.5)
def test_new_socket_creates_a_fernet_encoder():
# Given
key = generate_key_32()
# When
udp_socket = UDPSocket(key=key, socket_port=50014).start()
# Then
assert udp_socket.encoder is not None
assert type(udp_socket.encoder) is ChaCha20Poly1305
udp_socket.stop()
time.sleep(.5)
def __init__(self, socket_ip: Optional[str] = "127.0.0.1", socket_port: Optional[int] = 50000,
encryption_in_transit: Optional[bool] = False, max_queue_size: Optional[int] = 100,
buffer_size: Optional[int] = 65543, key: Optional[Union[None, bytes]] = None,
enable_multicast: Optional[bool] = False, multicast_ttl: Optional[int] = 2,
must_listen: Optional[bool] = True, setblocking: Optional[bool] = True,
run_new_process: Optional[bool] = False) -> None:
"""Create a new UDPSocket object with given parameters.
:param socket_ip: The ip used to bind the socket.
:param socket_port: The port used to bind the socket.
:param encryption_in_transit: Define if the messages must be encrypted.
:param max_queue_size: The max size of message queue.
:param buffer_size: The max size of the received message buffer.
:param key: The encryption _key used to encrypt message. If no value is provided it will generate a new one.
:param enable_multicast: Specify if the socket can use multicast.
:param multicast_ttl: The TTL used for multicast.
:param must_listen: Define if the socket must listen for messages.
:param setblocking: Define if the socket must block.
:param run_new_process: Specify if the UDPSocket instance must be run in a new process.
"""
self.socket_ip = socket_ip
self.socket_port = socket_port
self.encryption_in_transit: bool = encryption_in_transit
self.max_queue_size: int = max_queue_size
self.buffer_size: int = buffer_size
self.queue: List[Tuple[bytes, Any]] = []
self.socket: Union[socket.socket, None] = None
self.is_running: bool = False
self._key: bytes = key if key is not None else generate_key_32()
self.encoder: Union[ChaCha20Poly1305, None] = None
self.enable_multicast: bool = enable_multicast
self.multicast_ttl: int = multicast_ttl
self.must_listen = must_listen
self.setblocking = setblocking
self.run_new_process = run_new_process
self.internal_pipe, self.external_pipe = mp.Pipe()
This script get the flux from the camera of the computer and send it to itself using
VideoStream object as emitter and consumer.
Press ESC to quit the example while running.
"""
from hermes.stream.VideoStream import VideoStream
import cv2
import datetime
from hermes.security.utils import generate_key_32
if __name__ == "__main__":
encoding_param = {"params": [int(cv2.IMWRITE_JPEG_QUALITY), 50]}
emitter_address_port = ('127.0.0.1', 50000)
consumer_address_port = ('127.0.0.1', 50001)
key = generate_key_32()
emitter = VideoStream(role=VideoStream.EMITTER,
socket_ip=emitter_address_port[0],
socket_port=emitter_address_port[1],
async_msg_generation=True,
encoding=1,
encoding_param=encoding_param,
encryption_in_transit=True,
key=key).start()
consumer = VideoStream(role=VideoStream.CONSUMER,
socket_ip=consumer_address_port[0],
socket_port=consumer_address_port[1],
use_rcv_img_buffer=False,
max_queue_size=10000,
encryption_in_transit=True,
key=key).start()
