Add usage examples to README.md.

Merge experiment2 into main

See merge request dmi-pet/bsc-msc/2024-bsc-sebastian-lenzlinger!9

.gitignore

@@ -1,10 +1,38 @@
-.obsidian
-venv
 __pycache__
-*.log
-.idea/*
-*/.idea
-*.idea
-/.idea
+.venv
+iottb.egg-info
 .idea/
-2024-bsc-sebastian-lenzlinger.iml
+*.log
+logs/
+*.pyc
+.obsidian
+dist/
+build/
+
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+.private/
+*.pcap

.idea/2024-bsc-sebastian-lenzlinger.iml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module version="4">
-  <component name="PyDocumentationSettings">
-    <option name="format" value="PLAIN" />
-    <option name="myDocStringFormat" value="Plain" />
-  </component>
-  <component name="TestRunnerService">
-    <option name="PROJECT_TEST_RUNNER" value="py.test" />
-  </component>
-</module>

.idea/inspectionProfiles/Project_Default.xml

@@ -1,17 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="DuplicatedCode" enabled="true" level="WEAK WARNING" enabled_by_default="true">
-      <Languages>
-        <language minSize="67" name="Python" />
-      </Languages>
-    </inspection_tool>
-    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
-      <option name="ignoredErrors">
-        <list>
-          <option value="N806" />
-        </list>
-      </option>
-    </inspection_tool>
-  </profile>
-</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <settings>
-    <option name="USE_PROJECT_PROFILE" value="false" />
-    <version value="1.0" />
-  </settings>
-</component>

.idea/misc.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Black">
-    <option name="sdkName" value="Python 3.12 (pythonProject)" />
-  </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12 (2024-bsc-sebastian-lenzlinger)" project-jdk-type="Python SDK" />
-</project>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

.idea/webResources.xml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="WebResourcesPaths">
-    <contentEntries>
-      <entry url="file://$PROJECT_DIR$">
-        <entryData>
-          <resourceRoots>
-            <path value="file://$PROJECT_DIR$/data" />
-          </resourceRoots>
-        </entryData>
-      </entry>
-    </contentEntries>
-  </component>
-</project>

README.md

@@ -1,4 +1,4 @@
-# Your Project Name
+# IOTTB
 
 Hello! This is the README file that accompanies the Gitlab repository for your Bachelor or Master thesis. You'll need to update this README as you work on your thesis to reflect relevant information about your thesis.
 
@@ -6,29 +6,26 @@ Hello! This is the README file that accompanies the Gitlab repository for your B
 
 ## Organization of the repository
 - **code** folder: holds source code
-- **data** folder: holds (input) data required for the project. If your input data files are larger than 100MB, create a sample data file smaller than 100MB and commit the sample instead of the full data file. Include a note explaining how the full data can be retrieved.
-- **results** folder: holds results files generated as part of the project
-- **thesis** folder: contains the latex sources + PDF of the final thesis. You can use the [basilea-latex template](https://github.com/ivangiangreco/basilea-latex) as a starting point.
-- **presentation** folder: contains the sources of the presentation (e.g., latex or PPT)
-- **literature** folder: contains any research paper that the student needs to read or finds interesting
-- **notes** folder: holds minutes of meetings
+- **data** folder: Holds no relevant data for this thesis. Files in here where used for debugging and testing.
+- **thesis** folder: contains the latex sources + PDF of the final thesis.
+- **presentation** folder: contains PDF and sources of the presentation.
+- **literature** used can be found in the **thesis** folder .bib or in the **presentation** folders .bib file.
+- **notes** folder: Various notes and the beginnings of a wiki.
+- `iottb` is the python testbed as a single executable (including python interpreter) which should be able to run on Linux machines.
 
-## Useful resources
-- [Efficient Reading of Papers in Science and Technology](https://www.cs.columbia.edu/~hgs/netbib/efficientReading.pdf)
-- [Heilmeier's catechism](https://en.wikipedia.org/wiki/George_H._Heilmeier#Heilmeier%27s_Catechism)
 
 ## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
+In this thesis I design a automation testbed for IoT devices.
+The main result is the software `iottb` which automates some aspects of experimenting with IoT devices.
+Currently, it implements a database guided by the FAIR principles of open data as well as wraps tcpdump such that metadata is stored.
 
 ## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
+For more info see `code/iottb-project/README.md`. 
+As well as examples in the thesis writeup at `thesis/BScThesisUnibas_main-5.pdf`. <br>
+In general:
+```bash
+iottb --help # Most general overview
+iottb <subcommand> --help
+```
 ## License
-To allow further development and use during public events of the implemented system through the University of Basel, the system is expected to be well documented and provided to the university under a license that allows such reuse, e.g., the [BSD 3-clause license](https://opensource.org/license/bsd-3-clause/). The student agrees that all code produced during the project may be released open-source in the context of the PET group's projects.
-
+The code is licensed under a BSD 3-clause license, a copy of which is provided in the file `code/iottb-project/LICENSE`.

archive/functions_dump.py

@@ -30,3 +30,30 @@ def setup_sniff_parser(subparsers):
 def setup_pcap_filter_parser(parser_sniff):
     parser_pcap_filter = parser_sniff.add_argument_parser('pcap-filter expression')
     pass
+
+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 setting "IOTTB_HOME"')
+                print('TODO')
+                print("Aborting execution...")
+                return ReturnCodes.ABORTED
+            else:
+                print(f'Setting environment variable IOTTB_HOME""')
+                Path(IOTTB_HOME_ABS).mkdir(parents=True,
+                                           exist_ok=False)  # Should always work since in 'not exist' code path
+                return ReturnCodes.SUCCESS
+        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.SUCCESS

archive/iottb/__main__.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+import argparse
+from os import environ
+from pathlib import Path
+import logging
+from archive.iottb.subcommands.add_device import setup_init_device_root_parser
+# from iottb.subcommands.capture import setup_capture_parser
+from iottb.subcommands.sniff import setup_sniff_parser
+from iottb.utils.tcpdump_utils import list_interfaces
+from iottb.logger import setup_logging
+
+logger = logging.getLogger('iottbLogger.__main__')
+logger.setLevel(logging.DEBUG)
+
+
+######################
+# Argparse setup
+######################
+def setup_argparse():
+    # create top level parser
+    root_parser = argparse.ArgumentParser(prog='iottb')
+    # shared options
+    root_parser.add_argument('--verbose', '-v', action='count', default=0)
+    root_parser.add_argument('--script-mode', action='store_true', help='Run in script mode (non-interactive)')
+    # Group of args w.r.t iottb.db creation
+    group = root_parser.add_argument_group('database options')
+    group.add_argument('--db-home', default=Path.home() / 'IoTtb.db')
+    group.add_argument('--config-home', default=Path.home() / '.config' / 'iottb.conf', type=Path, )
+    group.add_argument('--user', default=Path.home().stem, type=Path, )
+
+    # configure subcommands
+    subparsers = root_parser.add_subparsers(title='subcommands', required=True, dest='command')
+    # setup_capture_parser(subparsers)
+    setup_init_device_root_parser(subparsers)
+    setup_sniff_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
+
+
+###
+# Where put ?!
+###
+class IoTdb:
+    def __init__(self, db_home=Path.home() / 'IoTtb.db', iottb_config=Path.home() / '.conf' / 'iottb.conf',
+                 user=Path.home().stem):
+        self.db_home = db_home
+        self.config_home = iottb_config
+        self.default_filters_home = db_home / 'default_filters'
+        self.user = user
+
+    def create_db(self, mode=0o777, parents=False, exist_ok=False):
+        logger.info(f'Creating db at {self.db_home}')
+        try:
+            self.db_home.mkdir(mode=mode, parents=parents, exist_ok=exist_ok)
+        except FileExistsError:
+            logger.error(f'Database path already at {self.db_home} exists and is not a directory')
+        finally:
+            logger.debug(f'Leaving finally clause in create_db')
+
+    def create_device_tree(self, mode=0o777, parents=False, exist_ok=False):
+        logger.info(f'Creating device tree at {self.db_home / 'devices'}')
+        #TODO
+
+    def parse_db_config(self):
+        pass
+
+    def parse_iottb_config(self):
+        pass
+
+    def get_known_devices(self):
+        pass
+
+
+def iottb_db_exists(db_home=Path.home() / 'IoTtb.db'):
+    res = db_home.is_dir()
+
+
+def main():
+    logger.debug(f'Pre setup_argparse()')
+    parser = setup_argparse()
+    logger.debug('Post setup_argparse().')
+    args = parser.parse_args()
+    logger.debug(f'Args parsed: {args}')
+    if args.command:
+        try:
+            args.func(args)
+        except KeyboardInterrupt:
+            print('Received keyboard interrupt. Exiting...')
+            exit(1)
+        except Exception as e:
+            logger.debug(f'Error in main: {e}')
+            print(f'Error: {e}')
+    # create_capture_directory(args.device_name)
+
+
+if __name__ == '__main__':
+    setup_logging()
+    logger.debug("Debug level is working")
+    logger.info("Info level is working")
+    logger.warning("Warning level is working")
+
+    main()

archive/iottb/logger.py

@@ -0,0 +1,35 @@
+import logging
+import sys
+import os
+from logging.handlers import RotatingFileHandler
+
+
+def setup_logging():
+    # Ensure the logs directory exists
+    log_directory = 'logs'
+    if not os.path.exists(log_directory):
+        os.makedirs(log_directory)
+
+    # Create handlers
+    file_handler = RotatingFileHandler(os.path.join(log_directory, 'iottb.log'), maxBytes=1048576, backupCount=5)
+    console_handler = logging.StreamHandler(sys.stdout)
+
+    # Create formatters and add it to handlers
+    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)
+
+    # Get the root logger and add handlers
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.DEBUG)
+    root_logger.addHandler(file_handler)
+    root_logger.addHandler(console_handler)
+
+    # Prevent propagation to the root logger to avoid duplicate logs
+    root_logger.propagate = False
+
+
+setup_logging()

archive/iottb/models/capture_metadata_model.py

@@ -6,17 +6,20 @@ 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
+import logging
+
+logger = logging.getLogger('iottbLogger.capture_metadata_model')
+logger.setLevel(logging.DEBUG)
 
 
 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
@@ -39,7 +42,8 @@ class CaptureMetadata:
     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_id = str(uuid.uuid4())
+        self.capture_date = datetime.now().strftime('%d-%m-%YT%H:%M:%S').lower()
         self.capture_dir = capture_dir
         assert capture_dir.is_dir(), f'Capture directory {capture_dir} does not exist'
 
@@ -47,7 +51,7 @@ class CaptureMetadata:
         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
+            prefix = "iphone-14" #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}'

archive/iottb/models/device_metadata_model.py

@@ -6,7 +6,10 @@ from typing import Optional, List
 
 # iottb modules
 from iottb.definitions import ReturnCodes, DEVICE_METADATA_FILE
-from iottb.logger import logger
+import logging
+
+logger = logging.getLogger('iottbLogger.device_metadata_model')
+logger.setLevel(logging.DEBUG)
 # 3rd party libs
 
 IMMUTABLE_FIELDS = {'device_name', 'device_short_name', 'device_id', 'date_created'}

archive/iottb/subcommands/add_device.py

@@ -1,18 +1,21 @@
 import logging
+import os
 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
-
+# logger.setLevel(logging.INFO)  # Since module currently passes all tests
+logger = logging.getLogger('iottbLogger.add_device')
+logger.setLevel(logging.INFO)
 
 def setup_init_device_root_parser(subparsers):
+    #assert os.environ['IOTTB_HOME'] is not None, "IOTTB_HOME environment variable is not set"
     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())
+    parser.add_argument('--root_dir', type=pathlib.Path,
+                        default=definitions.IOTTB_HOME_ABS)  # TODO: Refactor code to not use this or handle iottb here
     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')
@@ -20,14 +23,12 @@ def setup_init_device_root_parser(subparsers):
 
 
 def handle_add(args):
+    # TODO: This whole function should be refactored into using the fact that IOTTB_HOME is set, and the dir exists
     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)
+        metadata = guided_setup(args.root_dir)  # TODO refactor to use IOTTB_HOME
         logger.debug('guided setup complete')
     else:
         logger.debug('Setup through passed args: setup')
@@ -36,7 +37,7 @@ def handle_add(args):
             return ReturnCodes.ERROR
         metadata = DeviceMetadata(args.name, args.root_dir)
 
-    file_path = args.root_dir / DEVICE_METADATA_FILE
+    file_path = args.root_dir / DEVICE_METADATA_FILE    # TODO IOTTB_HOME REFACTOR
     if file_path.exists():
         print('Directory already contains a metadata file. Aborting.')
         return ReturnCodes.ABORTED

archive/iottb/subcommands/capture.py

@@ -2,11 +2,15 @@ import subprocess
 from pathlib import Path
 
 from iottb.definitions import *
+import logging
 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
 
+logger = logging.getLogger('iottbLogger.capture')
+logger.setLevel(logging.DEBUG)
+
 def setup_capture_parser(subparsers):
     parser = subparsers.add_parser('sniff', help='Sniff packets with tcpdump')
     # metadata args
@@ -33,7 +37,7 @@ def setup_capture_parser(subparsers):
                                       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('-c', '--count', type=int, help='Number of packets to capture.', default=10)
     cap_size_group.add_argument('--mins', type=int, help='Time in minutes to capture.', default=1)
 
     parser.set_defaults(func=handle_capture)
@@ -88,6 +92,7 @@ def handle_capture(args):
     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
+    logger.info(f'Device root directory: {args.device_root}')
     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')
@@ -98,6 +103,7 @@ def handle_capture(args):
     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)
@@ -152,7 +158,7 @@ def build_tcpdump_args(args, cmd, capture_metadata: CaptureMetadata):
 
     capture_metadata.build_capture_file_name()
     cmd.append('-w')
-    cmd.append(capture_metadata.capture_file)
+    cmd.append(str(capture_metadata.capture_dir) + "/" + capture_metadata.capture_file)
 
     if args.safe:
         cmd.append(f'host {args.device_ip}')  # if not specified, filter 'any' implied by tcpdump
@@ -160,7 +166,6 @@ def build_tcpdump_args(args, cmd, capture_metadata: CaptureMetadata):
 
     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:

archive/iottb/subcommands/sniff.py

@@ -0,0 +1,63 @@
+import subprocess
+import logging
+
+
+logger = logging.getLogger('iottbLogger.capture')
+logger.setLevel(logging.DEBUG)
+class Sniffer:
+    def __init__(self):
+        pass
+
+
+def setup_sniff_parser(subparsers):
+    parser = subparsers.add_parser('sniff', help='Sniff packets with tcpdump')
+    # metadata args
+    parser.add_argument('-a', '--addr', help='IP or MAC address of IoT device')
+    # tcpdump args
+    parser.add_argument('--app', help='Application name to sniff', 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=10)
+    cap_size_group.add_argument('--mins', type=int, help='Time in minutes to capture.', default=1)
+
+    parser.set_defaults(func=sniff)
+
+
+def parse_addr(addr):
+    #TODO Implement
+    pass
+
+
+def sniff(args):
+    if args.addr is None:
+        print('You must supply either a MAC or IP(v4) address to use this tool!')
+        logger.info("Exiting on account of missing MAC/IP.")
+        exit(1)
+    else:
+        (type, value) = parse_addr(args.addr)
+        #TODO Get this party started
+
+def sniff_tcpdump(args, filter):
+    pass
+
+def sniff_mitmproxy(args, filter):
+    pass
+
+def sniff_raw(cmd,args):
+    pass

archive/iottb/utils/tcpdump_utils.py

@@ -15,12 +15,12 @@ def ensure_installed():
         raise RuntimeError('tcpdump is not installed. Please install it to continue.')
 
 
-def list_interfaces() -> str:
+def list_interfaces(args) -> 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
+        print(result.stdout)
     except subprocess.CalledProcessError as e:
         print(f'Failed to list interfaces: {e}')
         return ''

archive/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = 'iottb'
+version = '0.1.0'
+authors = [{name = "Sebastian Lenzlinger", email = "sebastian.lenzlinger@unibas.ch"}]
+description = "Automation Tool for Capturing Network packets of IoT devices."
+requires-python = ">=3.8"
+
+[tool.setuptools]
+packages = ["iottb"]
+
+[project.scripts]
+iottb = "iottb.__main__:main"

code/iottb-project

@@ -1 +0,0 @@
-Subproject commit a5d4390f37f94839b0820da9a06c44f46be75000

code/iottb-project/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Sebastian Lenzlinger
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

code/iottb-project/README.md

@@ -0,0 +1,82 @@
+# Iottb
+
+## Installation
+There are a few different ways to install `iottb`.
+
+In Linux, to install to a users local bin directory using poetry or pip:
+- Move into the project root `cd path/to/iottb-project`, so that you are in the directory which contains the `pyproject.toml` file.
+```bash
+poetry install --editable
+# or with pip
+pip install -e .
+```
+Currently, this is the recommended method. 
+Alternatively install with pip into any activated environment:
+```bash
+pip install -r requirements.txt
+```
+
+It is possible to make a single executable for you machine which you can just put in your path using pyinstaller.
+1. Install pyinstaller
+```bash
+pip install pyinstaller 
+```
+2. Make the executable
+```bash
+pyinstaller --onefile --name iottb --distpath ~/opt iottb/main.py
+```
+to be able to run it as `iottb` if `~/opt' is a directory on your PATH.
+A executable which should be able to run on linux is included in the repo.
+## Basic Invocation
+```bash
+Usage: iottb [OPTIONS] COMMAND [ARGS]...
+
+Options:
+  -v, --verbosity    Set verbosity  [default: 0; 0<=x<=3]
+  -d, --debug        Enable debug mode
+  --cfg-file PATH    Path to iottb config file  [default:
+                     /home/seb/.config/iottb/iottb.cfg]
+  --help             Show this message and exit.
+
+  --dry-run BOOLEAN  currently NOT USED!  [default: True]
+  
+Commands:
+  add-device           Add a device to a database
+  init-db
+  sniff                Sniff packets with tcpdump
+  
+Debugging Commands:
+  show-all             Show everything: configuration, databases, and...
+  show-cfg             Show the current configuration context
+```
+
+## Usage Examples
+### Initializing a database
+Before devices can be added and packet captures performed, there must be a database.
+Initialze a database with default values at the default location:
+```bash
+iottb init-db
+```
+### Adding a device
+Typically, captures are performed for devices. To add a device (to the current default database)
+```bash
+iottb add-device 'Echo Dot 2'
+```
+if the devices is named 'Echo Dot 2'. This will get the cannonical name 'echo-dot'. This name should be used when performing
+captures with `iottb`.
+### Performing captures/sniffing traffic
+```bash
+iottb sniff -a <ipv4-addr or mac-addr> 'echo-dot'
+```
+to sniff traffic on the previously added device 'Echo Dot 2' which received the canonical name 'echo-dot'.
+You can get the subcommand specif helptext by adding the `--help` option.
+## Configuration
+### Env Vars
+- IOTTB_CONF_HOME
+
+By setting this variable you control where the basic iottb application
+configuration should be looked for
+
+## License
+This project is licensed under a BSD 3-clause License, a copy of which is provided in the file `code/iottb-project/LICENSE`.
+

code/iottb-project/docs/command_reference.txt

@@ -0,0 +1,110 @@
+Usage: iottb [OPTIONS] COMMAND [ARGS]...
+
+Options:
+  -v, --verbosity  Set verbosity  [default: 0; 0<=x<=3]
+  -d, --debug      Enable debug mode
+  --dry-run        [default: True]
+  --cfg-file PATH  Path to iottb config file  [default:
+                   /home/seb/.config/iottb/iottb.cfg]
+  --help           Show this message and exit.
+
+Commands:
+  add-device           Add a device to a database
+  init-db
+  rm-cfg               Removes the cfg file from the filesystem.
+  rm-dbs               Removes ALL(!) databases from the filesystem if...
+  set-key-in-table-to  Edit config or metadata files.
+  show-all             Show everything: configuration, databases, and...
+  show-cfg             Show the current configuration context
+  sniff                Sniff packets with tcpdump
+Usage: iottb init-db [OPTIONS]
+
+Options:
+  -d, --dest PATH                 Location to put (new) iottb database
+  -n, --name TEXT                 Name of new database.  [default: iottb.db]
+  --update-default / --no-update-default
+                                  If new db should be set as the new default
+                                  [default: update-default]
+  --help                          Show this message and exit.
+Usage: iottb add-device [OPTIONS]
+
+  Add a device to a database
+
+Options:
+  --dev, --device-name TEXT   The name of the device to be added. If this
+                              string contains spaces or other special
+                              characters               normalization is
+                              performed to derive a canonical name  [required]
+  --db, --database DIRECTORY  Database in which to add this device. If not
+                              specified use default from config.  [env var:
+                              IOTTB_DB]
+  --guided                    Add device interactively  [env var:
+                              IOTTB_GUIDED_ADD]
+  --help                      Show this message and exit.
+Usage: iottb sniff [OPTIONS] [TCPDUMP-ARGS] [DEVICE]
+
+  Sniff packets with tcpdump
+
+Options:
+  Testbed sources: 
+    --db, --database TEXT  Database of device. Only needed if not current
+                           default.  [env var: IOTTB_DB]
+    --app TEXT             Companion app being used during capture
+  Runtime behaviour: 
+    --unsafe               Disable checks for otherwise required options.
+                           [env var: IOTTB_UNSAFE]
+    --guided               [env var: IOTTB_GUIDED]
+    --pre TEXT             Script to be executed before main  command is
+                           started.
+    --post TEXT            Script to be executed upon completion of main
+                           command.
+  Tcpdump options: 
+    -i, --interface TEXT   Network interface to capture on.If not specified
+                           tcpdump tries to find and appropriate one.  [env
+                           var: IOTTB_CAPTURE_INTERFACE]
+    -a, --address TEXT     IP or MAC address to filter packets by.  [env var:
+                           IOTTB_CAPTURE_ADDRESS]
+    -I, --monitor-mode     Put interface into monitor mode.
+    --ff TEXT              tcpdump filter as string or file path.  [env var:
+                           IOTTB_CAPTURE_FILTER]
+    -#, --print-pacno      Print packet number at beginning of line. True by
+                           default.  [default: True]
+    -e, --print-ll         Print link layer headers. True by default.
+    -c, --count INTEGER    Number of packets to capture.  [default: 1000]
+  --help                   Show this message and exit.
+Utility Commands mostly for development
+Usage: iottb rm-cfg [OPTIONS]
+
+  Removes the cfg file from the filesystem.
+
+  This is mostly a utility during development. Once non-standard database
+  locations are implemented, deleting this would lead to iottb not being able
+  to find them anymore.
+
+Options:
+  --yes   Confirm the action without prompting.
+  --help  Show this message and exit.
+Usage: iottb rm-dbs [OPTIONS]
+
+  Removes ALL(!) databases from the filesystem if they're empty.
+
+  Development utility currently unfit for use.
+
+Options:
+  --yes   Confirm the action without prompting.
+  --help  Show this message and exit.
+Usage: iottb show-cfg [OPTIONS]
+
+  Show the current configuration context
+
+Options:
+  --cfg-file PATH  Path to the config file  [default:
+                   /home/seb/.config/iottb/iottb.cfg]
+  -pp              Pretty Print
+  --help           Show this message and exit.
+Usage: iottb show-all [OPTIONS]
+
+  Show everything: configuration, databases, and device metadata
+
+Options:
+  --help  Show this message and exit.

code/iottb-project/docs/help.txt

@@ -0,0 +1,38 @@
+Usage: iottb [OPTIONS] COMMAND [ARGS]...
+
+Options:
+  -v, --verbosity  Set verbosity  [default: 0; 0<=x<=3]
+  -d, --debug      Enable debug mode
+  --dry-run        [default: True]
+  --cfg-file PATH  Path to iottb config file  [default:
+                   /home/seb/.config/iottb/iottb.cfg]
+  --help           Show this message and exit.
+
+Commands:
+  add-device           Add a device to a database
+  init-db
+  rm-cfg               Removes the cfg file from the filesystem.
+  rm-dbs               Removes ALL(!) databases from the filesystem if...
+  set-key-in-table-to  Edit config or metadata files.
+  show-all             Show everything: configuration, databases, and...
+  show-cfg             Show the current configuration context
+  sniff                Sniff packets with tcpdump
+Usage: iottb [OPTIONS] COMMAND [ARGS]...
+
+Options:
+  -v, --verbosity  Set verbosity  [default: 0; 0<=x<=3]
+  -d, --debug      Enable debug mode
+  --dry-run        [default: True]
+  --cfg-file PATH  Path to iottb config file  [default:
+                   /home/seb/.config/iottb/iottb.cfg]
+  --help           Show this message and exit.
+
+Commands:
+  add-device           Add a device to a database
+  init-db
+  rm-cfg               Removes the cfg file from the filesystem.
+  rm-dbs               Removes ALL(!) databases from the filesystem if...
+  set-key-in-table-to  Edit config or metadata files.
+  show-all             Show everything: configuration, databases, and...
+  show-cfg             Show the current configuration context
+  sniff                Sniff packets with tcpdump

code/iottb-project/docs/help_messages.md

@@ -0,0 +1,142 @@
+# Main Command: `iottb`
+
+ Usage: `iottb  [OPTIONS] COMMAND [ARGS]...`
+
+Options:
+  -v, --verbosity  Set verbosity  [0<=x<=3] \n
+  -d, --debug      Enable debug mode
+  --dry-run
+  --cfg-file PATH  Path to iottb config file
+  --help           Show this message and exit.
+
+Commands:
+  add-device           Add a device to a database
+  init-db
+  rm-cfg               Removes the cfg file from the filesystem.
+  rm-dbs               Removes ALL(!) databases from the filesystem if...
+  set-key-in-table-to  Edit config or metadata files.
+  show-all             Show everything: configuration, databases, and...
+  show-cfg             Show the current configuration context
+  sniff                Sniff packets with tcpdump
+
+
+Command: init-db
+ Usage:  [OPTIONS]
+
+Options:
+  -d, --dest PATH                 Location to put (new) iottb database
+  -n, --name TEXT                 Name of new database.
+  --update-default / --no-update-default
+                                  If new db should be set as the new default
+  --help                          Show this message and exit.
+
+
+Command: rm-cfg
+ Usage:  [OPTIONS]
+
+  Removes the cfg file from the filesystem.
+
+  This is mostly a utility during development. Once non-standard database
+  locations are implemented, deleting this would lead to iottb not being able
+  to find them anymore.
+
+Options:
+  --yes   Confirm the action without prompting.
+  --help  Show this message and exit.
+
+
+Command: set-key-in-table-to
+ Usage:  [OPTIONS]
+
+  Edit config or metadata files. TODO: Implement
+
+Options:
+  --file TEXT
+  --table TEXT
+  --key TEXT
+  --value TEXT
+  --help        Show this message and exit.
+
+
+Command: rm-dbs
+ Usage:  [OPTIONS]
+
+  Removes ALL(!) databases from the filesystem if they're empty.
+
+  Development utility currently unfit for use.
+
+Options:
+  --yes   Confirm the action without prompting.
+  --help  Show this message and exit.
+
+
+Command: add-device
+ Usage:  [OPTIONS]
+
+  Add a device to a database
+
+Options:
+  --dev, --device-name TEXT   The name of the device to be added. If this
+                              string contains spaces or other special
+                              characters               normalization is
+                              performed to derive a canonical name  [required]
+  --db, --database DIRECTORY  Database in which to add this device. If not
+                              specified use default from config.  [env var:
+                              IOTTB_DB]
+  --guided                    Add device interactively  [env var:
+                              IOTTB_GUIDED_ADD]
+  --help                      Show this message and exit.
+
+
+Command: show-cfg
+ Usage:  [OPTIONS]
+
+  Show the current configuration context
+
+Options:
+  --cfg-file PATH  Path to the config file
+  -pp              Pretty Print
+  --help           Show this message and exit.
+
+
+Command: sniff
+ Usage:  [OPTIONS] [TCPDUMP-ARGS] [DEVICE]
+
+  Sniff packets with tcpdump
+
+Options:
+  Testbed sources: 
+    --db, --database TEXT  Database of device. Only needed if not current
+                           default.  [env var: IOTTB_DB]
+    --app TEXT             Companion app being used during capture
+  Runtime behaviour: 
+    --unsafe               Disable checks for otherwise required options.
+                           [env var: IOTTB_UNSAFE]
+    --guided               [env var: IOTTB_GUIDED]
+    --pre PATH             Script to be executed before main commandis
+                           started.
+  Tcpdump options: 
+    -i, --interface TEXT   Network interface to capture on.If not specified
+                           tcpdump tries to find and appropriate one.  [env
+                           var: IOTTB_CAPTURE_INTERFACE]
+    -a, --address TEXT     IP or MAC address to filter packets by.  [env var:
+                           IOTTB_CAPTURE_ADDRESS]
+    -I, --monitor-mode     Put interface into monitor mode.
+    --ff TEXT              tcpdump filter as string or file path.  [env var:
+                           IOTTB_CAPTURE_FILTER]
+    -#, --print-pacno      Print packet number at beginning of line. True by
+                           default.
+    -e, --print-ll         Print link layer headers. True by default.
+    -c, --count INTEGER    Number of packets to capture.
+  --help                   Show this message and exit.
+
+
+Command: show-all
+ Usage:  [OPTIONS]
+
+  Show everything: configuration, databases, and device metadata
+
+Options:
+  --help  Show this message and exit.
+
+

code/iottb-project/iottb/__init__.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+
+from iottb import definitions
+import logging
+from iottb.utils.user_interaction import tb_echo
+import click
+
+click.echo = tb_echo  # This is very hacky
+logging.basicConfig(level=definitions.LOGLEVEL)
+log_dir = definitions.LOGDIR
+# Ensure logs dir exists before new handlers are registered in main.py
+if not log_dir.is_dir():
+    log_dir.mkdir()
+
+DOCS_FOLDER = Path.cwd() / 'docs'
+

code/iottb-project/iottb/commands/add_device.py

@@ -0,0 +1,199 @@
+import json
+import sys
+
+import click
+from pathlib import Path
+import logging
+import re
+
+from iottb import definitions
+from iottb.models.device_metadata import DeviceMetadata
+from iottb.models.iottb_config import IottbConfig
+from iottb.definitions import CFG_FILE_PATH, TB_ECHO_STYLES
+
+logger = logging.getLogger(__name__)
+
+
+def prompt_for_device_details():
+    device_details = {}
+    aliases = []
+    while True:
+        click.echo("\nEnter the details for the new device:")
+        click.echo("1. Device Name")
+        click.echo("2. Description")
+        click.echo("3. Model")
+        click.echo("4. Manufacturer")
+        click.echo("5. Current Firmware Version")
+        click.echo("6. Device Type")
+        click.echo("7. Supported Interfaces")
+        click.echo("8. Companion Applications")
+        click.echo("9. Add Alias")
+        click.echo("10. Finish and Save")
+
+        choice = click.prompt("Choose an option", type=int)
+
+        if choice == 1:
+            device_details['device_name'] = click.prompt("Enter the device name")
+        elif choice == 2:
+            device_details['description'] = click.prompt("Enter the description")
+        elif choice == 3:
+            device_details['model'] = click.prompt("Enter the model")
+        elif choice == 4:
+            device_details['manufacturer'] = click.prompt("Enter the manufacturer")
+        elif choice == 5:
+            device_details['firmware_version'] = click.prompt("Enter the current firmware version")
+        elif choice == 6:
+            device_details['device_type'] = click.prompt("Enter the device type")
+        elif choice == 7:
+            device_details['supported_interfaces'] = click.prompt("Enter the supported interfaces")
+        elif choice == 8:
+            device_details['companion_applications'] = click.prompt("Enter the companion applications")
+        elif choice == 9:
+            alias = click.prompt("Enter an alias")
+            aliases.append(alias)
+        elif choice == 10:
+            break
+        else:
+            click.echo("Invalid choice. Please try again.")
+
+    device_details['aliases'] = aliases
+    return device_details
+
+
+def confirm_and_add_device(device_details, db_path):
+    click.echo("\nDevice metadata:")
+    for key, value in device_details.items():
+        click.echo(f"{key.replace('_', ' ').title()}: {value}")
+
+    confirm = click.confirm("Do you want to add this device with above metadata?")
+    if confirm:
+        device_name = device_details.get('device_name')
+        if not device_name:
+            click.echo("Device name is required. Exiting...")
+            return
+
+        device_metadata = DeviceMetadata(**device_details)
+        device_dir = db_path / device_metadata.canonical_name
+
+        if device_dir.exists():
+            click.echo(f"Device {device_name} already exists in the database.")
+            click.echo("Exiting...")
+            return
+
+        try:
+            device_dir.mkdir(parents=True, exist_ok=True)
+            metadata_path = device_dir / definitions.DEVICE_METADATA_FILE_NAME
+            device_metadata.save_metadata_to_file(metadata_path)
+            click.echo(f"Successfully added device {device_name} to database.")
+        except OSError as e:
+            click.echo(f"Error trying to create device directory: {e}")
+            click.echo("Exiting...")
+    else:
+        click.echo("Operation cancelled. Exiting...")
+
+
+def add_device_guided(cfg, db):
+    logger.info('Adding device interactively')
+    # logger.debug(f'Parameters: {params}. value: {value}')
+    databases = cfg.db_path_dict
+    if not databases:
+        click.echo('No databases found in config file.')
+        return
+    click.echo('Available Databases:')
+    last = 0
+    for i, db_name in enumerate(databases.keys(), start=1):
+        click.echo(f'[{i}] {db_name}')
+        last = i if last < i else last
+    db_choice = click.prompt('Select the database to add the new device to  (1 - {last}, 0 to quit)',
+                             type=int, default=1)
+    if 1 <= db_choice <= last:
+        selected_db = list(databases.keys())[db_choice - 1]
+        click.confirm(f'Use {selected_db}?', abort=True)
+        db_path = Path(databases[selected_db]) / selected_db
+        logger.debug(f'DB Path {str(db_path)}')
+        device_details = prompt_for_device_details()
+        confirm_and_add_device(device_details, db_path)
+    elif db_choice == 0:
+        click.echo(f'Quitting...')
+    else:
+        click.echo(f'{db_choice} is not a valid choice. Please rerun command and select a valid database.')
+
+
+@click.command('add-device', help='Add a device to a database')
+@click.argument('device', type=str, default="")
+@click.option('--db', '--database', type=str,
+              envvar='IOTTB_DB', show_envvar=True, default="",
+              help='Database in which to add this device. If not specified use default from config.')
+@click.option('--guided', is_flag=True,
+              help='Add device interactively')
+def add_device(device, db, guided):
+    """Add a new device to a database
+
+        Device name must be supplied unless in an interactive setup. 
+        Database is taken from config by default.
+        If this device name contains spaces or other special characters normalization is performed to derive a canonical name.
+    """
+    logger.info('add-device invoked')
+
+    # Step 1: Load Config
+    # Dependency: Config file must exist
+    config = IottbConfig(Path(CFG_FILE_PATH))
+    logger.debug(f'Config loaded: {config}')
+    # If guided flag set, continue with guided add and leave
+    if guided:
+        click.echo('Guided option set. Continuing with guided add.')
+        add_device_guided(config, device, db)
+        logger.info('Finished guided device add.')
+        return
+
+    # Step 2: Load database
+    # dependency: Database folder must exist
+    if db != "":
+        database = db
+        path = config.db_path_dict[database]
+        logger.debug(f'Resolved (path, db) {path}, {database}')
+    else:
+        path = config.default_db_location
+        database = config.default_database
+        logger.debug(f'Default (path, db) {path}, {database}')
+    click.secho(f'Using database {database}')
+    full_db_path = Path(path) / database
+    if not full_db_path.is_dir():
+        logger.warning(f'No database at {database}')
+        click.echo(f'No database found at {full_db_path}', lvl='w')
+        click.echo(
+            f'You need to initialize the testbed before before you add devices!')
+        click.echo(
+            f'To initialize the testbed in the default location run "iottb init-db"')
+        click.echo('Exiting...')
+        sys.exit()
+    # Ensure a device name was passed as argument
+    if device == "":
+        click.echo("Device name cannot be an empty string. Exiting...", lvl='w')
+        return
+
+    # Step 3: Check if device already exists in database
+    # dependency: DeviceMetadata object
+    device_metadata = DeviceMetadata(device_name=device)
+    device_dir = full_db_path / device_metadata.canonical_name
+
+    # Check if device is already registered
+    if device_dir.exists():
+        logger.warning(f'Device directory {device_dir} already exists.')
+        click.echo(f'Device {device} already exists in the database.')
+        click.echo('Exiting...')
+        sys.exit()
+    try:
+        device_dir.mkdir()
+    except OSError as e:
+        logger.error(f'Error trying to create device {e}')
+        click.echo('Exiting...')
+        sys.exit()
+
+    # Step 4: Save metadata into device_dir
+    metadata_path = device_dir / definitions.DEVICE_METADATA_FILE_NAME
+    with metadata_path.open('w') as metadata_file:
+        json.dump(device_metadata.__dict__, metadata_file, indent=4)
+    click.echo(f'Successfully added device {device} to database')
+    logger.debug(f'Added device {device} to database {database}. Full path of metadata {metadata_path}')
+    logger.info(f'Metadata for {device} {device_metadata.print_attributes()}')

code/iottb-project/iottb/commands/developer.py

@@ -0,0 +1,130 @@
+from pathlib import Path
+import logging
+import click
+
+from iottb import tb_echo
+from iottb.definitions import DB_NAME, CFG_FILE_PATH
+from iottb.models.iottb_config import IottbConfig
+
+logger = logging.getLogger(__name__)
+
+
+@click.group('util')
+def tb():
+    pass
+
+
+@click.command()
+@click.option('--file', default=DB_NAME)
+@click.option('--table', type=str, default='DefaultDatabase')
+@click.option('--key')
+@click.option('--value')
+@click.pass_context
+def set_key_in_table_to(ctx, file, table, key, value):
+    """Edit config or metadata files. TODO: Implement"""
+    click.echo(f'set_key_in_table_to invoked')
+    logger.warning("Unimplemented subcommand invoked.")
+
+
+@click.command()
+@click.confirmation_option(prompt="Are you certain that you want to delete the cfg file?")
+def rm_cfg():
+    """ Removes the cfg file from the filesystem.
+
+        This is mostly a utility during development. Once non-standard database locations are implemented,
+        deleting this would lead to iottb not being able to find them anymore.
+    """
+    Path(CFG_FILE_PATH).unlink()
+    click.echo(f'Iottb configuration removed at {CFG_FILE_PATH}')
+
+
+@click.command()
+@click.confirmation_option(prompt="Are you certain that you want to delete the databases file?")
+def rm_dbs(dbs):
+    """ Removes ALL(!) databases from the filesystem if they're empty.
+
+        Development utility currently unfit for use.
+    """
+    config = IottbConfig()
+    paths = config.get_know_database_paths()
+    logger.debug(f'Known db paths: {str(paths)}')
+    for dbs in paths:
+        try:
+            Path(dbs).rmdir()
+            click.echo(f'{dbs} deleted')
+        except Exception as e:
+            logger.debug(f'Failed unlinking db {dbs} with error {e}')
+    logger.info(f'All databases deleted')
+
+
+@click.command('show-cfg', help='Show the current configuration context')
+@click.option('--cfg-file', type=click.Path(), default=CFG_FILE_PATH, help='Path to the config file')
+@click.option('-pp', is_flag=True, default=False, help='Pretty Print')
+@click.pass_context
+def show_cfg(ctx, cfg_file, pp):
+    logger.debug(f'Pretty print option set to {pp}')
+    if pp:
+        try:
+            config = IottbConfig(Path(cfg_file))
+            click.echo("Configuration Context:")
+            click.echo(f"Default Database: {config.default_database}")
+            click.echo(f"Default Database Path: {config.default_db_location}")
+            click.echo("Database Locations:")
+            for db_name, db_path in config.db_path_dict.items():
+                click.echo(f"  - {db_name}: {db_path}")
+        except Exception as e:
+            logger.error(f"Error loading configuration: {e}")
+            click.echo(f"Failed to load configuration from {cfg_file}")
+    else:
+        path = Path(cfg_file)
+
+        if path.is_file():
+            with path.open('r') as file:
+                content = file.read()
+                click.echo(content)
+        else:
+            click.echo(f"Configuration file not found at {cfg_file}")
+
+
+@click.command('show-all', help='Show everything: configuration, databases, and device metadata')
+@click.pass_context
+def show_everything(ctx):
+    """Show everything that can be recursively found based on config except file contents."""
+    config = ctx.obj['CONFIG']
+    click.echo("Configuration Context:")
+    click.echo(f"Default Database: {config.default_database}")
+    click.echo(f"Default Database Path: {config.default_db_location}")
+    click.echo("Database Locations:")
+    everything_dict = {}
+    for db_name, db_path in config.db_path_dict.items():
+
+        click.echo(f"  - {db_name}: {db_path}")
+    for db_name, db_path in config.db_path_dict.items():
+        full_db_path = Path(db_path) / db_name
+        if full_db_path.is_dir():
+            click.echo(f"\nContents of {full_db_path}:")
+            flag = True
+            for item in full_db_path.iterdir():
+                flag = False
+                if item.is_file():
+                    click.echo(f"    - {item.name}")
+                    try:
+                        with item.open('r', encoding='utf-8') as file:
+                            content = file.read()
+                            click.echo(f"      Content:\n{content}")
+                    except UnicodeDecodeError:
+                        click.echo("      Content is not readable as text")
+                elif item.is_dir():
+                    click.echo(f"    - {item.name}/")
+                    for subitem in item.iterdir():
+                        if subitem.is_file():
+                            click.echo(f"      - {subitem.name}")
+                        elif subitem.is_dir():
+                            click.echo(f"      - {subitem.name}/")
+            if flag:
+                tb_echo(f'\t EMPTY')
+        else:
+            click.echo(f"{full_db_path} is not a directory")
+
+
+

code/iottb-project/iottb/commands/sniff.py

@@ -0,0 +1,347 @@
+import json
+import logging
+import os
+import re
+import subprocess
+import sys
+import uuid
+from datetime import datetime
+from pathlib import Path
+from time import time
+
+import click
+from click_option_group import optgroup
+
+from iottb.utils.string_processing import make_canonical_name
+
+# Setup logger
+logger = logging.getLogger('iottb.sniff')
+
+
+def is_ip_address(address):
+    ip_pattern = re.compile(r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$")
+    return ip_pattern.match(address) is not None
+
+
+def is_mac_address(address):
+    mac_pattern = re.compile(r"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$")
+    return mac_pattern.match(address) is not None
+
+
+def load_config(cfg_file):
+    """Loads configuration from the given file path."""
+    with open(cfg_file, 'r') as config_file:
+        return json.load(config_file)
+
+
+def validate_sniff(ctx, param, value):
+    logger.info('Validating sniff...')
+    if ctx.params.get('unsafe') and not value:
+        return None
+    if not ctx.params.get('unsafe') and not value:
+        raise click.BadParameter('Address is required unless --unsafe is set.')
+    if not is_ip_address(value) and not is_mac_address(value):
+        raise click.BadParameter('Address must be a valid IP address or MAC address.')
+    return value
+
+
+def run_pre(pre):
+    subprocess.run(pre, shell=True)
+    logger.debug(f'finnished {pre}')
+
+
+def run_post(post):
+    subprocess.run(post, shell=True)
+    logger.debug(f'finnished {post}')
+
+
+@click.command('sniff', help='Sniff packets with tcpdump')
+@optgroup.group('Testbed sources')
+@optgroup.option('--db', '--database', type=str, envvar='IOTTB_DB', show_envvar=True,
+                 help='Database of device. Only needed if not current default.')
+@optgroup.option('--app', type=str, help='Companion app being used during capture', required=False)
+@optgroup.group('Runtime behaviour')
+@optgroup.option('--unsafe', is_flag=True, default=False, envvar='IOTTB_UNSAFE', is_eager=True,
+                 help='Disable checks for otherwise required options.\n', show_envvar=True)
+@optgroup.option('--guided', is_flag=True, default=False, envvar='IOTTB_GUIDED', show_envvar=True)
+@optgroup.option('--pre', help='Script to be executed before main  command is started.')
+@optgroup.option('--post',  help='Script to be executed upon completion of main  command.')
+@optgroup.group('Tcpdump options')
+@optgroup.option('-i', '--interface',
+                 help='Network interface to capture on.' +
+                      'If not specified tcpdump tries to find and appropriate one.\n', show_envvar=True,
+                 envvar='IOTTB_CAPTURE_INTERFACE')
+@optgroup.option('-a', '--address', callback=validate_sniff,
+                 help='IP or MAC address to filter packets by.\n', show_envvar=True,
+                 envvar='IOTTB_CAPTURE_ADDRESS')
+@optgroup.option('-I', '--monitor-mode', help='Put interface into monitor mode.\n', is_flag=True)
+@optgroup.option('--ff', type=str, envvar='IOTTB_CAPTURE_FILTER', show_envvar=True,
+                 help='tcpdump filter as string or file path.')
+@optgroup.option('-#', '--print-pacno', is_flag=True, default=True,
+                 help='Print packet number at beginning of line. True by default.\n')
+@optgroup.option('-e', '--print-ll', is_flag=True, default=False,
+                 help='Print link layer headers. True by default.')
+@optgroup.option('-c', '--count', type=int, help='Number of packets to capture.', default=1000)
+# @optgroup.option('--mins', type=int, help='Time in minutes to capture.', default=1)
+@click.argument('tcpdump-args', nargs=-1, required=False, metavar='[TCPDUMP-ARGS]')
+@click.argument('device', required=False)
+@click.pass_context
+def sniff(ctx, device, interface, print_pacno, ff, count, monitor_mode, print_ll, address, db, unsafe, guided,
+          app, tcpdump_args, pre, post, **params):
+    """ Sniff packets from a device """
+    logger.info('sniff command invoked')
+    # Step 0: run pre script:
+    if pre:
+        click.echo(f'Running pre command {pre}')
+        run_pre(pre)
+    # Step1: Load Config
+    config = ctx.obj['CONFIG']
+    logger.debug(f'Config loaded: {config}')
+
+    # Step2: determine relevant database
+    database = db if db else config.default_database
+    path = config.db_path_dict[database]
+    full_db_path = Path(path) / database
+    logger.debug(f'Full db path is {str(full_db_path)}')
+
+    # 2.2: Check if it exists
+    if not full_db_path.is_dir():
+        logger.error('DB unexpectedly missing')
+        click.echo('DB unexpectedly missing')
+        return
+
+    canonical_name, aliases = make_canonical_name(device)
+    click.echo(f'Using canonical device name {canonical_name}')
+    device_path = full_db_path / canonical_name
+
+    # Step 3: now the device
+    if not device_path.exists():
+        if not unsafe:
+            logger.error(f'Device path {device_path} does not exist')
+            click.echo(f'Device path {device_path} does not exist')
+            return
+        else:
+            device_path.mkdir(parents=True, exist_ok=True)
+            logger.info(f'Device path {device_path} created')
+
+    click.echo(f'Found device at path {device_path}')
+    # Step 4: Generate filter
+    generic_filter = None
+    cap_filter = None
+    if ff:
+        logger.debug(f'ff: {ff}')
+        if Path(ff).is_file():
+            logger.info('Given filter option is a file')
+            with open(ff, 'r') as f:
+                cap_filter = f.read().strip()
+        else:
+            logger.info('Given filter option is an expression')
+            cap_filter = ff
+    else:
+        if address is not None:
+            if is_ip_address(address):
+                generic_filter = 'net'
+                cap_filter = f'{generic_filter} {address}'
+            elif is_mac_address(address):
+                generic_filter = 'ether net'
+                cap_filter = f'{generic_filter} {address}'
+            elif not unsafe:
+                logger.error('Invalid address format')
+                click.echo('Invalid address format')
+                return
+
+    logger.info(f'Generic filter {generic_filter}')
+    click.echo(f'Using filter {cap_filter}')
+
+    # Step 5: prep capture directory
+    capture_date = datetime.now().strftime('%Y-%m-%d')
+    capture_base_dir = device_path / f'sniffs/{capture_date}'
+    capture_base_dir.mkdir(parents=True, exist_ok=True)
+
+    logger.debug(f'Previous captures {capture_base_dir.glob('cap*')}')
+    capture_count = sum(1 for _ in capture_base_dir.glob('cap*'))
+    logger.debug(f'Capture count is {capture_count}')
+
+    capture_dir = f'cap{capture_count:04d}-{datetime.now().strftime('%H%M')}'
+    logger.debug(f'capture_dir: {capture_dir}')
+
+    # Full path
+    capture_dir_full_path = capture_base_dir / capture_dir
+    capture_dir_full_path.mkdir(parents=True, exist_ok=True)
+
+    click.echo(f'Files will be placed in {str(capture_dir_full_path)}')
+    logger.debug(f'successfully created capture directory')
+
+    # Step 6: Prepare capture file names
+    # Generate UUID for filenames
+    capture_uuid = str(uuid.uuid4())
+    click.echo(f'Capture has id {capture_uuid}')
+
+    pcap_file = f"{canonical_name}_{capture_uuid}.pcap"
+    pcap_file_full_path = capture_dir_full_path / pcap_file
+    stdout_log_file = f'stdout_{capture_uuid}.log'
+    stderr_log_file = f'stderr_{capture_uuid}.log'
+
+    logger.debug(f'Full pcap file path is {pcap_file_full_path}')
+    logger.info(f'pcap file name is {pcap_file}')
+    logger.info(f'stdout log file is {stdout_log_file}')
+    logger.info(f'stderr log file is {stderr_log_file}')
+
+    # Step 7: Build tcpdump command
+    logger.debug(f'pgid {os.getpgrp()}')
+    logger.debug(f'ppid {os.getppid()}')
+    logger.debug(f'(real, effective, saved) user id: {os.getresuid()}')
+    logger.debug(f'(real, effective, saved) group id: {os.getresgid()}')
+
+    cmd = ['sudo', 'tcpdump']
+
+    # 7.1 process flags
+    flags = []
+    if print_pacno:
+        flags.append('-#')
+    if print_ll:
+        flags.append('-e')
+    if monitor_mode:
+        flags.append('-I')
+    flags.append('-n')  # TODO: Integrate, in case name resolution is wanted!
+    cmd.extend(flags)
+    flags_string = " ".join(flags)
+    logger.debug(f'Flags: {flags_string}')
+
+    # debug interlude
+    verbosity = ctx.obj['VERBOSITY']
+    if verbosity > 0:
+        verbosity_flag = '-'
+        for i in range(0, verbosity):
+            verbosity_flag = verbosity_flag + 'v'
+        logger.debug(f'verbosity string to pass to tcpdump: {verbosity_flag}')
+        cmd.append(verbosity_flag)
+
+    # 7.2 generic (i.e. reusable) kw args
+    generic_kw_args = []
+    if count:
+        generic_kw_args.extend(['-c', str(count)])
+    # if mins:
+    #     generic_kw_args.extend(['-G', str(mins * 60)]) TODO: this currently loads to errors with sudo
+    cmd.extend(generic_kw_args)
+    generic_kw_args_string = " ".join(generic_kw_args)
+    logger.debug(f'KW args: {generic_kw_args_string}')
+
+    # 7.3 special kw args (not a priori reusable)
+    non_generic_kw_args = []
+    if interface:
+        non_generic_kw_args.extend(['-i', interface])
+    non_generic_kw_args.extend(['-w', str(pcap_file_full_path)])
+    cmd.extend(non_generic_kw_args)
+    non_generic_kw_args_string = " ".join(non_generic_kw_args)
+    logger.debug(f'Non transferable (special) kw args: {non_generic_kw_args_string}')
+
+    # 7.4 add filter expression
+    if cap_filter:
+        logger.debug(f'cap_filter (not generic): {cap_filter}')
+        cmd.append(cap_filter)
+
+    full_cmd_string = " ".join(cmd)
+
+    logger.info(f'tcpdump command: {"".join(full_cmd_string)}')
+    click.echo('Capture setup complete!')
+    # Step 8: Execute tcpdump command
+    start_time = datetime.now().strftime("%H:%M:%S")
+    start = time()
+    try:
+        if guided:
+            click.confirm(f'Execute following command: {full_cmd_string}')
+        stdout_log_file_abs_path = capture_dir_full_path / stdout_log_file
+        stderr_log_file_abs_path = capture_dir_full_path / stderr_log_file
+        stdout_log_file_abs_path.touch(mode=0o777)
+        stderr_log_file_abs_path.touch(mode=0o777)
+        with open(stdout_log_file_abs_path, 'w') as out, open(stderr_log_file_abs_path, 'w') as err:
+            logger.debug(f'\nstdout: {out}.\nstderr: {err}.\n')
+
+            tcp_complete = subprocess.run(cmd, check=True, capture_output=True, text=True)
+
+            out.write(tcp_complete.stdout)
+            err.write(tcp_complete.stderr)
+
+            # click.echo(f'Mock sniff execution')
+        click.echo(f"Capture complete. Saved to {pcap_file}")
+    except subprocess.CalledProcessError as e:
+        logger.error(f'Failed to capture packets: {e}')
+        click.echo(f'Failed to capture packets: {e}')
+        click.echo(f'Check {stderr_log_file} for more info.')
+        if ctx.obj['DEBUG']:
+            msg = [f'STDERR log {stderr_log_file} contents:\n']
+            with open(capture_dir_full_path / stderr_log_file) as log:
+                for line in log:
+                    msg.append(line)
+
+            click.echo("\t".join(msg), lvl='e')
+            # print('DEBUG ACTIVE')
+        if guided:
+            click.prompt('Create metadata anyway?')
+        else:
+            click.echo('Aborting capture...')
+            sys.exit()
+    end_time = datetime.now().strftime("%H:%M:%S")
+    end = time()
+    delta = end - start
+
+
+    click.echo(f'tcpdump took {delta:.2f} seconds.')
+    # Step 9: Register metadata
+    metadata = {
+        'device': canonical_name,
+        'device_id': device,
+        'capture_id': capture_uuid,
+        'capture_date_iso': datetime.now().isoformat(),
+        'invoked_command': " ".join(map(str, cmd)),
+        'capture_duration': delta,
+        'generic_parameters': {
+            'flags': flags_string,
+            'kwargs': generic_kw_args_string,
+            'filter': generic_filter
+        },
+        'non_generic_parameters': {
+            'kwargs': non_generic_kw_args_string,
+            'filter': cap_filter
+        },
+        'features': {
+            'interface': interface,
+            'address': address
+        },
+        'resources': {
+            'pcap_file': str(pcap_file),
+            'stdout_log': str(stdout_log_file),
+            'stderr_log': str(stderr_log_file),
+            'pre': str(pre),
+            'post': str(post)
+        },
+        'environment': {
+            'capture_dir': capture_dir,
+            'database': database,
+            'capture_base_dir': str(capture_base_dir),
+            'capture_dir_abs_path': str(capture_dir_full_path)
+        }
+    }
+
+    click.echo('Ensuring correct ownership of created files.')
+    username = os.getlogin()
+    gid = os.getgid()
+
+    # Else there are issues when running with sudo:
+    try:
+        subprocess.run(f'sudo chown -R {username}:{username} {device_path}', shell=True)
+    except OSError as e:
+        click.echo(f'Some error {e}')
+
+    click.echo(f'Saving metadata.')
+    metadata_abs_path = capture_dir_full_path / 'capture_metadata.json'
+    with open(metadata_abs_path, 'w') as f:
+        json.dump(metadata, f, indent=4)
+
+    click.echo(f'END  SNIFF SUBCOMMAND')
+    if post:
+        click.echo(f'Running post script {post}')
+        run_post(post)
+
+

code/iottb-project/iottb/commands/testbed.py

@@ -0,0 +1,70 @@
+import click
+from pathlib import Path
+import logging
+from logging.handlers import RotatingFileHandler
+import sys
+from iottb.models.iottb_config import IottbConfig
+from iottb.definitions import DB_NAME, CFG_FILE_PATH
+
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.option('-d', '--dest', type=click.Path(exists=True, file_okay=False, dir_okay=True),
+              help='Location to put (new) iottb database')
+@click.option('-n', '--name', default=DB_NAME, type=str,
+              help='Name of new database.')
+@click.option('--update-default/--no-update-default', default=True,
+              help='If new db should be set as the new default')
+@click.pass_context
+def init_db(ctx, dest, name, update_default):
+    logger.info('init-db invoked')
+    config = ctx.obj['CONFIG']
+    logger.debug(f'str(config)')
+    # Use the default path from config if dest is not provided
+    known_dbs = config.get_known_databases()
+    logger.debug(f'Known databases: {known_dbs}')
+    if name in known_dbs:
+        dest = config.get_database_location(name)
+        if Path(dest).joinpath(name).is_dir():
+            click.echo(f'A database {name} already exists.')
+            logger.debug(f'DB {name} exists in {dest}')
+            click.echo(f'Exiting...')
+            sys.exit()
+        logger.debug(f'DB name {name} registered but does not exist.')
+    if not dest:
+        logger.info('No dest set, choosing default destination.')
+        dest = Path(config.default_db_location)
+
+    db_path = Path(dest).joinpath(name)
+    logger.debug(f'Full path for db {str(db_path)}')
+    # Create the directory if it doesn't exist
+    db_path.mkdir(parents=True, exist_ok=True)
+    logger.info(f"mkdir {db_path} successful")
+    click.echo(f'Created {db_path}')
+
+    # Update configuration
+    config.set_database_location(name, str(dest))
+    if update_default:
+        config.set_default_database(name, str(dest))
+    config.save_config()
+    logger.info(f"Updated configuration with database {name} at {db_path}")
+
+
+# @click.group('config')
+# @click.pass_context
+# def cfg(ctx):
+#     pass
+#
+# @click.command('set', help='Set the location of a database.')
+# @click.argument('database', help='Name of database')
+# @click.argument('location', help='Where the database is located (i.e. its parent directory)')
+# @click.pass_context
+# def set(ctx, key, value):
+#     click.echo(f'Setting {key} to {value} in config')
+#     config = ctx.obj['CONFIG']
+#     logger.warning('No checks performed!')
+#     config.set_database_location(key, value)
+#     config.save_config()
+
+

code/iottb-project/iottb/definitions.py

@@ -0,0 +1,48 @@
+import logging
+from pathlib import Path
+
+import click
+
+APP_NAME = 'iottb'
+DB_NAME = 'iottb.db'
+CFG_FILE_PATH = str(Path(click.get_app_dir(APP_NAME)).joinpath('iottb.cfg'))
+CONSOLE_LOG_FORMATS = {
+    0: '%(levelname)s - %(message)s',
+    1: '%(levelname)s - %(module)s - %(message)s',
+    2: '%(levelname)s - %(module)s - %(funcName)s - %(lineno)d - %(message)s'
+}
+
+LOGFILE_LOG_FORMAT = {
+    0: '%(levelname)s - %(asctime)s - %(module)s  - %(message)s',
+    1: '%(levelname)s - %(asctime)s - %(module)s - %(funcName)s - %(message)s',
+    2: '%(levelname)s - %(asctime)s - %(module)s - %(funcName)s - %(lineno)d - %(message)s'
+}
+MAX_VERBOSITY = len(CONSOLE_LOG_FORMATS) - 1
+assert len(LOGFILE_LOG_FORMAT) == len(CONSOLE_LOG_FORMATS), 'Log formats must be same size'
+
+LOGLEVEL = logging.DEBUG
+LOGDIR = Path.cwd() / 'logs'
+
+# Characters to just replace
+REPLACEMENT_SET_CANONICAL_DEVICE_NAMES = {' ', '_', ',', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '+', '=',
+                                          '{', '}', '[', ']',
+                                          '|',
+                                          '\\', ':', ';', '"', "'", '<', '>', '?', '/', '`', '~'}
+# Characters to possibly error on
+ERROR_SET_CANONICAL_DEVICE_NAMES = {',', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '+', '=', '{', '}', '[', ']',
+                                    '|',
+                                    '\\', ':', ';', '"', "'", '<', '>', '?', '/', '`', '~'}
+
+DEVICE_METADATA_FILE_NAME = 'device_metadata.json'
+
+TB_ECHO_STYLES = {
+    'w': {'fg': 'yellow', 'bold': True},
+    'i': {'fg': 'blue', 'italic': True},
+    's': {'fg': 'green', 'bold': True},
+    'e': {'fg': 'red', 'bold': True},
+    'header': {'fg': 'bright_cyan', 'bold': True, 'italic': True}
+}
+
+NAME_OF_CAPTURE_DIR = 'sniffs'
+
+

code/iottb-project/iottb/main.py

@@ -0,0 +1,77 @@
+import sys
+
+import click
+from pathlib import Path
+import logging
+
+from iottb.commands.sniff import sniff
+from iottb.commands.developer import set_key_in_table_to, rm_cfg, rm_dbs, show_cfg, show_everything
+
+##################################################
+# Import package modules
+#################################################
+from iottb.utils.logger_config import setup_logging
+from iottb import definitions
+from iottb.models.iottb_config import IottbConfig
+from iottb.commands.testbed import init_db
+from iottb.commands.add_device import add_device
+
+############################################################################
+# Module shortcuts for global definitions
+###########################################################################
+APP_NAME = definitions.APP_NAME
+DB_NAME = definitions.DB_NAME
+CFG_FILE_PATH = definitions.CFG_FILE_PATH
+# These are (possibly) redundant when defined in definitions.py
+# keeping them here until refactored and tested
+MAX_VERBOSITY = definitions.MAX_VERBOSITY
+
+# Logger stuff
+loglevel = definitions.LOGLEVEL
+logger = logging.getLogger(__name__)
+
+
+@click.group(context_settings=dict(auto_envvar_prefix='IOTTB', show_default=True))
+@click.option('-v', '--verbosity', count=True, type=click.IntRange(0, 3), default=0, is_eager=True,
+              help='Set verbosity')
+@click.option('-d', '--debug', is_flag=True, default=False, is_eager=True,
+              help='Enable debug mode')
+@click.option('--dry-run', is_flag=False, default=True, is_eager=True, help='NOT USED!')
+@click.option('--cfg-file', type=click.Path(),
+              default=Path(click.get_app_dir(APP_NAME)).joinpath('iottb.cfg'),
+              envvar='IOTTB_CONF_HOME', help='Path to iottb config file')
+@click.pass_context
+def cli(ctx, verbosity, debug, dry_run, cfg_file):
+    # Setup logging based on the loaded configuration and other options
+    setup_logging(verbosity, debug)
+    ctx.ensure_object(dict)  # Make sure context is ready for use
+    logger.info("Starting execution.")
+    ctx.obj['CONFIG'] = IottbConfig(cfg_file)  # Load configuration directly
+    ctx.meta['FULL_PATH_CONFIG_FILE'] = str(cfg_file)
+    ctx.meta['DRY_RUN'] = dry_run
+    logger.debug(f'Verbosity: {verbosity}')
+    ctx.obj['VERBOSITY'] = verbosity
+    logger.debug(f'Debug: {debug}')
+    ctx.obj['DEBUG'] = debug
+
+
+##################################################################################
+# Add all subcommands to group here
+#################################################################################
+# TODO: Is there a way to do this without pylint freaking out?
+# noinspection PyTypeChecker
+cli.add_command(init_db)
+cli.add_command(rm_cfg)
+cli.add_command(set_key_in_table_to)
+cli.add_command(rm_dbs)
+# noinspection PyTypeChecker
+cli.add_command(add_device)
+cli.add_command(show_cfg)
+cli.add_command(sniff)
+cli.add_command(show_everything)
+
+
+if __name__ == '__main__':
+    cli()
+    for log in Path.cwd().iterdir():
+        log.chmod(0o777)

code/iottb-project/iottb/models/database.py

@@ -0,0 +1,6 @@
+class Database:
+
+    def __init__(self, name, path):
+        self.name = name
+        self.path = path
+        self.device_list = [] # List of the canonical names of devices registered in this database

code/iottb-project/iottb/models/device_metadata.py

@@ -0,0 +1,50 @@
+import json
+import logging
+import uuid
+from datetime import datetime
+import logging
+import click
+
+from iottb.utils.string_processing import make_canonical_name
+
+logger = logging.getLogger(__name__)
+
+
+class DeviceMetadata:
+    def __init__(self, device_name, description="", model="", manufacturer="", firmware_version="", device_type="",
+                 supported_interfaces="", companion_applications="", save_to_file=None, aliases=None):
+        self.device_id = str(uuid.uuid4())
+        self.device_name = device_name
+        cn, default_aliases = make_canonical_name(device_name)
+        logger.debug(f'cn, default aliases = {cn}, {str(default_aliases)}')
+        self.aliases = default_aliases if aliases is None else default_aliases + aliases
+        self.canonical_name = cn
+        self.date_added = datetime.now().isoformat()
+        self.description = description
+        self.model = model
+        self.manufacturer = manufacturer
+        self.current_firmware_version = firmware_version
+        self.device_type = device_type
+        self.supported_interfaces = supported_interfaces
+        self.companion_applications = companion_applications
+        self.last_metadata_update = datetime.now().isoformat()
+        if save_to_file is not None:
+            click.echo('TODO: Implement saving config to file after creation!')
+
+    def add_alias(self, alias: str = ""):
+        if alias == "":
+            return
+        self.aliases.append(alias)
+
+    def get_canonical_name(self):
+        return self.canonical_name
+
+    def print_attributes(self):
+        print(f'Printing attribute value pairs in {__name__}')
+        for attr, value in self.__dict__.items():
+            print(f'{attr}: {value}')
+
+    def save_metadata_to_file(self, metadata_path):
+        with open(metadata_path, 'w') as metadata_file:
+            json.dump(self.__dict__, metadata_file, indent=4)
+        click.echo(f'Metadata saved to {metadata_path}')

code/iottb-project/iottb/models/iottb_config.py

@@ -0,0 +1,124 @@
+import json
+from pathlib import Path
+
+from iottb import definitions
+import logging
+
+logger = logging.getLogger(__name__)
+
+DB_NAME = definitions.DB_NAME
+
+
+class IottbConfig:
+    """ Class to handle testbed configuration.
+
+       TODO: Add instead of overwrite Database locations when initializing if a location with valid db
+        exists.
+    """
+
+    @staticmethod
+    def warn():
+        logger.warning(f'DatabaseLocations are DatabaseLocationMap in the class {__name__}')
+
+    def __init__(self, cfg_file=definitions.CFG_FILE_PATH):
+        logger.info('Initializing Config object')
+        IottbConfig.warn()
+        self.cfg_file = Path(cfg_file)
+        self.default_database = None
+        self.default_db_location = None
+        self.db_path_dict = dict()
+        self.load_config()
+
+    def create_default_config(self):
+        """Create default iottb config file."""
+        logger.info(f'Creating default config file at {self.cfg_file}')
+        self.default_database = DB_NAME
+        self.default_db_location = str(Path.home())
+        self.db_path_dict = {
+            DB_NAME: self.default_db_location
+        }
+
+        defaults = {
+            'DefaultDatabase': self.default_database,
+            'DefaultDatabasePath': self.default_db_location,
+            'DatabaseLocations': self.db_path_dict
+        }
+
+        try:
+            self.cfg_file.parent.mkdir(parents=True, exist_ok=True)
+            with self.cfg_file.open('w') as config_file:
+                json.dump(defaults, config_file, indent=4)
+        except IOError as e:
+            logger.error(f"Failed to create default configuration file at {self.cfg_file}: {e}")
+            raise RuntimeError(f"Failed to create configuration file: {e}") from e
+
+    def load_config(self):
+        """Loads or creates default configuration from given file path."""
+        logger.info('Loading configuration file')
+        if not self.cfg_file.is_file():
+            logger.info('Config file does not exist.')
+            self.create_default_config()
+        else:
+            logger.info('Config file exists, opening.')
+            with self.cfg_file.open('r') as config_file:
+                data = json.load(config_file)
+                self.default_database = data.get('DefaultDatabase')
+                self.default_db_location = data.get('DefaultDatabasePath')
+                self.db_path_dict = data.get('DatabaseLocations', {})
+
+    def save_config(self):
+        """Save the current configuration to the config file."""
+        data = {
+            'DefaultDatabase': self.default_database,
+            'DefaultDatabasePath': self.default_db_location,
+            'DatabaseLocations': self.db_path_dict
+        }
+        try:
+            with self.cfg_file.open('w') as config_file:
+                json.dump(data, config_file, indent=4)
+        except IOError as e:
+            logger.error(f"Failed to save configuration file at {self.cfg_file}: {e}")
+            raise RuntimeError(f"Failed to save configuration file: {e}") from e
+
+    def set_default_database(self, name, path):
+        """Set the default database and its path."""
+        self.default_database = name
+        self.default_db_location = path
+        self.db_path_dict[name] = path
+
+    def get_default_database_location(self):
+        return self.default_db_location
+
+    def get_default_database(self):
+        return self.default_database
+
+    def get_database_location(self, name):
+        """Get the location of a specific database."""
+        return self.db_path_dict.get(name)
+
+    def set_database_location(self, name, path):
+        """Set the location for a database."""
+        logger.debug(f'Type of "path" parameter {type(path)}')
+        logger.debug(f'String value of "path" parameter {str(path)}')
+        logger.debug(f'Type of "name" parameter {type(name)}')
+        logger.debug(f'String value of "name" parameter {str(name)}')
+        path = Path(path)
+        name = Path(name)
+        logger.debug(f'path:name = {path}:{name}')
+        if path.name == name:
+            path = path.parent
+        self.db_path_dict[str(name)] = str(path)
+
+    def get_known_databases(self):
+        """Get the set of known databases"""
+        logger.info(f'Getting known databases.')
+
+        return self.db_path_dict.keys()
+
+    def get_know_database_paths(self):
+        """Get the paths of all known databases"""
+        logger.info(f'Getting known database paths.')
+        return self.db_path_dict.values()
+
+    def get_full_default_path(self):
+        return Path(self.default_db_location) / self.default_database

code/iottb-project/iottb/models/sniff_metadata.py

@@ -0,0 +1,39 @@
+import json
+import logging
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+logger = logging.getLogger('iottb.sniff')  # Log with sniff subcommand
+
+class CaptureMetadata:
+    def __init__(self, device_id, capture_dir, interface, address, capture_file, tcpdump_command, tcpdump_stdout, tcpdump_stderr, packet_filter, alias):
+        self.base_data = {
+            'device_id': device_id,
+            'capture_id': str(uuid.uuid4()),
+            'capture_date': datetime.now().isoformat(),
+            'capture_dir': str(capture_dir),
+            'capture_file': capture_file,
+            'start_time': "",
+            'stop_time': "",
+            'alias': alias
+        }
+        self.features = {
+            'interface': interface,
+            'device_ip_address': address if address else "No IP Address set",
+            'tcpdump_stdout': str(tcpdump_stdout),
+            'tcpdump_stderr': str(tcpdump_stderr),
+            'packet_filter': packet_filter
+        }
+        self.command = tcpdump_command
+
+    def save_to_file(self):
+        metadata = {
+            'base_data': self.base_data,
+            'features': self.features,
+            'command': self.command
+        }
+        metadata_file_path = Path(self.base_data['capture_dir']) / 'metadata.json'
+        with open(metadata_file_path, 'w') as f:
+            json.dump(metadata, f, indent=4)
+        logger.info(f'Metadata saved to {metadata_file_path}')

code/iottb-project/iottb/scripts/generate_help.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+
+import click
+from io import StringIO
+import sys
+from iottb import DOCS_FOLDER
+# Import your CLI app here
+from iottb.main import cli
+
+"""Script to generate the help text and write to file.
+
+    Definitely needs better formatting.
+    Script is also not very flexible.
+"""
+
+
+def get_help_text(command):
+    """Get the help text for a given command."""
+    help_text = StringIO()
+    with click.Context(command) as ctx:
+        # chatgpt says this helps: was right
+        sys_stdout = sys.stdout
+        sys.stdout = help_text
+        try:
+            click.echo(command.get_help(ctx))
+        finally:
+            sys.stdout = sys_stdout
+    return help_text.getvalue()
+
+
+def write_help_to_file(cli, filename):
+    """Write help messages of all commands and subcommands to a file."""
+    with open(filename, 'w+') as f:
+        # main
+        f.write(f"Main Command: iottb\n")
+        f.write(get_help_text(cli))
+        f.write("\n\n")
+
+        # go through subcommands
+        for cmd_name, cmd in cli.commands.items():
+            f.write(f"Command: {cmd_name}\n")
+            f.write(get_help_text(cmd))
+            f.write("\n\n")
+
+            # subcommands of subcommands
+            if isinstance(cmd, click.Group):
+                for sub_cmd_name, sub_cmd in cmd.commands.items():
+                    f.write(f"Subcommand: {cmd_name} {sub_cmd_name}\n")
+                    f.write(get_help_text(sub_cmd))
+                    f.write("\n\n")
+
+
+def manual():
+    comands = [
+        'init-db',
+        'add-device',
+        'sniff'
+    ]
+    dev_commands = [
+        'show-all',
+        'rm-dbs',
+        'show-cfg',
+        'show-all'
+    ]
+
+
+if __name__ == "__main__":
+    from iottb import DOCS_FOLDER
+
+    print('Must be in project root for this to work properly!')
+    print(f'CWD is {str(Path.cwd())}')
+    DOCS_FOLDER.mkdir(exist_ok=True)
+    write_help_to_file(cli, str(DOCS_FOLDER / "help_messages.md"))
+    print(f'Wrote help_messages.md to {str(DOCS_FOLDER / "help_messages.md")}')

code/iottb-project/iottb/scripts/sudo_iottb

@@ -0,0 +1,4 @@
+#/bin/sh
+echo 'Running iottb as sudo'
+sudo $(which python) iottb $@
+echo 'Finished executing iottb with sudo'

code/iottb-project/iottb/utils/logger_config.py

@@ -0,0 +1,41 @@
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+
+from iottb import definitions
+from iottb.definitions import MAX_VERBOSITY, CONSOLE_LOG_FORMATS, APP_NAME, LOGFILE_LOG_FORMAT
+
+loglevel = definitions.LOGLEVEL
+
+
+def setup_logging(verbosity, debug=loglevel):
+    """ Setup root logger for iottb """
+    log_level = loglevel
+    handlers = []
+    date_format = '%Y-%m-%d %H:%M:%S'
+    if verbosity > 0:
+        log_level = logging.WARNING
+        if verbosity > MAX_VERBOSITY:
+            verbosity = MAX_VERBOSITY
+            log_level = logging.INFO
+        assert verbosity <= MAX_VERBOSITY, f'Verbosity must be <= {MAX_VERBOSITY}'
+        console_handler = logging.StreamHandler(sys.stdout)
+        print(str(sys.stdout))
+        console_handler.setFormatter(logging.Formatter(CONSOLE_LOG_FORMATS[verbosity], datefmt=date_format))
+        console_handler.setLevel(logging.DEBUG)  # can keep at debug since it depends on global level?
+        handlers.append(console_handler)
+
+    if debug:
+        log_level = logging.DEBUG
+
+    # Logfile logs INFO+, no debugs though
+    file_handler = RotatingFileHandler(f'{str(definitions.LOGDIR / APP_NAME)}.log', maxBytes=10240, backupCount=5)
+    file_handler.setFormatter(logging.Formatter(LOGFILE_LOG_FORMAT[verbosity], datefmt=date_format))
+    file_handler.setLevel(logging.INFO)
+
+    # finnish root logger setup
+    handlers.append(file_handler)
+    # Force this config to be applied to root logger
+    logging.basicConfig(level=log_level, handlers=handlers, force=True)
+
+

code/iottb-project/iottb/utils/string_processing.py

@@ -0,0 +1,40 @@
+import re
+from iottb import definitions
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def normalize_string(s, chars_to_replace=None, replacement=None, allow_unicode=False):
+    pass
+
+
+def make_canonical_name(name):
+    """
+    Normalize the device name to a canonical form:
+    - Replace the first two occurrences of spaces and transform characters with dashes.
+    - Remove any remaining spaces and non-ASCII characters.
+    - Convert to lowercase.
+    """
+    aliases = [name]
+    logger.info(f'Normalizing name {name}')
+
+    # We first normalize
+    chars_to_replace = definitions.REPLACEMENT_SET_CANONICAL_DEVICE_NAMES
+    pattern = re.compile('|'.join(re.escape(char) for char in chars_to_replace))
+    norm_name = pattern.sub('-', name)
+    norm_name = re.sub(r'[^\x00-\x7F]+', '', norm_name) # removes non ascii chars
+
+    aliases.append(norm_name)
+    # Lower case
+    norm_name = norm_name.lower()
+    aliases.append(norm_name)
+
+    # canonical name is only first two parts of resulting string
+    parts = norm_name.split('-')
+    canonical_name = canonical_name = '-'.join(parts[:2])
+    aliases.append(canonical_name)
+    aliases = list(set(aliases))
+    logger.debug(f'Canonical name: {canonical_name}')
+    logger.debug(f'Aliases: {aliases}')
+    return canonical_name, aliases

code/iottb-project/iottb/utils/user_interaction.py

@@ -0,0 +1,42 @@
+# iottb/utils/user_interaction.py
+
+import click
+from iottb.definitions import TB_ECHO_STYLES
+import sys
+import os
+
+
+def tb_echo2(msg: str, lvl='i', log=True):
+    style = TB_ECHO_STYLES.get(lvl, {})
+    click.secho(f'[IOTTB]', **style)
+    click.secho(f'[IOTTB] \t {msg}', **style)
+
+
+last_prefix = None
+
+
+def tb_echo(msg: str, lvl='i', log=True):
+    global last_prefix
+    prefix = f'Testbed [{lvl.upper()}]\n'
+
+    if last_prefix != prefix:
+        click.secho(prefix, nl=False, **TB_ECHO_STYLES['header'])
+        last_prefix = prefix
+
+    click.secho(f' {msg}', **TB_ECHO_STYLES[lvl])
+
+
+def main():
+    tb_echo('Info message', 'i')
+    tb_echo('Warning message', 'w')
+    tb_echo('Error message', 'e')
+    tb_echo('Success message', 's')
+
+
+if __name__ == '__main__':
+    # arrrgggg hacky
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.abspath(os.path.join(current_dir, '../../'))
+    sys.path.insert(0, project_root)
+
+    main()

code/iottb-project/poetry.lock

@@ -0,0 +1,107 @@
+# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
+
+[[package]]
+name = "click"
+version = "8.1.7"
+description = "Composable command line interface toolkit"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
+    {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
+[[package]]
+name = "click-option-group"
+version = "0.5.6"
+description = "Option groups missing in Click"
+optional = false
+python-versions = ">=3.6,<4"
+files = [
+    {file = "click-option-group-0.5.6.tar.gz", hash = "sha256:97d06703873518cc5038509443742b25069a3c7562d1ea72ff08bfadde1ce777"},
+    {file = "click_option_group-0.5.6-py3-none-any.whl", hash = "sha256:38a26d963ee3ad93332ddf782f9259c5bdfe405e73408d943ef5e7d0c3767ec7"},
+]
+
+[package.dependencies]
+Click = ">=7.0,<9"
+
+[package.extras]
+docs = ["Pallets-Sphinx-Themes", "m2r2", "sphinx"]
+tests = ["pytest"]
+tests-cov = ["coverage", "coveralls", "pytest", "pytest-cov"]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+description = "Cross-platform colored terminal text."
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+files = [
+    {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
+    {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.0.0"
+description = "brain-dead simple config-ini parsing"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
+    {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
+]
+
+[[package]]
+name = "packaging"
+version = "24.1"
+description = "Core utilities for Python packages"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"},
+    {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
+]
+
+[[package]]
+name = "pluggy"
+version = "1.5.0"
+description = "plugin and hook calling mechanisms for python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
+    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
+]
+
+[package.extras]
+dev = ["pre-commit", "tox"]
+testing = ["pytest", "pytest-benchmark"]
+
+[[package]]
+name = "pytest"
+version = "8.2.2"
+description = "pytest: simple powerful testing with Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pytest-8.2.2-py3-none-any.whl", hash = "sha256:c434598117762e2bd304e526244f67bf66bbd7b5d6cf22138be51ff661980343"},
+    {file = "pytest-8.2.2.tar.gz", hash = "sha256:de4bb8104e201939ccdc688b27a89a7be2079b22e2bd2b07f806b6ba71117977"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "sys_platform == \"win32\""}
+iniconfig = "*"
+packaging = "*"
+pluggy = ">=1.5,<2.0"
+
+[package.extras]
+dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
+
+[metadata]
+lock-version = "2.0"
+python-versions = "^3.12"
+content-hash = "05aa11a74b8a6411a4413684f1a4cb0e5bcd271e16b4de9ae5205d52232c91a3"

code/iottb-project/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "iottb"
+version = "0.1.0"
+description = "IoT Testbed"
+authors = ["Sebastian Lenzlinger <sebastian.lenzlinger@unibas.ch>"]
+readme = "README.md"
+license = "LICENSE"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+click = "^8.1"
+# scapy = "^2.5"
+click-option-group = "^0.5.6"
+
+[tool.poetry.scripts]
+iottb = "iottb.main:cli"
+
+[tool.poetry.group.test.dependencies]
+pytest = "^8.2.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

code/iottb-project/requirements.txt

@@ -0,0 +1,9 @@
+click-option-group==0.5.6 ; python_version >= "3.12" and python_version < "4" \
+    --hash=sha256:38a26d963ee3ad93332ddf782f9259c5bdfe405e73408d943ef5e7d0c3767ec7 \
+    --hash=sha256:97d06703873518cc5038509443742b25069a3c7562d1ea72ff08bfadde1ce777
+click==8.1.7 ; python_version >= "3.12" and python_version < "4.0" \
+    --hash=sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28 \
+    --hash=sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de
+colorama==0.4.6 ; python_version >= "3.12" and python_version < "4.0" and platform_system == "Windows" \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6

code/iottb-project/tests/test_make_canonical_name.py

@@ -0,0 +1,23 @@
+from iottb.utils.string_processing import make_canonical_name
+
+import pytest
+
+
+class TestMakeCanonicalName:
+
+    def test_normalizes_name_with_spaces_to_dashes(self):
+        name = "Device Name With Spaces"
+        expected_canonical_name = "device-name"
+        canonical_name, aliases = make_canonical_name(name)
+        assert canonical_name == expected_canonical_name
+        assert "device-name-with-spaces" in aliases
+        assert "device-name" in aliases
+        assert "Device Name With Spaces" in aliases
+
+    def test_name_with_no_spaces_or_special_characters(self):
+        name = "DeviceName123"
+        expected_canonical_name = "devicename123"
+        canonical_name, aliases = make_canonical_name(name)
+        assert canonical_name == expected_canonical_name
+        assert "DeviceName123" in aliases
+        assert "devicename123" in aliases

code/iottb/__main__.py

@@ -1,82 +0,0 @@
-#!/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/logger.py

@@ -1,28 +0,0 @@
-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()

notes/journal/2024-05-15-wed.md

@@ -11,4 +11,5 @@ With the above idea it would be possible to also refactor or rewrite how tcpdump
 I want an option such that one can automatically convert a captures resulting file into a csv. Probably will focus on tcpdump for now, since other tools like [[mitmproxy]] have different output files. 
 
 ## Defining Experiment
-I want a pair of commands that 1. provide a guided cli interface to define an experiment and 2. to run that  experiment -> Here [Collective Knowledge Framework](https://github.com/mlcommons/ck) might actually come in handy. The already have tooling for setting up and defining aspects of experiments so that they become reproducible. So maybe one part of the `iottb` as a tool would be to write the correct json files into the directory which contain the informatin on how the command was run. Caveat: All all option values are the same, basically only, if it was used or not (flagging options) or that it was used (e.g. an ip address was used in the filter but the specific value of the ip is of no use for reproducing). Also, Collective Minds tooling relies very common ML algos/framework and static data. So maybe this only comes into play after a capture has been done. So maybe a feature extraction tool (see [[further considerations#Usage paths/ Workflows]]) should create the data and built the database separately.
+I want a pair of commands that 1. provide a guided cli interface to define an experiment and 2. to run that  experiment -> Here [Collective Knowledge Framework](https://github.com/mlcommons/ck) might actually come in handy. The already have tooling for setting up and defining aspects of experiments so that they become reproducible. So maybe one part of the `iottb` as a tool would be to write the correct json files into the directory which contain the informatin on how the command was run. Caveat: All all option values are the same, basically only, if it was used or not (flagging options) or that it was used (e.g. an ip address was used in the filter but the specific value of the ip is of no use for reproducing). Also, Collective Minds tooling relies very common ML algos/framework and static data. So maybe this only comes into play after a capture has been done. So maybe a feature extraction tool (see [[further considerations#Usage paths/ Workflows]]) should create the data and built the database separately.
+#remark TCP dump filter could also be exported into an environment variable? But then again what is the use of defining a conformance, then could use the raw capture idea for tcpdump, too.

notes/scrible

@@ -0,0 +1,13 @@
+`iottb sniff`:
+  min: nothing
+  min meaningfull: interface
+  min usefull: ip/mac addr of dev
+  good: ip/mac, device type
+  better:
+
+`iottb device`
+  `add`: add new device config
+
+`iottb db`
+      `init` initialize device database
+      `add`  add device

notes/scrible.py

@@ -0,0 +1,7 @@
+class Config:
+    db_dir = Path.home()
+    app_config_dir = Path.home /.Config
+    db_name = 'IoTtb.db'
+    app_config_name = 'iottb.conf'
+     
+

presentation/BSc-Presentation/content.typ

@@ -0,0 +1,447 @@
+#import "/globals.typ": *
+
+//#outline-slide()
+
+= Introduction
+
+== Why are we here?
+#slide[
+  #set align(center)
+  #grid(align: auto, rows: (13fr, 1fr), gutter: 1pt, inset: 1pt,
+  [#image("resources/iot-diagram-1.jpg") 
+  #set text(size: 13pt)
+  #link("https://tse3.mm.bing.net/th?id=OIP.o3AVQNkQCCG_2cmhQzD1zQHaEW&pid=Api"),
+  #v(5pt)]
+)
+]
+#slide[
+  #set align(left)
+  == Project Description
+To study the privacy and security aspects of IoT devices 
+- _systematically_ and 
+- _reproducibly_, 
+we need an easy-to-use 
+- _testbed_ 
+that 
+- _automates_ 
+#text(size: 0.7em, [(some aspects of)]) the process of experimenting with IoT devices. 
+#v(5pt)
+*In this presentation I describe an implementation of such a testbed:* `IOTTB`
+
+#speaker-note[
+  - _systematically_: standardization, 
+  - _reproducible_: a systematic approach promises more reproducible experiments, and thus better verifiable results.
+  - _testbed_: and environment which fixes certain parameters
+  - _automates_: beyond reproducibility, the level of manual involvement influences feasibility w.r.t. reproduction
+]
+]
+
+== Principal Objectives
+#slide[
+  #v(5pt)
+  == Objectives
+  Key objectives:
+  + _Automation recipes_ @fursinckorg2021 for repeated execution of experiments, including data collection and analysis.
+  + _FAIR_ data storage (Findable, Accessible, Interoperable, Reusable) (see @faircsartefacts2022, @go-fair and @wilkinson_fair_2016).
+
+]
+
+
+
+= Motivation
+== Problem(s)
+#slide(composer: utils.side-by-side)[
+  1 Manual setup and configuration of tools
+    - e.g. `tcpdump`, `Wireshark`, `Frida`
+    - configurations not interoperable between tools
+  #pause
+  2 Ad-hoc decisions
+    - file/artefact naming
+    - measured/extracted data features
+    - metadata recorded
+  #pause
+  3 Tailored utilities
+    - lack interoperability
+    - require adaptation depending on project
+  ][
+  #pause
+    4 Scattered data and lack of standardization
+    - Inconsistent data collection and storage
+    - Difficult to maintain compatibility across projects
+  #pause
+    5 Onboarding challenges
+    - New members create ad-hoc solutions
+    - Perpetuates inefficiency and inconsistency
+]
+
+
+
+== Challenges Faced
+#slide[
+  - Problems with current approach:
+    + Inconsistent data collection
+    + Lack of standardized tools and methods
+    + Issues with file naming and data structuring
+  - Resulting difficulties:
+    + Compatibility across projects
+    + Onboarding new members
+    + Ad-hoc solutions perpetuating inefficiency
+]
+
+= Background
+== IoT Devices
+#slide[
+  #set text(size: 14pt)
+  #grid(
+    rows: (4fr, 7fr),
+    gutter: 3pt,
+    grid(columns: 4,
+    [#figure(image("resources/philips-hue.jpg"),caption: [Smart Lighting])<fig:philips-hue>],
+    [#figure(image("resources/echo-dot.jpeg"), caption: [Smart Speakers])<fig:echo-dot>],
+    [#figure(image("resources/mi-camera.png", height: 80%), caption: [Home Surveillance Camera])<fig:mi-camera>],
+    [#figure(image("resources/meta-quest-2.png"), caption: [VR Headset])<fig:meta-quest-2>]),
+    grid(columns: (2.5fr, 3fr,2.5fr, 3fr),
+    [#figure(image("resources/dall-e-home-topo-1.jpeg", height: 80%), caption: [Dall-E Diagram of a Smart Home Network])],
+    grid.cell(colspan: 1, align: top+left, inset: 0.5em, breakable: true, [
+      #set text(size: 15pt)
+      #h(12pt)
+      #v(12pt)
+      IoT devices offer #alert[benefits]:
+      - Home lighting control
+      - Remote video monitoring
+      - Automated cleaning
+      #v(-5pt)
+     and more! But, they becuase
+      + Used in Homes
+      + Connected
+        - LAN only
+        - Internet
+          - #text(size:0.8em, [May lead to information leakage])
+    ]),
+    grid.cell(colspan: 1, align: top+left, inset: 1em, breakable: true, [
+      #set text(size: 15pt)
+      #h(12pt)
+      #v(12pt)
+      #math.arrow.r.double Security and privacy *risks*
+      - Surveillance potential
+      - Unauthorized data sharing
+      - Vulnerable to bugs and security failures]),
+    [#figure(image("resources/dall-e-home-topo-2.jpeg", height: 80%), caption: [Dall-E Schematic Smart Home Network])]
+)
+  )
+]
+
+#slide[
+  #set align(left)
+  - *IoT Devices Overview:*
+    - Devices connected to the internet (voice assistants, smart watches, smart home gadgets)
+    - Embedded with microprocessors and software
+  - *Examples of IoT Devices:*
+    - Security cameras
+    - Home lighting systems
+    - Children's toys
+  - *Importance of IoT:*
+    - Physical dimension (sensors, controllers)
+    - Internet connectivity
+]
+
+== Testbeds
+#slide[
+  #set align(left)
+  - *What is a Testbed?*
+    - Controlled environment for experiments
+    - Ensures reproducibility and standardization
+  - *Examples of Testbeds:*
+    - Industry and Engineering: Platforms for product development
+    - Natural Sciences: Laboratories (e.g., climate chambers, wind tunnels, see @vaughan2005use)
+    - Computing: Software testing environments (unit tests, IDEs)
+    - Interdisciplinary: Complex systems (e.g., smart electric grid testbeds, see @tbsmartgrid2013)
+]
+
+== FAIR Data Principles
+#slide[
+  #set align(left)
+  - *FAIR Data Principles:* @wilkinson_fair_2016, @go-fair
+    - *Findability:* Data should be easy to find
+    - *Accessibility:* Data should be accessible under well-defined conditions
+    - *Interoperability:* Data should be integrated with other data
+    - *Reusability:* Data should be reusable for future research
+  - *Purpose:*
+    - Improve reusability of scientific data
+    - Guide for designing _data storage_ systems
+#speaker-note[
+  #set text(size: 0.5em)
+  #grid(columns: 2,[
+  *Findability:*
+  - Ensuring data is easily locatable and identifiable.
+  - Use of persistent identifiers like DOIs.
+  - Metadata should be richly described to enable precise searching.
+  - *Positive Example:* A dataset with a DOI and comprehensive metadata that is indexed in major search engines.
+  - *Negative Example:* A dataset stored on a personal computer with no metadata and no persistent identifier.
+
+  *Accessibility:*
+  - Data should be retrievable by authorized users.
+  - Use of standardized protocols for data access.
+  - Clear access conditions and usage licenses.
+  - *Positive Example:* A dataset available through a well-documented API with clear access guidelines and permissions.
+  - *Negative Example:* A dataset stored in a proprietary format that requires special software to access, with unclear or restrictive access conditions.
+],[
+  *Interoperability:*
+  - Data should integrate with other datasets.
+  - Use of standardized formats and vocabularies.
+  - Ensure compatibility with existing data and tools.
+  - *Positive Example:* A dataset in CSV format using standardized column headers that align with other datasets in the field.
+  - *Negative Example:* A dataset in a non-standard format with custom jargon that is difficult to merge with other data sources.
+
+  *Reusability:*
+  - Data should be well-documented to allow future use.
+  - Include clear licensing for reuse.
+  - Ensure data quality and provenance are maintained.
+  - *Positive Example:* A dataset with a clear Creative Commons license, detailed documentation, and a version history.
+  - *Negative Example:* A dataset with no documentation, unclear provenance, and no stated reuse policy.
+])
+]
+]
+
+== Network Traffic
+#slide[
+  #set align(left)
+  - *Importance of Network Traffic in IoT:*
+    + Captures communication patterns (device-to-server (internet), device-to-device (LAN, e.g., companion apps))
+    + Essential for evaluating performance and identifying unauthorized communications
+  - *Protocol Analysis:*
+    + Understand device operation and communication protocols
+    + Identify compatibility, efficiency, and security issues
+  - *Flow Monitoring:*
+    + Detect potential security threats (data breaches, unauthorized access, malware)
+    + Monitor for anomalies indicating security incidents or vulnerabilities
+  - *Information Leakage:*
+    + Adversaries can passively observe traffic and extract sensitive information
+    + Even encrypted traffic can leak information about the smart environment and users
+  see @infoexpiot, @iothome2019, @friesssniffing2018, @infoexpiot and @peekaboo2020
+  #speaker-note[
+    - Nw traffic important for various reasons for us
+    - due to data being encrypted in many cases now adays
+      - most methods boild down to some type of network traffic analysis
+  ]
+]
+== Findings from Key Studies
+#slide[
+  #set align(left)
+  *Examples:*\
+  - *Leakage:* Personal data and device usage patterns. @infoexpiot
+      - *Details:* The study found that IoT devices often leak personal data and detailed usage patterns to third-party servers.
+  - *Leakage:* Home device interactions and usage. @iothome2019
+      - *Details:* This research revealed that interactions with home devices can be intercepted, providing insights into daily routines and activities.
+  - *Leakage:* Device/Network communication _patterns_.@friesssniffing2018
+      - *Details:* Sniffing tools can capture communications between IoT devices. WiFi packets expose usage patterns regardless of encryption@peekaboo2020. Those patterns contain features which can be extracted (i.e. leaked) and fed into machine learning models which are capable of exposing more meaningful information (e.g., identifying devices and their functionality) @alyamiwifi2022.
+  In the end these are all some aspect of the same issue: even encrypted traffic leaks information which can be valuable to adversaries.
+  #speaker-note[
+    Examples:
+    - how many people live in a houshold
+    - how many devices are in the household
+    - when which devices are on line
+    - when, who is home
+  ]
+]
+
+== Packet Capture
+#slide[
+  #set align(left)
+  - *Network Packet Capture:*
+    + Intercepting and storing data packets on a network
+    + Principal technique for studying device behavior and communication patterns
+  - *Importance in IoT Security Research:*
+    + Main data collection mechanism
+    + Essential for analyzing network traffic
+  //#math.arrow.r.double Wireshark Example
+  #speaker-note[
+    - data collection for network traffic
+  ]
+]
+
+== Automation Recipes
+#slide[
+  #set align(left)
+  - *Automation Recipes:*
+    - Platform agnostic automation
+      - e.g., install tool y, retrieve dataset x
+    - Integrate with existing scripts/tools
+    - Examples in ML
+    - _Collective Mind Framework:_ @CommonLanguageFacilitate2023, @fursinckorg2021
+      - Provides reusable recipes for building, running, benchmarking, and optimizing applications
+      - Platform-independent or supplemented with user-specific scripts
+
+    #speaker-note[
+        - *Importance of Automation:*
+    - Automates workflows irrespective of underlying tools
+    - the agnostic part is just the goal
+    - these recipies must be able to integrate well with existing tools, personal scripts
+    - Enhances reproducibility and efficiency in experiments
+    - Underlying data has a standardized (w.r.t. to tooling) format, if tool is available
+    ]
+]
+
+== Summary of Key Points
+#slide[
+  #set align(left)
+  - *Key Issues Identified:*
+    + Manual setup and configuration of tools
+    + Ad-hoc decisions in file naming, data features, and metadata
+    + Tailored utilities lacking interoperability
+    + Scattered data and lack of standardization
+    + Onboarding challenges for new members
+  - *Importance of Addressing These Issues:*
+    + Improve reproducibility and reliability of experiments
+    + Enhance data quality and interoperability
+    + Facilitate easier onboarding and collaboration
+]
+
+== Return to ...
+#slide[
+  #set align(left)
+  - *How IOTTB Addresses These Issues:*
+    + *Automation Recipes:*
+      - Standardize the setup and configuration of tools
+      - Ensure consistent data collection and analysis processes
+    + *FAIR Data Storage:*
+      - Enhance findability, accessibility, interoperability, and reusability of data
+      - Improve data management and sharing practices
+    + *Testbed Design:*
+      - Provide a controlled environment for reproducible experiments
+      - Simplify onboarding and collaboration through standardized procedures
+]
+= #smallcaps[IoTdb]
+== Model Environment
+#slide(composer: (1fr, 1fr))[
+  #figure(
+    image("resources/network-setup1.png"),
+    caption: [Common capture setup. Separate AP, switch and capturing device.]
+  )<fig:setup1>
+][
+  #figure(
+    image("resources/setup2.png"),
+    caption: [Setup with AP and "Capture Device" on same machine.]
+  )
+]
+
+== The testbed
+#slide[
+  #align(top + center)[_[...] testbed for IoT devices which automates aspects of running experiments._]
+  #pause
+  How is this realized?\
+  #pause
+  *`iottb`*:
+  - Python Package
+    - Defines Data Storage (implicit in behaviour)
+      - Database is a directory hierarchy in a file system
+      - DB is a collection of "device"-folders
+      - Devices in turn hold some metadata and can have subfolders containing capture data #pause
+    - Defines a metadata schema for devices, as well as captures
+    - Automates collecting of metadata + data
+]
+
+#focus-slide[#align(center+horizon,[DEMO])]
+= Outlook
+== Evaluation
+#slide[
+  *FAIR*-ness?\
+  #pause
+  _Findability_:\
+    - supported through use of UUIDs, while maintaining human readability.
+        #speaker-note[Findable
+
+F1. (Meta)data are assigned a globally unique and persistent identifier
+
+F2. Data are described with rich metadata (defined by R1 below)
+
+F3. Metadata clearly and explicitly include the identifier of the data they describe
+
+F4. (Meta)data are registered or indexed in a searchable resourc]
+  ]
+  #slide[
+      *FAIR*-ness?\
+  _Findability_:\
+    - supported through use of UUIDs, while maintaining human readability.
+  _Accessibility_:\
+    - to a degree up to user of testbed
+    - UUID precondition for data met
+    - metadata makes sense also without data
+  #speaker-note[
+    A1. (Meta)data are retrievable by their identifier using a standardised communications protocol
+
+A1.1 The protocol is open, free, and universally implementable
+
+A1.2 The protocol allows for an authentication and authorisation procedure, where necessary
+
+A2. Metadata are accessible, even when the data are no longer available 
+  ]
+  ]
+  #slide[
+      *FAIR*-ness?\
+  _Findability_:\
+    - supported through use of UUIDs, while maintaining human readability.
+  _Accessibility_:\
+    - to a degree up to user of testbed
+    - UUID precondition for data met
+    - metadata makes sense also without data
+  _Interoperability_:\
+    - Used data formats are common and well known (json, pcap)
+    - Metadata schema understandable given example
+  #speaker-note[
+    1. (Meta)data use a formal, accessible, shared, and broadly applicable language for knowledge representation.
+
+I2. (Meta)data use vocabularies that follow FAIR principles
+
+I3. (Meta)data include qualified references to other (meta)data 
+  ]
+  ]
+  #slide[
+      *FAIR*-ness?\
+  _Findability_:\
+    - supported through use of UUIDs, while maintaining human readability.
+  _Accessibility_:\
+    - to a degree up to user of testbed
+    - UUID precondition for data met
+    - metadata makes sense also without data
+  _Interoperability_:\
+    - Used data formats are common and well known (json, pcap)
+    - Metadata schema understandable given example
+  _Reusability_:\
+    - Used formats support this.
+    - Data capture tool (`iottb`) can be made available
+    - + rerun with the same configuration
+    #speaker-note[
+R1. (Meta)data are richly described with a plurality of accurate and relevant attributes
+
+R1.1. (Meta)data are released with a clear and accessible data usage license
+
+R1.2. (Meta)data are associated with detailed provenance
+
+R1.3. (Meta)data meet domain-relevant community standard
+    ]
+]
+#slide[
+  *Automation Recipes*?\
+  - `iottb` automates capture
+  - Metadata should allow repeating experiments
+  - want: configure capture based on metadata
+]
+
+= Questions
+
+
+= Appendix
+#bibliography("presentation-bsc.bib", style: "ieee")
+== Images
+#slide[
+  #set text(size: 13pt)
+  //#show link: underline
+  #show link: set text(stroke: blue)
+  *Introduction*#footnote([Images licenced for free share and use to the best of my knowledge.])\
+  - IoT Network Diagram: #link("https://tse3.mm.bing.net/th?id=OIP.o3AVQNkQCCG_2cmhQzD1zQHaEW&pid=Api")
+  - @fig:echo-dot: #link("https://i0.wp.com/thegroyne.com/wp-content/uploads/2018/04/Amazon-Echo-Dot-Altavoces-inteligentes-04.jpeg")
+  - @fig:philips-hue: #link("https://www.multimediaplayer.it/wp-content/uploads/kit-philips-hue.jpg")
+  - @fig:mi-camera: #link("https://d.otto.de/files/bd42f6e9-ac45-5e1c-8d5f-ac3affcee9d6.pdf")#footnote("Unclear licence")
+  
+]

presentation/BSc-Presentation/globals.typ

@@ -0,0 +1,23 @@
+#import "@preview/touying:0.4.2": *
+#import "university.typ"
+
+#let s = university.register(aspect-ratio: "16-9")
+
+#let s = (s.methods.info)(
+  self: s,
+  title: [IOTTB],
+  subtitle: [An Automation Testbed for IoT Devices],
+  author: [Sebastian Lenzlinger],
+  date: datetime.today(),
+  institution: [University of Basel \ Department of Mathematics and Computer Science 
+                \ Privacy-Enhancing Technologies Group],
+  logo: image("logo-en.svg")
+)
+#let s = (s.methods.numbering)(self: s, section: "1.", "1.1.1")
+//#let s = (s.methods.show-notes-on-second-screen)(self: s, right)
+
+#show figure.caption: set text(size: 8pt)
+
+#let (init, slides, touying-outline, alert, speaker-note) = utils.methods(s)
+
+#let (slide, empty-slide, title-slide, outline-slide, focus-slide, matrix-slide) = utils.slides(s)

presentation/BSc-Presentation/main.typ

@@ -0,0 +1,12 @@
+// main.typ
+#import "/globals.typ": *
+
+#show link: underline
+#show link: set text(stroke: blue)
+#show: init
+#show strong: alert
+#show: slides
+
+
+
+#include "content.typ"

presentation/BSc-Presentation/presentation-bsc.bib

@@ -0,0 +1,577 @@
+@article{abuwaragaTestbed2020,
+  title = {Design and Implementation of Automated {{IoT}} Security Testbed},
+  author = {Abu Waraga, Omnia and Bettayeb, Meriem and Nasir, Qassim and Abu Talib, Manar},
+  date = {2020-01-01},
+  journaltitle = {Computers \& Security},
+  shortjournal = {Computers \& Security},
+  volume = {88},
+  pages = {101648},
+  issn = {0167-4048},
+  doi = {10.1016/j.cose.2019.101648},
+  abstract = {The emergence of technology associated with the Internet of Things (IoT) is reshaping our lives, while simultaneously raising many issues due to their low level of security, which attackers can exploit for malicious purposes. This research paper conducts a comprehensive analysis of previous studies on IoT device security with a focus on the various tools used to test IoT devices and the vulnerabilities that were found. Additionally, the paper contains a survey of IoT-based security testbeds in the research literature. In this research study, we introduce an open source platform for identifying weaknesses in IoT networks and communications. The platform is easily modifiable and extendible to enable the addition of new security assessment tests and functionalities. It automates security evaluation, allowing for testing without human intervention. The testbed reports the security problems of the tested devices and can detect all attacks made against the devices. It is also designed to monitor communications within the testbed and with connected devices, enabling the system to abort if malicious activity is detected. To demonstrate the capabilities of the proposed IoT security testbed, it is used to examine the vulnerabilities of two IoT devices: a wireless camera and a smart bulb.},
+  keywords = {Automated testbed architecture,Internet of Things,IoT testbed,Vulnerability assessment},
+  file = {/home/seb/Zotero/storage/U3D2SCU4/S0167404819301920.html}
+}
+
+@article{al-hawawrehDevelopingSecurityTestbed2021,
+  title = {Developing a {{Security Testbed}} for {{Industrial Internet}} of {{Things}}},
+  author = {Al-Hawawreh, Muna and Sitnikova, Elena},
+  date = {2021-04},
+  journaltitle = {IEEE Internet of Things Journal},
+  shortjournal = {IEEE Internet Things J.},
+  volume = {8},
+  number = {7},
+  pages = {5558--5573},
+  issn = {2327-4662},
+  doi = {10.1109/JIOT.2020.3032093},
+  abstract = {While achieving security for Industrial Internet of Things (IIoT) is a critical and nontrivial task, more attention is required for brownfield IIoT systems. This is a consequence of long life cycles of their legacy devices which were initially designed without considering security and IoT connectivity, but they are now becoming more connected and integrated with emerging IoT technologies and messaging communication protocols. Deploying today's methodologies and solutions in brownfield IIoT systems is not viable, as security solutions must co-exist and fit these systems' requirements. This necessitates a realistic standardized IIoT testbed that can be used as an optimal format to measure the credibility of security solutions of IIoT networks, analyze IIoT attack landscapes and extract threat intelligence. Developing a testbed for brownfield IIoT systems is considered a significant challenge as these systems are comprised of legacy, heterogeneous devices, communication layers and applications that need to be implemented holistically to achieve high fidelity. In this article, we propose a new generic end-to-end IIoT security testbed, with a particular focus on the brownfield system and provide details of the testbed's architectural design and the implementation process. The proposed testbed can be easily reproduced and reconfigured to support the testing activities of new processes and various security scenarios. The proposed testbed operation is demonstrated on different connected devices, communication protocols and applications. The experiments demonstrate that this testbed is effective in terms of its operation and security testing. A comparison with existing testbeds, including a table of features is provided.},
+  eventtitle = {{{IEEE Internet}} of {{Things Journal}}},
+  keywords = {Brownfield,ieee,Industrial Internet of Things (IIoT),iot,Protocols,Resilience,Security,security testing,Sensors,testbed,Testing},
+  file = {/home/seb/Zotero/storage/7JFQCP4C/Al-Hawawreh and Sitnikova - 2021 - Developing a Security Testbed for Industrial Inter.pdf;/home/seb/Zotero/storage/U9SM7UYK/9233425.html}
+}
+
+@inproceedings{alyamiwifi2022,
+  title = {{{WiFi-based IoT Devices Profiling Attack}} Based on {{Eavesdropping}} of {{Encrypted WiFi Traffic}}},
+  booktitle = {2022 {{IEEE}} 19th {{Annual Consumer Communications}} \& {{Networking Conference}} ({{CCNC}})},
+  author = {Alyami, Mnassar and Alharbi, Ibrahim and Zou, Cliff and Solihin, Yan and Ackerman, Karl},
+  date = {2022-01-08},
+  pages = {385--392},
+  publisher = {IEEE},
+  location = {Las Vegas, NV, USA},
+  doi = {10.1109/CCNC49033.2022.9700674},
+  abstract = {Recent research has shown that in-network observers of WiFi communication (i.e., observers who have joined the WiFi network) can obtain much information regarding the types, user identities, and activities of Internet-of-Things (IoT) devices in the network. What has not been explored is the question of how much information can be inferred by an out-ofnetwork observer who does not have access to the WiFi network. This attack scenario is more realistic and much harder to defend against, thus imposes a real threat to user privacy. In this paper, we investigate privacy leakage derived from an out-of-network traffic eavesdropper on the encrypted WiFi traffic of popular IoT devices. We instrumented a testbed of 12 popular IoT devices and evaluated multiple machine learning methods for fingerprinting and inferring what IoT devices exist in a WiFi network. By only exploiting the WiFi frame header information, we have achieved 95\% accuracy in identifying the devices and often their working status. This study demonstrates that information leakage and privacy attack is a real threat for WiFi networks and IoT applications.},
+  eventtitle = {2022 {{IEEE}} 19th {{Annual Consumer Communications}} \& {{Networking Conference}} ({{CCNC}})},
+  isbn = {978-1-66543-161-3},
+  langid = {english},
+  file = {/home/seb/Zotero/storage/7A9CFI4D/Alyami et al. - 2022 - WiFi-based IoT Devices Profiling Attack based on E.pdf}
+}
+
+@inproceedings{aysom23,
+  title = {Are {{You Spying}} on {{Me}}? \{\vphantom\}{{Large-Scale}}\vphantom\{\} {{Analysis}} on \{\vphantom\}{{IoT}}\vphantom\{\} {{Data Exposure}} through {{Companion Apps}}},
+  shorttitle = {Are {{You Spying}} on {{Me}}?},
+  author = {Nan, Yuhong and Wang, Xueqiang and Xing, Luyi and Liao, Xiaojing and Wu, Ruoyu and Wu, Jianliang and Zhang, Yifan and Wang, XiaoFeng},
+  date = {2023},
+  pages = {6665--6682},
+  url = {https://www.usenix.org/conference/usenixsecurity23/presentation/nan},
+  urldate = {2024-02-25},
+  eventtitle = {32nd {{USENIX Security Symposium}} ({{USENIX Security}} 23)},
+  isbn = {978-1-939133-37-3},
+  langid = {english},
+  file = {/home/seb/Zotero/storage/M5HNUNW8/Nan et al. - 2023 - Are You Spying on Me Large-Scale Analysis on I.pdf}
+}
+
+@article{bashir2017internet,
+  title = {The {{Internet}} of {{Things}} Testbed: A Survey and Evaluation},
+  author = {Bashir, Abid H and Gill, Khurram},
+  date = {2017},
+  journaltitle = {Future Generation Computer Systems},
+  shortjournal = {Future Gener. Comput. Syst.},
+  volume = {78},
+  pages = {409--421},
+  publisher = {Elsevier}
+}
+
+@online{click,
+  title = {Welcome to {{Click}} — {{Click Documentation}} (8.1.x)},
+  url = {https://click.palletsprojects.com/en/8.1.x/},
+  urldate = {2024-06-30},
+  file = {/home/seb/Zotero/storage/88MW53XH/8.1.x.html}
+}
+
+@unpublished{CommonLanguageFacilitate2023,
+  title = {Toward a Common Language to Facilitate Reproducible Research and Technology Transfer: Challenges and Solutions},
+  shorttitle = {Toward a Common Language to Facilitate Reproducible Research and Technology Transfer},
+  date = {2023-06-28},
+  doi = {10.5281/zenodo.8105339},
+  abstract = {The keynote presentation from the 1st ACM conference on reproducibility and replicability (ACM REP'23).The video of this presentation is available at the ACM YouTube channel.Please don't hesitate to provide your feedback via the public Discord server~from the MLCommons Task Force on Automation and Reproducibility and GitHub issues.[ GitHub project~] [ Public Collective Knowledge repository ][ Related reproducibility initiatives ] [ cTuning.org ] [ cKnowledge.org ]During the past 10 years, we have considerably improved the reproducibility of experimental results from published papers by introducing the artifact evaluation process with a unified artifact appendix and reproducibility checklists, Jupyter notebooks, containers, and Git repositories. On the other hand, our experience reproducing more than 200 papers shows that it can take weeks and months of painful and repetitive interactions between teams to reproduce artifacts. This effort includes decrypting numerous README files, examining ad-hoc artifacts and containers, and figuring out how to reproduce computational results. Furthermore, snapshot containers pose a challenge to optimize algorithms' performance, accuracy, power consumption and operational costs across diverse and rapidly evolving software, hardware, and data used in the real world.In this talk, I~explain how our practical artifact evaluation experience and the feedback from researchers and evaluators motivated us to develop a simple, intuitive, technology agnostic, and English-like scripting language called Collective Mind (CM). It helps to automatically adapt any given experiment to any software, hardware, and data while automatically generating unified README files and synthesizing modular containers with a unified API. It is being developed by MLCommons to facilitate reproducible AI/ML Systems research and minimizing manual and repetitive benchmarking and optimization efforts, reduce time and costs for reproducible research, and simplify technology transfer to production. I also present several recent use cases of how CM helps MLCommons, the Student Cluster Competition, and artifact evaluation at ACM/IEEE conferences. I conclude with our development plans, new challenges, possible solutions, and upcoming reproducibility and optimization challenges powered by the MLCommons Collective Knowledge platform and CM:~access.cKnowledge.org.},
+  keywords = {artifact evaluation,artificial intelligence,automation,chatgpt,cknowledge,collective knowledge,collective mind,competitions,cTuning,llm,llm automation,machine learning,mlcommons,mlperf,optimization challenges,performance,replicability,reproducibility,reusability,systems},
+  file = {/home/seb/Zotero/storage/AGZTALNV/Fursin - 2023 - Toward a common language to facilitate reproducibl.pdf}
+}
+
+@online{coryefelleCorrectingIoTHistory2016,
+  title = {Correcting the {{IoT History}}},
+  author = {CoryEfelle},
+  date = {2016-03-14T22:28:21+00:00},
+  url = {http://www.chetansharma.com/correcting-the-iot-history/},
+  urldate = {2024-06-20},
+  abstract = {In the last 5 years, IoT has entered the industry consciousness. There are varying forecasts calling for tremendous growth and … Continued},
+  langid = {american},
+  organization = {Chetan Sharma},
+  file = {/home/seb/Zotero/storage/LJX88N74/correcting-the-iot-history.html}
+}
+
+@inproceedings{dasilvaComRoad2021,
+  title = {A {{Community Roadmap}} for {{Scientific Workflows Research}} and {{Development}}},
+  booktitle = {2021 {{IEEE Workshop}} on {{Workflows}} in {{Support}} of {{Large-Scale Science}} ({{WORKS}})},
+  author = {family=Silva, given=Rafael Ferreira, prefix=da, useprefix=true and Casanova, Henri and Chard, Kyle and Altintas, Ilkay and Badia, Rosa M and Balis, Bartosz and Coleman, Tainã and Coppens, Frederik and Di Natale, Frank and Enders, Bjoern and Fahringer, Thomas and Filgueira, Rosa and Fursin, Grigori and Garijo, Daniel and Goble, Carole and Howell, Dorran and Jha, Shantenu and Katz, Daniel S. and Laney, Daniel and Leser, Ulf and Malawski, Maciej and Mehta, Kshitij and Pottier, Loïc and Ozik, Jonathan and Peterson, J. Luc and Ramakrishnan, Lavanya and Soiland-Reyes, Stian and Thain, Douglas and Wolf, Matthew},
+  date = {2021-11},
+  pages = {81--90},
+  doi = {10.1109/WORKS54523.2021.00016},
+  abstract = {The landscape of workflow systems for scientific applications is notoriously convoluted with hundreds of seemingly equivalent workflow systems, many isolated research claims, and a steep learning curve. To address some of these challenges and lay the groundwork for transforming workflows research and development, the WorkflowsRI and ExaWorks projects partnered to bring the international workflows community together. This paper reports on discussions and findings from two virtual “Workflows Community Summits” (January and April, 2021). The overarching goals of these workshops were to develop a view of the state of the art, identify crucial research challenges in the workflows community, articulate a vision for potential community efforts, and discuss technical approaches for realizing this vision. To this end, participants identified six broad themes: FAIR computational workflows; AI workflows; exascale challenges; APIs, interoperability, reuse, and standards; training and education; and building a workflows community. We summarize discussions and recommendations for each of these themes.},
+  eventtitle = {2021 {{IEEE Workshop}} on {{Workflows}} in {{Support}} of {{Large-Scale Science}} ({{WORKS}})},
+  keywords = {AI workflows,Artificial intelligence,Buildings,community roadmap,Conferences,data management,exascale computing,interoperability,Research and development,Scientific workflows,Stakeholders,Standards,Training},
+  file = {/home/seb/Zotero/storage/856IVVCZ/da Silva et al. - 2021 - A Community Roadmap for Scientific Workflows Resea.pdf;/home/seb/Zotero/storage/7QR6LPZV/authors.html}
+}
+
+@report{dasilvaworkflow2021,
+  title = {Workflows {{Community Summit}}: {{Bringing}} the {{Scientific Workflows Community Together}}},
+  shorttitle = {Workflows {{Community Summit}}},
+  author = {family=Silva, given=Rafael Ferreira, prefix=da, useprefix=true and Casanova, Henri and Chard, Kyle and Laney, Dan and Ahn, Dong and Jha, Shantenu and Goble, Carole and Ramakrishnan, Lavanya and Peterson, Luc and Enders, Bjoern and Thain, Douglas and Altintas, Ilkay and Babuji, Yadu and Badia, Rosa M. and Bonazzi, Vivien and Coleman, Taina and Crusoe, Michael and Deelman, Ewa and Di Natale, Frank and Di Tommaso, Paolo and Fahringer, Thomas and Filgueira, Rosa and Fursin, Grigori and Ganose, Alex and Gruning, Bjorn and Katz, Daniel S. and Kuchar, Olga and Kupresanin, Ana and Ludascher, Bertram and Maheshwari, Ketan and Mattoso, Marta and Mehta, Kshitij and Munson, Todd and Ozik, Jonathan and Peterka, Tom and Pottier, Loic and Randles, Tim and Soiland-Reyes, Stian and Tovar, Benjamin and Turilli, Matteo and Uram, Thomas and Vahi, Karan and Wilde, Michael and Wolf, Matthew and Wozniak, Justin},
+  date = {2021-03-16},
+  eprint = {2103.09181},
+  eprinttype = {arXiv},
+  eprintclass = {cs},
+  doi = {10.5281/zenodo.4606958},
+  abstract = {Scientific workflows have been used almost universally across scientific domains, and have underpinned some of the most significant discoveries of the past several decades. Many of these workflows have high computational, storage, and/or communication demands, and thus must execute on a wide range of large-scale platforms, from large clouds to upcoming exascale high-performance computing (HPC) platforms. These executions must be managed using some software infrastructure. Due to the popularity of workflows, workflow management systems (WMSs) have been developed to provide abstractions for creating and executing workflows conveniently, efficiently, and portably. While these efforts are all worthwhile, there are now hundreds of independent WMSs, many of which are moribund. As a result, the WMS landscape is segmented and presents significant barriers to entry due to the hundreds of seemingly comparable, yet incompatible, systems that exist. As a result, many teams, small and large, still elect to build their own custom workflow solution rather than adopt, or build upon, existing WMSs. This current state of the WMS landscape negatively impacts workflow users, developers, and researchers. The "Workflows Community Summit" was held online on January 13, 2021. The overarching goal of the summit was to develop a view of the state of the art and identify crucial research challenges in the workflow community. Prior to the summit, a survey sent to stakeholders in the workflow community (including both developers of WMSs and users of workflows) helped to identify key challenges in this community that were translated into 6 broad themes for the summit, each of them being the object of a focused discussion led by a volunteer member of the community. This report documents and organizes the wealth of information provided by the participants before, during, and after the summit.},
+  keywords = {Computer Science - Distributed Parallel and Cluster Computing},
+  file = {/home/seb/Zotero/storage/JWQWSRVM/da Silva et al. - 2021 - Workflows Community Summit Bringing the Scientifi.pdf;/home/seb/Zotero/storage/4DY745J9/2103.html}
+}
+
+@inproceedings{faircsartefacts2022,
+  title = {Toward Findable, Accessible, Interoperable, and Reusable Cybersecurity Artifacts},
+  booktitle = {Proceedings of the 15th Workshop on Cyber Security Experimentation and Test},
+  author = {Balenson, David and Benzel, Terry and Eide, Eric and Emmerich, David and Johnson, David and Mirkovic, Jelena and Tinnel, Laura},
+  date = {2022},
+  series = {Cset '22},
+  pages = {65--70},
+  publisher = {Association for Computing Machinery},
+  location = {New York, NY, USA},
+  doi = {10.1145/3546096.3546104},
+  abstract = {Researchers in experimental cybersecurity are increasingly sharing the code, data, and other artifacts associated with their studies. This trend is encouraged and rewarded by conferences and journals through practices such as artifact evaluation and badging. While these trends in sharing artifacts are promising, the cybersecurity community is still far from an ecosystem in which artifacts are FAIR: findable, accessible, interoperable, and reusable. The lack of established standards and best practices for sharing and reuse results in artifacts that are often difficult to find and reuse; in addition, the lack of community standards results in artifacts that may be incomplete and low-quality. In this paper we describe our experience in creating an online community hub, called SEARCCH, to promote the sharing and reuse of artifacts for cybersecurity research. Based on our experience, we offer lessons learned: issues that must be addressed to further promote FAIR principles in experimental cybersecurity.},
+  isbn = {978-1-4503-9684-4},
+  pagetotal = {6},
+  keywords = {artifact catalog,cybersecurity artifacts,FAIR principles,reproducibility,SEARCCH}
+}
+
+@online{FHSReferencedSpecifications,
+  title = {{{FHS Referenced Specifications}}},
+  url = {https://refspecs.linuxfoundation.org/fhs.shtml},
+  urldate = {2024-06-22},
+  file = {/home/seb/Zotero/storage/E75NBMV5/fhs.html}
+}
+
+@inproceedings{friesssniffing2018,
+  title = {Multichannel-{{Sniffing-System}} for {{Real-World Analysing}} of {{Wi-Fi-Packets}}},
+  booktitle = {2018 {{Tenth International Conference}} on {{Ubiquitous}} and {{Future Networks}} ({{ICUFN}})},
+  author = {Friess, Kristof},
+  date = {2018-07},
+  pages = {358--364},
+  issn = {2165-8536},
+  doi = {10.1109/ICUFN.2018.8436715},
+  abstract = {Wireless technologies like Wi-Fi send their data using multiple channels. To analyze an environment and all Wi-Fi packets inside, a sniffing system is needed, which can sniff on all used channels of the wireless technology at the same time. This allows catching most packets on each channel. In this paper, a way to build up a multi-channel-sniffing-system (MCSS) is described. The test system uses several single board computers (SBC) with an external Wi-Fi adapter (USB), 19 SBCs are sniffing nodes (SFN) and one SBC as sending node (SN). The sniffing SBCs are placed in a cycle around the sender so that every node has the same chance to receive the simulated packets from the SN. For the control of all 20 SBCs, a self-developed software is used, which connects from the host to the clients and is used for configuring the experiments. The configuration is sent to each client and will initiate their start, so that their times are also synchronized, for this all clients are synchronised using a time server.},
+  eventtitle = {2018 {{Tenth International Conference}} on {{Ubiquitous}} and {{Future Networks}} ({{ICUFN}})},
+  keywords = {Bluetooth,Europe,Hardware,Monitoring,multichannel,node.js,sbc,sniffing,Universal Serial Bus,wifi,Wireless communication,Wireless fidelity},
+  file = {/home/seb/Zotero/storage/AIPDUX7V/Friess - 2018 - Multichannel-Sniffing-System for Real-World Analys.pdf;/home/seb/Zotero/storage/E38MLQA3/8436715.html}
+}
+
+@standard{fsh-home,
+  title = {3.8.~/Home : {{User}} Home Directories (Optional)},
+  url = {https://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch03s08.html},
+  urldate = {2024-06-22},
+  file = {/home/seb/Zotero/storage/PHTUTULW/ch03s08.html}
+}
+
+@article{fursinckorg2021,
+  title = {Collective Knowledge: Organizing Research Projects as a Database of Reusable Components and Portable Workflows with Common Interfaces},
+  shorttitle = {Collective Knowledge},
+  author = {Fursin, Grigori},
+  date = {2021-03-29},
+  journaltitle = {Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences},
+  shortjournal = {Philos. Trans. R. Soc. Math. Phys. Eng. Sci.},
+  volume = {379},
+  number = {2197},
+  pages = {20200211},
+  publisher = {Royal Society},
+  doi = {10.1098/rsta.2020.0211},
+  abstract = {This article provides the motivation and overview of the Collective Knowledge Framework (CK or cKnowledge). The CK concept is to decompose research projects into reusable components that encapsulate research artifacts and provide unified application programming interfaces (APIs), command-line interfaces (CLIs), meta descriptions and common automation actions for related artifacts. The CK framework is used to organize and manage research projects as a database of such components. Inspired by the USB ‘plug and play’ approach for hardware, CK also helps to assemble portable workflows that can automatically plug in compatible components from different users and vendors (models, datasets, frameworks, compilers, tools). Such workflows can build and run algorithms on different platforms and environments in a unified way using the customizable CK program pipeline with software detection plugins and the automatic installation of missing packages. This article presents a number of industrial projects in which the modular CK approach was successfully validated in order to automate benchmarking, auto-tuning and co-design of efficient software and hardware for machine learning and artificial intelligence in terms of speed, accuracy, energy, size and various costs. The CK framework also helped to automate the artifact evaluation process at several computer science conferences as well as to make it easier to reproduce, compare and reuse research techniques from published papers, deploy them in production, and automatically adapt them to continuously changing datasets, models and systems. The long-term goal is to accelerate innovation by connecting researchers and practitioners to share and reuse all their knowledge, best practices, artifacts, workflows and experimental results in a common, portable and reproducible format at cKnowledge.io. This article is part of the theme issue ‘Reliability and reproducibility in computational science: implementing verification, validation and uncertainty quantification in silico’.},
+  keywords = {DevOps,FAIR principles,portability,reproducibility,research automation,reusability},
+  file = {/home/seb/Zotero/storage/6DM4S7B7/Fursin - 2021 - Collective knowledge organizing research projects.pdf}
+}
+
+@online{go-fair,
+  title = {{{FAIR Principles}}},
+  url = {https://www.go-fair.org/fair-principles/},
+  urldate = {2024-06-22},
+  abstract = {In 2016, the ‘FAIR Guiding Principles for scientific data management and stewardship’~were published in~Scientific Data. The authors intended to provide guidelines to improve the Findability, Accessibility, Interoperability, and Reuse of digital assets. The principles emphasise machine-actionability (i.e., the capacity of… Continue reading →},
+  langid = {american},
+  organization = {GO FAIR},
+  file = {/home/seb/Zotero/storage/MLUAT2GN/fair-principles.html}
+}
+
+@article{huang2011testbed,
+  title = {Testbed for Evaluating Performance of Health Monitoring Systems},
+  author = {Huang, Qinfen and Liu, Min and Garcia, Alfredo and Reynolds, Matthew},
+  date = {2011},
+  journaltitle = {IEEE Transactions on Instrumentation and Measurement},
+  shortjournal = {IEEE Trans. Instrum. Meas.},
+  volume = {60},
+  number = {1},
+  pages = {114--123},
+  publisher = {IEEE}
+}
+
+@inproceedings{infoexpiot,
+  title = {Information {{Exposure From Consumer IoT Devices}}: {{A Multidimensional}}, {{Network-Informed Measurement Approach}}},
+  shorttitle = {Information {{Exposure From Consumer IoT Devices}}},
+  booktitle = {Proceedings of the {{Internet Measurement Conference}}},
+  author = {Ren, Jingjing and Dubois, Daniel J. and Choffnes, David and Mandalari, Anna Maria and Kolcun, Roman and Haddadi, Hamed},
+  date = {2019-10-21},
+  series = {{{IMC}} '19},
+  pages = {267--279},
+  publisher = {Association for Computing Machinery},
+  location = {New York, NY, USA},
+  doi = {10.1145/3355369.3355577},
+  abstract = {Internet of Things (IoT) devices are increasingly found in everyday homes, providing useful functionality for devices such as TVs, smart speakers, and video doorbells. Along with their benefits come potential privacy risks, since these devices can communicate information about their users to other parties over the Internet. However, understanding these risks in depth and at scale is difficult due to heterogeneity in devices' user interfaces, protocols, and functionality. In this work, we conduct a multidimensional analysis of information exposure from 81 devices located in labs in the US and UK. Through a total of 34,586 rigorous automated and manual controlled experiments, we characterize information exposure in terms of destinations of Internet traffic, whether the contents of communication are protected by encryption, what are the IoT-device interactions that can be inferred from such content, and whether there are unexpected exposures of private and/or sensitive information (e.g., video surreptitiously transmitted by a recording device). We highlight regional differences between these results, potentially due to different privacy regulations in the US and UK. Last, we compare our controlled experiments with data gathered from an in situ user study comprising 36 participants.},
+  isbn = {978-1-4503-6948-0},
+  file = {/home/seb/Zotero/storage/YT9SKQLS/Ren et al. - 2019 - Information Exposure From Consumer IoT Devices A .pdf}
+}
+
+@incollection{iotfundamentals,
+  title = {{{IoT Fundamentals}}: {{Definitions}}, {{Architectures}}, {{Challenges}}, and {{Promises}}},
+  booktitle = {Intelligent {{Internet}} of {{Things}}: {{From Device}} to {{Fog}} and {{Cloud}}},
+  author = {Firouzi, Farshad and Farahani, Bahar and Weinberger, Markus and DePace, Gabriel and Aliee, Fereidoon Shams},
+  editor = {Firouzi, Farshad and Chakrabarty, Krishnendu and Nassif, Sani},
+  date = {2020},
+  pages = {3--50},
+  publisher = {Springer International Publishing},
+  location = {Cham},
+  doi = {10.1007/978-3-030-30367-9_1},
+  abstract = {The Internet is everywhere and touched almost every corner of the globe affecting our lives in previously unimagined ways. As a living entity, the Internet is constantly evolving, and now, an era of widespread connectivity through various smart devices (i.e., things) that connect with the Internet has begun. This paradigm change is generally referred to as the Internet of Things (IoT). Welcoming IoT will bring significant benefits to economies and businesses as it enables greater innovation and productivity. On the other hand, the rapid adoption of IoT presents new challenges regarding connectivity, security, data processing, and scalability. Because the IoT world is vast and versatile, it cannot be viewed as a single technology. IoT looks more like an umbrella covering many protocols, technologies, and concepts that depend on specific industries. In this chapter, we will seek to look at the history of IoT, more clearly define it, and review its terms and concepts. We will also review vertical IoT markets and higher-level use cases that have successfully adopted IoT solutions. We will also discuss the details of the business implications, business models, and opportunities of IoT. Finally, the complete IoT stack and reference architectures from smart objects, to the networks, to the cloud, and finally the applications where information is leveraged are explained.},
+  isbn = {978-3-030-30367-9}
+}
+
+@inproceedings{iothome2019,
+  title = {All Things Considered: {{An}} Analysis of {{IoT}} Devices on Home Networks},
+  booktitle = {28th {{USENIX}} Security Symposium ({{USENIX}} Security 19)},
+  author = {Kumar, Deepak and Shen, Kelly and Case, Benton and Garg, Deepali and Alperovich, Galina and Kuznetsov, Dmitry and Gupta, Rajarshi and Durumeric, Zakir},
+  date = {2019-08},
+  pages = {1169--1185},
+  publisher = {USENIX Association},
+  location = {Santa Clara, CA},
+  url = {https://www.usenix.org/conference/usenixsecurity19/presentation/kumar-deepak},
+  isbn = {978-1-939133-06-9}
+}
+
+@inproceedings{iotInHomes2019,
+  title = {All {{Things Considered}}: {{An Analysis}} of \{\vphantom\}{{IoT}}\vphantom\{\} {{Devices}} on {{Home Networks}}},
+  shorttitle = {All {{Things Considered}}},
+  author = {Kumar, Deepak and Shen, Kelly and Case, Benton and Garg, Deepali and Alperovich, Galina and Kuznetsov, Dmitry and Gupta, Rajarshi and Durumeric, Zakir},
+  date = {2019},
+  pages = {1169--1185},
+  url = {https://www.usenix.org/conference/usenixsecurity19/presentation/kumar-deepak},
+  urldate = {2024-06-30},
+  eventtitle = {28th {{USENIX Security Symposium}} ({{USENIX Security}} 19)},
+  isbn = {978-1-939133-06-9},
+  langid = {english},
+  keywords = {adoption,home,iot},
+  file = {/home/seb/Zotero/storage/73BEXVMZ/Kumar et al. - 2019 - All Things Considered An Analysis of IoT Device.pdf}
+}
+
+@article{islamiot2023,
+  title = {Internet of {{Things}}: {{Device Capabilities}}, {{Architectures}}, {{Protocols}}, and {{Smart Applications}} in {{Healthcare Domain}}},
+  shorttitle = {Internet of {{Things}}},
+  author = {Islam, Md. Milon and Nooruddin, Sheikh and Karray, Fakhri and Muhammad, Ghulam},
+  date = {2023-02},
+  journaltitle = {IEEE Internet of Things Journal},
+  shortjournal = {IEEE Internet Things J.},
+  volume = {10},
+  number = {4},
+  pages = {3611--3641},
+  issn = {2327-4662},
+  doi = {10.1109/JIOT.2022.3228795},
+  abstract = {Nowadays, the Internet has spread to practically every country around the world and is having unprecedented effects on people’s lives. The Internet of Things (IoT) is getting more popular and has a high level of interest in both practitioners and academicians in the age of wireless communication due to its diverse applications. The IoT is a technology that enables everyday things to become savvier, everyday computation toward becoming intellectual, and everyday communication to become a little more insightful. In this article, the most common and popular IoT device capabilities, architectures, and protocols are demonstrated in brief to provide a clear overview of the IoT technology to the researchers in this area. The common IoT device capabilities, including hardware (Raspberry Pi, Arduino, and ESP8266) and software (operating systems (OSs), and built-in tools) platforms are described in detail. The widely used architectures that have recently evolved and used are the three-layer architecture, service-oriented architecture, and middleware-based architecture. The popular protocols for IoT are demonstrated which include constrained application protocol, message queue telemetry transport, extensible messaging and presence protocol, advanced message queuing protocol, data distribution service, low power wireless personal area network, Bluetooth low energy, and ZigBee that are frequently utilized to develop smart IoT applications. Additionally, this research provides an in-depth overview of the potential healthcare applications based on IoT technologies in the context of addressing various healthcare concerns. Finally, this article summarizes state-of-the-art knowledge, highlights open issues and shortcomings, and provides recommendations for further studies which would be quite beneficial to anyone with a desire to work in this field and make breakthroughs to get expertise in this area.},
+  eventtitle = {{{IEEE Internet}} of {{Things Journal}}},
+  keywords = {Communication protocol,Computer architecture,device capabilities,Hardware,healthcare applications,Internet of Things,Internet of Things (IoT),IoT architecture,Medical services,Protocols,Security,Software},
+  file = {/home/seb/Zotero/storage/HDMX3ZVW/Islam et al. - 2023 - Internet of Things Device Capabilities, Architect.pdf;/home/seb/Zotero/storage/WDKWMKN9/references.html}
+}
+
+@online{mitmproxy,
+  title = {Mitmproxy - an Interactive {{HTTPS}} Proxy},
+  url = {https://mitmproxy.org/},
+  urldate = {2024-06-30},
+  keywords = {proxy,sniffing,tools},
+  file = {/home/seb/Zotero/storage/NTUXF55S/mitmproxy.org.html}
+}
+
+@standard{OverviewInternetThings2012,
+  type = {Recommendation},
+  title = {Overview of the {{Internet}} of Things},
+  shorttitle = {Y.{{IoT-overview}}},
+  date = {2012-06-15},
+  number = {ITU-T Y.4000},
+  url = {https://handle.itu.int/11.1002/1000/11559},
+  abstract = {Recommendation ITU-T Y.2060 provides an overview of the Internet of things (IoT). It clarifies the concept and scope of the IoT, identifies the fundamental characteristics and high-level requirements of the IoT and describes the IoT reference model. The ecosystem and business models are also provided in an informative appendix. Former ITU-T Y.2060 renumbered as ITU-T Y.4000 on 2016-02-05 without further modification and without being republished.},
+  pubstate = {In force}
+}
+
+@inproceedings{peekaboo2020,
+  title = {Peek-a-{{Boo}}: {{I}} See Your Smart Home Activities, Even Encrypted!},
+  shorttitle = {Peek-a-{{Boo}}},
+  booktitle = {Proceedings of the 13th {{ACM Conference}} on {{Security}} and {{Privacy}} in {{Wireless}} and {{Mobile Networks}}},
+  author = {Acar, Abbas and Fereidooni, Hossein and Abera, Tigist and Sikder, Amit Kumar and Miettinen, Markus and Aksu, Hidayet and Conti, Mauro and Sadeghi, Ahmad-Reza and Uluagac, Selcuk},
+  date = {2020-07-08},
+  eprint = {1808.02741},
+  eprinttype = {arXiv},
+  eprintclass = {cs},
+  pages = {207--218},
+  doi = {10.1145/3395351.3399421},
+  abstract = {A myriad of IoT devices such as bulbs, switches, speakers in a smart home environment allow users to easily control the physical world around them and facilitate their living styles through the sensors already embedded in these devices. Sensor data contains a lot of sensitive information about the user and devices. However, an attacker inside or near a smart home environment can potentially exploit the innate wireless medium used by these devices to exfiltrate sensitive information from the encrypted payload (i.e., sensor data) about the users and their activities, invading user privacy. With this in mind,in this work, we introduce a novel multi-stage privacy attack against user privacy in a smart environment. It is realized utilizing state-of-the-art machine-learning approaches for detecting and identifying the types of IoT devices, their states, and ongoing user activities in a cascading style by only passively sniffing the network traffic from smart home devices and sensors. The attack effectively works on both encrypted and unencrypted communications. We evaluate the efficiency of the attack with real measurements from an extensive set of popular off-the-shelf smart home IoT devices utilizing a set of diverse network protocols like WiFi, ZigBee, and BLE. Our results show that an adversary passively sniffing the traffic can achieve very high accuracy (above 90\%) in identifying the state and actions of targeted smart home devices and their users. To protect against this privacy leakage, we also propose a countermeasure based on generating spoofed traffic to hide the device states and demonstrate that it provides better protection than existing solutions.},
+  keywords = {BLE,Computer Science - Cryptography and Security,network traffic,privacy,smart-home,wifi,ZigBee},
+  file = {/home/seb/Zotero/storage/HKM4PAZW/Acar et al. - 2020 - Peek-a-Boo I see your smart home activities, even.pdf;/home/seb/Zotero/storage/ISVLWPED/1808.html}
+}
+
+@article{pmsSpinellis2012,
+  title = {Package {{Management Systems}}},
+  author = {Spinellis, Diomidis},
+  date = {2012-03},
+  journaltitle = {IEEE Software},
+  shortjournal = {IEEE Softw.},
+  volume = {29},
+  number = {2},
+  pages = {84--86},
+  issn = {1937-4194},
+  doi = {10.1109/MS.2012.38},
+  abstract = {A package management system organizes and simplifies the installation and maintenance of software by standardizing and organizing the production and consumption of software collections. As a software developer, you can benefit from package managers in two ways: through a rich and stable development environment and through friction-free reuse. Promisingly, the structure that package managers bring both to the tools we use in our development process and the libraries we reuse in our products ties nicely with the recent move emphasizing DevOps (development operations) as an integration between software development and IT operations.},
+  eventtitle = {{{IEEE Software}}},
+  keywords = {DevOps,Maintenance engineering,module dependencies,package management system,Product management,shared library,Software libraries,Software reusability,software reuse},
+  file = {/home/seb/Zotero/storage/DA6A82Z4/6155145.html}
+}
+
+@online{poetry,
+  title = {Poetry - {{Python}} Dependency Management and Packaging Made Easy},
+  url = {https://python-poetry.org/},
+  urldate = {2024-06-30},
+  file = {/home/seb/Zotero/storage/BYK5CXZT/python-poetry.org.html}
+}
+
+@online{pydantic,
+  title = {Welcome to {{Pydantic}} - {{Pydantic}}},
+  url = {https://docs.pydantic.dev/latest/},
+  urldate = {2024-07-01},
+  file = {/home/seb/Zotero/storage/FF8XYTKG/latest.html}
+}
+
+@online{pythonorg,
+  title = {Welcome to {{Python}}.Org},
+  date = {2024-06-27},
+  url = {https://www.python.org/},
+  urldate = {2024-06-30},
+  abstract = {The official home of the Python Programming Language},
+  langid = {english},
+  organization = {Python.org},
+  keywords = {tool},
+  file = {/home/seb/Zotero/storage/BKHKLAP9/www.python.org.html}
+}
+
+@online{recommendedformatrsLOC,
+  type = {web page},
+  title = {Recommended {{Formats Statement}} – {{Datasets}} | {{Resources}} ({{Preservation}}, {{Library}} of {{Congress}})},
+  url = {https://www.loc.gov/preservation/resources/rfs/data.html},
+  urldate = {2024-06-23},
+  abstract = {Lists technical characteristics of and metadata for datasets that best support the preservation of and long-term access to these creative works. Identifies the formats the Library of Congress prefers or finds acceptable.},
+  langid = {english},
+  file = {/home/seb/Zotero/storage/G5K5R8ES/data.html}
+}
+
+@article{romanfeatures2013,
+  title = {On the Features and Challenges of Security and Privacy in Distributed Internet of Things},
+  author = {Roman, Rodrigo and Zhou, Jianying and Lopez, Javier},
+  date = {2013-07-05},
+  journaltitle = {Computer Networks},
+  shortjournal = {Computer Networks},
+  series = {Towards a {{Science}} of {{Cyber Security}}},
+  volume = {57},
+  number = {10},
+  pages = {2266--2279},
+  issn = {1389-1286},
+  doi = {10.1016/j.comnet.2012.12.018},
+  abstract = {In the Internet of Things, services can be provisioned using centralized architectures, where central entities acquire, process, and provide information. Alternatively, distributed architectures, where entities at the edge of the network exchange information and collaborate with each other in a dynamic way, can also be used. In order to understand the applicability and viability of this distributed approach, it is necessary to know its advantages and disadvantages – not only in terms of features but also in terms of security and privacy challenges. The purpose of this paper is to show that the distributed approach has various challenges that need to be solved, but also various interesting properties and strengths.},
+  keywords = {connectivity,Distributed Architectures,Internet of Things,iot,network,Security},
+  file = {/home/seb/Zotero/storage/CNBJ9Q6H/S1389128613000054.html}
+}
+
+@online{rrrr2023,
+  title = {Repeatability, {{Reproducibility}}, {{Replicability}}, {{Reusability}} ({{4R}}) in {{Journals}}' {{Policies}} and {{Software}}/{{Data Management}} in {{Scientific Publications}}: {{A Survey}}, {{Discussion}}, and {{Perspectives}}},
+  shorttitle = {Repeatability, {{Reproducibility}}, {{Replicability}}, {{Reusability}} ({{4R}}) in {{Journals}}' {{Policies}} and {{Software}}/{{Data Management}} in {{Scientific Publications}}},
+  author = {Hernández, José Armando and Colom, Miguel},
+  date = {2023-12-18},
+  eprint = {2312.11028},
+  eprinttype = {arXiv},
+  eprintclass = {cs},
+  doi = {10.48550/arXiv.2312.11028},
+  abstract = {With the recognized crisis of credibility in scientific research, there is a growth of reproducibility studies in computer science, and although existing surveys have reviewed reproducibility from various perspectives, especially very specific technological issues, they do not address the author-publisher relationship in the publication of reproducible computational scientific articles. This aspect requires significant attention because it is the basis for reliable research. We have found a large gap between the reproducibility-oriented practices, journal policies, recommendations, publisher artifact Description/Evaluation guidelines, submission guides, technological reproducibility evolution, and its effective adoption to contribute to tackling the crisis. We conducted a narrative survey, a comprehensive overview and discussion identifying the mutual efforts required from Authors, Journals, and Technological actors to achieve reproducibility research. The relationship between authors and scientific journals in their mutual efforts to jointly improve the reproducibility of scientific results is analyzed. Eventually, we propose recommendations for the journal policies, as well as a unified and standardized Reproducibility Guide for the submission of scientific articles for authors. The main objective of this work is to analyze the implementation and experiences of reproducibility policies, techniques and technologies, standards, methodologies, software, and data management tools required for scientific reproducible publications. Also, the benefits and drawbacks of such an adoption, as well as open challenges and promising trends, to propose possible strategies and efforts to mitigate the identified gaps. To this purpose, we analyzed 200 scientific articles, surveyed 16 Computer Science journals, and systematically classified them according to reproducibility strategies, technologies, policies, code citation, and editorial business. We conclude there is still a reproducibility gap in scientific publications, although at the same time also the opportunity to reduce this gap with the joint effort of authors, publishers, and technological providers.},
+  pubstate = {prepublished},
+  keywords = {Computer Science - Software Engineering,repeatability,replicability,reproducibility,reusability},
+  file = {/home/seb/Zotero/storage/TD6WP27L/Hernández and Colom - 2023 - Repeatability, Reproducibility, Replicability, Reu.pdf;/home/seb/Zotero/storage/PQMREEDV/2312.html}
+}
+
+@article{sibonitestbed2019,
+  title = {Security {{Testbed}} for {{Internet-of-Things Devices}}},
+  author = {Siboni, Shachar and Sachidananda, Vinay and Meidan, Yair and Bohadana, Michael and Mathov, Yael and Bhairav, Suhas and Shabtai, Asaf and Elovici, Yuval},
+  date = {2019-03},
+  journaltitle = {IEEE Transactions on Reliability},
+  shortjournal = {IEEE Trans. Reliab.},
+  volume = {68},
+  number = {1},
+  pages = {23--44},
+  issn = {1558-1721},
+  doi = {10.1109/TR.2018.2864536},
+  abstract = {The Internet of Things (IoT) is a global ecosystem of information and communication technologies aimed at connecting any type of object (thing), at any time, and in any place, to each other and to the Internet. One of the major problems associated with the IoT is the heterogeneous nature of such deployments; this heterogeneity poses many challenges, particularly, in the areas of security and privacy. Specifically, security testing and analysis of IoT devices is considered a very complex task, as different security testing methodologies, including software and hardware security testing approaches, are needed. In this paper, we propose an innovative security testbed framework targeted at IoT devices. The security testbed is aimed at testing all types of IoT devices, with different software/hardware configurations, by performing standard and advanced security testing. Advanced analysis processes based on machine learning algorithms are employed in the testbed in order to monitor the overall operation of the IoT device under test. The architectural design of the proposed security testbed along with a detailed description of the testbed implementation is discussed. The testbed operation is demonstrated on different IoT devices using several specific IoT testing scenarios. The results obtained demonstrate that the testbed is effective at detecting vulnerabilities and compromised IoT devices.},
+  eventtitle = {{{IEEE Transactions}} on {{Reliability}}},
+  keywords = {Hardware,Internet of Things,Internet of Things (IoT),IoT devices,privacy,security,Security,Software,Standards,testbed framework,Testing},
+  file = {/home/seb/Zotero/storage/SVD5VNTV/Siboni et al. - 2019 - Security Testbed for Internet-of-Things Devices.pdf;/home/seb/Zotero/storage/VXRRDTR9/8565917.html}
+}
+
+@article{surveytestingmethods2022,
+  title = {Survey of {{Testing Methods}} and {{Testbed Development Concerning Internet}} of {{Things}}},
+  author = {Zhu, Shicheng and Yang, Shunkun and Gou, Xiaodong and Xu, Yang and Zhang, Tao and Wan, Yueliang},
+  date = {2022-03-01},
+  journaltitle = {Wireless Personal Communications},
+  shortjournal = {Wireless Pers Commun},
+  volume = {123},
+  number = {1},
+  pages = {165--194},
+  issn = {1572-834X},
+  doi = {10.1007/s11277-021-09124-5},
+  abstract = {The concept of Internet of Things (IoT) was designed to change everyday lives of people via multiple forms of computing and easy deployment of applications. In recent years, the increasing complexity of IoT-ready devices and processes has led to potential risks related to system reliability. Therefore, the comprehensive testing of IoT technology has attracted the attention of many researchers, which promotes the extensive development of IoT testing methods and infrastructure. However, the current research on IoT testing methods and testbeds mainly focuses on specific application scenarios, lacking systematic review and analysis of many applications from different points of view. This paper systematically summarizes the latest testing methods covering different IoT fields and discusses the development status of the existing Internet of things testbed. Findings of this review demonstrate that IoT testing is moving toward larger scale and intelligent testing, and that in near future, IoT test architecture is set to become more standardized and universally applicable with multi-technology convergence—i.e., a combination of big data, cloud computing, and artificial intelligence—being the prime focus of IoT testing.},
+  langid = {english},
+  keywords = {Internet of Things,IoT testing,Testbed,Testing method},
+  file = {/home/seb/Zotero/storage/ZZ6KBCP6/Zhu et al. - 2022 - Survey of Testing Methods and Testbed Development .pdf}
+}
+
+@article{tbsmartgrid2013,
+  title = {Cyber-{{Physical Security Testbeds}}: {{Architecture}}, {{Application}}, and {{Evaluation}} for {{Smart Grid}}},
+  shorttitle = {Cyber-{{Physical Security Testbeds}}},
+  author = {Hahn, Adam and Ashok, Aditya and Sridhar, Siddharth and Govindarasu, Manimaran},
+  date = {2013-06},
+  journaltitle = {IEEE Transactions on Smart Grid},
+  shortjournal = {IEEE Trans. Smart Grid},
+  volume = {4},
+  number = {2},
+  pages = {847--855},
+  issn = {1949-3061},
+  doi = {10.1109/TSG.2012.2226919},
+  abstract = {The development of a smarter electric grid will depend on increased deployments of information and communication technology (ICT) to support novel communication and control functions. Unfortunately, this additional dependency also expands the risk from cyber attacks. Designing systems with adequate cyber security depends heavily on the availability of representative environments, such as testbeds, where current issues and future ideas can be evaluated. This paper provides an overview of a smart grid security testbed, including the set of control, communication, and physical system components required to provide an accurate cyber-physical environment. It then identifies various testbed research applications and also identifies how various components support these applications. The PowerCyber testbed at Iowa State University is then introduced, including the architecture, applications, and novel capabilities, such as virtualization, Real Time Digital Simulators (RTDS), and ISEAGE WAN emulation. Finally, several attack scenarios are evaluated using the testbed to explore cyber-physical impacts. In particular, availability and integrity attacks are demonstrated with both isolated and coordinated approaches, these attacks are then evaluated based on the physical system's voltage and rotor angle stability.},
+  eventtitle = {{{IEEE Transactions}} on {{Smart Grid}}},
+  keywords = {Computer architecture,cyber security,Cyber-physical systems,ieee,iot,Protocols,Real-time systems,Security,smart grid,Smart grids,Software,Substations,testbed,testbeds},
+  file = {/home/seb/Zotero/storage/DHKLTKRM/6473865.html}
+}
+
+@online{tcpdump,
+  title = {Home | {{TCPDUMP}} \& {{LIBPCAP}}},
+  url = {https://www.tcpdump.org/},
+  urldate = {2024-06-30},
+  file = {/home/seb/Zotero/storage/SXMBIDLR/www.tcpdump.org.html}
+}
+
+@online{testbedOxford,
+  title = {Test Bed Noun - {{Definition}}, Pictures, Pronunciation and Usage Notes | {{Oxford Advanced Learner}}'s {{Dictionary}} at {{OxfordLearnersDictionaries}}.Com},
+  url = {https://www.oxfordlearnersdictionaries.com/definition/english/test-bed},
+  urldate = {2024-06-20}
+}
+
+@inproceedings{ukilEmbeddedSecurityInternet2011,
+  title = {Embedded Security for {{Internet}} of {{Things}}},
+  booktitle = {2011 2nd {{National Conference}} on {{Emerging Trends}} and {{Applications}} in {{Computer Science}}},
+  author = {Ukil, Arijit and Sen, Jaydip and Koilakonda, Sripad},
+  date = {2011-03},
+  pages = {1--6},
+  doi = {10.1109/NCETACS.2011.5751382},
+  abstract = {Internet of Things (IoT) consists of several tiny devices connected together to form a collaborative computing environment. IoT imposes peculiar constraints in terms of connectivity, computational power and energy budget, which make it significantly different from those contemplated by the canonical doctrine of security in distributed systems. In order to circumvent the problem of security in IoT domain, networks and devices need to be secured. In this paper, we consider the embedded device security only, assuming that network security is properly in place. It can be noticed that the existence of tiny computing devices that form ubiquity in IoT domain are very much vulnerable to different security attacks. In this work, we provide the requirements of embedded security, the solutions to resists different attacks and the technology for resisting temper proofing of the embedded devices by the concept of trusted computing. Our paper attempts to address the issue of security for data at rest. Addressing this issue is equivalent to addressing the security issue of the hardware platform. Our work also partially helps in addressing securing data in transit.},
+  eventtitle = {2011 2nd {{National Conference}} on {{Emerging Trends}} and {{Applications}} in {{Computer Science}}},
+  keywords = {ARM,Computer architecture,confidentiality,embedded device,Embedded systems,Hardware,Internet of things (IoT),Protocols,security,Security,Smart phones,Trustzone,ubiquitous computing},
+  file = {/home/seb/Zotero/storage/IQGX2SWB/5751382.html}
+}
+
+@thesis{vacuumpie2023,
+  type = {Master Thgesis},
+  title = {Private {{Information Exposed}} by the {{Use}} of {{Robot Vacuum Cleaner}} in {{Smart Environments}}},
+  author = {Ulsmåg, Benjamin Andreas},
+  date = {2023-01-06},
+  institution = {{Norwegian University of Science and Technology}},
+  location = {Gjøvik},
+  abstract = {Robot vacuum cleaners are popular IoT devices and are deployed in all kinds of smart environments. Integration with IoT systems introduce more security and privacy issues related to the operation of these devices. Vendors have developed smart phone applications where users can personalize cleaning or view informa- tion about the vacuum cleaner. This increase the integration between user’s life and the robot vacuum cleaner, which potentially exposes private information. In- dustry standards include end-to-end encryption between the application, cloud service and robot vacuum cleaner to secure the private information exchanged. Regardless of encryption, network header metadata is still available through net- work eavesdropping attacks. In this project we investigated the potential private information exposed by this metadata. An Irobot Roomba i7 was deployed in two different smart environments where passive network eavesdropping was conduc- ted during smart feature triggering. Analysis revealed that it was possible to attrib- ute different events triggered on the Irobot Roomba i7, only based on metadata in the Internet traffic capture. Different signature-based detection algorithms are proposed, with a high detection rate. Wi-Fi and Internet capturing metadata were compared and similar patterns were identified, making the detection method ap- plicable for Wi-Fi eavesdropping as well. This thesis covers the implementation, capturing and analysis of network traffic and proposes event detection algorithms.},
+  langid = {english}
+}
+
+@article{vassermanVampireAttacksDraining2013,
+  title = {Vampire {{Attacks}}: {{Draining Life}} from {{Wireless Ad Hoc Sensor Networks}}},
+  shorttitle = {Vampire {{Attacks}}},
+  author = {Vasserman, Eugene Y. and Hopper, Nicholas},
+  date = {2013-02},
+  journaltitle = {IEEE Transactions on Mobile Computing},
+  shortjournal = {IEEE Trans. Mob. Comput.},
+  volume = {12},
+  number = {2},
+  pages = {318--332},
+  issn = {1558-0660},
+  doi = {10.1109/TMC.2011.274},
+  abstract = {Ad hoc low-power wireless networks are an exciting research direction in sensing and pervasive computing. Prior security work in this area has focused primarily on denial of communication at the routing or medium access control levels. This paper explores resource depletion attacks at the routing protocol layer, which permanently disable networks by quickly draining nodes' battery power. These "Vampire” attacks are not specific to any specific protocol, but rather rely on the properties of many popular classes of routing protocols. We find that all examined protocols are susceptible to Vampire attacks, which are devastating, difficult to detect, and are easy to carry out using as few as one malicious insider sending only protocol-compliant messages. In the worst case, a single Vampire can increase network-wide energy usage by a factor of O(N), where N in the number of network nodes. We discuss methods to mitigate these types of attacks, including a new proof-of-concept protocol that provably bounds the damage caused by Vampires during the packet forwarding phase.},
+  eventtitle = {{{IEEE Transactions}} on {{Mobile Computing}}},
+  keywords = {ad hoc networks,Ad hoc networks,Denial of service,Energy consumption,Network topology,routing,Routing,Routing protocols,security,sensor networks,Topology,wireless networks},
+  file = {/home/seb/Zotero/storage/W96J7MD8/Vasserman and Hopper - 2013 - Vampire Attacks Draining Life from Wireless Ad Ho.pdf;/home/seb/Zotero/storage/TY3DMJZZ/6112758.html}
+}
+
+@article{vaughan2005use,
+  title = {The Use of Climate Chambers in Biological Research},
+  author = {family=Vaughan, given=TL, given-i=TL and family=Battle, given=SC, given-i=SC and family=Walker, given=KL, given-i=KL},
+  date = {2005},
+  journaltitle = {Environmental Science \& Technology},
+  shortjournal = {Environ. Sci. Technol.},
+  volume = {39},
+  number = {14},
+  pages = {5121--5127},
+  publisher = {ACS Publications}
+}
+
+@article{whatissmartdevice2018,
+  title = {What Is a Smart Device? - a Conceptualisation within the Paradigm of the Internet of Things},
+  author = {Silverio-Fernández, Manuel and Renukappa, Suresh and Suresh, Subashini},
+  date = {2018-05-09},
+  journaltitle = {Visualization in Engineering},
+  shortjournal = {Visualization in Engineering},
+  volume = {6},
+  number = {1},
+  pages = {3},
+  issn = {2213-7459},
+  doi = {10.1186/s40327-018-0063-8},
+  abstract = {The Internet of Things (IoT) is an interconnected network of objects which range from simple sensors to smartphones and tablets; it is a relatively novel paradigm that has been rapidly gaining ground in the scenario of modern wireless telecommunications with an expected growth of 25 to 50 billion of connected devices for 2020 Due to the recent rise of this paradigm, authors across the literature use inconsistent terms to address the devices present in the IoT, such as mobile device, smart device, mobile technologies or mobile smart device. Based on the existing literature, this paper chooses the term smart device as a starting point towards the development of an appropriate definition for the devices present in the IoT. This investigation aims at exploring the concept and main features of smart devices as well as their role in the IoT. This paper follows a systematic approach for reviewing compendium of literature to explore the current research in this field. It has been identified smart devices as the primary objects interconnected in the network of IoT, having an essential role in this paradigm. The developed concept for defining smart device is based on three main features, namely context-awareness, autonomy and device connectivity. Other features such as mobility and user-interaction were highly mentioned in the literature, but were not considered because of the nature of the IoT as a network mainly oriented to device-to-device connectivity whether they are mobile or not and whether they interact with people or not. What emerges from this paper is a concept which can be used to homogenise the terminology used on further research in the Field of digitalisation and smart technologies.}
+}
+
+@article{wilkinson_fair_2016,
+  title = {The {{FAIR Guiding Principles}} for Scientific Data Management and Stewardship},
+  author = {Wilkinson, Mark D. and Swertz, Morris A. and family=al., prefix=et, useprefix=true},
+  date = {2016-03-15},
+  journaltitle = {Scientific Data},
+  shortjournal = {Sci Data},
+  volume = {3},
+  number = {1},
+  pages = {160018},
+  publisher = {Nature Publishing Group},
+  issn = {2052-4463},
+  doi = {10.1038/sdata.2016.18},
+  abstract = {There is an urgent need to improve the infrastructure supporting the reuse of scholarly data. A diverse set of stakeholders—representing academia, industry, funding agencies, and scholarly publishers—have come together to design and jointly endorse a concise and measureable set of principles that we refer to as the FAIR Data Principles. The intent is that these may act as a guideline for those wishing to enhance the reusability of their data holdings. Distinct from peer initiatives that focus on the human scholar, the FAIR Principles put specific emphasis on enhancing the ability of machines to automatically find and use the data, in addition to supporting its reuse by individuals. This Comment is the first formal publication of the FAIR Principles, and includes the rationale behind them, and some exemplar implementations in the community.},
+  langid = {english},
+  keywords = {Publication characteristics,Research data},
+  file = {/home/seb/Zotero/storage/LDIYYE8H/Wilkinson et al. - 2016 - The FAIR Guiding Principles for scientific data ma.pdf}
+}
+
+@online{wiresharkorg,
+  title = {Wireshark · {{Go Deep}}},
+  url = {https://www.wireshark.org/},
+  urldate = {2024-06-30},
+  file = {/home/seb/Zotero/storage/SZ3UZZG4/www.wireshark.org.html}
+}
+
+@article{zander2014survey,
+  title = {A Survey of Testbeds and Experimental Research Infrastructures for Wireless Networks},
+  author = {Zander, Justus and Zinner, Thomas and Bifulco, Roberto and Carle, Georg},
+  date = {2014},
+  journaltitle = {IEEE Communications Surveys \& Tutorials},
+  shortjournal = {IEEE Commun. Surv. Tutor.},
+  volume = {15},
+  number = {4},
+  pages = {1231--1246},
+  publisher = {IEEE},
+  keywords = {iot,springer,survey,testbed}
+}