Detecting vulnerabilities in a program's code is crucial and hard. Although many vulnerabilities are well-known and understood by developers, they continue to appear in new programs again and again. Interestingly, vulnerabilities often arise from a minimal set of instructions, sometimes just two or three. For these reasons, one would expect automated tools to be effective in finding code vulnerabilities. The complexity of large-scale programs' execution flows makes them extremely difficult to find in practice.

Background Smart contracts are revolutionizing the way two or more parties subscribe to and apply an agreement. The main reason is that they promise to increase efficiency, transparency, and security. However, their inherent vulnerabilities can lead to automated exploits, resulting in significant resource losses. Among these, reentrancy is one of the most impactful security flaws. Over the past few years, reentrancy vulnerabilities have caused substantial financial damage and threatened the viability of entire blockchain ecosystems. Therefore, investigating whether reentrancy can be effectively mitigated and exploring the methodologies designed to address it is crucial. Methodology This paper aims to provide a comprehensive understanding of the impact of reentrancy vulnerabilities in Ethereum smart contracts and to assess the theoretical and practical approaches proposed to counter them. By following the PRISMA framework, we conduct a literature review of academic publications to identify, screen, and analyze relevant studies on detection and mitigation techniques. Results Our findings indicate that the estimated financial loss due to reentrancy attacks amounted to around 350 million USD by 2023, with increasing frequency and profitability of incidents. Despite advancements in mitigation tools, particularly machine learning, they only partially address vulnerabilities and remain ineffective against zero-day attacks. Contribution This paper identifies critical challenges in reentrancy detection, including the lack of standardized benchmarks and data on zero-day vulnerabilities. It emphasizes the need for unified datasets and evaluation frameworks to facilitate fair comparisons, improving detection effectiveness. Additionally, it highlights the need for tools addressing all four reentrancy vulnerability types and reporting performance results.

Zero-day malware is a serious cybersecurity concern since it can evade detection techniques using trained and expert systems. In this paper, we propose Z-MDZS - a scheme to effectively identify zero-day malware using a zero-shot1 machine learning approach. Our objective is to detect previously unseen malware based on its properties and relationships to known malware variants, by applying zero-shot learning methods. We evaluate the effectiveness of Z-MDZS, using different machine learning methods, including Random Forest, Deep Neural Networks, and Convolutional Neural Networks. Our results demonstrate that even with smaller feature sets, the zero-shot ML strategy yields solid results, particularly when Random Forest is used as the classifier. Furthermore, we discovered that balancing class samples using Generative Adversarial Network greatly increases classifier accuracy. highlighting its signnificance.

The gender gap in cybersecurity remains a persistent and concerning issue. Despite efforts to promote diversity and inclusivity, women remain significantly underrepresented in cybersecurity roles. One of the primary factors contributing to the gender gap in cybersecurity is the lack of female representation and encouragement in STEM (Science, Technology, Engineering, and Mathematics) fields. Stereotypes and societal biases often dissuade girls and young women from pursuing careers in these fields, leading to a smaller pool of women candidates entering the cybersecurity workforce.

The gender gap is one of the main concerns in the IT sector, in general, and in cybersecurity, in particular. Although well known, the problem is multifaceted and some of its root causes may be found in the education system. In the last years, many initiatives have been proposed targeting high-school students that might be interested in cybersecurity. Many of these programs rely on capture-the-flag (CTF) competitions to gradually form technical skills in an entertaining way. Despite these efforts, however, the number of girls that attend and complete these programs is still often unsatisfactory.

Physical layer security mechanisms use primitives that exploit physical properties of the communication channel to protect data. Protecting communications at the physical layer offers some advantages, e.g., in terms of reduced computations, since complex cryptographic procedures are not executed, However, these mechanisms lack a formal specification that prevent protocols and applications that use them from being verified and compared with those based on cyptography. Here we start filling this gap by providing an axiomatization of key physical layer security primitives and proposing a variant of the Dolev–Yao attacker model that takes them into account. We show that our formalization enables applying existing automatic tools for verifying security of protocols. Then, we show that these primitives are a valuable alternative and effective complement to cryptography, because they ensure confidentiality and integrity but require a lower energy consumption and often they also reduce transmission time. Finally, we characterize the specific application domains and network features that make adopting these security mechanisms particularly profitable with respect to the AES cypher.

The rising of the Cyber-Physical System (CPS) and the Industry 4.0 paradigms demands the design and implementation of Digital Twin Frameworks (DTFs) that may support the quick build of reliable Digital Twins (DTs) for experimental and testing purposes. Most of the current DTF proposals allow the generation of DTs at a good pace but affect generality, scalability, portability, and completeness. As a consequence, current DTF are mostly domain-specific and hardly span several application domains (e.g., from simple IoT deployments to the modeling of complex critical infrastructures). Furthermore, the generated DTs often requires a high amount of computational resource to run. In this paper, we present LiDiTE, a solution based on a novel reference model for general-purpose DTFs. LiDiTE overcomes the limitations of state-of-the-art tools by supporting the fine-grained development of real-world complexity scenarios. To achieve that, LiDiTE builds on technologies that favor scalability, reuse, and extensibility of scenarios. We show such features by building the DT of real critical infrastructure and evaluating the performance of our DT against those of the real system. Further contributions of this paper include open access to the source code of LiDiTE and the experimental dataset.

Abstract Verifying the correctness of a system as a whole requires establishing that it satisfies a global specification. When it does not, it would be helpful to determine which modules are incorrect. As a consequence, specification decomposition is a relevant problem from both a theoretical and practical point of view. Until now, specification decomposition has been independently addressed by the control theory and verification communities throughnatural projectionandpartial model checking, respectively. We prove that natural projection reduces to partial model checking and, when cast in a common setting, the two are equivalent. Apart from their foundational interest, our results build a bridge whereby the control theory community can reuse algorithms and results developed by the verification community. Furthermore, we extend the notions of natural projection and partial model checking from finite-state to symbolic transition systems and we show that the equivalence still holds. Symbolic transition systems are more expressive than traditional finite-state transition systems, as they can model large systems, whose behavior depends on the data handled, and not only on the control flow. Finally, we present an algorithm for the partial model checking of both kinds of systems that can be used as an alternative to natural projection.

Cyber Ranges are (virtual) infrastructures for the execution of cyber exercises of the highest quality that simulate cyber scenarios of real-world complexity. Building the computing infrastructure is only the first step towards the successful execution of the cyber exercises. The design, validation, and deployment of scenarios are costly and error-prone activities that may require specialized personnel for weeks or even months. Furthermore, a misconfiguration in the resulting scenario can spoil the entire cyber exercise. In this paper, we propose a framework for automating the (i) design, (ii) model validation, (iii) generation and (iv) testing of cyber scenarios. We introduce a Scenario Definition Language (SDL) based on the OASIS Topology and Orchestration Specification for Cloud Applications (TOSCA). SDL allows for the high level, declarative specification of the components and their interplay. We show that SDL specifications can be encoded into Datalog and that this allows for the automatic checking of the resulting model against a set of validation goals. If the check fails, then a design modification process is triggered. Otherwise, the validated scenario can be automatically deployed on the cyber range. The validation proof is then automatically converted into test cases whose successful execution gives evidence that also the deployed scenario meets the validation goals.

Mobile code distribution relies on digital signatures to guarantee code authenticity. Unfortunately, standard signature schemes are not well suited for use in conjunction with program transformation techniques, such as aspect-oriented programming. With these techniques, code development is performed in sequence by multiple teams of programmers. This is fundamentally different from traditional single-developer/ single-user models, where users can verify end-to-end (i.e., developer-to-user) authenticity of the code using digital signatures. To address this limitation, we introduce FLEX, a flexible code authentication framework for mobile applications. FLEX allows semi-trusted intermediaries to modify mobile code without invalidating the developer's signature, as long as the modification complies with a "contract" issued by the developer. We introduce formal definitions for secure code modification, and show that our instantiation of FLEX is secure under these definitions. Although FLEX can be instantiated using any language, we design AMJ--a novel programming language that supports code annotations--and implement a FLEX prototype based on our new language.

The Android Security Framework controls the executions of applications through permissions which are statically granted by the user during installation. However, the definition of security policies over permissions is not supported. Security policies must be therefore manually encoded into the application by the developer, which is a dangerous practice and may cause security breaches. We propose an improvement over the Android permission system that supports the specification and enforcement of fine-grained security policies. Enforcement is achieved by reducing policy decision problems to propositional satisfiability and leveraging a state-of-the-art SAT solver. Unlike alternative proposals, our approach does not require changes in the operating system and, therefore, it can be readily deployed in any commercial device.

Mobile security is a hot research topic. Yet most of available techniques focus on securing individual applications and therefore cannot possibly tackle security weaknesses stemming from the combined use of one or more applications (e.g. confused deputy attacks). Preventing these types of attacks is crucial in many important application scenarios. For instance, their prevention is a prerequisite for the widespread adoption of the BYOD paradigm in the corporate setting.

Service Oriented Computing (SOC) is a programming paradigm aiming at characterising Service Networks. Services are entities waiting for requests from clients and they often result from the composition of many (sub-)services. We address here the probl

Security-by-Contract (S×C) is a paradigm providing security assurances for mobile applications. In this work, we present an extension of S×C enriched with an automatic trust management infrastructure. Indeed, we enhance the already existing architecture by adding new modules and configurations for contracts managing. At deploy-time, our system decides the run-time configuration depending on the credentials of contract provider. Roughly, the run-time environment can both enforce a security policy and monitor the declared contract. According to the actual behaviour of the running program our architecture updates the trust level associated with the contract provider. The main advantage of this method is an automatic management of the level of trust of software and contract releasers.