pydiode 0.0.1__tar.gz

pydiode-0.0.1/.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+.DS_Store
+/dist

pydiode-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Peter Story
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydiode-0.0.1/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: pydiode
+Version: 0.0.1
+Summary: Transfer data through a unidirectional network (i.e., a data diode)
+Project-URL: Homepage, https://github.com/ClarkuCSCI/pydiode
+Project-URL: Bug Tracker, https://github.com/ClarkuCSCI/pydiode/issues
+Author-email: Peter Story <peter.garth.story@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# pydiode
+
+Transfer data through a unidirectional network (i.e., a data diode).
+
+## Installation
+
+Install from PyPI:
+```
+pip install pydiode
+```
+
+To install from source, clone the repo then run:
+```
+pip install .
+```
+
+## Usage
+
+Documentation:
+```
+pydiode --help
+pydiode send --help
+pydiode receive --help
+```
+
+Start a receiver on localhost:
+```
+pydiode --debug receive 127.0.0.1
+```
+
+Send data to the receiver, from localhost to localhost:
+```
+pydiode --debug send 127.0.0.1 127.0.0.1
+```
+
+Type some information into the receiver. When finished, press enter, then type Control-D to signal the end-of-file. The receiver should print the received information.
+
+With debug-level logging, you will see details about each packet sent and received. Omit the `--debug` paramater when sending large amount of data, since debug-level logging incurs significant CPU usage.
+
+## Development
+
+Run unit tests:
+```
+python -m unittest tests.tests
+```
+
+Since [the unit tests run on the installed code](https://blog.ionelmc.ro/2014/05/25/python-packaging/), remember to install the latest version of the code before running the unit tests.

pydiode-0.0.1/README.md

@@ -0,0 +1,47 @@
+# pydiode
+
+Transfer data through a unidirectional network (i.e., a data diode).
+
+## Installation
+
+Install from PyPI:
+```
+pip install pydiode
+```
+
+To install from source, clone the repo then run:
+```
+pip install .
+```
+
+## Usage
+
+Documentation:
+```
+pydiode --help
+pydiode send --help
+pydiode receive --help
+```
+
+Start a receiver on localhost:
+```
+pydiode --debug receive 127.0.0.1
+```
+
+Send data to the receiver, from localhost to localhost:
+```
+pydiode --debug send 127.0.0.1 127.0.0.1
+```
+
+Type some information into the receiver. When finished, press enter, then type Control-D to signal the end-of-file. The receiver should print the received information.
+
+With debug-level logging, you will see details about each packet sent and received. Omit the `--debug` paramater when sending large amount of data, since debug-level logging incurs significant CPU usage.
+
+## Development
+
+Run unit tests:
+```
+python -m unittest tests.tests
+```
+
+Since [the unit tests run on the installed code](https://blog.ionelmc.ro/2014/05/25/python-packaging/), remember to install the latest version of the code before running the unit tests.

pydiode-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pydiode"
+version = "0.0.1"
+authors = [
+    { name="Peter Story", email="peter.garth.story@gmail.com" },
+]
+description = "Transfer data through a unidirectional network (i.e., a data diode)"
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/ClarkuCSCI/pydiode"
+"Bug Tracker" = "https://github.com/ClarkuCSCI/pydiode/issues"
+
+[project.scripts]
+pydiode = "pydiode.main:main"

pydiode-0.0.1/src/pydiode/common.py

@@ -0,0 +1,32 @@
+import logging
+import struct
+
+# How much data will fit in each packet we send?
+# Experimentally, this is the maximum UDP payload I can send on macOS.
+UDP_MAX_BYTES = 9216
+
+# Number of bits in a byte
+BYTE = 8
+
+# Color, represented as a character: Red, Blue, and blacK (1 byte).
+# Number of packets, represented as an unsigned short (2 bytes)
+# Sequence number, represented as an unsigned short (2 bytes)
+# The payload, represented as an array of bytes
+PACKET_HEADER = struct.Struct("<cHH")
+
+# Maximum payload length
+MAX_PAYLOAD = UDP_MAX_BYTES - PACKET_HEADER.size
+
+# Whether to log details about each packet sent/received.
+# Only log packet details when debugging, due to CPU overhead.
+LOG_PACKETS = False
+
+
+def log_packet(prefix, data):
+    if LOG_PACKETS:
+        color, n_packets, seq = PACKET_HEADER.unpack(data[: PACKET_HEADER.size])
+        payload_length = len(data) - PACKET_HEADER.size
+        logging.debug(
+            f"{prefix} <Packet color={color} n_packets={n_packets} "
+            f"seq={seq} payload_length={payload_length}>"
+        )

pydiode-0.0.1/src/pydiode/generator.py

@@ -0,0 +1,49 @@
+import argparse
+import hashlib
+import random
+
+
+def generate_data(byte_count, seed, output):
+    """
+    :param byte_count: Number of bytes
+    :param seed: Seed used to generate the data
+    :param output: Output file name
+    :returns: A checksum of the data
+    """
+    # It's faster to generate data in chunks, instead of one byte at a time
+    WRITE_CHUNK = 1000
+    random.seed(seed)
+    with open(output, "wb") as f:
+        for i in range(int(byte_count / WRITE_CHUNK)):
+            f.write(random.randbytes(WRITE_CHUNK))
+        f.write(random.randbytes(byte_count % WRITE_CHUNK))
+    with open(output, "rb") as f:
+        return hashlib.file_digest(f, "sha256").hexdigest()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate a file containing random data."
+    )
+    parser.add_argument(
+        "output",
+        help="Output file name",
+    )
+    parser.add_argument(
+        "--byte-count",
+        help="Number of bytes to generate",
+        type=int,
+        default=125000,
+    )
+    parser.add_argument(
+        "--seed",
+        help="Random seed for generating data",
+        type=int,
+        default=random.randint(0, 1000000),
+    )
+    args = parser.parse_args()
+    print(generate_data(args.byte_count, args.seed, args.output))
+
+
+if __name__ == "__main__":
+    main()

pydiode-0.0.1/src/pydiode/main.py

@@ -0,0 +1,148 @@
+import argparse
+import asyncio
+import logging
+
+import pydiode.common
+from .common import BYTE, MAX_PAYLOAD, PACKET_HEADER, UDP_MAX_BYTES
+from .send import read_data, send_data
+from .receive import AsyncWriter, receive_data
+
+
+async def async_main():
+    parser = argparse.ArgumentParser(
+        description="Send and receive data through a data diode via UDP."
+    )
+    subparsers = parser.add_subparsers(
+        help="Whether to run in send or receive mode"
+    )
+    parser.add_argument(
+        "--debug",
+        help="Print DEBUG logging",
+        action="store_const",
+        dest="loglevel",
+        const=logging.DEBUG,
+        default=logging.WARNING,
+    )
+    parser.add_argument(
+        "--verbose",
+        help="Print INFO logging",
+        action="store_const",
+        dest="loglevel",
+        const=logging.INFO,
+    )
+
+    send_parser = subparsers.add_parser("send", help="Send data")
+    send_parser.add_argument(
+        "read_ip", help="The IP of the interface data is read from"
+    )
+    send_parser.add_argument(
+        "write_ip",
+        help="The IP of the interface data is written to",
+    )
+    send_parser.add_argument(
+        "--port",
+        type=int,
+        help="Send and receive data using this port",
+        default=1234,
+    )
+    send_parser.add_argument(
+        "--max-bitrate",
+        type=int,
+        help="Maximum number of bits transferred per second",
+        default=1000000000,
+    )
+    send_parser.add_argument(
+        "--chunk-duration",
+        type=float,
+        help="Send each chunk for this many seconds",
+    )
+    send_parser.add_argument(
+        "--chunk-max-packets",
+        type=int,
+        help="The maximum number of packets a chunk should contain",
+    )
+    send_parser.add_argument(
+        "--redundancy",
+        type=int,
+        help="How many times to send each chunk",
+        default=2,
+    )
+
+    receive_parser = subparsers.add_parser("receive", help="Receive data")
+    receive_parser.add_argument(
+        "read_ip", help="The IP of the interface data is read from"
+    )
+    receive_parser.add_argument(
+        "--port",
+        type=int,
+        help="Send and receive data using this port",
+        default=1234,
+    )
+
+    args = parser.parse_args()
+    logging.basicConfig(level=args.loglevel)
+    # Only log packet details when debugging, due to CPU overhead
+    if args.loglevel == logging.DEBUG:
+        pydiode.common.LOG_PACKETS = True
+
+    # If we are sending data
+    if "write_ip" in args:
+        if args.chunk_duration and args.chunk_max_packets:
+            raise ValueError(
+                "Supply either --chunk-duration or --chunk-max-packets"
+            )
+        elif not args.chunk_duration and not args.chunk_max_packets:
+            args.chunk_max_packets = 100
+
+        # Calculate chunk_duration based on chunk_max_packets, or vice versa
+        if args.chunk_max_packets:
+            # How many seconds do we need to send this many fully loaded
+            # packets without exceeding max_bitrate?
+            args.chunk_duration = (
+                args.chunk_max_packets * UDP_MAX_BYTES * BYTE / args.max_bitrate
+            )
+        else:
+            # How many fully loaded packets can be sent per second without
+            # exceeding max_bitrate?
+            # TODO Consider whether to account for UDP and IPv4 headers.
+            args.chunk_max_packets = (
+                args.chunk_duration * args.max_bitrate / BYTE / UDP_MAX_BYTES
+            )
+        logging.debug(f"chunk_max_packets={args.chunk_max_packets}")
+        logging.debug(f"chunk_duration={args.chunk_duration}")
+
+        # How much data will fit in these packets?
+        chunk_max_data_bytes = int(args.chunk_max_packets * MAX_PAYLOAD)
+        logging.debug(f"PACKET_HEADER.size={PACKET_HEADER.size}")
+        logging.debug(f"MAX_PAYLOAD={MAX_PAYLOAD}")
+        logging.debug(f"chunk_max_data_bytes={chunk_max_data_bytes}")
+
+        # Queue of chunks to be sent
+        chunks = []
+        # Read and send data concurrently
+        await asyncio.gather(
+            read_data(chunks, chunk_max_data_bytes, args.chunk_duration),
+            send_data(
+                chunks,
+                args.chunk_duration,
+                args.redundancy,
+                args.read_ip,
+                args.write_ip,
+                args.port,
+            ),
+        )
+    # If we are receiving data
+    else:
+        queue = asyncio.Queue()
+        writer = AsyncWriter(queue)
+        await asyncio.gather(
+            receive_data(queue, args.read_ip, args.port), writer.write()
+        )
+
+
+def main():
+    asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    main()

pydiode-0.0.1/src/pydiode/receive.py

@@ -0,0 +1,79 @@
+import asyncio
+import logging
+import sys
+
+from .common import log_packet, PACKET_HEADER
+
+
+class AsyncWriter:
+    def __init__(self, queue):
+        self.queue = queue
+        # TODO If connected to a terminal, display output immediately
+
+    async def write(self):
+        """
+        Write data asynchronously to STDOUT.
+        """
+        while True:
+            data = await self.queue.get()
+            self.queue.task_done()
+            if data is None:
+                break
+            else:
+                await asyncio.get_event_loop().run_in_executor(
+                    None, sys.stdout.buffer.write, data
+                )
+
+
+class DiodeReceiveProtocol(asyncio.DatagramProtocol):
+    def __init__(self, queue, on_con_lost):
+        self.queue = queue
+        self.on_con_lost = on_con_lost
+        # Completed chunks
+        self.completed = {b"R": False, b"B": False}
+        # Packets for the chunks
+        self.packets = {b"R": {}, b"B": {}}
+
+    def datagram_received(self, data, addr):
+        color, n_packets, seq = PACKET_HEADER.unpack(data[: PACKET_HEADER.size])
+        log_packet("Received", data)
+        # If EOF (blacK) packet
+        if color == b"K":
+            self.queue.put_nowait(None)
+            self.on_con_lost.set_result(True)
+        # Is this packet for an incomplete chunk?
+        elif not self.completed[color]:
+            # Record the payload
+            self.packets[color][seq] = data[PACKET_HEADER.size :]
+            # Did we complete the chunk?
+            if len(self.packets[color]) == n_packets:
+                logging.debug(f"Packet completed the {color} chunk")
+                # Write each packet to STDOUT
+                for seq in range(n_packets):
+                    self.queue.put_nowait(self.packets[color][seq])
+                # Mark this chunk as completed
+                self.completed[color] = True
+                self.packets[color] = {}
+                # Mark the other chunk as incomplete
+                other_color = b"B" if color == b"R" else b"R"
+                self.completed[other_color] = False
+
+
+async def receive_data(queue, read_ip, port):
+    """
+    Receive chunks over the network.
+
+    :queue: Store received data onto this queue
+    :param read_ip: Listen for data on this IP address
+    :param port: Listen for data on this port
+    """
+    loop = asyncio.get_running_loop()
+    on_con_lost = loop.create_future()
+    transport, protocol = await loop.create_datagram_endpoint(
+        lambda: DiodeReceiveProtocol(queue, on_con_lost),
+        local_addr=(read_ip, port),
+    )
+    try:
+        await on_con_lost
+    finally:
+        transport.close()

pydiode-0.0.1/src/pydiode/send.py

@@ -0,0 +1,245 @@
+import asyncio
+import logging
+import math
+import os
+import stat
+import sys
+import time
+
+from .common import log_packet, MAX_PAYLOAD, PACKET_HEADER
+
+# Number of EOF packets to send per chunk duration
+N_EOF = 4
+
+# Sleep after sending this many packets
+PACKET_BURST = 10
+
+
+class Chunk:
+    def __init__(self, data):
+        self.data = data
+        self.n_packets = math.ceil(len(data) / MAX_PAYLOAD)
+
+    def __iter__(self):
+        for i in range(self.n_packets):
+            yield self.data[i * MAX_PAYLOAD : ((i + 1) * MAX_PAYLOAD)]
+
+
+class AsyncReader:
+    def __init__(self, chunk_max_data_bytes):
+        self.chunk_max_data_bytes = chunk_max_data_bytes
+        self.regular_file = stat.S_ISREG(os.fstat(sys.stdin.fileno()).st_mode)
+        self.stream_reader = None
+
+    async def read(self):
+        """
+        Read data asynchronously from STDIN.
+
+        :returns: Bytes read from STDIN
+        """
+        if self.regular_file:
+            # If connected to a regular file, there's no need for a
+            # StreamReader: we can quickly read the maximum amount of data for
+            # a chunk.
+            return await asyncio.get_event_loop().run_in_executor(
+                None, sys.stdin.buffer.read, self.chunk_max_data_bytes
+            )
+        else:
+            # If STDIN is a pipe or character device, data may become available
+            # incrementally. StreamReader lets us read the input incrementally,
+            # instead of waiting for a fixed number of bytes to become
+            # available.
+            # StreamReader doesn't work (and isn't necessary) with file
+            # redirection.
+            # https://stackoverflow.com/a/71627449
+            if not self.stream_reader:
+                loop = asyncio.get_event_loop()
+                self.stream_reader = asyncio.StreamReader()
+                protocol = asyncio.StreamReaderProtocol(self.stream_reader)
+                await loop.connect_read_pipe(lambda: protocol, sys.stdin.buffer)
+            # Read up to the maximum amount of data in a chunk
+            return await self.stream_reader.read(self.chunk_max_data_bytes)
+
+
+def append_to_chunks(chunks, data, chunk_max_data_bytes):
+    """
+    Append data to the end of the chunks array, filling chunks that have
+    space.
+
+    :param chunks: An array of bytes and bytearrays
+    :param data: bytes, to be store in chunks
+    :param chunk_max_data_bytes: The maximum number of bytes stored in a chunk.
+                                 We assume the data parameter never exceeds
+                                 this value.
+    """
+    # If there are no chunks, or if the last chunk is full
+    if (len(chunks) == 0) or (len(chunks[-1]) == chunk_max_data_bytes):
+        if len(data) == chunk_max_data_bytes:
+            # There's no room for additional data, so immutable suffices
+            chunks.append(data)
+        else:
+            # Append a mutable bytearray, so we can add data later
+            chunks.append(bytearray(data))
+    # If the last chunk has room for data
+    else:
+        # How much data can fit in the last chunk?
+        remaining_space = chunk_max_data_bytes - len(chunks[-1])
+        chunks[-1].extend(data[:remaining_space])
+        # If some of the data didn't fit in the last chunk
+        if remaining_space < len(data):
+            chunks.append(data[remaining_space:])
+
+
+async def read_data(chunks, chunk_max_data_bytes, chunk_duration):
+    """
+    Read data from STDIN, and store it into the chunks queue.
+
+    :param chunks: An array of bytes and bytearrays
+    :param chunk_max_data_bytes: The maximum number of bytes stored in a chunk
+    :param chunk_duration: Amount of time taken to send each chunk
+    """
+    reader = AsyncReader(chunk_max_data_bytes)
+    data = await reader.read()
+    # Until EOF is encountered
+    while data:
+        logging.debug(f"Read {len(data)} bytes of data")
+        append_to_chunks(chunks, data, chunk_max_data_bytes)
+        while len(chunks) > 3:
+            # At least the first and second chunks will be full.
+            # Wait for chunks to be sent.
+            await asyncio.sleep(chunk_duration)
+        data = await reader.read()
+    # Signal there won't be more data
+    chunks.append(None)
+
+
+class AsyncSleeper:
+    def __init__(self, n_sleeps, duration):
+        # The number of sleeps we've performed so far
+        self.n = 0
+        # We will eventually sleep this many times
+        self.n_sleeps = n_sleeps
+        # Eventually, this much time should pass
+        self.duration = duration
+        self.start = time.time()
+
+    async def sleep(self):
+        self.n += 1
+        if self.n > self.n_sleeps:
+            raise IndexError(f"Already slept {self.n_sleeps} times")
+        # How much time should elapse from start by the end of this sleep?
+        target_elapsed = (self.n / self.n_sleeps) * self.duration
+        already_elapsed = time.time() - self.start
+        sleep_duration = target_elapsed - already_elapsed
+        logging.debug(f"Sleeping {sleep_duration:.5f} seconds")
+        await asyncio.sleep(sleep_duration)
+
+    async def sleep_remainder(self):
+        # If we haven't yet slept for the specified number of times, we will
+        # perform one big sleep to fill the remaining time
+        if self.n < self.n_sleeps:
+            # How much time should elapse from start by the end of this sleep?
+            already_elapsed = time.time() - self.start
+            sleep_duration = self.duration - already_elapsed
+            logging.debug(f"Sleeping remaining {sleep_duration:.5f} seconds")
+            await asyncio.sleep(sleep_duration)
+            # Record that we have met our "sleep quota"
+            self.n = self.n_sleeps
+
+
+async def _send_eof(chunk_duration, transport):
+    sleeper = AsyncSleeper(N_EOF, chunk_duration)
+    for seq in range(N_EOF):
+        data = PACKET_HEADER.pack(b"K", N_EOF, seq)
+        transport.sendto(data)
+        log_packet("Sent", data)
+        await sleeper.sleep()
+
+
+async def _send_chunk(chunk, color, redundancy, chunk_duration, transport):
+    start = time.time()
+    # Wrap the chunk bytes in a helper class
+    c = Chunk(chunk)
+    # Sleep after sending this many packets to avoid sending large bursts
+    packet_burst = min(c.n_packets, PACKET_BURST)
+    # Send the data over the network
+    logging.debug(f"{c.n_packets} packets needed to send {color} chunk")
+    for r in range(redundancy):
+        sleeper = AsyncSleeper(
+            math.ceil(c.n_packets / packet_burst), chunk_duration
+        )
+        logging.debug(f"Send iteration {r + 1}/{redundancy}")
+        for seq, payload in enumerate(c):
+            header = PACKET_HEADER.pack(color, c.n_packets, seq)
+            data = header + payload
+            transport.sendto(data)
+            log_packet("Sent", data)
+            # Sleep after "packet_burst" packets have been sent
+            if ((seq + 1) % packet_burst) == 0:
+                await sleeper.sleep()
+        # Sleep for any remaining time (i.e., if the number of packets isn't a
+        # multiple of packet_burst)
+        await sleeper.sleep_remainder()
+    logging.debug(
+        f"Sent {color} chunk of length {len(chunk)} "
+        f"in {time.time() - start:.5f} seconds"
+    )
+
+
+class DiodeSendProtocol(asyncio.DatagramProtocol):
+    def __init__(self, on_con_lost):
+        self.on_con_lost = on_con_lost
+
+    def connection_lost(self, exc):
+        self.on_con_lost.set_result(True)
+
+
+async def send_data(
+    chunks, chunk_duration, redundancy, read_ip, write_ip, port
+):
+    """
+    Send chunks over the network.
+
+    :param chunks: An array of bytes and bytearrays
+    :param chunk_duration: Amount of time taken to send each chunk
+    :param redundancy: How many times to transfer the data
+    :param read_ip: Send data to this IP address
+    :param write_ip: Send data from this IP address
+    :param port: Send data using this port
+    """
+    # The current chunk color
+    color = b"R"
+
+    # Open a UDP "connection"
+    loop = asyncio.get_event_loop()
+    on_con_lost = loop.create_future()
+    transport, _ = await loop.create_datagram_endpoint(
+        lambda: DiodeSendProtocol(on_con_lost),
+        remote_addr=(read_ip, port),
+        # Don't specify the send port: the OS will choose an available port
+        local_addr=(write_ip, None),
+    )
+
+    # Send data until a None chunk is encountered, indicating EOF
+    while True:
+        if len(chunks) > 0:
+            chunk = chunks.pop(0)
+            # There will never be more data
+            if chunk is None:
+                await _send_eof(chunk_duration, transport)
+                break
+            # We have a chunk of data to send
+            else:
+                await _send_chunk(
+                    chunk, color, redundancy, chunk_duration, transport
+                )
+                # Switch the color
+                color = b"B" if color == b"R" else b"R"
+        # Wait for more data
+        else:
+            await asyncio.sleep(chunk_duration)
+
+    # Close the UDP "connection"
+    transport.close()
+    # Wait for the buffer to flush before returning
+    await on_con_lost

pydiode-0.0.1/tests/tests.py

@@ -0,0 +1,82 @@
+import hashlib
+import os
+import subprocess
+import tempfile
+import unittest
+
+from pydiode.generator import generate_data
+from pydiode.send import append_to_chunks
+
+# Number of bytes in a 1 Mbit
+MBIT_BYTES = 125000
+
+
+class TestPyDiode(unittest.TestCase):
+    def test_diode_file_io(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            RANDOM_DATA = os.path.join(tempdir, "random_data")
+            # Generate 1Mbit of random data
+            expected_checksum = generate_data(MBIT_BYTES, 42, RANDOM_DATA)
+            # Send the data through localhost
+            receive = subprocess.Popen(
+                f"pydiode receive 127.0.0.1",
+                stdout=subprocess.PIPE,
+                shell=True,
+            )
+            checksum = subprocess.Popen(
+                "shasum -a 256",
+                stdin=receive.stdout,
+                stdout=subprocess.PIPE,
+                shell=True,
+            )
+            send = subprocess.Popen(
+                f"pydiode send 127.0.0.1 127.0.0.1 < {RANDOM_DATA}",
+                shell=True,
+            )
+            send.communicate()
+            receive.communicate()
+            checksum_stdout, _ = checksum.communicate()
+            actual_checksum = checksum_stdout.decode("utf-8").split(" ")[0]
+            # Check whether the received data matches the sent data
+            self.assertEqual(expected_checksum, actual_checksum)
+
+    def test_diode_pipe_io(self):
+        expected_hasher = hashlib.sha256()
+        expected_hasher.update(b"Hello\n")
+        # Send "Hello" through localhost
+        receive = subprocess.Popen(
+            f"pydiode receive 127.0.0.1",
+            stdout=subprocess.PIPE,
+            shell=True,
+        )
+        send = subprocess.Popen(
+            "echo Hello | pydiode send 127.0.0.1 127.0.0.1",
+            shell=True,
+        )
+        send.communicate()
+        receive_stdout, _ = receive.communicate()
+        actual_hasher = hashlib.sha256()
+        actual_hasher.update(receive_stdout)
+        # Check whether the received data matches the sent data
+        self.assertEqual(expected_hasher.hexdigest(), actual_hasher.hexdigest())
+
+
+class TestChunks(unittest.TestCase):
+    def test_empty_chunks(self):
+        chunks = []
+        append_to_chunks(chunks, b"Hello", 10)
+        self.assertEqual([b"Hello"], chunks)
+
+    def test_full_chunks(self):
+        chunks = []
+        append_to_chunks(chunks, b"I am full!", 10)
+        self.assertEqual([b"I am full!"], chunks)
+        append_to_chunks(chunks, b"Hello", 10)
+        self.assertEqual([b"I am full!", b"Hello"], chunks)
+
+    def test_partial_chunks(self):
+        chunks = []
+        append_to_chunks(chunks, b"Not full", 10)
+        self.assertEqual([b"Not full"], chunks)
+        append_to_chunks(chunks, b"Hello", 10)
+        self.assertEqual([b"Not fullHe", b"llo"], chunks)