WHAT

code/iottb/__main__.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+import argparse
+from os import environ
+from pathlib import Path
+
+from iottb.logger import logger
+from iottb.subcommands.add_device import setup_init_device_root_parser
+from iottb.subcommands.capture import setup_capture_parser
+from iottb.utils.tcpdump_utils import list_interfaces
+from definitions import IOTTB_HOME_ABS, ReturnCodes
+
+
+######################
+# Argparse setup
+######################
+def setup_argparse():
+    # create top level parser
+    root_parser = argparse.ArgumentParser(prog='iottb')
+    subparsers = root_parser.add_subparsers(title='subcommands', required=True, dest='command')
+
+    # shared options
+    root_parser.add_argument('--verbose', '-v', action='count', default=0)
+    # configure subcommands
+    setup_capture_parser(subparsers)
+    setup_init_device_root_parser(subparsers)
+
+    # Utility to list interfaces directly with iottb instead of relying on external tooling
+
+    interfaces_parser = subparsers.add_parser('list-interfaces', aliases=['li', 'if'],
+                                              help='List available network interfaces.')
+    interfaces_parser.set_defaults(func=list_interfaces)
+
+    return root_parser
+
+
+def check_iottb_env():
+    # This makes the option '--root-dir' obsolescent # TODO How to streamline this?\
+    try:
+        iottb_home = environ['IOTTB_HOME']  # TODO WARN implicit declaration of env var name!
+    except KeyError:
+        logger.error(f"Environment variable 'IOTTB_HOME' is not set."
+                     f"Setting environment variable 'IOTTB_HOME' to '~/{IOTTB_HOME_ABS}'")
+        environ['IOTTB_HOME'] = IOTTB_HOME_ABS
+    finally:
+        if not Path(IOTTB_HOME_ABS).exists():
+            print(f'"{IOTTB_HOME_ABS}" does not exist.')
+            response = input('Do you want to create it now? [y/N]')
+            logger.debug(f'response: {response}')
+            if response.lower() != 'y':
+                logger.debug(f'Not creating "{environ['IOTTB_HOME']}"')
+                print('TODO')
+                print("Aborting execution...")
+                return ReturnCodes.ABORTED
+            else:
+                print(f'Creating "{environ['IOTTB_HOME']}"')
+                Path(IOTTB_HOME_ABS).mkdir(parents=True,
+                                           exist_ok=False)  # Should always work since in 'not exist' code path
+                return ReturnCodes.OK
+        logger.info(f'"{IOTTB_HOME_ABS}" exists.')
+        # TODO: Check that it is a valid iottb dir or can we say it is valid by definition if?
+        return ReturnCodes.OK
+
+
+def main():
+    if check_iottb_env() != ReturnCodes.OK:
+        exit(ReturnCodes.ABORTED)
+    parser = setup_argparse()
+    args = parser.parse_args()
+    print(args)
+    if args.command:
+        try:
+            args.func(args)
+        except KeyboardInterrupt:
+            print('Received keyboard interrupt. Exiting...')
+            exit(1)
+        except Exception as e:
+            print(f'Error: {e}')
+    # create_capture_directory(args.device_name)
+
+
+if __name__ == '__main__':
+    main()

code/iottb/definitions.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+from enum import Flag, unique, global_enum
+from pathlib import Path
+
+
+''' 
+Defining IOTTB_HOME_ABS here implies that it be immutable.
+It is used here so that one could configure it. 
+But after its used in __man__ this cannot be relied upon.
+'''
+IOTTB_HOME_ABS = Path().home() / 'IOTTB.db'
+
+# TODO maybe wrap this into class to make it easier to pass along to different objects
+# But will need more refactoring
+DEVICE_METADATA_FILE = 'device_metadata.json'
+CAPTURE_METADATA_FILE = 'capture_metadata.json'
+TODAY_DATE_STRING = datetime.now().strftime('%d%b%Y').lower()  # TODO convert to function in utils or so
+
+CAPTURE_FOLDER_BASENAME = 'capture_###'
+
+AFFIRMATIVE_USER_RESPONSE = {'yes', 'y', 'true', 'Y', 'Yes', 'YES'}
+NEGATIVE_USER_RESPONSE = {'no', 'n', 'N', 'No'}
+YES_DEFAULT = AFFIRMATIVE_USER_RESPONSE.union({'', ' '})
+NO_DEFAULT = NEGATIVE_USER_RESPONSE.union({'', ' '})
+
+
+@unique
+@global_enum
+class ReturnCodes(Flag):
+    SUCCESS = 0
+    ABORTED = 1
+    FAILURE = 2
+    UNKNOWN = 3
+    FILE_NOT_FOUND = 4
+    FILE_ALREADY_EXISTS = 5
+    INVALID_ARGUMENT = 6
+    INVALID_ARGUMENT_VALUE = 7
+
+
+def iottb_home_abs():
+    return None

code/iottb/logger.py

@@ -0,0 +1,28 @@
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+
+
+def setup_logging():
+    logger_obj = logging.getLogger('iottbLogger')
+    logger_obj.setLevel(logging.DEBUG)
+
+    file_handler = RotatingFileHandler('iottb.log')
+    console_handler = logging.StreamHandler(sys.stdout)
+
+    file_handler.setLevel(logging.INFO)
+    console_handler.setLevel(logging.DEBUG)
+
+    file_fmt = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    console_fmt = logging.Formatter('%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(funcName)s - %(message)s')
+
+    file_handler.setFormatter(file_fmt)
+    console_handler.setFormatter(console_fmt)
+
+    logger_obj.addHandler(file_handler)
+    logger_obj.addHandler(console_handler)
+
+    return logger_obj
+
+
+logger = setup_logging()

code/iottb/models/capture_metadata_model.py

@@ -0,0 +1,102 @@
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from iottb.definitions import ReturnCodes, CAPTURE_METADATA_FILE
+from iottb.models.device_metadata_model import DeviceMetadata
+from iottb.logger import logger
+
+
+class CaptureMetadata:
+    # Required Fields
+    device_metadata: DeviceMetadata
+    capture_id: str = lambda: str(uuid.uuid4())
+    device_id: str
+    capture_dir: Path
+    capture_file: str
+    capture_date: str = lambda: datetime.now().strftime('%d-%m-%YT%H:%M:%S').lower()
+
+    # Statistics
+    start_time: str
+    stop_time: str
+
+    # tcpdump
+    packet_count: Optional[int]
+    pcap_filter: str = ''
+    tcpdump_command: str = ''
+    interface: str = ''
+
+    # Optional Fields
+    device_ip_address: str = 'No IP Address set'
+    device_mac_address: Optional[str] = None
+
+    app: Optional[str] = None
+    app_version: Optional[str] = None
+    firmware_version: Optional[str] = None
+
+    def __init__(self, device_metadata: DeviceMetadata, capture_dir: Path):
+        logger.info(f'Creating CaptureMetadata model from DeviceMetadata: {device_metadata}')
+        self.device_metadata = device_metadata
+
+        self.capture_dir = capture_dir
+        assert capture_dir.is_dir(), f'Capture directory {capture_dir} does not exist'
+
+    def build_capture_file_name(self):
+        logger.info(f'Building capture file name')
+        if self.app is None:
+            logger.debug(f'No app specified')
+            prefix = self.device_metadata.device_short_name
+        else:
+            logger.debug(f'App specified: {self.app}')
+            assert str(self.app).strip() not in {'', ' '}, f'app is not a valid name: {self.app}'
+            prefix = self.app.lower().replace(' ', '_')
+        # assert self.capture_dir is not None, f'{self.capture_dir} does not exist'
+        filename = f'{prefix}_{str(self.capture_id)}.pcap'
+        logger.debug(f'Capture file name: {filename}')
+        self.capture_file = filename
+
+    def save_capture_metadata_to_json(self, file_path: Path = Path(CAPTURE_METADATA_FILE)):
+        assert self.capture_dir.is_dir(), f'capture_dir is not a directory: {self.capture_dir}'
+        if file_path.is_file():
+            print(f'File {file_path} already exists, update instead.')
+            return ReturnCodes.FILE_ALREADY_EXISTS
+        metadata = self.to_json(indent=2)
+        with file_path.open('w') as file:
+            json.dump(metadata, file)
+            return ReturnCodes.SUCCESS
+
+    def to_json(self, indent=2):
+        # TODO: Where to validate data?
+        logger.info(f'Converting CaptureMetadata to JSON')
+        data = {}
+
+        # List of fields from CaptureData class, if fields[key]==True, then it is a required field
+        fields = {
+            'capture_id': True,  #
+            'device_id': True,
+            'capture_dir': True,
+            'capture_file': False,
+            'capture_date': False,
+            'start_time': True,
+            'stop_time': True,
+            'packet_count': False,
+            'pcap_filter': False,
+            'tcpdump_command': False,
+            'interface': False,
+            'device_ip_address': False,
+            'device_mac_address': False,
+            'app': False,
+            'app_version': False,
+            'firmware_version': False
+        }
+
+        for field, is_mandatory in fields.items():
+            value = getattr(self, field, None)
+            if value not in [None, ''] or is_mandatory:
+                if value in [None, ''] and is_mandatory:
+                    raise ValueError(f'Field {field} is required and cannot be empty.')
+                data[field] = str(value) if not isinstance(value, str) else value
+        logger.debug(f'Capture metadata: {data}')
+        return json.dumps(data, indent=indent)

code/iottb/models/device_metadata_model.py

@@ -0,0 +1,111 @@
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, List
+
+# iottb modules
+from iottb.definitions import ReturnCodes, DEVICE_METADATA_FILE
+from iottb.logger import logger
+# 3rd party libs
+
+IMMUTABLE_FIELDS = {'device_name', 'device_short_name', 'device_id', 'date_created'}
+
+
+class DeviceMetadata:
+    # Required fields
+    device_name: str
+    device_short_name: str
+    device_id: str
+    date_created: str
+
+    device_root_path: Path
+    # Optional Fields
+    aliases: Optional[List[str]] = None
+    device_type: Optional[str] = None
+    device_serial_number: Optional[str] = None
+    device_firmware_version: Optional[str] = None
+    date_updated: Optional[str] = None
+
+    capture_files: Optional[List[str]] = []
+
+    def __init__(self, device_name: str, device_root_path: Path):
+        self.device_name = device_name
+        self.device_short_name = device_name.lower().replace(' ', '_')
+        self.device_id = str(uuid.uuid4())
+        self.date_created = datetime.now().strftime('%d-%m-%YT%H:%M:%S').lower()
+        self.device_root_path = device_root_path
+        if not self.device_root_path or not self.device_root_path.is_dir():
+            logger.error(f'Invalid device root path: {device_root_path}')
+            raise ValueError(f'Invalid device root path: {device_root_path}')
+        logger.debug(f'Device name: {device_name}')
+        logger.debug(f'Device short_name: {self.device_short_name}')
+        logger.debug(f'Device root dir: {device_root_path}')
+        logger.info(f'Initialized DeviceMetadata model: {device_name}')
+
+    @classmethod
+    def load_from_json(cls, device_file_path: Path):
+        logger.info(f'Loading DeviceMetadata from JSON file: {device_file_path}')
+        assert device_file_path.is_file(), f'{device_file_path} is not a file'
+        assert device_file_path.name == DEVICE_METADATA_FILE, f'{device_file_path} is not a {DEVICE_METADATA_FILE}'
+        device_meta_filename = device_file_path
+
+        with device_meta_filename.open('r') as file:
+            metadata_json = json.load(file)
+        metadata_model_obj = cls.from_json(metadata_json)
+        return metadata_model_obj
+
+    def save_to_json(self, file_path: Path):
+        logger.info(f'Saving DeviceMetadata to JSON file: {file_path}')
+        if file_path.is_file():
+            print(f'File {file_path} already exists, update instead.')
+            return ReturnCodes.FILE_ALREADY_EXISTS
+        metadata = self.to_json(indent=2)
+        with file_path.open('w') as file:
+            json.dump(metadata, file)
+            return ReturnCodes.SUCCESS
+
+    @classmethod
+    def from_json(cls, metadata_json):
+        if isinstance(metadata_json, dict):
+            return DeviceMetadata(**metadata_json)
+
+    def to_json(self, indent=2):
+        # TODO: atm almost exact copy as in CaptureMetadata
+        data = {}
+
+        fields = {
+            'device_name': True,
+            'device_short_name': True,
+            'device_id': True,
+            'date_created': True,
+            'device_root_path': True,
+            'aliases': False,
+            'device_type': False,
+            'device_serial_number': False,
+            'device_firmware_version': False,
+            'date_updated': False,
+            'capture_files': False,
+        }
+
+        for field, is_mandatory in fields.items():
+            value = getattr(self, field, None)
+            if value not in [None, ''] or is_mandatory:
+                if value in [None, ''] and is_mandatory:
+                    logger.debug(f'Mandatory field {field}: {value}')
+                    raise ValueError(f'Field {field} is required and cannot be empty.')
+                data[field] = str(value) if not isinstance(value, str) else value
+        logger.debug(f'Device metadata: {data}')
+        return json.dumps(data, indent=indent)
+
+
+def dir_contains_device_metadata(dir_path: Path):
+    if not dir_path.is_dir():
+        return False
+    else:
+        meta_file_path = dir_path / DEVICE_METADATA_FILE
+        print(f'Device metadata file path {str(meta_file_path)}')
+        if not meta_file_path.is_file():
+            return False
+        else:
+            return True

code/iottb/subcommands/add_device.py

@@ -0,0 +1,76 @@
+import logging
+import pathlib
+
+from iottb import definitions
+from iottb.definitions import DEVICE_METADATA_FILE, ReturnCodes
+from iottb.logger import logger
+from iottb.models.device_metadata_model import DeviceMetadata
+
+logger.setLevel(logging.INFO)  # Since module currently passes all tests
+
+
+def setup_init_device_root_parser(subparsers):
+    parser = subparsers.add_parser('add-device', aliases=['add-device-root', 'add'],
+                                   help='Initialize a folder for a device.')
+    parser.add_argument('--root_dir', type=pathlib.Path, default=pathlib.Path.cwd())
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--guided', action='store_true', help='Guided setup', default=False)
+    group.add_argument('--name', action='store', type=str, help='name of device')
+    parser.set_defaults(func=handle_add)
+
+
+def handle_add(args):
+    logger.info(f'Add device handler called with args {args}')
+
+    args.root_dir.mkdir(parents=True,
+                        exist_ok=True)  # else metadata.save_to_file will fail TODO: unclear what to assume
+
+    if args.guided:
+        logger.debug('begin guided setup')
+        metadata = guided_setup(args.root_dir)
+        logger.debug('guided setup complete')
+    else:
+        logger.debug('Setup through passed args: setup')
+        if not args.name:
+            logger.error('No device name specified with unguided setup.')
+            return ReturnCodes.ERROR
+        metadata = DeviceMetadata(args.name, args.root_dir)
+
+    file_path = args.root_dir / DEVICE_METADATA_FILE
+    if file_path.exists():
+        print('Directory already contains a metadata file. Aborting.')
+        return ReturnCodes.ABORTED
+    serialized_metadata = metadata.to_json()
+    response = input(f'Confirm device metadata: {serialized_metadata} [y/N]')
+    logger.debug(f'response: {response}')
+    if response not in definitions.AFFIRMATIVE_USER_RESPONSE:
+        print('Adding device aborted by user.')
+        return ReturnCodes.ABORTED
+
+    logger.debug(f'Device metadata file {file_path}')
+    if metadata.save_to_json(file_path) == ReturnCodes.FILE_ALREADY_EXISTS:
+        logger.error('File exists after checking, which should not happen.')
+        return ReturnCodes.ABORTED
+
+    print('Device metadata successfully created.')
+    return ReturnCodes.SUCCESS
+
+
+def configure_metadata():
+    pass
+
+
+def guided_setup(device_root) -> DeviceMetadata:
+    logger.info('Guided setup')
+    response = 'N'
+    device_name = ''
+    while response.upper() == 'N':
+        device_name = input('Please enter name of device: ')
+        response = input(f'Confirm device name: {device_name} [y/N] ')
+        if device_name == '' or device_name is None:
+            print('Name cannot be empty')
+            logger.warning('Name cannot be empty')
+        logger.debug(f'Response is {response}')
+        logger.debug(f'Device name is {device_name}')
+
+    return DeviceMetadata(device_name, device_root)

code/iottb/subcommands/capture.py

@@ -0,0 +1,174 @@
+import subprocess
+from pathlib import Path
+
+from iottb.definitions import *
+from iottb.models.capture_metadata_model import CaptureMetadata
+from iottb.models.device_metadata_model import DeviceMetadata, dir_contains_device_metadata
+from iottb.utils.capture_utils import get_capture_src_folder, make_capture_src_folder
+from iottb.utils.tcpdump_utils import check_installed
+
+def setup_capture_parser(subparsers):
+    parser = subparsers.add_parser('sniff', help='Sniff packets with tcpdump')
+    # metadata args
+    parser.add_argument('-a', '--ip-address', help='IP address of the device to sniff', dest='device_ip')
+    # tcpdump args
+    parser.add_argument('device_root', help='Root folder for device to sniff',
+                        type=Path, default=Path.cwd())
+    parser.add_argument('-s', '--safe', help='Ensure correct device root folder before sniffing', action='store_true')
+    parser.add_argument('--app', help='Application name to sniff', dest='app_name', default=None)
+
+    parser_sniff_tcpdump = parser.add_argument_group('tcpdump arguments')
+    parser_sniff_tcpdump.add_argument('-i', '--interface', help='Interface to capture on.', dest='capture_interface',
+                                      required=True)
+    parser_sniff_tcpdump.add_argument('-I', '--monitor-mode', help='Put interface into monitor mode',
+                                      action='store_true')
+    parser_sniff_tcpdump.add_argument('-n', help='Deactivate name resolution. True by default.',
+                                      action='store_true', dest='no_name_resolution')
+    parser_sniff_tcpdump.add_argument('-#', '--number',
+                                      help='Print packet number at beginning of line. True by default.',
+                                      action='store_true')
+    parser_sniff_tcpdump.add_argument('-e', help='Print link layer headers. True by default.',
+                                      action='store_true', dest='print_link_layer')
+    parser_sniff_tcpdump.add_argument('-t', action='count', default=0,
+                                      help='Please see tcpdump manual for details. Unused by default.')
+
+    cap_size_group = parser.add_mutually_exclusive_group(required=False)
+    cap_size_group.add_argument('-c', '--count', type=int, help='Number of packets to capture.', default=1000)
+    cap_size_group.add_argument('--mins', type=int, help='Time in minutes to capture.', default=1)
+
+    parser.set_defaults(func=handle_capture)
+
+
+def cwd_is_device_root_dir() -> bool:
+    device_metadata_file = Path.cwd() / DEVICE_METADATA_FILE
+    return device_metadata_file.is_file()
+
+
+def start_guided_device_root_dir_setup():
+    assert False, 'Not implemented'
+
+
+def handle_metadata():
+    assert not cwd_is_device_root_dir()
+    print(f'Unable to find {DEVICE_METADATA_FILE} in current working directory')
+    print('You need to setup a device root directory before using this command')
+    response = input('Would you like to be guided through the setup? [y/n]')
+    if response.lower() == 'y':
+        start_guided_device_root_dir_setup()
+    else:
+        print('\'iottb init-device-root --help\' for more information.')
+        exit(ReturnCodes.ABORTED)
+    # device_id = handle_capture_metadata()
+    return ReturnCodes.SUCCESS
+
+
+def get_device_metadata_from_file(device_metadata_filename: Path) -> str:
+    assert device_metadata_filename.is_file(), f'Device metadata file f"{device_metadata_filename}" does not exist'
+    device_metadata = DeviceMetadata.load_from_json(device_metadata_filename)
+    return device_metadata
+
+
+def run_tcpdump(cmd):
+    # TODO: Maybe specify files for stout and stderr
+    try:
+        p = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        if p.returncode != 0:
+            print(f'Error running tcpdump {p.stderr}')
+            # TODO add logging
+        else:
+            print(f'tcpdump run successfully\n: {p.stdout}')
+    except KeyboardInterrupt:
+        pass
+
+
+def handle_capture(args):
+    if not check_installed():
+        print('Please install tcpdump first')
+        exit(ReturnCodes.ABORTED)
+    assert args.device_root is not None, f'Device root directory is required'
+    assert dir_contains_device_metadata(args.device_root), f'Device metadata file \'{args.device_root}\' does not exist'
+    # get device metadata
+    if args.safe and not dir_contains_device_metadata(args.device_root):
+        print(f'Supplied folder contains no device metadata. '
+              f'Please setup a device root directory before using this command')
+        exit(ReturnCodes.ABORTED)
+    elif dir_contains_device_metadata(args.device_root):
+        device_metadata_filename = args.device_root / DEVICE_METADATA_FILE
+        device_data = DeviceMetadata.load_from_json(device_metadata_filename)
+    else:
+        name = input('Please enter a device name: ')
+        args.device_root.mkdir(parents=True, exist_ok=True)
+        device_data = DeviceMetadata(name, args.device_root)
+    # start constructing environment for capture
+    capture_dir = get_capture_src_folder(args.device_root)
+    make_capture_src_folder(capture_dir)
+    capture_metadata = CaptureMetadata(device_data, capture_dir)
+
+    capture_metadata.interface = args.capture_interface
+    cmd = ['sudo', 'tcpdump', '-i', args.capture_interface]
+    cmd = build_tcpdump_args(args, cmd, capture_metadata)
+    capture_metadata.tcpdump_command = cmd
+
+    print('Executing: ' + ' '.join(cmd))
+
+    # run capture
+    try:
+        start_time = datetime.now().strftime('%H:%M:%S')
+        run_tcpdump(cmd)
+        stop_time = datetime.now().strftime('%H:%M:%S')
+        capture_metadata.start_time = start_time
+        capture_metadata.stop_time = stop_time
+    except KeyboardInterrupt:
+        print('Received keyboard interrupt.')
+        exit(ReturnCodes.ABORTED)
+    except subprocess.CalledProcessError as e:
+        print(f'Failed to capture packet: {e}')
+        exit(ReturnCodes.FAILURE)
+    except Exception as e:
+        print(f'Failed to capture packet: {e}')
+        exit(ReturnCodes.FAILURE)
+
+    return ReturnCodes.SUCCESS
+
+
+def build_tcpdump_args(args, cmd, capture_metadata: CaptureMetadata):
+    if args.monitor_mode:
+        cmd.append('-I')
+    if args.no_name_resolution:
+        cmd.append('-n')
+    if args.number:
+        cmd.append('-#')
+    if args.print_link_layer:
+        cmd.append('-e')
+
+    if args.count:
+        cmd.append('-c')
+        cmd.append(str(args.count))
+    elif args.mins:
+        assert False, 'Unimplemented option'
+
+    if args.app_name is not None:
+        capture_metadata.app = args.app_name
+
+    capture_metadata.build_capture_file_name()
+    cmd.append('-w')
+    cmd.append(capture_metadata.capture_file)
+
+    if args.safe:
+        cmd.append(f'host {args.device_ip}')  # if not specified, filter 'any' implied by tcpdump
+        capture_metadata.device_id = args.device_ip
+
+    return cmd
+
+
+# def capture_file_cmd(args, cmd, capture_dir, capture_metadata: CaptureMetadata):
+#     capture_file_prefix = capture_metadata.get_device_metadata().get_device_short_name()
+#     if args.app_name is not None:
+#         capture_file_prefix = args.app_name
+#         capture_metadata.set_app(args.app_name)
+#     capfile_name = capture_file_prefix + '_' + str(capture_metadata.get_capture_id()) + '.pcap'
+#     capture_metadata.set_capture_file(capfile_name)
+#     capfile_abs_path = capture_dir / capfile_name
+#     capture_metadata.set_capture_file(capfile_name)
+#     cmd.append('-w')
+#     cmd.append(str(capfile_abs_path))

code/iottb/utils/capture_utils.py

@@ -0,0 +1,44 @@
+import uuid
+from pathlib import Path
+from iottb.models.device_metadata_model import dir_contains_device_metadata
+from iottb.utils.utils import get_iso_date
+
+
+def get_capture_uuid():
+    return str(uuid.uuid4())
+
+
+def get_capture_date_folder(device_root: Path):
+    today_iso = get_iso_date()
+    today_folder = device_root / today_iso
+    if dir_contains_device_metadata(device_root):
+        if not today_folder.is_dir():
+            try:
+                today_folder.mkdir()
+            except FileExistsError:
+                print(f'Folder {today_folder} already exists')
+        return today_folder
+    raise FileNotFoundError(f'Given path {device_root} is not a device root directory')
+
+
+def get_capture_src_folder(device_folder: Path):
+    assert device_folder.is_dir(), f'Given path {device_folder} is not a folder'
+    today_iso = get_iso_date()
+    max_sequence_number = 1
+    for d in device_folder.iterdir():
+        if d.is_dir() and d.name.startswith(f'{today_iso}_capture_'):
+            name = d.name
+            num = int(name.split('_')[2])
+            max_sequence_number = max(max_sequence_number, num)
+
+    next_sequence_number = max_sequence_number + 1
+    return device_folder.joinpath(f'{today_iso}_capture_{next_sequence_number:03}')
+
+
+def make_capture_src_folder(capture_src_folder: Path):
+    try:
+        capture_src_folder.mkdir()
+    except FileExistsError:
+        print(f'Folder {capture_src_folder} already exists')
+    finally:
+        return capture_src_folder

code/iottb/utils/tcpdump_utils.py

@@ -0,0 +1,41 @@
+import ipaddress
+import shutil
+import subprocess
+from typing import Optional
+
+
+def check_installed() -> bool:
+    """Check if tcpdump is installed and available on the system path."""
+    return shutil.which('tcpdump') is not None
+
+
+def ensure_installed():
+    """Ensure that tcpdump is installed, raise an error if not."""
+    if not check_installed():
+        raise RuntimeError('tcpdump is not installed. Please install it to continue.')
+
+
+def list_interfaces() -> str:
+    """List available network interfaces using tcpdump."""
+    ensure_installed()
+    try:
+        result = subprocess.run(['tcpdump', '--list-interfaces'], capture_output=True, text=True, check=True)
+        return result.stdout
+    except subprocess.CalledProcessError as e:
+        print(f'Failed to list interfaces: {e}')
+        return ''
+
+
+def is_valid_ipv4(ip: str) -> bool:
+    try:
+        ipaddress.IPv4Address(ip)
+        return True
+    except ValueError:
+        return False
+
+def str_to_ipv4(ip: str) -> (bool, Optional[ipaddress]):
+    try:
+        address = ipaddress.IPv4Address(ip)
+        return address == ipaddress.IPv4Address(ip), address
+    except ipaddress.AddressValueError:
+        return False, None

code/iottb/utils/utils.py

@@ -0,0 +1,18 @@
+import uuid
+from datetime import datetime
+from iottb.definitions import TODAY_DATE_STRING, DEVICE_METADATA_FILE, CAPTURE_METADATA_FILE
+from pathlib import Path
+
+
+def get_iso_date():
+    return datetime.now().strftime('%Y-%m-%d')
+
+
+def subfolder_exists(parent: Path, child: str):
+    return parent.joinpath(child).exists()
+
+
+def generate_unique_string_with_prefix(prefix: str):
+    return prefix + '_' + str(uuid.uuid4())
+
+