Self-Sovereign Identity (SSI) empowers users to govern their digital identity and personal data. This approach has changed the identity paradigm where users become the central governor of their identity; hence the rapid growth of the SSI model. Utilizing the security and privacy properties of blockchain, together with other security technologies, SSI purports to provide a robust security and privacy service. However, this governing power for users comes with a greater accountability and security risk, as not all users are capable or trained in its use and therefore in its efficient application. This trade-off requires a systematic evaluation of potential attacks on the SSI system and their security risks. Hitherto, there have been no noteworthy research studies performed to evaluate potential attacks on the SSI system and their security risks. This paper proposes an easy, efficient and economical approach to perform an evaluation of potential attacks on the SSI system and their security risks. This approach utilises a combination of an attack tree model and risk matrix model to perform this evaluation of potential attacks and their security risks, in addition to outlining a systematic approach including describing the system architecture and determining its assets in order to perform this evaluation of potential attacks and their security risks. This evaluation work has identified three potential attacks on the SSI system: faking identity, identity theft and distributed denial of service attacks, and performed their security risk evaluation utilising the proposed approach. Finally, this paper has proposed several mitigation strategies for the three evaluated attacks on the SSI system. This proposed evaluation approach is a systematic and generalised approach for evaluating attacks and their security risks, and can be applied to any other IT system.

Online services are becoming increasingly data-centric; they collect, process, analyze and anonymously disclose growing amounts of personal data. It is crucial that such systems are engineered in a privacy-aware manner in order to satisfy both the privacy requirements of the user, and the legal privacy regulations that the system operates under. How can system developers be better supported to create privacy-aware systems and help them to understand and identify privacy risks? Model-Driven Engineering (MDE) offers a principled approach to engineer systems software. The capture of shared domain knowledge in models and corresponding tool support can increase the developers' understanding. In this paper, we argue for the application of MDE approaches to engineer privacy-aware systems. We present a general purpose privacy model and methodology that can be used to analyse and identify privacy risks in systems that comprise both access control and data pseudonymization enforcement technologies. We evaluate this method using a case-study based approach and show how the model can be applied to engineer privacy-aware systems and privacy policies that reduce the risk of unintended disclosure.

The growth in cloud-based services tailored for users means more and more personal data is being exploited, and with this comes the need to better handle user privacy. Software technologies concentrating on privacy preservation typically present a one-size fits all solution. However, users have different viewpoints of what privacy means to them and therefore, configurable and dynamic privacy preserving solutions have the potential to create useful and tailored services without breaching any user's privacy. In this paper, we present a model of user-centered privacy that can be used to analyse a service's behaviour against user preferences, such that a user can be informed of the privacy implications of that service and what fine-grained actions they can take to maintain their privacy. We show through study that the user-based privacy model can: i) provide customizable privacy aligned with user needs; and ii) identify potential privacy breaches.

This paper proposes a new delivery-centric abstraction. A delivery-centric abstraction allows applications to generate content requests agnostic to location or protocol, with the additional ability to stipulate high-level requirements regarding such things as performance, security, resource consumption and monetary cost. A delivery-centric system therefore constantly adapts to fulfil these requirements, given the constraints of the environment. This abstraction has been realised through a delivery-centric middleware called Juno, which uses a reconfigurable software architecture to (i) discover multiple sources of an item of content, (ii) model each source's ability to provide the content, then (iii) adapt to interact with the source(s) that can best fulfil the application's requirements. Juno therefore utilises existing providers in a backwards compatible way, supporting immediate deployment. This paper evaluates Juno using Emulab to validate its ability to adapt to its environment.

This article proposes a new delivery-centric abstraction which extends the existing content-centric networking API. A delivery-centric abstraction allows applications to generate content requests agnostic to location or protocol, with the additional ability to stipulate high-level requirements regarding such things as performance, security, and resource consumption. Fulfilling these requirements, however, is complex as often the ability of a provider to satisfy requirements will vary between different consumers and over time. Therefore, we argue that it is vital to manage this variance to ensure an application fulfils its needs. To this end, we present the Juno middleware, which implements delivery-centric support using a reconfigurable software architecture to: (i) discover multiple sources of an item of content; (ii) model each source’s ability to provide the content; then (iii) adapt to interact with the source(s) that can best fulfil the application’s requirements. Juno therefore utilizes existing providers in a backwards compatible way, supporting immediate deployment. This article evaluates Juno using Emulab to validate its ability to adapt to its environment.

Interoperability remains a challenging and growing problem within distributed systems. A range of heterogeneous network and middleware protocols which cannot interact with one another are now widely used, for example, the set of remote method invocation protocols, and the set of service discovery protocols. In environments where systems and services are composed dynamically, e.g. pervasive computing and systems-of-systems, the protocols used by two systems wishing to interact is unknown until runtime and hence interoperability cannot be guaranteed. In such situations, dynamic solutions are required to identify the differences between heterogeneous protocols and generate middleware connectors (or bridges) that will allow the systems to inter operate. In this paper, we present the Starlink middleware, a general framework into which runtime generated interoperability logic (in the form of higher level models) can be deployed to connect two heterogeneous protocols. For this, it provides: i) an abstract representation of network messages with a corresponding generic parser and composer, ii) an engine to execute coloured automata that represent the required interoperability behaviour between protocols, and iii) translation logic to describe the exchange of message content from one protocol to another. We show through case-study based evaluation that Starlink can bridge heterogeneous protocol types. Starlink is also compared against base-line protocol benchmarks to show that acceptable performance can still be achieved in spite of the high-level nature of the solution.

Service Discovery Protocols (SDPs) provide mechanisms that allow networked devices and applications to advertise and locate services with minimum or no human intervention. For fixed networked devices, SDPs such as SLP, Bonjour, and UPnP have been proposed. For more dynamic networked environments such as ad hoc, sensor, and wireless networks, a set of discovery technologies have been designed to operate optimally in such conditions; these include protocols like Ariadne, Allia, GSD, and UDDI. Hence, it is possible to advertise and discover services in diverse network types using one of a suite of technologies. Importantly, there are differences between individual protocols in terms of: (i) service description language, (ii) message format, (iii) directory architecture, (iv) discovery protocol behavior, (v) network communication, and (vi) nonfunctional features. These differences mean it is not possible to discover services with one protocol that is advertised by another and vice versa; we characterize this as service discovery protocol heterogeneity . In this article, we propose SeDiM, a dynamic middleware solution to allow heterogeneous discovery protocols within and across different domains to interoperate with one another. SeDiM is evaluated within a case study that demonstrates transparent interoperation of protocols including SLP and Bonjour in highly heterogeneous environments.

Component-based software engineering has recently emerged as a promising solution to the development of system-level software. Unfortunately, current approaches are limited to specific platforms and domains. This lack of generality is particularly problematic as it prevents knowledge sharing and generally drives development costs up. In the past, we have developed a generic approach to component-based software engineering for system-level software called OpenCom. In this paper, we present OpenComL an instantiation of OpenCom to Linux environments and show how it can be profiled to meet a range of system-level software in Linux environments. For this, we demonstrate its application to constructing a programmable router platform and a middleware for parallel environments.

The CONNECT European project that started in February 2009 aims at dropping the interoperability barrier faced by todaypsilas distributed systems. It does so by adopting a revolutionary approach to the seamless networking of digital systems, that is, synthesizing on the fly the connectors via which networked systems communicate. CONNECT then investigates formal foundations for connectors together with associated automated support for learning, reasoning about and adapting the interaction behavior of networked systems.

The innate dynamicity and complexity of mobile ad-hoc networks (MANETs) has resulted in numerous ad-hoc routing protocols being proposed. Furthermore, numerous variants and hybrids continue to be reported in the literature. This diversity appears to be inherent to the field-it seems unlikely that there will ever be a ‘one-size-fits-all’ solution to the ad-hoc routing problem. However, typical deployment environments for ad-hoc routing protocols still force the choice of a single fixed protocol; and the resultant compromise can easily lead to sub-optimal performance, depending on current operating conditions. In this paper we address this problem by exploring a framework approach to the construction and deployment of ad-hoc routing protocols. Our framework supports the simultaneous deployment of multiple protocols so that MANET nodes can switch protocols to optimise to current operating conditions. The framework also supports finer-grained dynamic reconfiguration in terms of protocol variation and hybridisation. We evaluate our framework by using it to construct and (simultaneously) deploy two popular ad-hoc routing protocols (DYMO and OLSR), and also to derive fine-grained variants of these. We measure the performance and resource overhead of these implementations compared to monolithic ones, and find the comparison to be favourable to our approach.

In order to provide an increasing number of functionalities and benefit from sophisticated and application-tailored services from the network, distributed applications are led to integrate an ever-widening range of networking technologies. As these applications become more complex, this requirement for 'network heterogeneity' is becoming a crucial issue in their development. Although progress has been made in the networking community in addressing such needs through the development of network overlays, we claim in this paper that the middleware community has been slow to integrate these advances into middleware architectures, and, hence, to provide the foundational bedrock for heterogeneous distributed applications. In response, we propose our 'open overlays' framework. This framework, which is part of a wider middleware architecture, accommodates 'overlay plug-ins', allows physical nodes to support multiple overlays, supports the stacking of overlays to create composite protocols, and adopts a declarative approach to configurable deployment and dynamic reconfigurability. The framework has been in development for a number of years and supports an extensive range of overlay plug-ins including popular protocols such as Chord and Pastry. We report on our experiences with the open overlays framework, evaluate it in detail, and illustrate its application in a detailed case study of network heterogeneity.

Engineering adaptive software is an increasingly complex task. Here, we demonstrate Genie, a tool that supports the modelling, generation, and operation of highly reconfigurable, component-based systems. We showcase how Genie is used in two case-studies: i) the development and operation of an adaptive flood warning system, and ii) a service discovery application. In this context, adaptation is enabled by the Gridkit reflective middleware platform.

Although a growing number of devices have the support for parallel processing, parallelism is not widely exploited, as it should be. This can be illustrated by the fact that all Apple desktops and laptops are currently supplied with one or more dual- core processors. Despite this, parallel programming in popular languages such as Java is not widely encouraged and often only recommended as a last resort. In addition, it is likely that the next generation parallel applications will have to operate within a diverse range of heterogeneous devices ranging from supercomputers to sensors. This paper proposes a flexible component-based middleware that aims at facilitating the construction of deadlock-free parallel and concurrent applications for heterogeneous environments. The middleware is particularly targeted to tailor applications to the target need and environment. For our prototyping, we implemented plu- gins that are capable of deploying JCSP (CSP library for Java programmers) and OCCam-pi processes. Both JCSP and OCCam-pi make use of the CSP disciplines. The CSP (Communicating Sequential Processes) paradigm helps us to avoid concurrency problems such as deadlocks. It should be stressed that there is no bias towards these languages as the proposed middleware is highly extensible.

Abstract Flooding is a growing problem, which affects more than 10% of the U.K. population. The cost of damage caused by flooding correlates closely with the warning time given before a flood event, making flood monitoring and prediction critical to minimizing the cost of flood damage. This paper describes a wireless sensor network (WSN) for flood warning, which is capable of not only integrating with remote fixed‐network grids for computationally intensive flood modelling purposes but also performing on‐site grid computation. This functionality is supported by the reflective and component‐based GridKit middleware, which provides support for both WSN and grid application domains. Copyright © 2007 John Wiley & Sons, Ltd.

Component-based software structuring principles are now commonplace at the application level; but componentization is far less established when it comes to building low-level systems software. Although there have been pioneering efforts in applying componentization to systems-building, these efforts have tended to target specific application domains (e.g., embedded systems, operating systems, communications systems, programmable networking environments, or middleware platforms). They also tend to be targeted at specific deployment environments (e.g., standard personal computer (PC) environments, network processors, or microcontrollers). The disadvantage of this narrow targeting is that it fails to maximize the genericity and abstraction potential of the component approach. In this article, we argue for the benefits and feasibility of a generic yet tailorable approach to component-based systems-building that offers a uniform programming model that is applicable in a wide range of systems-oriented target domains and deployment environments. The component model, called OpenCom , is supported by a reflective runtime architecture that is itself built from components. After describing OpenCom and evaluating its performance and overhead characteristics, we present and evaluate two case studies of systems we have built using OpenCom technology, thus illustrating its benefits and its general applicability.

Transaction execution in mobile environments needs to be flexible, not only to support typical mobile computing characteristics, like movement, disconnections and limited resources, but also to support the variety of transactional properties that might be required by different applications. This paper presents an approach for flexible transaction processing in mobile applications, and describes an adaptive middleware for mobile transaction services (MobileTSe), that makes transaction services with different properties available on the mobile unit. We suggest a solution with transaction service discovery and control using UPnP.

Current approaches to flood monitoring (e.g. in river valleys) involve statically deploying depth and ultrasoundbased flow sensors across flood-prone areas, and feeding the collected data off-site (e.g. using GSM) to grid-based

Abstract Significant progress has been made in the design and development of Grid middleware which, in its present form, is founded on Web services technologies. However, we argue that present‐day Grid middleware is severely limited in supporting projected next‐generation applications which will involve pervasive and heterogeneous networked infrastructures, and advanced services such as collaborative distributed visualization. In this paper we discuss a new Grid middleware framework that features (i) support for advanced network services based on the novel concept of pluggable overlay networks, (ii) an architectural framework for constructing bespoke Grid middleware platforms in terms of ‘middleware domains’ such as extensible interaction types and resource discovery. We believe that such features will become increasingly essential with the emergence of next‐generation e‐Science applications. Copyright © 2005 John Wiley & Sons, Ltd.

Reflection is widely acknowledged as a useful mechanism for facilitating the run-time adaptation/ reconfiguration of software. Often, however, it is also thought to impose intolerably high overheads in performance-critical systems software environments like middleware platforms, operating systems, or programmable routers. In this paper we argue that there are many varieties of reflection (i.e. many types of 'meta-models') and that some of these in fact impose zero or negligible overhead. We further argue that in many cases, particularly cases involving highly dynamic software environments, reflection can actually enhance performance by laying open choices of alternative mechanisms that are best suited to current environmental conditions. Finally, we discuss the case of interception meta-models which, in many implementations, do lead to significant performance problems, and present our experience to date in attempting to minimise these problems.