toolsaf 0.2.0__tar.gz

toolsaf-0.2.0/Info.md

@@ -0,0 +1,16 @@
+# Toolsaf
+
+Welcome to the **Toolsaf**, a tool-driven security assessment framework.
+Toolsaf is for security assessment of _Internet of Things_ (IoT) and other systems using different security tools.
+Security assessment process using Toolsaf has two main phases:
+
+  1. Creation of a _security statement_ which describes security-related features of an IoT product or system.
+  2. Verification of the security statement with security tools, thus confirming the security posture of the product or system.
+
+Some of the applications of this approach could be:
+
+  1. Security testing and regression testing of IoT systems.
+  2. Communicating system security properites in a machine-readable and verifiable format.
+  3. Documenting results of a system's reverse-engineering.
+
+Toolsaf is an open-source project driven by [Test of Things](https://testofthings.com). More information about toolsaf can be found in [Toolsaf Github](https://github.com/testofthings/toolsaf).

toolsaf-0.2.0/LICENSE

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

toolsaf-0.2.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: toolsaf
+Version: 0.2.0
+Summary: Tool-Driven Security Assesment Framework
+Author-email: Rauli Kaksonen <rauli.kaksonen@testofthings.com>
+License: MIT License
+Project-URL: Repository, https://github.com/testofthings/toolsaf.git
+Project-URL: Documentation, https://github.com/testofthings/toolsaf/tree/main/documentation
+Project-URL: Issues, https://github.com/testofthings/toolsaf/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: packet-framing
+Requires-Dist: censys
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
+Requires-Dist: sqlalchemy
+Requires-Dist: watchdog
+Requires-Dist: colored
+Requires-Dist: diagrams
+Requires-Dist: shodan
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
+
+# Toolsaf
+
+Welcome to the **Toolsaf**, a tool-driven security assessment framework.
+Toolsaf is for security assessment of _Internet of Things_ (IoT) and other systems using different security tools.
+Security assessment process using Toolsaf has two main phases:
+
+  1. Creation of a _security statement_ which describes security-related features of an IoT product or system.
+  2. Verification of the security statement with security tools, thus confirming the security posture of the product or system.
+
+Some of the applications of this approach could be:
+
+  1. Security testing and regression testing of IoT systems.
+  2. Communicating system security properites in a machine-readable and verifiable format.
+  3. Documenting results of a system's reverse-engineering.
+
+Toolsaf is an open-source project driven by [Test of Things](https://testofthings.com). More information about toolsaf can be found in [Toolsaf Github](https://github.com/testofthings/toolsaf).

toolsaf-0.2.0/README.md

@@ -0,0 +1,115 @@
+# Toolsaf
+
+[Table of contents](documentation/README.md)
+
+Welcome to the early version of **Toolsaf**, a tool-driven security assessment framework.
+Toolsaf is for security assessment of _Internet of Things_ (IoT) and other systems using different security tools.
+Security assessment process using Toolsaf has two main phases:
+
+  1. Creation of a _security statement_ which describes security-related features of an IoT product or system.
+  2. Verification of the security statement with security tools, thus confirming the security posture of the product or system.
+
+Some of the applications of this approach could be:
+
+  1. Security testing and regression testing of IoT systems.
+  2. Communicating system security properites in a machine-readable and verifiable format.
+  3. Documenting results of a system's reverse-engineering.
+
+Toolsaf is an open-source project driven by [Test of Things](https://testofthings.com).
+It was originally created as part of Rauli Kaksonen's doctoral thesis "[Transparent and tool-driven security assessment for sustainable IoT cybersecurity](https://urn.fi/URN:NBN:fi:oulu-202406264941)" under the name of 'tcsfw'.
+The thesis introduces _Tool-driven security assessment_ (TDSA) to enhance the cybersecurity of
+IoT products and systems.
+
+## How Toolsaf and TDSA work?
+
+The basic idea of TDSA is to first describe the IoT system or product with
+the security statement, then use tools to verify that the security statement is accurate, and finally use
+the statement for different purposes.
+A security statement provides a machine-readable description of the system's security,
+which allows automated verification.
+
+At the moment, security statements are created by Toolsaf using a dedicated Python-based _Domain-Specific Language_ (DSL).
+(JSON-based format is under development).
+Security statement verification is done by running any of the [supported tools](documentation/Tools.md) and saving their output. Toolsaf uses the tools' output to verify that the security statement is accurate.
+Some tools perform their own security checks, which can be incorporated into the security statement verdict.
+
+## Getting Started with Toolsaf
+
+The following shows how to start using Toolsaf.
+For this, you need to perform two tasks:
+
+  1.  Install the Toolsaf Python module.
+  2.  Initialize a new or copy an existing security statement.
+
+You need a recent [Python](https://www.python.org/) interpreter, such as 3.10 or newer.
+Most Linux distributions should already come with a suitable one, the command
+name might be `python3` to separate from older Python interpreters.
+
+Create virtual environment to install Toolsaf and run it. Then install from PyPI with 'pip'.
+
+```shell
+python3 -m venv .venv
+source .venv/bin/activate   # Activate the virtual environment
+pip install toolsaf
+```
+Now that Toolsaf is installed, you have to create a directory for your first security statement.
+The commands below produce the [expected project structure](documentation/CreatingSecurityStatements.md#project-structure) for your statement.
+
+```shell
+mkdir statement-device
+cd statement-device
+mkdir product
+touch product/statement.py  # This is the 'security statement'!
+```
+
+Alternatively, you may copy an existing security statement.
+In that case you must also create and activate the virtual environment and install the Toolsaf module.
+
+If you want to visualize your security statements you also need to install [Graphviz](https://graphviz.org/download/).
+
+In the above, we used _venv_ virtual environments, but as security statements are essentially
+Python-code, any other environment should work fine.
+
+## Working with Security Statements
+
+To recap, a security statement is Python DSL code in its own directory, which uses the Toolsaf Python module.
+There are two basic approaches to create a security statement:
+
+  1. Write the security statement code first, then run tools and verify it.
+  2. Run tools to collect information first, then write security statement to match the findings.
+
+If you’re the device manufacturer you will likely use the former approach, as you (hopefully)
+know your product's attack surface and other properties.
+If you are a security researcher who is reverse-engineering or pen-testing a product,
+you have to use the latter approach.
+
+The following documents describe security statements creation and verification:
+
+  - [Creating Security Statements](documentation/CreatingSecurityStatements.md)
+  - [Verifying Security Statements](documentation/VerifyingSecurityStatements.md)
+
+## Command Line Options
+
+Toolsaf is a command-line tool, and its command-line options are listed [here](documentation/CommandLineOptions.md).
+
+## Sample Security Statements
+Minimal security statement examples are available in the `samples` directory. They can be executed like this:
+```shell
+python samples/device-backend/statement.py
+```
+The command outputs basic information about the security statement.
+
+Security statements for **real devices** are available in their own repositories:
+- [Ruuvi Gateway & Tags](https://github.com/testofthings/statement-ruuvi/)
+- [Deltaco Smart Outdoor Plug](https://github.com/testofthings/statement-deltaco-smart-outdoor-plug)
+- [IPC360](https://github.com/testofthings/statement-IPC360)
+
+## Contact
+
+Contact Toolsaf team by mail <code>&#116;&#111;&#111;&#108;&#115;&#97;&#102;&#32;&#97;&#116;&#32;&#116;&#101;&#115;&#116;&#111;&#102;&#116;&#104;&#105;&#110;&#103;&#115;&#46;&#99;&#111;&#109;</code>
+
+## License and Contributions
+
+The project is published with [MIT license](LICENSE).
+
+We are happy to accept contributions to Toolsaf, please see the [instructions](documentation/Contributing.md).

toolsaf-0.2.0/pyproject.toml

@@ -0,0 +1,89 @@
+[build-system]
+requires        = ["setuptools"]
+build-backend   = "setuptools.build_meta"
+
+# Project metadata
+[project]
+name            = "toolsaf"
+version         = "0.2.0"
+requires-python = ">=3.10"
+description     = "Tool-Driven Security Assesment Framework"
+readme          = "Info.md"
+license         = {text = "MIT License"}
+authors         = [
+    {name = "Rauli Kaksonen", email = "rauli.kaksonen@testofthings.com"}
+]
+classifiers     = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "packet-framing",
+    "censys",
+    "aiohttp",
+    "aiofiles",
+    "sqlalchemy",
+    "watchdog",
+    "colored",
+    "diagrams",
+    "shodan"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pylint",
+    "mypy"
+]
+
+[project.urls]
+Repository      = "https://github.com/testofthings/toolsaf.git"
+Documentation   = "https://github.com/testofthings/toolsaf/tree/main/documentation"
+Issues          = "https://github.com/testofthings/toolsaf/issues"
+
+# Setuptools config
+[tool.setuptools.packages]
+find = { where = ["."], include = [
+        "toolsaf",
+        "toolsaf.adapters",
+        "toolsaf.common",
+        "toolsaf.common.serializer",
+        "toolsaf.core",
+        "toolsaf.core.serializer"
+] }
+
+[tool.setuptools.package-data]
+"toolsaf.adapters"  = ["data/*.json"]
+"toolsaf"           = ["diagram_visualizer/*.png"]
+
+[tool.setuptools]
+include-package-data = true
+
+# Pytest config
+[tool.pytest.ini_options]
+pythonpath = "."
+
+# Pylint config
+[tool.pylint.format]
+max-line-length = 120
+
+[tool.pylint.messages_control]
+disable = [
+    "too-few-public-methods",
+    "too-many-arguments",
+    "too-many-public-methods",
+    "too-many-locals",
+    "too-many-instance-attributes",
+    "too-many-branches",
+    "too-many-statements",
+    "too-many-lines",
+    "too-many-positional-arguments",
+    "too-many-return-statements"
+]
+
+# Mypy config
+[tool.mypy]
+show_error_codes    = true
+disable_error_code  = ["import-untyped"]
+strict              = true
+follow_imports      = "silent"

toolsaf-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

toolsaf-0.2.0/tests/test_address.py

@@ -0,0 +1,312 @@
+from typing import Optional
+from ipaddress import IPv4Network
+from toolsaf.common.address import (
+    Addresses, DNSName, EndpointAddress, EntityTag, HWAddress, HWAddresses, PseudoAddress,
+    IPAddress, IPAddresses, Network, Protocol, AddressSequence, AddressSegment, AnyAddress
+)
+from toolsaf.common.traffic import Protocol
+from toolsaf.main import HTTP, TCP, BLEAdvertisement
+from tests.test_model import Setup
+
+
+def test_hw_address():
+    ad = HWAddress("00:11:22:33:44:55")
+    assert f"{ad}" == "00:11:22:33:44:55"
+    assert ad.get_parseable_value() == "00:11:22:33:44:55|hw"
+    assert ad.is_null() is False
+    assert ad.is_global() is False
+    assert ad == HWAddress.new("00:11:22:33:44:55")
+    assert ad == HWAddress.new("0:11:22:33:44:55")
+
+    assert HWAddresses.NULL == HWAddress.new("00:00:00:00:00:00")
+    assert HWAddresses.NULL.is_null() is True
+
+
+def test_ip_address():
+    ad = IPAddress.new("1.2.3.4")
+    assert f"{ad}" == "1.2.3.4"
+    assert ad.get_parseable_value() == "1.2.3.4"
+    assert ad.is_null() is False
+    assert ad.is_global() is True
+
+    assert IPAddress.new("0.0.0.0") == IPAddresses.NULL
+    assert IPAddresses.NULL.is_null() is True
+    assert IPAddresses.NULL.is_global() is False
+
+    assert IPAddress.new("192.168.1.1").is_global() is False
+
+
+def test_dns_name():
+    ad = DNSName("www.example.com")
+    assert f"{ad}" == "www.example.com"
+    assert ad.get_parseable_value() == "www.example.com|name"
+    assert ad.is_null() is False
+    assert ad.is_global() is True
+    assert ad == DNSName("www.example.com")
+    assert ad != DNSName("www.example.org")
+
+
+def test_endpoint_address():
+    ad = EndpointAddress.ip("1.2.3.4", Protocol.UDP, 1234)
+    assert f"{ad}" == "1.2.3.4/udp:1234"
+    assert ad.get_parseable_value() == "1.2.3.4/udp:1234"
+    assert ad.get_host() == IPAddress.new("1.2.3.4")
+    assert ad.protocol == Protocol.UDP
+    assert ad.port == 1234
+
+    ad = EndpointAddress.hw("0:1:2:3:4:5", Protocol.UDP, 1234)
+    assert f"{ad}" == "00:01:02:03:04:05/udp:1234"
+    assert ad.get_parseable_value() == "00:01:02:03:04:05|hw/udp:1234"
+
+
+def test_parse_address():
+    a = Addresses.parse_address("1.2.3.4")
+    assert isinstance(a, IPAddress)
+    assert f"{a}" == "1.2.3.4"
+
+    a = Addresses.parse_address("www.example.com|name")
+    assert isinstance(a, DNSName)
+    assert f"{a}" == "www.example.com"
+
+    a = Addresses.parse_address("1:2:3:4:5:6|hw")
+    assert isinstance(a, HWAddress)
+    assert f"{a}" == "01:02:03:04:05:06"
+
+
+def test_parse_endpoint_address():
+    a = Addresses.parse_endpoint("1.2.3.4/udp:1234")
+    assert isinstance(a, EndpointAddress)
+    assert f"{a}" == "1.2.3.4/udp:1234"
+    assert a.get_host() == IPAddress.new("1.2.3.4")
+    assert a.protocol == Protocol.UDP
+    assert a.port == 1234
+
+    a = Addresses.parse_endpoint("1:2:3:4:5:6|hw/HTTP")
+    assert f"{a}" == "01:02:03:04:05:06/http"
+    assert a.get_host() == HWAddress.new("01:02:03:04:05:06")
+    assert a.protocol == Protocol.HTTP
+    assert a.port == -1
+
+    ad = EndpointAddress(EntityTag.new("xxx"), Protocol.ETHERNET, 35000)
+    assert f"{ad}" == "xxx/eth:35000"
+    ad2 = Addresses.parse_endpoint(ad.get_parseable_value())
+    assert ad == ad2
+
+
+def test_hw_address_generation():
+    ip = IPAddress.new("192.168.0.2")
+    hw = HWAddress.from_ip(ip)
+    assert hw == HWAddress('40:00:c0:a8:00:02')
+
+
+def test_ip_network_matching():
+    nw = Network("net", ip_network=IPv4Network("22.33.0.0/16"))
+    assert not nw.is_local(IPAddress.new("22.2.3.4"))
+    assert nw.is_local(IPAddress.new("22.33.3.4"))
+    assert nw.is_local(IPAddress.new("22.33.33.4"))
+
+    nw = Network("net", ip_network=IPv4Network("0.0.0.0/0"))
+    assert nw.is_local(IPAddress.new("22.33.3.4"))
+    assert nw.is_local(IPAddress.new("22.2.3.4"))
+    assert nw.is_local(IPAddress.new("22.33.3.4"))
+    assert nw.is_local(IPAddress.new("22.33.33.4"))
+
+
+def _segment(address: AnyAddress, segment_type: Optional[str]=None) -> AddressSegment:
+    return AddressSegment(address, segment_type)
+
+
+def test_address_sequence():
+    addr1 = EntityTag.new("Test1")
+    addr2 = EndpointAddress(EntityTag("Test2"), Protocol.TCP, 80)
+    seq = AddressSequence.new(addr1, addr2)
+    assert seq.segments == (_segment(addr1), _segment(addr2))
+
+
+def test_address_sequence_get_parseable_value():
+    addr1 = _segment(EntityTag.new("Test1"))
+    addr2 = _segment(EndpointAddress(EntityTag("Test2"), Protocol.TCP, 80))
+    addr3 = _segment(EntityTag("Test_SW"), segment_type="software")
+
+    assert AddressSequence([addr1]).get_parseable_value() == "Test1"
+    assert AddressSequence([addr2]).get_parseable_value() == "Test2/tcp:80"
+    assert AddressSequence([addr1, addr2, addr3]).get_parseable_value() == "Test1&Test2/tcp:80&software=Test_SW"
+
+    addr2.segment_type = "source"
+    addr4 = _segment(EndpointAddress(EntityTag("Test4"), Protocol.UDP, 123), segment_type="target")
+    assert AddressSequence([addr2, addr4]).get_parseable_value() == \
+        "source=Test2/tcp:80&target=Test4/udp:123"
+
+
+def test_get_system_address():
+    system = Setup().system
+    system.system.name = "Test System"
+    device = system.device("D")
+
+    # IoTSystem - empty sequence
+    assert system.system.get_system_address() == AddressSequence((),)
+
+    # Host
+    assert device.entity.get_system_address() == AddressSequence.new(
+        EntityTag.new("D")
+    )
+
+    # Service
+    service = (device / HTTP).entity
+    assert service.get_system_address() == AddressSequence.new(
+        EntityTag("D"), EndpointAddress(Addresses.ANY, Protocol.TCP, 80)
+    )
+
+    # NodeComponent
+    software = device.software("SW").get_software()
+    assert software.get_system_address() == AddressSequence((
+        _segment(EntityTag("D")), _segment(EntityTag("SW"), segment_type="software")
+    ))
+
+    # Connection
+    backend = system.backend("B")
+    connection = (device >> backend / HTTP).connection
+    assert connection.get_system_address() == AddressSequence((
+        _segment(EntityTag("D"), "source"),
+        _segment(EntityTag("B"), "target"), _segment(EndpointAddress(Addresses.ANY, Protocol.TCP, 80)),
+    ))
+
+    connection = ((device / HTTP) >> backend / TCP(port=111)).connection
+    assert connection.get_system_address() == AddressSequence((
+        _segment(EntityTag("D"), "source"), _segment(EndpointAddress(Addresses.ANY, Protocol.TCP, 80)),
+        _segment(EntityTag("B"), "target"), _segment(EndpointAddress(Addresses.ANY, Protocol.TCP, 111)),
+    ))
+
+    ble_ad = device.broadcast(BLEAdvertisement(event_type=0x03))
+    assert ble_ad.entity.get_system_address() == AddressSequence.new(
+        EntityTag("D"), EndpointAddress(Addresses.ANY, Protocol.BLE, 3)
+    )
+
+    connection = (backend << ble_ad).connection
+    assert connection.get_system_address() == AddressSequence((
+        _segment(EntityTag("D"), "source"),
+        _segment(EntityTag("B"), "target"), _segment(EndpointAddress(PseudoAddress("BLE_Ad"), Protocol.BLE, 3)),
+    ))
+
+
+def test_parse_system_address():
+    assert Addresses.parse_system_address(
+        "1.2.3.4"
+    ) == AddressSequence.new(IPAddress.new("1.2.3.4"))
+
+    assert Addresses.parse_system_address(
+        "1:2:3:4:5:6|hw"
+    ) == AddressSequence.new(HWAddress.new("1:2:3:4:5:6"))
+
+    assert Addresses.parse_system_address(
+        "Test_Device"
+    ) == AddressSequence.new(EntityTag("Test_Device"))
+
+    assert Addresses.parse_system_address(
+        "1.2.3.4/udp:1234"
+    ) == AddressSequence.new(EndpointAddress(IPAddress.new("1.2.3.4"), Protocol.UDP, 1234))
+
+    assert Addresses.parse_system_address(
+        "Test_Device/tcp:80"
+    ) == AddressSequence.new(EndpointAddress(EntityTag("Test_Device"), Protocol.TCP, 80))
+
+    assert Addresses.parse_system_address(
+        "ff_ff_ff_ff_ff_ff/arp"
+    ) == AddressSequence.new(EndpointAddress(EntityTag("ff_ff_ff_ff_ff_ff"), Protocol.ARP))
+
+    assert Addresses.parse_system_address(
+        "Test_Device&software=Test_SW"
+    ) == AddressSequence((
+        _segment(EntityTag("Test_Device")), _segment(EntityTag("Test_SW"), "software")
+    ))
+
+    assert Addresses.parse_system_address(
+        "source=Test_Device&target=Test_Device/tcp:80"
+    ) == AddressSequence((
+        _segment(EntityTag("Test_Device"), "source"), _segment(EndpointAddress(EntityTag("Test_Device"), Protocol.TCP, 80), "target")
+    ))
+
+    assert Addresses.parse_system_address(
+        "source=Test_Device/udp:123&target=Test_Device"
+    ) == AddressSequence((
+        _segment(EndpointAddress(EntityTag("Test_Device"), Protocol.UDP, 123), "source"), _segment(EntityTag("Test_Device"), "target")
+    ))
+
+    assert Addresses.parse_system_address(
+        "source=Test_Device/tcp:80&target=Test_Device/udp:123"
+    ) == AddressSequence((
+        _segment(EndpointAddress(EntityTag("Test_Device"), Protocol.TCP, 80), "source"),
+        _segment(EndpointAddress(EntityTag("Test_Device"), Protocol.UDP, 123), "target")
+    ))
+
+    assert Addresses.parse_system_address(
+        "source=1.2.3.4&target=Test_Device/tcp:80"
+    ) == AddressSequence((
+        _segment(IPAddress.new("1.2.3.4"), "source"), _segment(EndpointAddress(EntityTag("Test_Device"), Protocol.TCP, 80), "target")
+    ))
+
+    assert Addresses.parse_system_address(
+        "source=1.2.3.4/tcp:80&target=01:01:01:01:01:01|hw/tcp:80"
+    ) == AddressSequence((
+        _segment(EndpointAddress(IPAddress.new("1.2.3.4"), Protocol.TCP, 80), "source"),
+        _segment(EndpointAddress(HWAddress.new("01:01:01:01:01:01"), Protocol.TCP, 80), "target")
+    ))
+
+    assert Addresses.parse_system_address(
+        "Test_Device/tcp:80&software=Test_SW"
+    ) == AddressSequence((
+        _segment(EndpointAddress(EntityTag("Test_Device"), Protocol.TCP, 80)), _segment(EntityTag("Test_SW"), "software")
+    ))
+
+    assert Addresses.parse_system_address(
+        "Test/tcp:80&software=VM&VirtualEnv/udp:123"
+    ) == AddressSequence((
+        _segment(EndpointAddress(EntityTag("Test"), Protocol.TCP, 80)),
+        _segment(EntityTag("VM"), "software"),
+        _segment(EndpointAddress(EntityTag("VirtualEnv"), Protocol.UDP, 123))
+    ))
+
+    assert Addresses.parse_system_address(
+        "Test/ble:3"
+    ) == AddressSequence((
+        _segment(EndpointAddress(EntityTag("Test"), Protocol.BLE, 3)),
+    ))
+
+    assert Addresses.parse_system_address(
+        'source=Test1&target=Test2/ble:3'
+    ) == AddressSequence((
+        _segment(EntityTag("Test1"), "source"),
+        _segment(EndpointAddress(EntityTag("Test2"), Protocol.BLE, 3), "target")
+    ))
+
+
+def test_system_endpoint_address():
+    # Endpoint address with host
+    ep = AddressSequence.new(EndpointAddress(EntityTag("Device"), Protocol.TCP, 1234))
+    # Endpoint address ANY host, as it is used in services
+    ep_any = AddressSequence.new(EntityTag("Device"), EndpointAddress(Addresses.ANY, Protocol.TCP, 1234))
+    # Explicit endpoint address for a service
+    ep_exp = AddressSequence.new(EntityTag("Device"), EndpointAddress(IPAddresses.BROADCAST, Protocol.TCP, 1234))
+
+    ep_s = ep.get_parseable_value()
+    ep_any_s = ep_any.get_parseable_value()
+    ep_exp_s = ep_exp.get_parseable_value()
+    assert ep_s == "Device/tcp:1234"
+    assert ep_any_s == "Device/tcp:1234"
+    assert ep_exp_s == "Device&255.255.255.255/tcp:1234"
+
+    ep2 = Addresses.parse_system_address(ep_s)
+    ep_any2 = Addresses.parse_system_address(ep_any_s)
+    ep_exp2 = Addresses.parse_system_address(ep_exp_s)
+    assert ep2 == ep
+    assert ep_any2 == ep  # Parses into same as ep!
+    assert ep_exp2 == ep_exp2
+
+
+def test_system_endpoint_address_no_protocol():
+    ep = AddressSequence.new(EntityTag("Device"), EndpointAddress(Addresses.ANY, Protocol.ETHERNET))
+    ep_str = ep.get_parseable_value()
+    assert ep_str == "Device/eth"
+    # parsed into one entity tag
+    ep2 = Addresses.parse_system_address(ep_str)
+    assert [s.address for s in ep2.segments] == [EndpointAddress(EntityTag("Device"), Protocol.ETHERNET)]

toolsaf-0.2.0/tests/test_arp.py

@@ -0,0 +1,40 @@
+from toolsaf.common.address import Protocol
+from toolsaf.builder_backend import SystemBackend
+from toolsaf.core.inspector import Inspector
+from toolsaf.main import ARP
+from toolsaf.common.basics import ExternalActivity
+from toolsaf.common.traffic import EthernetFlow
+from toolsaf.common.basics import Status
+
+
+def test_serve_arp():
+    sb = SystemBackend()
+    dev1 = sb.device().hw("1:0:0:0:0:1")
+    dev1.serve(ARP)
+    dev2 = sb.device().hw("1:0:0:0:0:2")
+    dev3 = sb.device().hw("1:0:0:0:0:3")
+    dev3.entity.set_external_activity(ExternalActivity.UNLIMITED)
+    dev4 = sb.device().hw("1:0:0:0:0:4")
+    dev4 >> dev1 / ARP
+
+    m = Inspector(sb.system)
+
+    # dev3 can make external calls
+    f1 = m.connection(EthernetFlow.new(Protocol.ARP, "1:0:0:0:0:3") >> "ff:ff:ff:ff:ff:ff")
+    assert f1.status == Status.EXTERNAL
+
+    # dev2 not defined to make ARP calls
+    f1 = m.connection(EthernetFlow.new(Protocol.ARP, "1:0:0:0:0:2") >> "ff:ff:ff:ff:ff:ff")
+    assert f1.status == Status.UNEXPECTED
+
+    # unknown device can make ARP calls
+    f1 = m.connection(EthernetFlow.new(Protocol.ARP, "1:0:0:0:1:1") >> "ff:ff:ff:ff:ff:ff")
+    assert f1.status == Status.EXTERNAL
+
+    # dev4 can make ARP calls
+    f1 = m.connection(EthernetFlow.new(Protocol.ARP, "1:0:0:0:0:4") >> "ff:ff:ff:ff:ff:ff")
+    assert f1.status == Status.EXPECTED
+    # FIXME: The remaining does not work
+    f1 = m.connection(EthernetFlow.new(Protocol.ARP, "1:0:0:0:0:4") << "1:0:0:0:0:1")
+    # assert f1.status == Status.EXPECTED
+